chore(workspace): Update eslint and add missing rules (#3350)

exchanges/auth/src/authExchange.ts

···
+import type { Source } from 'wonka';
 import {
-  Source,
   pipe,
   map,
   filter,
···
   merge,
 } from 'wonka';
 
-import {
-  createRequest,
-  makeOperation,
-  makeErrorResult,
+import type {
   Operation,
   OperationContext,
   OperationResult,
···
   AnyVariables,
   OperationInstance,
 } from '@urql/core';
+import { createRequest, makeOperation, makeErrorResult } from '@urql/core';
 
 /** Utilities to use while refreshing authentication tokens. */
 export interface AuthUtilities {

exchanges/context/src/context.ts

···
-import {
-  Exchange,
-  makeOperation,
-  Operation,
-  OperationContext,
-} from '@urql/core';
+import type { Exchange, Operation, OperationContext } from '@urql/core';
+import { makeOperation } from '@urql/core';
 
 import { fromPromise, fromValue, mergeMap, pipe } from 'wonka';
 

exchanges/execute/src/execute.ts

···
-import { Source, pipe, filter, takeUntil, mergeMap, merge, make } from 'wonka';
+import type { Source } from 'wonka';
+import { pipe, filter, takeUntil, mergeMap, merge, make } from 'wonka';
 
-import {
+import type {
   GraphQLSchema,
   GraphQLFieldResolver,
   GraphQLTypeResolver,
-  execute,
-  subscribe,
   ExecutionArgs,
   SubscriptionArgs,
-  Kind,
 } from 'graphql';
+import { execute, subscribe, Kind } from 'graphql';
 
-import {
+import type {
   Exchange,
   ExecutionResult,
-  makeResult,
-  makeErrorResult,
-  mergeResultPatch,
   Operation,
   OperationResult,
 } from '@urql/core';
+import { makeResult, makeErrorResult, mergeResultPatch } from '@urql/core';
 
 /** Input parameters for the {@link executeExchange}.
  * @see {@link ExecutionArgs} which this interface mirrors. */

exchanges/graphcache/src/ast/node.ts

···
-import {
+import type {
   NamedTypeNode,
   NameNode,
   DirectiveNode,
···
   FragmentDefinitionNode,
 } from '@0no-co/graphql.web';
 
-import { FormattedNode } from '@urql/core';
+import type { FormattedNode } from '@urql/core';
 
 export type SelectionSet = readonly FormattedNode<SelectionNode>[];
 

exchanges/graphcache/src/ast/schemaPredicates.ts

···
-import {
+import type {
   InlineFragmentNode,
   FragmentDefinitionNode,
 } from '@0no-co/graphql.web';
 
 import { warn, invariant } from '../helpers/help';
 import { getTypeCondition } from './node';
-import { SchemaIntrospector, SchemaObject } from './schema';
+import type { SchemaIntrospector, SchemaObject } from './schema';
 
-import {
+import type {
   KeyingConfig,
   UpdatesConfig,
   ResolverConfig,

exchanges/graphcache/src/ast/traversal.ts

···
-import {
+import type {
   SelectionNode,
   DocumentNode,
   OperationDefinitionNode,
   FragmentSpreadNode,
   InlineFragmentNode,
-  valueFromASTUntyped,
-  Kind,
 } from '@0no-co/graphql.web';
+import { valueFromASTUntyped, Kind } from '@0no-co/graphql.web';
 
-import { FormattedNode } from '@urql/core';
+import type { FormattedNode } from '@urql/core';
 import { getName, getDirectives } from './node';
 import { invariant } from '../helpers/help';
-import { Fragments, Variables } from '../types';
+import type { Fragments, Variables } from '../types';
 
 function getMainOperation(
   doc: FormattedNode<DocumentNode>

exchanges/graphcache/src/ast/variables.test.ts

···
   it('normalizes variables', () => {
     const input = { x: 42 };
     const operation = getMainOperation(
-      formatDocument(
-        gql`
-          query ($x: Int!) {
-            field
-          }
-        `
-      )
+      formatDocument(gql`
+        query ($x: Int!) {
+          field
+        }
+      `)
     );
     const normalized = normalizeVariables(operation, input);
     expect(normalized).toEqual({ x: 42 });
···
   it('normalizes variables with defaults', () => {
     const input = { x: undefined };
     const operation = getMainOperation(
-      formatDocument(
-        gql`
-          query ($x: Int! = 42) {
-            field
-          }
-        `
-      )
+      formatDocument(gql`
+        query ($x: Int! = 42) {
+          field
+        }
+      `)
     );
     const normalized = normalizeVariables(operation, input);
     expect(normalized).toEqual({ x: 42 });
···
   it('normalizes variables even with missing fields', () => {
     const input = { x: undefined };
     const operation = getMainOperation(
-      formatDocument(
-        gql`
-          query ($x: Int!) {
-            field
-          }
-        `
-      )
+      formatDocument(gql`
+        query ($x: Int!) {
+          field
+        }
+      `)
     );
     const normalized = normalizeVariables(operation, input);
     expect(normalized).toEqual({});
···
 
   it('skips normalizing for queries without variables', () => {
     const operation = getMainOperation(
-      formatDocument(
-        gql`
-          query {
-            field
-          }
-        `
-      )
+      formatDocument(gql`
+        query {
+          field
+        }
+      `)
     );
     (operation as any).variableDefinitions = undefined;
     const normalized = normalizeVariables(operation, {});
···
 
   it('preserves missing variables', () => {
     const operation = getMainOperation(
-      formatDocument(
-        gql`
-          query {
-            field
-          }
-        `
-      )
+      formatDocument(gql`
+        query {
+          field
+        }
+      `)
     );
     (operation as any).variableDefinitions = undefined;
     const normalized = normalizeVariables(operation, { test: true });
···
 describe('filterVariables', () => {
   it('returns undefined when no variables are defined', () => {
     const operation = getMainOperation(
-      formatDocument(
-        gql`
-          query {
-            field
-          }
-        `
-      )
+      formatDocument(gql`
+        query {
+          field
+        }
+      `)
     );
     const vars = filterVariables(operation, { test: true });
     expect(vars).toBe(undefined);
···
   it('filters out missing vars', () => {
     const input = { x: true, y: false };
     const operation = getMainOperation(
-      formatDocument(
-        gql`
-          query ($x: Int!) {
-            field
-          }
-        `
-      )
+      formatDocument(gql`
+        query ($x: Int!) {
+          field
+        }
+      `)
     );
     const vars = filterVariables(operation, input);
     expect(vars).toEqual({ x: true });
···
   it('ignores defaults', () => {
     const input = { x: undefined };
     const operation = getMainOperation(
-      formatDocument(
-        gql`
-          query ($x: Int! = 42) {
-            field
-          }
-        `
-      )
+      formatDocument(gql`
+        query ($x: Int! = 42) {
+          field
+        }
+      `)
     );
     const vars = filterVariables(operation, input);
     expect(vars).toEqual({ x: undefined });

exchanges/graphcache/src/ast/variables.ts

···
-import {
+import type {
   FieldNode,
   DirectiveNode,
   OperationDefinitionNode,
-  valueFromASTUntyped,
 } from '@0no-co/graphql.web';
+import { valueFromASTUntyped } from '@0no-co/graphql.web';
 
 import { getName } from './node';
 
-import { Variables } from '../types';
+import type { Variables } from '../types';
 
 /** Evaluates a fields arguments taking vars into account */
 export const getFieldArguments = (

exchanges/graphcache/src/cacheExchange.ts

···
-import {
+import type {
   Exchange,
-  formatDocument,
-  makeOperation,
   Operation,
   OperationResult,
   RequestPolicy,
   CacheOutcome,
 } from '@urql/core';
+import { formatDocument, makeOperation } from '@urql/core';
 
+import type { Source } from 'wonka';
 import {
   filter,
   map,
···
   fromArray,
   mergeMap,
   empty,
-  Source,
 } from 'wonka';
 
 import { _query } from './operations/query';
···
 import { addMetadata, toRequestPolicy } from './helpers/operation';
 import { filterVariables, getMainOperation } from './ast';
 import { Store } from './store/store';
-import { Data, Dependencies, CacheExchangeOpts } from './types';
+import type { Data, Dependencies, CacheExchangeOpts } from './types';
 
 import {
   initDataState,
···
       if (operation.kind === 'subscription' || result.hasNext)
         reserveLayer(store.data, operation.key, true);
 
-      let queryDependencies: void | Dependencies;
+      let queryDependencies: undefined | Dependencies;
       let data: Data | null = result.data;
       if (data) {
         // Write the result to cache and collect all dependencies that need to be

exchanges/graphcache/src/default-storage/index.ts

···
-import { SerializedEntries, SerializedRequest, StorageAdapter } from '../types';
+import type {
+  SerializedEntries,
+  SerializedRequest,
+  StorageAdapter,
+} from '../types';
 
 const getRequestPromise = <T>(request: IDBRequest<T>): Promise<T> => {
   return new Promise((resolve, reject) => {
···
 
   const deserializeBatch = (input: string) => {
     const data = {};
-    let char = '',
-      key = '',
-      entry = '',
-      mode = 0,
-      index = 0;
-
+    let char = '';
+    let key = '';
+    let entry = '';
+    let mode = 0;
+    let index = 0;
     while (index < input.length) {
       entry = '';
       while ((char = input[index++]) !== ':' && char) {

exchanges/graphcache/src/extras/relayPagination.ts

···
 import { stringifyVariables } from '@urql/core';
-import { Cache, Resolver, Variables, NullArray } from '../types';
+import type { Cache, Resolver, Variables, NullArray } from '../types';
 
 export type MergeMode = 'outwards' | 'inwards';
 

exchanges/graphcache/src/extras/simplePagination.ts

···
 import { stringifyVariables } from '@urql/core';
-import { Resolver, Variables, NullArray } from '../types';
+import type { Resolver, Variables, NullArray } from '../types';
 
 export type MergeMode = 'before' | 'after';
 

exchanges/graphcache/src/helpers/help.ts

···
 // Every warning and error comes with a number that uniquely identifies them.
 // You can read more about the messages themselves in `docs/graphcache/errors.md`
 
-import {
-  Kind,
+import type {
   ExecutableDefinitionNode,
   InlineFragmentNode,
 } from '@0no-co/graphql.web';
+import { Kind } from '@0no-co/graphql.web';
 
 export type ErrorCode =
   | 1

exchanges/graphcache/src/helpers/operation.ts

···
-import {
-  Operation,
-  RequestPolicy,
-  OperationDebugMeta,
-  makeOperation,
-} from '@urql/core';
+import type { Operation, RequestPolicy, OperationDebugMeta } from '@urql/core';
+import { makeOperation } from '@urql/core';
 
 // Returns the given operation result with added cacheOutcome meta field
 export const addMetadata = (

exchanges/graphcache/src/offlineExchange.ts

···
 import { pipe, share, merge, makeSubject, filter, onPush } from 'wonka';
 
-import {
+import type {
   Operation,
   OperationResult,
   Exchange,
   ExchangeIO,
   CombinedError,
   RequestPolicy,
-  stringifyDocument,
-  createRequest,
-  makeOperation,
 } from '@urql/core';
+import { stringifyDocument, createRequest, makeOperation } from '@urql/core';
 
-import { SerializedRequest, CacheExchangeOpts, StorageAdapter } from './types';
+import type {
+  SerializedRequest,
+  CacheExchangeOpts,
+  StorageAdapter,
+} from './types';
 import { cacheExchange } from './cacheExchange';
 import { toRequestPolicy } from './helpers/operation';
 

exchanges/graphcache/src/operations/invalidate.ts

···
 import * as InMemoryData from '../store/data';
 import { keyOfField } from '../store/keys';
-import { FieldArgs } from '../types';
+import type { FieldArgs } from '../types';
 
 interface PartialFieldInfo {
   fieldKey: string;

exchanges/graphcache/src/operations/query.ts

···
-import { formatDocument, FormattedNode, CombinedError } from '@urql/core';
+import type { FormattedNode, CombinedError } from '@urql/core';
+import { formatDocument } from '@urql/core';
 
-import {
+import type {
   FieldNode,
   DocumentNode,
   FragmentDefinitionNode,
 } from '@0no-co/graphql.web';
 
+import type { SelectionSet } from '../ast';
 import {
   getSelectionSet,
   getName,
-  SelectionSet,
   getFragmentTypeName,
   getFieldAlias,
   getFragments,
···
   getDirectives,
 } from '../ast';
 
-import {
+import type {
   Variables,
   Data,
   DataField,
···
 } from '../types';
 
 import { joinKeys, keyOfField } from '../store/keys';
-import { Store } from '../store/store';
+import type { Store } from '../store/store';
 import * as InMemoryData from '../store/data';
 import { warn, pushDebugNode, popDebugNode } from '../helpers/help';
 
+import type { Context } from './shared';
 import {
-  Context,
   makeSelectionIterator,
   ensureData,
   makeContext,

exchanges/graphcache/src/operations/shared.test.ts

···
 
 describe('makeSelectionIterator', () => {
   it('emits all fields', () => {
-    const selection = selectionOfDocument(
-      gql`
-        {
-          a
-          b
-          c
-        }
-      `
-    );
+    const selection = selectionOfDocument(gql`
+      {
+        a
+        b
+        c
+      }
+    `);
     const iterate = makeSelectionIterator(
       'Query',
       'Query',

exchanges/graphcache/src/operations/shared.ts

···
-import { CombinedError, ErrorLike, FormattedNode } from '@urql/core';
+import type { CombinedError, ErrorLike, FormattedNode } from '@urql/core';
 
-import {
-  Kind,
+import type {
   FieldNode,
   InlineFragmentNode,
   FragmentDefinitionNode,
 } from '@0no-co/graphql.web';
+import { Kind } from '@0no-co/graphql.web';
 
-import {
-  isDeferred,
-  getTypeCondition,
-  getSelectionSet,
-  getName,
-  SelectionSet,
-} from '../ast';
+import type { SelectionSet } from '../ast';
+import { isDeferred, getTypeCondition, getSelectionSet, getName } from '../ast';
 
 import { warn, pushDebugNode, popDebugNode } from '../helpers/help';
 import { hasField, currentOperation, currentOptimistic } from '../store/data';
 import { keyOfField } from '../store/keys';
-import { Store } from '../store/store';
+import type { Store } from '../store/store';
 
 import { getFieldArguments, shouldInclude, isInterfaceOfType } from '../ast';
 
-import {
+import type {
   Fragments,
   Variables,
   DataField,

exchanges/graphcache/src/operations/write.ts

···
-import { formatDocument, FormattedNode, CombinedError } from '@urql/core';
+import type { FormattedNode, CombinedError } from '@urql/core';
+import { formatDocument } from '@urql/core';
 
-import {
+import type {
   FieldNode,
   DocumentNode,
   FragmentDefinitionNode,
 } from '@0no-co/graphql.web';
 
+import type { SelectionSet } from '../ast';
 import {
   getFragments,
   getMainOperation,
···
   isFieldAvailableOnType,
   getSelectionSet,
   getName,
-  SelectionSet,
   getFragmentTypeName,
   getFieldAlias,
 } from '../ast';
 
 import { invariant, warn, pushDebugNode, popDebugNode } from '../helpers/help';
 
-import {
+import type {
   NullArray,
   Variables,
   Data,
···
 } from '../types';
 
 import { joinKeys, keyOfField } from '../store/keys';
-import { Store } from '../store/store';
+import type { Store } from '../store/store';
 import * as InMemoryData from '../store/data';
 
+import type { Context } from './shared';
 import {
-  Context,
   makeSelectionIterator,
   ensureData,
   makeContext,
···
 
     // Execute optimistic mutation functions on root fields, or execute recursive functions
     // that have been returned on optimistic objects
-    let resolver: OptimisticMutationResolver | void;
+    let resolver: OptimisticMutationResolver | undefined;
     if (ctx.optimistic && rootField === 'mutation') {
       resolver = ctx.store.optimisticMutations[fieldName];
       if (!resolver) continue;

exchanges/graphcache/src/store/data.ts

···
 import { stringifyVariables } from '@urql/core';
 
-import {
+import type {
   Link,
   EntityField,
   FieldInfo,

exchanges/graphcache/src/store/keys.ts

···
 import { stringifyVariables } from '@urql/core';
-import { FieldArgs, FieldInfo, KeyInfo } from '../types';
+import type { FieldArgs, FieldInfo, KeyInfo } from '../types';
 
 export const keyOfField = (fieldName: string, args?: FieldArgs) =>
   args ? `${fieldName}(${stringifyVariables(args)})` : fieldName;

exchanges/graphcache/src/store/store.ts

···
-import { TypedDocumentNode, formatDocument, createRequest } from '@urql/core';
+import type { TypedDocumentNode } from '@urql/core';
+import { formatDocument, createRequest } from '@urql/core';
 
-import {
+import type {
   Cache,
   FieldInfo,
   ResolverConfig,
···
 import { keyOfField } from './keys';
 import * as InMemoryData from './data';
 
+import type { SchemaIntrospector } from '../ast';
 import {
-  SchemaIntrospector,
   buildClientSchema,
   expectValidKeyingConfig,
   expectValidUpdatesConfig,
···
  * @internal
  */
 export class Store<
-  C extends Partial<CacheExchangeOpts> = Partial<CacheExchangeOpts>
+  C extends Partial<CacheExchangeOpts> = Partial<CacheExchangeOpts>,
 > implements Cache
 {
   data: InMemoryData.InMemoryData;

exchanges/graphcache/src/types.ts

···
-import {
+import type {
   AnyVariables,
   DocumentInput,
   RequestExtensions,
···
   ErrorLike,
 } from '@urql/core';
 
-import { DocumentNode, FragmentDefinitionNode } from '@0no-co/graphql.web';
-import { IntrospectionData } from './ast';
+import type { DocumentNode, FragmentDefinitionNode } from '@0no-co/graphql.web';
+import type { IntrospectionData } from './ast';
 
 /** Nullable GraphQL list types of `T`.
  *
···
 export type Resolver<
   ParentData = DataFields,
   Args = Variables,
-  Result = ResolverResult
+  Result = ResolverResult,
 > = {
   bivarianceHack(
     parent: ParentData,
···
  */
 export type OptimisticMutationResolver<
   Args = Variables,
-  Result = Link<Data> | Scalar
+  Result = Link<Data> | Scalar,
 > = {
   bivarianceHack(
     args: Args,

exchanges/persisted/src/persistedExchange.ts

···
   pipe,
 } from 'wonka';
 
-import {
-  makeOperation,
-  stringifyDocument,
+import type {
   PersistedRequestExtensions,
   TypedDocumentNode,
   OperationResult,
···
   Operation,
   OperationContext,
 } from '@urql/core';
+import { makeOperation, stringifyDocument } from '@urql/core';
 
 import { hash } from './sha256';
 

exchanges/persisted/src/test-utils.ts

···
-import {
-  gql,
-  GraphQLRequest,
-  OperationContext,
-  Operation,
-  makeOperation,
-} from '@urql/core';
+import type { GraphQLRequest, OperationContext, Operation } from '@urql/core';
+import { gql, makeOperation } from '@urql/core';
 
 const context: OperationContext = {
   fetchOptions: {

exchanges/populate/src/helpers/node.ts

···
-import {
-  NameNode,
-  GraphQLOutputType,
-  isWrappingType,
-  GraphQLWrappingType,
-  Kind,
-} from 'graphql';
+import type { NameNode, GraphQLOutputType, GraphQLWrappingType } from 'graphql';
+import { isWrappingType, Kind } from 'graphql';
 
 export type GraphQLFlatType = Exclude<GraphQLOutputType, GraphQLWrappingType>;
 

exchanges/populate/src/helpers/traverse.ts

···
-import {
+import type {
   SelectionNode,
-  Kind,
   ASTNode,
   DefinitionNode,
   GraphQLSchema,
   GraphQLFieldMap,
-  isAbstractType,
   FragmentDefinitionNode,
   FragmentSpreadNode,
 } from 'graphql';
+import { Kind, isAbstractType } from 'graphql';
 import { unwrapType, getName } from './node';
 
 export function traverse(

exchanges/populate/src/populateExchange.ts

···
-import {
-  buildClientSchema,
+import type {
   FragmentDefinitionNode,
   IntrospectionQuery,
-  isAbstractType,
-  Kind,
-  GraphQLObjectType,
   SelectionNode,
   GraphQLInterfaceType,
-  valueFromASTUntyped,
-  GraphQLScalarType,
   FieldNode,
   InlineFragmentNode,
   FragmentSpreadNode,
   ArgumentNode,
 } from 'graphql';
+import {
+  buildClientSchema,
+  isAbstractType,
+  Kind,
+  GraphQLObjectType,
+  valueFromASTUntyped,
+  GraphQLScalarType,
+} from 'graphql';
 import { pipe, tap, map } from 'wonka';
-import { Exchange, Operation, stringifyVariables } from '@urql/core';
+import type { Exchange, Operation } from '@urql/core';
+import { stringifyVariables } from '@urql/core';
 
-import { getName, GraphQLFlatType, unwrapType } from './helpers/node';
+import type { GraphQLFlatType } from './helpers/node';
+import { getName, unwrapType } from './helpers/node';
 import { traverse } from './helpers/traverse';
 
 /** Configuration options for the {@link populateExchange}'s behaviour */

exchanges/refocus/src/refocusExchange.ts

···
 import { pipe, tap } from 'wonka';
-import { Exchange, Operation } from '@urql/core';
+import type { Exchange, Operation } from '@urql/core';
 
 /** Exchange factory that reexecutes operations after a user returns to the tab.
  *

exchanges/request-policy/src/requestPolicyExchange.ts

···
-import {
-  makeOperation,
-  Operation,
-  OperationResult,
-  Exchange,
-} from '@urql/core';
+import type { Operation, OperationResult, Exchange } from '@urql/core';
+import { makeOperation } from '@urql/core';
 import { pipe, tap, map } from 'wonka';
 
 const defaultTTL = 5 * 60 * 1000;

exchanges/retry/src/retryExchange.ts

···
   takeUntil,
 } from 'wonka';
 
-import { makeOperation, Exchange, Operation, CombinedError } from '@urql/core';
+import type { Exchange, Operation, CombinedError } from '@urql/core';
+import { makeOperation } from '@urql/core';
 
 /** Input parameters for the {@link retryExchange}. */
 export interface RetryExchangeOptions {

package.json

···
     "@rollup/plugin-terser": "^0.4.1",
     "@rollup/pluginutils": "^5.0.2",
     "@types/node": "^18.16.3",
-    "@typescript-eslint/eslint-plugin": "^5.59.1",
-    "@typescript-eslint/parser": "^5.59.1",
+    "@typescript-eslint/eslint-plugin": "^6.2.1",
+    "@typescript-eslint/parser": "^6.2.1",
     "cypress": "^12.8.1",
     "dotenv": "^16.0.3",
-    "eslint": "^8.39.0",
-    "eslint-config-prettier": "^8.8.0",
+    "eslint": "^8.46.0",
+    "eslint-config-prettier": "^8.9.0",
     "eslint-plugin-es5": "^1.5.0",
-    "eslint-plugin-prettier": "^4.2.1",
-    "eslint-plugin-react": "^7.32.2",
+    "eslint-plugin-prettier": "^5.0.0",
+    "eslint-plugin-react": "^7.33.1",
     "eslint-plugin-react-hooks": "^4.6.0",
     "execa": "^7.1.1",
     "glob": "^9.3.0",
···
     "lint-staged": "^13.2.2",
     "npm-packlist": "^7.0.4",
     "npm-run-all": "^4.1.5",
-    "prettier": "^2.8.8",
+    "prettier": "^3.0.0",
     "react": "^17.0.2",
     "react-dom": "^17.0.2",
     "react-is": "^17.0.2",
···
     "rollup-plugin-visualizer": "^5.9.0",
     "tar": "^6.1.13",
     "terser": "^5.17.1",
-    "typescript": "^5.0.4",
+    "typescript": "^5.1.6",
     "vite": "^3.2.4",
     "vite-tsconfig-paths": "^4.2.0",
     "vitest": "^0.30.1"

packages/core/src/client.ts

···
 /* eslint-disable @typescript-eslint/no-use-before-define */
 
+import type { Source, Subscription } from 'wonka';
 import {
   lazy,
   filter,
···
   onStart,
   pipe,
   share,
-  Source,
   take,
   takeUntil,
   takeWhile,
···
   fromValue,
   merge,
   map,
-  Subscription,
 } from 'wonka';
 
 import { composeExchanges } from './exchanges';
 import { fallbackExchange } from './exchanges/fallback';
 
-import {
+import type {
   DocumentInput,
   AnyVariables,
   Exchange,
···
    */
   createRequestOperation<
     Data = any,
-    Variables extends AnyVariables = AnyVariables
+    Variables extends AnyVariables = AnyVariables,
   >(
     kind: OperationType,
     request: GraphQLRequest<Data, Variables>,
···
    */
   executeRequestOperation<
     Data = any,
-    Variables extends AnyVariables = AnyVariables
+    Variables extends AnyVariables = AnyVariables,
   >(
     operation: Operation<Data, Variables>
   ): OperationResultSource<OperationResult<Data, Variables>>;
···
    */
   executeSubscription<
     Data = any,
-    Variables extends AnyVariables = AnyVariables
+    Variables extends AnyVariables = AnyVariables,
   >(
     query: GraphQLRequest<Data, Variables>,
     opts?: Partial<OperationContext> | undefined

packages/core/src/exchanges/cache.ts

···
 /* eslint-disable @typescript-eslint/no-use-before-define */
 import { filter, map, merge, pipe, tap } from 'wonka';
 
-import { Client } from '../client';
-import { Exchange, Operation, OperationResult } from '../types';
+import type { Client } from '../client';
+import type { Exchange, Operation, OperationResult } from '../types';
 
 import {
   makeOperation,

packages/core/src/exchanges/debug.ts

···
 import { pipe, tap } from 'wonka';
-import { Exchange } from '../types';
+import type { Exchange } from '../types';
 
 /** Simple log debugger exchange.
  *

packages/core/src/exchanges/dedup.ts

···
-import { Exchange } from '../types';
+import type { Exchange } from '../types';
 
 /** Default deduplication exchange.
  * @deprecated

packages/core/src/exchanges/fallback.ts

···
 import { filter, pipe, tap } from 'wonka';
-import { ExchangeIO, ExchangeInput } from '../types';
+import type { ExchangeIO, ExchangeInput } from '../types';
 
 /** Used by the `Client` as the last exchange to warn about unhandled operations.
  *

packages/core/src/exchanges/fetch.ts

···
 /* eslint-disable @typescript-eslint/no-use-before-define */
 import { filter, merge, mergeMap, pipe, takeUntil, onPush } from 'wonka';
 
-import { Exchange } from '../types';
+import type { Exchange } from '../types';
 import {
   makeFetchBody,
   makeFetchURL,

packages/core/src/exchanges/map.ts

···
 import { mergeMap, fromValue, fromPromise, pipe } from 'wonka';
-import { Operation, OperationResult, Exchange } from '../types';
-import { CombinedError } from '../utils';
+import type { Operation, OperationResult, Exchange } from '../types';
+import type { CombinedError } from '../utils';
 
 /** Options for the `mapExchange` allowing it to react to incoming operations, results, or errors. */
 export interface MapExchangeOpts {

packages/core/src/exchanges/ssr.ts

···
 import type { GraphQLError } from '../utils/graphql';
 import { pipe, filter, merge, map, tap } from 'wonka';
-import { Exchange, OperationResult, Operation } from '../types';
+import type { Exchange, OperationResult, Operation } from '../types';
 import { addMetadata, CombinedError } from '../utils';
 import { reexecuteOperation, mapTypeNames } from './cache';
 

packages/core/src/exchanges/subscription.ts

···
-import {
-  filter,
-  make,
-  merge,
-  mergeMap,
-  pipe,
-  Subscription,
-  Source,
-  takeUntil,
-} from 'wonka';
+import type { Subscription, Source } from 'wonka';
+import { filter, make, merge, mergeMap, pipe, takeUntil } from 'wonka';
 
 import {
   makeResult,
···
   makeOperation,
 } from '../utils';
 
-import {
+import type {
   Exchange,
   ExecutionResult,
   Operation,
   OperationResult,
 } from '../types';
 
-import { FetchBody, makeFetchBody } from '../internal';
+import type { FetchBody } from '../internal';
+import { makeFetchBody } from '../internal';
 
 /** An abstract observer-like interface.
  *

packages/core/src/gql.test.ts

···
 
 it('interpolates nested GraphQL Documents', () => {
   expect(
-    print(
-      gql`
-        query {
-          ...Query
-        }
+    print(gql`
+      query {
+        ...Query
+      }
 
-        ${gql`
-          fragment Query on Query {
-            field
-          }
-        `}
-      `
-    )
+      ${gql`
+        fragment Query on Query {
+          field
+        }
+      `}
+    `)
   ).toMatchInlineSnapshot(`
     "{
       ...Query

packages/core/src/gql.ts

···
 /* eslint-disable prefer-rest-params */
 import { Kind } from '@0no-co/graphql.web';
 import type { DocumentNode, DefinitionNode } from './utils/graphql';
-import { AnyVariables, TypedDocumentNode } from './types';
+import type { AnyVariables, TypedDocumentNode } from './types';
 import { keyDocument, stringifyDocument } from './utils';
 
 /** A GraphQL parse function, which may be called as a tagged template literal, returning a parsed {@link DocumentNode}.

packages/core/src/internal/fetchOptions.ts

···
   extractFiles,
 } from '../utils';
 
-import { AnyVariables, GraphQLRequest, Operation } from '../types';
+import type { AnyVariables, GraphQLRequest, Operation } from '../types';
 
 /** Abstract definition of the JSON data sent during GraphQL HTTP POST requests. */
 export interface FetchBody {
···
  */
 export function makeFetchBody<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 >(request: Omit<GraphQLRequest<Data, Variables>, 'key'>): FetchBody {
   const isAPQ =
     request.extensions &&

packages/core/src/internal/fetchSource.ts

···
  * and `split` are the common, cross-compatible base implementations.
  */
 
-import { Source, fromAsyncIterable, onEnd, filter, pipe } from 'wonka';
-import { Operation, OperationResult, ExecutionResult } from '../types';
+import type { Source } from 'wonka';
+import { fromAsyncIterable, onEnd, filter, pipe } from 'wonka';
+import type { Operation, OperationResult, ExecutionResult } from '../types';
 import { makeResult, makeErrorResult, mergeResultPatch } from '../utils';
 
 const decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder() : null;
···
 ) {
   let networkMode = true;
   let result: OperationResult | null = null;
-  let response: Response | void;
+  let response: Response | undefined;
 
   try {
     // Delay for a tick to give the Client a chance to cancel the request

packages/core/src/test-utils/samples.ts

···
 import { gql } from '../gql';
 
-import {
+import type {
   ExecutionResult,
   GraphQLRequest,
   Operation,

packages/core/src/types.ts

···
   ValueNode,
   TypeNode,
 } from '@0no-co/graphql.web';
-import { Subscription, Source } from 'wonka';
-import { Client } from './client';
-import { CombinedError } from './utils/error';
+import type { Subscription, Source } from 'wonka';
+import type { Client } from './client';
+import type { CombinedError } from './utils/error';
 
 /** A GraphQL `DocumentNode` with attached generics for its result data and variables.
  *
···
  */
 export type TypedDocumentNode<
   Result = { [key: string]: any },
-  Variables = { [key: string]: any }
+  Variables = { [key: string]: any },
 > = DocumentNode & {
   /** Type to support `@graphql-typed-document-node/core`
    * @internal
···
  */
 export type DocumentInput<
   Result = { [key: string]: any },
-  Variables = { [key: string]: any }
+  Variables = { [key: string]: any },
 > = string | DocumentNode | TypedDocumentNode<Result, Variables>;
 
 /** A list of errors on {@link ExecutionResult | ExecutionResults}.
···
  */
 export interface GraphQLRequest<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > {
   /** Unique identifier for the `GraphQLRequest`.
    *
···
  */
 export type GraphQLRequestParams<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > =
   | ({
       query: DocumentInput<Data, Variables>;
···
  */
 export interface Operation<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > extends GraphQLRequest<Data, Variables> {
   /** The `OperationType` describing the kind of `Operation`.
    *
···
  */
 export interface OperationResult<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > {
   /** The [operation]{@link Operation} which has been executed. */
   /** The `Operation` which this `OperationResult` is for.

packages/core/src/utils/error.ts

···
 import { GraphQLError } from '@0no-co/graphql.web';
-import { ErrorLike } from '../types';
+import type { ErrorLike } from '../types';
 
 const generateErrorMessage = (
   networkErr?: Error,

packages/core/src/utils/formatDocument.ts

···
-import {
-  Kind,
+import type {
   FieldNode,
   SelectionNode,
   DefinitionNode,
   DirectiveNode,
 } from '@0no-co/graphql.web';
-import { KeyedDocumentNode, keyDocument } from './request';
-import { FormattedNode, TypedDocumentNode } from '../types';
+import { Kind } from '@0no-co/graphql.web';
+import type { KeyedDocumentNode } from './request';
+import { keyDocument } from './request';
+import type { FormattedNode, TypedDocumentNode } from '../types';
 
 const formatNode = <
-  T extends SelectionNode | DefinitionNode | TypedDocumentNode<any, any>
+  T extends SelectionNode | DefinitionNode | TypedDocumentNode<any, any>,
 >(
   node: T
 ): FormattedNode<T> => {

packages/core/src/utils/operation.ts

···
-import {
+import type {
   AnyVariables,
   GraphQLRequest,
   Operation,
···
  */
 function makeOperation<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 >(
   kind: OperationType,
   request: GraphQLRequest<Data, Variables>,
···
 
 function makeOperation<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 >(
   kind: OperationType,
   request: Operation<Data, Variables>,

packages/core/src/utils/request.test.ts

···
   });
 
   it('should return a valid query object with variables', () => {
-    const doc = print(
-      gql`
-        {
-          testF
-        }
-      `
-    );
+    const doc = print(gql`
+      {
+        testF
+      }
+    `);
     const val = createRequest(doc, { test: 5 });
 
     expect(print(val.query)).toBe(doc);

packages/core/src/utils/request.ts

···
 import { Kind, parse, print } from '@0no-co/graphql.web';
 import type { DocumentNode, DefinitionNode } from './graphql';
-import { HashValue, phash } from './hash';
+import type { HashValue } from './hash';
+import { phash } from './hash';
 import { stringifyVariables } from './variables';
 
 import type {
···
  */
 export const createRequest = <
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 >(
   _query: DocumentInput<Data, Variables>,
   _variables: Variables,

packages/core/src/utils/result.ts

···
-import {
+import type {
   ExecutionResult,
   Operation,
   OperationResult,

packages/core/src/utils/streamUtils.ts

···
-import { Sink, Source, subscribe, take, filter, toPromise, pipe } from 'wonka';
-import { OperationResult, OperationResultSource } from '../types';
+import type { Sink, Source } from 'wonka';
+import { subscribe, take, filter, toPromise, pipe } from 'wonka';
+import type { OperationResult, OperationResultSource } from '../types';
 
 /** Patches a `toPromise` method onto the `Source` passed to it.
  * @param source$ - the Wonka {@link Source} to patch.

packages/introspection/src/getIntrospectedSchema.ts

···
-import {
-  IntrospectionQuery,
-  GraphQLSchema,
-  parse,
-  buildSchema,
-  execute,
-  getIntrospectionQuery,
-} from 'graphql';
+import type { IntrospectionQuery, GraphQLSchema } from 'graphql';
+import { parse, buildSchema, execute, getIntrospectionQuery } from 'graphql';
 
 /** Returns an {@link IntrospectionQuery} result for a given GraphQL schema.
  *

packages/introspection/src/minifyIntrospectionQuery.ts

···
-import {
+import type {
   IntrospectionQuery,
   IntrospectionType,
   IntrospectionTypeRef,
···
           value =>
             ({
               name: value.name,
-            } as any)
+            }) as any
         ),
       };
 
···
               name: field.name,
               type: mapType(field.type),
               defaultValue: field.defaultValue || undefined,
-            } as IntrospectionInputValue)
+            }) as IntrospectionInputValue
         ),
       };
     }
···
                   name: arg.name,
                   type: mapType(arg.type),
                 })),
-            } as any)
+            }) as any
         ),
         interfaces:
           type.interfaces &&
···
                   name: arg.name,
                   type: mapType(arg.type),
                 })),
-            } as any)
+            }) as any
         ),
         interfaces:
           type.interfaces &&
···
           name: arg.name,
           type: mapType(arg.type),
           defaultValue: arg.defaultValue || undefined,
-        } as IntrospectionInputValue)
+        }) as IntrospectionInputValue
     ),
   }));
 

packages/next-urql/src/DataHydrationContext.ts

···
 import React from 'react';
 import { ServerInsertedHTMLContext } from 'next/navigation';
-import { UrqlResult } from './useUrqlValue';
+import type { UrqlResult } from './useUrqlValue';
 
 interface DataHydrationValue {
   isInjecting: boolean;

packages/next-urql/src/Provider.ts

···
 'use client';
 
 import React from 'react';
-import { Provider, SSRExchange, Client } from 'urql';
+import type { SSRExchange, Client } from 'urql';
+import { Provider } from 'urql';
 import { DataHydrationContextProvider } from './DataHydrationContext';
 
 export const SSRContext = React.createContext<SSRExchange | undefined>(

packages/next-urql/src/rsc.ts

···
 import * as React from 'react';
-import { Client } from '@urql/core';
+import type { Client } from '@urql/core';
 
 /** Function to cache an urql-client across React Server Components.
  *

packages/next-urql/src/useQuery.ts

···
 'use client';
 
-import {
+import type {
   AnyVariables,
   CombinedError,
   GraphQLRequestParams,
   Operation,
   OperationContext,
   RequestPolicy,
-  createRequest,
-  useQuery as orig_useQuery,
 } from 'urql';
+import { createRequest, useQuery as orig_useQuery } from 'urql';
 import { useUrqlValue } from './useUrqlValue';
 
 /** Input arguments for the {@link useQuery} hook.
···
  */
 export type UseQueryArgs<
   Variables extends AnyVariables = AnyVariables,
-  Data = any
+  Data = any,
 > = {
   /** Updates the {@link RequestPolicy} for the executed GraphQL query operation.
    *
···
  */
 export interface UseQueryState<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > {
   /** Indicates whether `useQuery` is waiting for a new result.
    *
···
  */
 export type UseQueryResponse<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > = [UseQueryState<Data, Variables>, UseQueryExecute];
 
 /** Hook to run a GraphQL query and get updated GraphQL results.
···
  */
 export function useQuery<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 >(args: UseQueryArgs<Variables, Data>): UseQueryResponse<Data, Variables> {
   const request = createRequest(
     args.query,

packages/preact-urql/src/components/Mutation.ts

···
-import { VNode } from 'preact';
-import { AnyVariables, DocumentInput } from '@urql/core';
+import type { VNode } from 'preact';
+import type { AnyVariables, DocumentInput } from '@urql/core';
 
-import { useMutation, UseMutationState, UseMutationExecute } from '../hooks';
+import type { UseMutationState, UseMutationExecute } from '../hooks';
+import { useMutation } from '../hooks';
 
 /** Props accepted by {@link Mutation}.
  *
···
  */
 export interface MutationProps<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > {
   /* The GraphQL mutation document that {@link useMutation} will execute. */
   query: DocumentInput<Data, Variables>;
···
  */
 export interface MutationState<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > extends UseMutationState<Data, Variables> {
   /** Alias to {@link useMutation}’s `executeMutation` function. */
   executeMutation: UseMutationExecute<Data, Variables>;
···
  */
 export function Mutation<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 >(props: MutationProps<Data, Variables>): VNode<any> {
   const mutation = useMutation<Data, Variables>(props.query);
   return props.children({ ...mutation[0], executeMutation: mutation[1] });

packages/preact-urql/src/components/Query.ts

···
-import { VNode } from 'preact';
-import { AnyVariables } from '@urql/core';
+import type { VNode } from 'preact';
+import type { AnyVariables } from '@urql/core';
 
-import {
-  useQuery,
-  UseQueryArgs,
-  UseQueryState,
-  UseQueryExecute,
-} from '../hooks';
+import type { UseQueryArgs, UseQueryState, UseQueryExecute } from '../hooks';
+import { useQuery } from '../hooks';
 
 /** Props accepted by {@link Query}.
  *
···
  */
 export type QueryProps<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > = UseQueryArgs<Variables, Data> & {
   children(arg: QueryState<Data, Variables>): VNode<any>;
 };
···
  */
 export interface QueryState<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > extends UseQueryState<Data, Variables> {
   /** Alias to {@link useQuery}’s `executeQuery` function. */
   executeQuery: UseQueryExecute;
···
  */
 export function Query<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 >(props: QueryProps<Data, Variables>): VNode<any> {
   const query = useQuery<Data, Variables>(props);
   return props.children({ ...query[0], executeQuery: query[1] });

packages/preact-urql/src/components/Subscription.ts

···
-import { VNode } from 'preact';
-import { AnyVariables } from '@urql/core';
+import type { VNode } from 'preact';
+import type { AnyVariables } from '@urql/core';
 
-import {
-  useSubscription,
+import type {
   UseSubscriptionArgs,
   UseSubscriptionState,
   UseSubscriptionExecute,
   SubscriptionHandler,
 } from '../hooks';
+import { useSubscription } from '../hooks';
 
 /** Props accepted by {@link Subscription}.
  *
···
 export type SubscriptionProps<
   Data = any,
   Result = Data,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > = UseSubscriptionArgs<Variables, Data> & {
   /** Accepts the {@link SubscriptionHandler} as a prop. */
   handler?: SubscriptionHandler<Data, Result>;
···
  */
 export interface SubscriptionState<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > extends UseSubscriptionState<Data, Variables> {
   /** Alias to {@link useSubscription}’s `executeMutation` function. */
   executeSubscription: UseSubscriptionExecute;
···
 export function Subscription<
   Data = any,
   Result = Data,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 >(props: SubscriptionProps<Data, Result, Variables>): VNode<any> {
   const subscription = useSubscription<Data, Result, Variables>(
     props,

packages/preact-urql/src/context.ts

···
 import { createContext } from 'preact';
 import { useContext } from 'preact/hooks';
-import { Client } from '@urql/core';
+import type { Client } from '@urql/core';
 
 const OBJ = {};
 

packages/preact-urql/src/hooks/useMutation.ts

···
 import { useState, useCallback, useRef, useEffect } from 'preact/hooks';
 import { pipe, onPush, filter, toPromise, take } from 'wonka';
 
-import {
+import type {
   AnyVariables,
   DocumentInput,
   OperationResult,
   OperationContext,
   CombinedError,
-  createRequest,
   Operation,
 } from '@urql/core';
+import { createRequest } from '@urql/core';
 
 import { useClient } from '../context';
 import { initialState } from './constants';
···
  */
 export interface UseMutationState<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > {
   /** Indicates whether `useMutation` is currently executing a mutation. */
   fetching: boolean;
···
  */
 export type UseMutationExecute<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > = (
   variables: Variables,
   context?: Partial<OperationContext>
···
  */
 export type UseMutationResponse<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > = [UseMutationState<Data, Variables>, UseMutationExecute<Data, Variables>];
 
 /** Hook to create a GraphQL mutation, run by passing variables to the returned execute function.
···
  */
 export function useMutation<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 >(query: DocumentInput<Data, Variables>): UseMutationResponse<Data, Variables> {
   const isMounted = useRef(true);
   const client = useClient();

packages/preact-urql/src/hooks/useQuery.ts

···
 import { useEffect, useCallback, useMemo } from 'preact/hooks';
 
+import type { Source } from 'wonka';
 import {
-  Source,
   pipe,
   share,
   takeWhile,
···
   scan,
 } from 'wonka';
 
-import {
+import type {
   Client,
   GraphQLRequestParams,
   AnyVariables,
···
  */
 export type UseQueryArgs<
   Variables extends AnyVariables = AnyVariables,
-  Data = any
+  Data = any,
 > = {
   /** Updates the {@link RequestPolicy} for the executed GraphQL query operation.
    *
···
  */
 export interface UseQueryState<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > {
   /** Indicates whether `useQuery` is waiting for a new result.
    *
···
  */
 export type UseQueryResponse<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > = [UseQueryState<Data, Variables>, UseQueryExecute];
 
 /** Convert the Source to a React Suspense source on demand
···
  */
 export function useQuery<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 >(args: UseQueryArgs<Variables, Data>): UseQueryResponse<Data, Variables> {
   const client = useClient();
   // This creates a request which will keep a stable reference

packages/preact-urql/src/hooks/useRequest.ts

···
-import { DocumentNode } from 'graphql';
+import type { DocumentNode } from 'graphql';
 import { useRef, useMemo } from 'preact/hooks';
-import {
+import type {
   AnyVariables,
   TypedDocumentNode,
   GraphQLRequest,
-  createRequest,
 } from '@urql/core';
+import { createRequest } from '@urql/core';
 
 /** Creates a request from a query and variables but preserves reference equality if the key isn't changing
  * @internal
  */
 export function useRequest<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 >(
   query: string | DocumentNode | TypedDocumentNode<Data, Variables>,
   variables: Variables

packages/preact-urql/src/hooks/useSource.ts

···
 
 import { useMemo, useEffect, useState } from 'preact/hooks';
 
-import { Source, fromValue, makeSubject, pipe, concat, subscribe } from 'wonka';
+import type { Source } from 'wonka';
+import { fromValue, makeSubject, pipe, concat, subscribe } from 'wonka';
 
 type Updater<T> = (input: T) => void;
 

packages/preact-urql/src/hooks/useSubscription.ts

···
 import { useEffect, useCallback, useRef, useMemo } from 'preact/hooks';
 import { pipe, concat, fromValue, switchMap, map, scan } from 'wonka';
 
-import {
+import type {
   AnyVariables,
   GraphQLRequestParams,
   CombinedError,
···
  */
 export type UseSubscriptionArgs<
   Variables extends AnyVariables = AnyVariables,
-  Data = any
+  Data = any,
 > = {
   /** Prevents {@link useSubscription} from automatically starting GraphQL subscriptions.
    *
···
  */
 export interface UseSubscriptionState<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > {
   /** Indicates whether `useSubscription`’s subscription is active.
    *
···
  */
 export type UseSubscriptionResponse<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > = [UseSubscriptionState<Data, Variables>, UseSubscriptionExecute];
 
 /** Hook to run a GraphQL subscription and get updated GraphQL results.
···
 export function useSubscription<
   Data = any,
   Result = Data,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 >(
   args: UseSubscriptionArgs<Variables, Data>,
   handler?: SubscriptionHandler<Data, Result>

packages/react-urql/src/components/Mutation.ts

···
-import { ReactElement } from 'react';
-import { AnyVariables, DocumentInput } from '@urql/core';
+import type { ReactElement } from 'react';
+import type { AnyVariables, DocumentInput } from '@urql/core';
 
-import { useMutation, UseMutationState, UseMutationExecute } from '../hooks';
+import type { UseMutationState, UseMutationExecute } from '../hooks';
+import { useMutation } from '../hooks';
 
 /** Props accepted by {@link Mutation}.
  *
···
  */
 export interface MutationProps<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > {
   /* The GraphQL mutation document that {@link useMutation} will execute. */
   query: DocumentInput<Data, Variables>;
···
  */
 export interface MutationState<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > extends UseMutationState<Data, Variables> {
   /** Alias to {@link useMutation}’s `executeMutation` function. */
   executeMutation: UseMutationExecute<Data, Variables>;
···
  */
 export function Mutation<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 >(props: MutationProps<Data, Variables>): ReactElement<any> {
   const mutation = useMutation<Data, Variables>(props.query);
   return props.children({ ...mutation[0], executeMutation: mutation[1] });

packages/react-urql/src/components/Query.ts

···
-import { ReactElement } from 'react';
-import { AnyVariables } from '@urql/core';
+import type { ReactElement } from 'react';
+import type { AnyVariables } from '@urql/core';
 
-import {
-  useQuery,
-  UseQueryArgs,
-  UseQueryState,
-  UseQueryExecute,
-} from '../hooks';
+import type { UseQueryArgs, UseQueryState, UseQueryExecute } from '../hooks';
+import { useQuery } from '../hooks';
 
 /** Props accepted by {@link Query}.
  *
···
  */
 export type QueryProps<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > = UseQueryArgs<Variables, Data> & {
   children(arg: QueryState<Data, Variables>): ReactElement<any>;
 };
···
  */
 export interface QueryState<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > extends UseQueryState<Data, Variables> {
   /** Alias to {@link useQuery}’s `executeQuery` function. */
   executeQuery: UseQueryExecute;
···
  */
 export function Query<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 >(props: QueryProps<Data, Variables>): ReactElement<any> {
   const query = useQuery<Data, Variables>(props);
   return props.children({ ...query[0], executeQuery: query[1] });

packages/react-urql/src/components/Subscription.ts

···
-import { ReactElement } from 'react';
-import { AnyVariables } from '@urql/core';
+import type { ReactElement } from 'react';
+import type { AnyVariables } from '@urql/core';
 
-import {
-  useSubscription,
+import type {
   UseSubscriptionArgs,
   UseSubscriptionState,
   UseSubscriptionExecute,
   SubscriptionHandler,
 } from '../hooks';
+import { useSubscription } from '../hooks';
 
 /** Props accepted by {@link Subscription}.
  *
···
 export type SubscriptionProps<
   Data = any,
   Result = Data,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > = UseSubscriptionArgs<Variables, Data> & {
   handler?: SubscriptionHandler<Data, Result>;
   children(arg: SubscriptionState<Result, Variables>): ReactElement<any>;
···
  */
 export interface SubscriptionState<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > extends UseSubscriptionState<Data, Variables> {
   /** Alias to {@link useSubscription}’s `executeMutation` function. */
   executeSubscription: UseSubscriptionExecute;
···
 export function Subscription<
   Data = any,
   Result = Data,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 >(props: SubscriptionProps<Data, Result, Variables>): ReactElement<any> {
   const subscription = useSubscription<Data, Result, Variables>(
     props,

packages/react-urql/src/context.ts

···
 import * as React from 'react';
-import { Client } from '@urql/core';
+import type { Client } from '@urql/core';
 
 const OBJ = {};
 

packages/react-urql/src/hooks/cache.ts

···
 import { pipe, subscribe } from 'wonka';
-import { Client, OperationResult } from '@urql/core';
+import type { Client, OperationResult } from '@urql/core';
 
 type CacheEntry = OperationResult | Promise<unknown> | undefined;
 

packages/react-urql/src/hooks/useMutation.ts

···
 import * as React from 'react';
 import { pipe, onPush, filter, toPromise, take } from 'wonka';
 
-import {
+import type {
   AnyVariables,
   DocumentInput,
   OperationResult,
   OperationContext,
   CombinedError,
-  createRequest,
   Operation,
 } from '@urql/core';
+import { createRequest } from '@urql/core';
 
 import { useClient } from '../context';
 import { deferDispatch, initialState } from './state';
···
  */
 export interface UseMutationState<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > {
   /** Indicates whether `useMutation` is currently executing a mutation. */
   fetching: boolean;
···
  */
 export type UseMutationExecute<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > = (
   variables: Variables,
   context?: Partial<OperationContext>
···
  */
 export type UseMutationResponse<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > = [UseMutationState<Data, Variables>, UseMutationExecute<Data, Variables>];
 
 /** Hook to create a GraphQL mutation, run by passing variables to the returned execute function.
···
  */
 export function useMutation<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 >(query: DocumentInput<Data, Variables>): UseMutationResponse<Data, Variables> {
   const isMounted = React.useRef(true);
   const client = useClient();

packages/react-urql/src/hooks/useQuery.ts

···
 /* eslint-disable react-hooks/exhaustive-deps */
 
-import { Source, pipe, subscribe, onEnd, onPush, takeWhile } from 'wonka';
+import type { Source } from 'wonka';
+import { pipe, subscribe, onEnd, onPush, takeWhile } from 'wonka';
 import * as React from 'react';
 
-import {
+import type {
   GraphQLRequestParams,
   AnyVariables,
   Client,
···
  */
 export type UseQueryArgs<
   Variables extends AnyVariables = AnyVariables,
-  Data = any
+  Data = any,
 > = {
   /** Updates the {@link RequestPolicy} for the executed GraphQL query operation.
    *
···
  */
 export interface UseQueryState<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > {
   /** Indicates whether `useQuery` is waiting for a new result.
    *
···
  */
 export type UseQueryResponse<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > = [UseQueryState<Data, Variables>, UseQueryExecute];
 
 const isSuspense = (client: Client, context?: Partial<OperationContext>) =>
···
  */
 export function useQuery<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 >(args: UseQueryArgs<Variables, Data>): UseQueryResponse<Data, Variables> {
   const client = useClient();
   const cache = getCacheForClient(client);

packages/react-urql/src/hooks/useRequest.ts

···
 import * as React from 'react';
-import {
-  AnyVariables,
-  DocumentInput,
-  GraphQLRequest,
-  createRequest,
-} from '@urql/core';
+import type { AnyVariables, DocumentInput, GraphQLRequest } from '@urql/core';
+import { createRequest } from '@urql/core';
 
 /** Creates a request from a query and variables but preserves reference equality if the key isn't changing
  * @internal
  */
 export function useRequest<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 >(
   query: DocumentInput<Data, Variables>,
   variables: Variables

packages/react-urql/src/hooks/useSubscription.ts

···
 import { pipe, subscribe, onEnd } from 'wonka';
 import * as React from 'react';
 
-import {
+import type {
   GraphQLRequestParams,
   AnyVariables,
   CombinedError,
···
  */
 export type UseSubscriptionArgs<
   Variables extends AnyVariables = AnyVariables,
-  Data = any
+  Data = any,
 > = {
   /** Prevents {@link useSubscription} from automatically starting GraphQL subscriptions.
    *
···
  */
 export interface UseSubscriptionState<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > {
   /** Indicates whether `useSubscription`’s subscription is active.
    *
···
  */
 export type UseSubscriptionResponse<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > = [UseSubscriptionState<Data, Variables>, UseSubscriptionExecute];
 
 /** Hook to run a GraphQL subscription and get updated GraphQL results.
···
 export function useSubscription<
   Data = any,
   Result = Data,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 >(
   args: UseSubscriptionArgs<Variables, Data>,
   handler?: SubscriptionHandler<Data, Result>

packages/site/plugins/react-router/browser.api.js

···
         </PreviousRoot>
       );
     },
-  Routes: PreviousRoutes => props =>
-    (
-      <Location>
-        {location => <PreviousRoutes {...props} location={location} />}
-      </Location>
-    ),
+  Routes: PreviousRoutes => props => (
+    <Location>
+      {location => <PreviousRoutes {...props} location={location} />}
+    </Location>
+  ),
 });
 
 export default ReactRouterPlugin;

packages/storage-rn/src/makeAsyncStorage.ts

···
-import { StorageAdapter } from '@urql/exchange-graphcache';
+import type { StorageAdapter } from '@urql/exchange-graphcache';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import NetInfo from '@react-native-community/netinfo';
 

packages/svelte-urql/src/common.ts

···
 import type { Readable, Writable } from 'svelte/store';
 import type { AnyVariables, OperationResult } from '@urql/core';
-import { Source, make } from 'wonka';
+import type { Source } from 'wonka';
+import { make } from 'wonka';
 
 /** An {@link OperationResult} with an added {@link OperationResultState.fetching} flag.
  *
···
  */
 export interface OperationResultState<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > extends OperationResult<Data, Variables> {
   /** Indicates whether the store is waiting for a new {@link OperationResult}.
    *
···
 /** A Readable store of {@link OperationResultState}. */
 export type OperationResultStore<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > = Readable<OperationResultState<Data, Variables>>;
 
 /** Consumes a {@link Readable} as a {@link Source}.

packages/svelte-urql/src/context.ts

···
 import { setContext, getContext } from 'svelte';
-import { Client, ClientOptions } from '@urql/core';
+import type { ClientOptions } from '@urql/core';
+import { Client } from '@urql/core';
 
 const _contextKey = '$$_urql';
 

packages/svelte-urql/src/mutationStore.ts

···
 import { pipe, map, scan, subscribe } from 'wonka';
 import { derived, writable } from 'svelte/store';
 
-import {
+import type {
   AnyVariables,
   GraphQLRequestParams,
   Client,
   OperationContext,
-  createRequest,
 } from '@urql/core';
+import { createRequest } from '@urql/core';
 
-import {
-  OperationResultState,
-  OperationResultStore,
-  initialResult,
-} from './common';
+import type { OperationResultState, OperationResultStore } from './common';
+import { initialResult } from './common';
 
 /** Input arguments for the {@link mutationStore} function.
  *
···
  */
 export type MutationArgs<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > = {
   /** The {@link Client} using which the subscription will be started.
    *
···
  */
 export function mutationStore<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 >(args: MutationArgs<Data, Variables>): OperationResultStore<Data, Variables> {
   const request = createRequest(args.query, args.variables as Variables);
   const operation = args.client.createRequestOperation(

packages/svelte-urql/src/queryStore.ts

···
-import {
+import type {
   Client,
   GraphQLRequestParams,
   AnyVariables,
   OperationContext,
   RequestPolicy,
-  createRequest,
 } from '@urql/core';
+import { createRequest } from '@urql/core';
 
+import type { Source } from 'wonka';
 import {
-  Source,
   pipe,
   map,
   fromValue,
···
 
 import { derived, writable } from 'svelte/store';
 
-import {
+import type {
   OperationResultState,
   OperationResultStore,
   Pausable,
-  initialResult,
-  createPausable,
-  fromStore,
 } from './common';
+import { initialResult, createPausable, fromStore } from './common';
 
 /** Input arguments for the {@link queryStore} function.
  *
···
  */
 export type QueryArgs<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > = {
   /** The {@link Client} using which the query will be executed.
    *
···
  */
 export function queryStore<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 >(
   args: QueryArgs<Data, Variables>
 ): OperationResultStore<Data, Variables> & Pausable {

packages/svelte-urql/src/subscriptionStore.ts

···
-import {
+import type {
   AnyVariables,
   GraphQLRequestParams,
   Client,
   OperationContext,
-  createRequest,
 } from '@urql/core';
+import { createRequest } from '@urql/core';
 
+import type { Source } from 'wonka';
 import {
-  Source,
   pipe,
   map,
   fromValue,
···
 
 import { derived, writable } from 'svelte/store';
 
-import {
+import type {
   OperationResultState,
   OperationResultStore,
   Pausable,
-  initialResult,
-  createPausable,
-  fromStore,
 } from './common';
+import { initialResult, createPausable, fromStore } from './common';
 
 /** Combines previous data with an incoming subscription result’s data.
  *
···
  */
 export type SubscriptionArgs<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > = {
   /** The {@link Client} using which the subscription will be started.
    *
···
 export function subscriptionStore<
   Data,
   Result = Data,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 >(
   args: SubscriptionArgs<Data, Variables>,
   handler?: SubscriptionHandler<Data, Result>

packages/vue-urql/src/useClient.ts

···
-import { App, getCurrentInstance, inject, provide, Ref, isRef, ref } from 'vue';
-import { Client, ClientOptions } from '@urql/core';
+import type { App, Ref } from 'vue';
+import { getCurrentInstance, inject, provide, isRef, ref } from 'vue';
+import type { ClientOptions } from '@urql/core';
+import { Client } from '@urql/core';
 
 const clientsPerInstance = new WeakMap<{}, Ref<Client>>();
 

packages/vue-urql/src/useClientHandle.ts

···
-import { DocumentNode } from 'graphql';
-import { AnyVariables, Client, TypedDocumentNode } from '@urql/core';
-import {
-  WatchStopHandle,
-  getCurrentInstance,
-  onMounted,
-  onBeforeUnmount,
-} from 'vue';
+import type { DocumentNode } from 'graphql';
+import type { AnyVariables, Client, TypedDocumentNode } from '@urql/core';
+import type { WatchStopHandle } from 'vue';
+import { getCurrentInstance, onMounted, onBeforeUnmount } from 'vue';
 
 import { useClient } from './useClient';
 
-import { callUseQuery, UseQueryArgs, UseQueryResponse } from './useQuery';
+import type { UseQueryArgs, UseQueryResponse } from './useQuery';
+import { callUseQuery } from './useQuery';
 
-import { callUseMutation, UseMutationResponse } from './useMutation';
+import type { UseMutationResponse } from './useMutation';
+import { callUseMutation } from './useMutation';
 
-import {
-  callUseSubscription,
+import type {
   UseSubscriptionArgs,
   SubscriptionHandlerArg,
   UseSubscriptionResponse,
 } from './useSubscription';
+import { callUseSubscription } from './useSubscription';
 
 /** Handle to create GraphQL operations outside of Vue’s `setup` functions.
  *

packages/vue-urql/src/useMutation.test.ts

···
       );
 
     const mutation = reactive(
-      useMutation(
-        gql`
-          mutation {
-            test
-          }
-        `
-      )
+      useMutation(gql`
+        mutation {
+          test
+        }
+      `)
     );
 
     expect(mutation).toMatchObject({

packages/vue-urql/src/useMutation.ts

···
 /* eslint-disable react-hooks/rules-of-hooks */
 
-import { ref, Ref } from 'vue';
-import { DocumentNode } from 'graphql';
+import type { Ref } from 'vue';
+import { ref } from 'vue';
+import type { DocumentNode } from 'graphql';
 import { pipe, onPush, filter, toPromise, take } from 'wonka';
 
-import {
+import type {
   Client,
   AnyVariables,
   TypedDocumentNode,
···
   Operation,
   OperationContext,
   OperationResult,
-  createRequest,
 } from '@urql/core';
+import { createRequest } from '@urql/core';
 
 import { useClient } from './useClient';
 import { unwrapPossibleProxy } from './utils';

packages/vue-urql/src/useQuery.ts

···
 /* eslint-disable react-hooks/rules-of-hooks */
 
-import {
-  WatchStopHandle,
-  Ref,
-  shallowRef,
-  ref,
-  watchEffect,
-  reactive,
-  isRef,
-} from 'vue';
+import type { WatchStopHandle, Ref } from 'vue';
+import { shallowRef, ref, watchEffect, reactive, isRef } from 'vue';
 
-import { Subscription, Source, pipe, subscribe, onEnd } from 'wonka';
+import type { Subscription, Source } from 'wonka';
+import { pipe, subscribe, onEnd } from 'wonka';
 
-import {
+import type {
   Client,
   AnyVariables,
   OperationResult,
···
   OperationContext,
   RequestPolicy,
   Operation,
-  createRequest,
 } from '@urql/core';
+import { createRequest } from '@urql/core';
 
 import { useClient } from './useClient';
 import { unwrapPossibleProxy, updateShallowRef } from './utils';
···
  */
 export type UseQueryArgs<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > = {
   /** Updates the {@link RequestPolicy} for the executed GraphQL query operation.
    *
···
  */
 export type UseQueryResponse<
   T,
-  V extends AnyVariables = AnyVariables
+  V extends AnyVariables = AnyVariables,
 > = UseQueryState<T, V> & PromiseLike<UseQueryState<T, V>>;
 
 const watchOptions = {

packages/vue-urql/src/useSubscription.ts

···
 /* eslint-disable react-hooks/rules-of-hooks */
 
-import { Source, pipe, subscribe, onEnd } from 'wonka';
+import type { Source } from 'wonka';
+import { pipe, subscribe, onEnd } from 'wonka';
 
-import {
-  WatchStopHandle,
-  Ref,
-  ref,
-  shallowRef,
-  watchEffect,
-  reactive,
-  isRef,
-} from 'vue';
+import type { WatchStopHandle, Ref } from 'vue';
+import { ref, shallowRef, watchEffect, reactive, isRef } from 'vue';
 
-import {
+import type {
   Client,
   GraphQLRequestParams,
   AnyVariables,
···
   CombinedError,
   OperationContext,
   Operation,
-  createRequest,
 } from '@urql/core';
+import { createRequest } from '@urql/core';
 
 import { useClient } from './useClient';
 import { unwrapPossibleProxy, updateShallowRef } from './utils';
···
  */
 export type UseSubscriptionArgs<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > = {
   /** Prevents {@link useSubscription} from automatically executing GraphQL subscription operations.
    *
···
 export interface UseSubscriptionResponse<
   T = any,
   R = T,
-  V extends AnyVariables = AnyVariables
+  V extends AnyVariables = AnyVariables,
 > {
   /** Indicates whether `useSubscription`’s subscription is active.
    *
···
 export function useSubscription<
   T = any,
   R = T,
-  V extends AnyVariables = AnyVariables
+  V extends AnyVariables = AnyVariables,
 >(
   args: UseSubscriptionArgs<T, V>,
   handler?: MaybeRef<SubscriptionHandler<T, R>>
···
 export function callUseSubscription<
   T = any,
   R = T,
-  V extends AnyVariables = AnyVariables
+  V extends AnyVariables = AnyVariables,
 >(
   _args: UseSubscriptionArgs<T, V>,
   handler?: MaybeRef<SubscriptionHandler<T, R>>,
···
             }),
             subscribe(result => {
               fetching.value = true;
-              (data.value =
+              data.value =
                 result.data !== undefined
                   ? typeof scanHandler.value === 'function'
                     ? scanHandler.value(data.value as any, result.data!)
                     : result.data
-                  : (result.data as any)),
-                (error.value = result.error);
+                  : (result.data as any);
+              error.value = result.error;
               extensions.value = result.extensions;
               stale.value = !!result.stale;
               operation.value = result.operation;

packages/vue-urql/src/utils.ts

···
-import { GraphQLRequest, AnyVariables } from '@urql/core';
-import { Ref, ShallowRef, isRef } from 'vue';
+import type { GraphQLRequest, AnyVariables } from '@urql/core';
+import type { Ref, ShallowRef } from 'vue';
+import { isRef } from 'vue';
 
 export function unwrapPossibleProxy<V>(possibleProxy: V | Ref<V>): V {
   return possibleProxy && isRef(possibleProxy)
···
 
 export interface RequestState<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 > {
   request: GraphQLRequest<Data, Variables>;
   isPaused: boolean;
···
 
 export function createRequestState<
   Data = any,
-  Variables extends AnyVariables = AnyVariables
+  Variables extends AnyVariables = AnyVariables,
 >(
   request: GraphQLRequest<Data, Variables>,
   isPaused: boolean

pnpm-lock.yaml

···
-lockfileVersion: '6.0'
+lockfileVersion: '6.1'
 
 settings:
   autoInstallPeers: true
···
         specifier: ^18.16.3
         version: 18.16.3
       '@typescript-eslint/eslint-plugin':
-        specifier: ^5.59.1
-        version: 5.59.1(@typescript-eslint/parser@5.59.1)(eslint@8.39.0)(typescript@5.0.4)
+        specifier: ^6.2.1
+        version: 6.2.1(@typescript-eslint/parser@6.2.1)(eslint@8.46.0)(typescript@5.1.6)
       '@typescript-eslint/parser':
-        specifier: ^5.59.1
-        version: 5.59.1(eslint@8.39.0)(typescript@5.0.4)
+        specifier: ^6.2.1
+        version: 6.2.1(eslint@8.46.0)(typescript@5.1.6)
       cypress:
         specifier: ^12.8.1
         version: 12.8.1
···
         specifier: ^16.0.3
         version: 16.0.3
       eslint:
-        specifier: ^8.39.0
-        version: 8.39.0
+        specifier: ^8.46.0
+        version: 8.46.0
       eslint-config-prettier:
-        specifier: ^8.8.0
-        version: 8.8.0(eslint@8.39.0)
+        specifier: ^8.9.0
+        version: 8.9.0(eslint@8.46.0)
       eslint-plugin-es5:
         specifier: ^1.5.0
-        version: 1.5.0(eslint@8.39.0)
+        version: 1.5.0(eslint@8.46.0)
       eslint-plugin-prettier:
-        specifier: ^4.2.1
-        version: 4.2.1(eslint-config-prettier@8.8.0)(eslint@8.39.0)(prettier@2.8.8)
+        specifier: ^5.0.0
+        version: 5.0.0(eslint-config-prettier@8.9.0)(eslint@8.46.0)(prettier@3.0.0)
       eslint-plugin-react:
-        specifier: ^7.32.2
-        version: 7.32.2(eslint@8.39.0)
+        specifier: ^7.33.1
+        version: 7.33.1(eslint@8.46.0)
       eslint-plugin-react-hooks:
         specifier: ^4.6.0
-        version: 4.6.0(eslint@8.39.0)
+        version: 4.6.0(eslint@8.46.0)
       execa:
         specifier: ^7.1.1
         version: 7.1.1
···
         specifier: ^4.1.5
         version: 4.1.5
       prettier:
-        specifier: ^2.8.8
-        version: 2.8.8
+        specifier: ^3.0.0
+        version: 3.0.0
       react:
         specifier: ^17.0.2
         version: 17.0.2
···
         version: 1.0.2(rollup@3.21.1)
       rollup-plugin-dts:
         specifier: ^5.3.0
-        version: 5.3.0(rollup@3.21.1)(typescript@5.0.4)
+        version: 5.3.0(rollup@3.21.1)(typescript@5.1.6)
       rollup-plugin-visualizer:
         specifier: ^5.9.0
         version: 5.9.0(rollup@3.21.1)
···
         specifier: ^5.17.1
         version: 5.17.1
       typescript:
-        specifier: ^5.0.4
-        version: 5.0.4
+        specifier: ^5.1.6
+        version: 5.1.6
       vite:
         specifier: ^3.2.4
         version: 3.2.5(@types/node@18.16.3)(terser@5.17.1)
       vite-tsconfig-paths:
         specifier: ^4.2.0
-        version: 4.2.0(typescript@5.0.4)(vite@3.2.5)
+        version: 4.2.0(typescript@5.1.6)(vite@3.2.5)
       vitest:
         specifier: ^0.30.1
         version: 0.30.1(jsdom@21.1.1)(terser@5.17.1)
···
     dependencies:
       graphql: 16.6.0
 
+  /@aashutoshrathi/word-wrap@1.2.6:
+    resolution: {integrity: sha512-1Yjs2SvM8TflER/OD3cOjhWWOZb58A2t7wpE2S9XfBYTiIl+XFhQG2bjy4Pu1I+EAlCNUzRDYDdFwFYUKvXcIA==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
   /@actions/artifact@1.1.1:
     resolution: {integrity: sha512-Vv4y0EW0ptEkU+Pjs5RGS/0EryTvI6s79LjSV9Gg/h+O3H/ddpjhuX/Bi/HZE4pbNPyjGtQjbdFWphkZhmgabA==}
     dependencies:
···
       commander: 4.1.1
       convert-source-map: 1.9.0
       fs-readdir-recursive: 1.1.0
-      glob: 7.1.6
+      glob: 7.2.3
       make-dir: 2.1.0
       slash: 2.0.0
       source-map: 0.5.7
···
     transitivePeerDependencies:
       - supports-color
 
-  /@babel/code-frame@7.21.4:
-    resolution: {integrity: sha512-LYvhNKfwWSPpocw8GI7gpK2nq3HSDuEPC/uSYaALSJu9xjsalaaYFOq0Pwt5KmVqwEbZlDu81aLXwBOmD/Fv9g==}
-    engines: {node: '>=6.9.0'}
-    dependencies:
-      '@babel/highlight': 7.18.6
-
   /@babel/code-frame@7.22.5:
     resolution: {integrity: sha512-Xmwn266vad+6DAqEB2A6V/CcZVp62BbwVmcOJc2RPuwih1kw02TjQvWVWlcKGbBPd+8/0V5DEkOcizRGYsspYQ==}
     engines: {node: '>=6.9.0'}
···
       '@babel/generator': 7.21.5
       '@babel/helper-module-transforms': 7.21.5
       '@babel/helpers': 7.21.5
-      '@babel/parser': 7.21.5
+      '@babel/parser': 7.22.4
       '@babel/template': 7.20.7
       '@babel/traverse': 7.21.5(supports-color@5.5.0)
-      '@babel/types': 7.21.5
+      '@babel/types': 7.22.4
       convert-source-map: 1.9.0
       debug: 4.3.4(supports-color@5.5.0)
       gensync: 1.0.0-beta.2
       json5: 2.2.3
       lodash: 4.17.21
-      resolve: 1.22.1
-      semver: 5.7.1
+      resolve: 1.22.2
+      semver: 5.7.2
       source-map: 0.5.7
     transitivePeerDependencies:
       - supports-color
···
     engines: {node: '>=6.9.0'}
     dependencies:
       '@ampproject/remapping': 2.2.0
-      '@babel/code-frame': 7.21.4
+      '@babel/code-frame': 7.22.5
       '@babel/generator': 7.21.5
       '@babel/helper-compilation-targets': 7.21.5(@babel/core@7.21.5)
       '@babel/helper-module-transforms': 7.21.5
       '@babel/helpers': 7.21.5
-      '@babel/parser': 7.21.5
+      '@babel/parser': 7.22.4
       '@babel/template': 7.20.7
       '@babel/traverse': 7.21.5(supports-color@5.5.0)
-      '@babel/types': 7.21.5
+      '@babel/types': 7.22.4
       convert-source-map: 1.9.0
       debug: 4.3.4(supports-color@5.5.0)
       gensync: 1.0.0-beta.2
       json5: 2.2.3
-      semver: 6.3.0
+      semver: 6.3.1
     transitivePeerDependencies:
       - supports-color
 
···
     resolution: {integrity: sha512-SrKK/sRv8GesIW1bDagf9cCG38IOMYZusoe1dfg0D8aiUe3Amvoj1QtjTPAWcfrZFvIwlleLb0gxzQidL9w14w==}
     engines: {node: '>=6.9.0'}
     dependencies:
-      '@babel/types': 7.21.5
+      '@babel/types': 7.22.4
       '@jridgewell/gen-mapping': 0.3.2
       '@jridgewell/trace-mapping': 0.3.17
       jsesc: 2.5.2
···
     resolution: {integrity: sha512-duORpUiYrEpzKIop6iNbjnwKLAKnJ47csTyRACyEmWj0QdUrm5aqNJGHSSEQSUAvNW0ojX0dOmK9dZduvkfeXA==}
     engines: {node: '>=6.9.0'}
     dependencies:
-      '@babel/types': 7.21.5
+      '@babel/types': 7.22.4
 
   /@babel/helper-builder-binary-assignment-operator-visitor@7.12.13:
     resolution: {integrity: sha512-CZOv9tGphhDRlVjVkAgm8Nhklm9RzSmWpX2my+t7Ua/KT616pEzXsQCjinzvkRvHWJ9itO4f296efroX23XCMA==}
     dependencies:
       '@babel/helper-explode-assignable-expression': 7.13.0
-      '@babel/types': 7.21.5
+      '@babel/types': 7.22.4
 
   /@babel/helper-compilation-targets@7.21.5(@babel/core@7.21.5):
     resolution: {integrity: sha512-1RkbFGUKex4lvsB9yhIfWltJM5cZKUftB2eNajaDv3dCMEp49iBG0K14uH8NnX9IPux2+mK7JGEOB0jn48/J6w==}
···
       '@babel/helper-validator-option': 7.21.0
       browserslist: 4.21.5
       lru-cache: 5.1.1
-      semver: 6.3.0
+      semver: 6.3.1
 
   /@babel/helper-create-class-features-plugin@7.21.5(@babel/core@7.21.5):
     resolution: {integrity: sha512-yNSEck9SuDvPTEUYm4BSXl6ZVC7yO5ZLEMAhG3v3zi7RDxyL/nQDemWWZmw4L0stPWwhpnznRRyJHPRcbXR2jw==}
···
       '@babel/helper-replace-supers': 7.21.5
       '@babel/helper-skip-transparent-expression-wrappers': 7.20.0
       '@babel/helper-split-export-declaration': 7.18.6
-      semver: 6.3.0
+      semver: 6.3.1
     transitivePeerDependencies:
       - supports-color
 
···
       debug: 4.3.4(supports-color@5.5.0)
       lodash.debounce: 4.0.8
       resolve: 1.22.2
-      semver: 6.3.0
+      semver: 6.3.1
     transitivePeerDependencies:
       - supports-color
 
···
   /@babel/helper-explode-assignable-expression@7.13.0:
     resolution: {integrity: sha512-qS0peLTDP8kOisG1blKbaoBg/o9OSa1qoumMjTK5pM+KDTtpxpsiubnCGP34vK8BXGcb2M9eigwgvoJryrzwWA==}
     dependencies:
-      '@babel/types': 7.21.5
+      '@babel/types': 7.22.4
 
   /@babel/helper-function-name@7.21.0:
     resolution: {integrity: sha512-HfK1aMRanKHpxemaY2gqBmL04iAPOPRj7DxtNbiDOrJK+gdwkiNRVpCpUJYbUT+aZyemKN8brqTOxzCaG6ExRg==}
     engines: {node: '>=6.9.0'}
     dependencies:
       '@babel/template': 7.20.7
-      '@babel/types': 7.21.5
+      '@babel/types': 7.22.4
 
   /@babel/helper-hoist-variables@7.18.6:
     resolution: {integrity: sha512-UlJQPkFqFULIcyW5sbzgbkxn2FKRgwWiRexcuaR8RNJRy8+LLveqPjwZV/bwrLZCN0eUHD/x8D0heK1ozuoo6Q==}
     engines: {node: '>=6.9.0'}
     dependencies:
-      '@babel/types': 7.21.5
+      '@babel/types': 7.22.4
 
   /@babel/helper-member-expression-to-functions@7.21.5:
     resolution: {integrity: sha512-nIcGfgwpH2u4n9GG1HpStW5Ogx7x7ekiFHbjjFRKXbn5zUvqO9ZgotCO4x1aNbKn/x/xOUaXEhyNHCwtFCpxWg==}
     engines: {node: '>=6.9.0'}
     dependencies:
-      '@babel/types': 7.21.5
+      '@babel/types': 7.22.4
 
   /@babel/helper-module-imports@7.21.4:
     resolution: {integrity: sha512-orajc5T2PsRYUN3ZryCEFeMDYwyw09c/pZeaQEZPH0MpKzSvn3e0uXsDBu3k03VI+9DBiRo+l22BfKTpKwa/Wg==}
     engines: {node: '>=6.9.0'}
     dependencies:
-      '@babel/types': 7.21.5
+      '@babel/types': 7.22.4
 
   /@babel/helper-module-transforms@7.21.5:
     resolution: {integrity: sha512-bI2Z9zBGY2q5yMHoBvJ2a9iX3ZOAzJPm7Q8Yz6YeoUjU/Cvhmi2G4QyTNyPBqqXSgTjUxRg3L0xV45HvkNWWBw==}
···
       '@babel/helper-module-imports': 7.21.4
       '@babel/helper-simple-access': 7.21.5
       '@babel/helper-split-export-declaration': 7.18.6
-      '@babel/helper-validator-identifier': 7.19.1
+      '@babel/helper-validator-identifier': 7.22.5
       '@babel/template': 7.20.7
       '@babel/traverse': 7.21.5(supports-color@5.5.0)
-      '@babel/types': 7.21.5
+      '@babel/types': 7.22.4
     transitivePeerDependencies:
       - supports-color
 
···
     resolution: {integrity: sha512-HP59oD9/fEHQkdcbgFCnbmgH5vIQTJbxh2yf+CdM89/glUNnuzr87Q8GIjGEnOktTROemO0Pe0iPAYbqZuOUiA==}
     engines: {node: '>=6.9.0'}
     dependencies:
-      '@babel/types': 7.21.5
+      '@babel/types': 7.22.4
 
   /@babel/helper-plugin-utils@7.10.4:
     resolution: {integrity: sha512-O4KCvQA6lLiMU9l2eawBPMf1xPP8xPfB3iEQw150hOVTqj/rfXz0ThTb4HEzqQfs2Bmo5Ay8BzxfzVtBrr9dVg==}
···
     dependencies:
       '@babel/helper-annotate-as-pure': 7.18.6
       '@babel/helper-wrap-function': 7.13.0
-      '@babel/types': 7.21.5
+      '@babel/types': 7.22.4
     transitivePeerDependencies:
       - supports-color
 
···
       '@babel/helper-optimise-call-expression': 7.18.6
       '@babel/template': 7.20.7
       '@babel/traverse': 7.21.5(supports-color@5.5.0)
-      '@babel/types': 7.21.5
+      '@babel/types': 7.22.4
     transitivePeerDependencies:
       - supports-color
 
···
     resolution: {integrity: sha512-ENPDAMC1wAjR0uaCUwliBdiSl1KBJAVnMTzXqi64c2MG8MPR6ii4qf7bSXDqSFbr4W6W028/rf5ivoHop5/mkg==}
     engines: {node: '>=6.9.0'}
     dependencies:
-      '@babel/types': 7.21.5
+      '@babel/types': 7.22.4
 
   /@babel/helper-skip-transparent-expression-wrappers@7.20.0:
     resolution: {integrity: sha512-5y1JYeNKfvnT8sZcK9DVRtpTbGiomYIHviSP3OQWmDPU3DeH4a1ZlT/N2lyQ5P8egjcRaT/Y9aNqUxK0WsnIIg==}
     engines: {node: '>=6.9.0'}
     dependencies:
-      '@babel/types': 7.21.5
+      '@babel/types': 7.22.4
 
   /@babel/helper-split-export-declaration@7.18.6:
     resolution: {integrity: sha512-bde1etTx6ZyTmobl9LLMMQsaizFVZrquTEHOqKeQESMKo4PlObf+8+JA25ZsIpZhT/WEd39+vOdLXAFG/nELpA==}
     engines: {node: '>=6.9.0'}
     dependencies:
-      '@babel/types': 7.21.5
+      '@babel/types': 7.22.4
 
   /@babel/helper-string-parser@7.21.5:
     resolution: {integrity: sha512-5pTUx3hAJaZIdW99sJ6ZUUgWq/Y+Hja7TowEnLNMm1VivRgZQL3vpBY3qUACVsvw+yQU6+YgfBVmcbLaZtrA1w==}
     engines: {node: '>=6.9.0'}
 
-  /@babel/helper-validator-identifier@7.19.1:
-    resolution: {integrity: sha512-awrNfaMtnHUr653GgGEs++LlAvW6w+DcPrOliSMXWCKo597CwL5Acf/wWdNkf/tfEQE3mjkeD1YOVZOUV/od1w==}
-    engines: {node: '>=6.9.0'}
-
   /@babel/helper-validator-identifier@7.22.5:
     resolution: {integrity: sha512-aJXu+6lErq8ltp+JhkJUfk1MTGyuA4v7f3pA+BJ5HLfNC6nAQ0Cpi9uOquUj8Hehg0aUiHzWQbOVJGao6ztBAQ==}
     engines: {node: '>=6.9.0'}
···
       '@babel/helper-function-name': 7.21.0
       '@babel/template': 7.20.7
       '@babel/traverse': 7.21.5(supports-color@5.5.0)
-      '@babel/types': 7.21.5
+      '@babel/types': 7.22.4
     transitivePeerDependencies:
       - supports-color
 
···
     dependencies:
       '@babel/template': 7.20.7
       '@babel/traverse': 7.21.5(supports-color@5.5.0)
-      '@babel/types': 7.21.5
+      '@babel/types': 7.22.4
     transitivePeerDependencies:
       - supports-color
 
-  /@babel/highlight@7.18.6:
-    resolution: {integrity: sha512-u7stbOuYjaPezCuLj29hNW1v64M2Md2qupEKP1fHc7WdOA3DgLh37suiSrZYY7haUB7iBeQZ9P1uiRF359do3g==}
-    engines: {node: '>=6.9.0'}
-    dependencies:
-      '@babel/helper-validator-identifier': 7.22.5
-      chalk: 2.4.2
-      js-tokens: 4.0.0
-
   /@babel/highlight@7.22.5:
     resolution: {integrity: sha512-BSKlD1hgnedS5XRnGOljZawtag7H1yPfQp0tdNJCHoH6AZ+Pcm9VvkrK59/Yy593Ypg0zMxH2BxD1VPYUQ7UIw==}
     engines: {node: '>=6.9.0'}
···
       chalk: 2.4.2
       js-tokens: 4.0.0
 
-  /@babel/parser@7.21.5:
-    resolution: {integrity: sha512-J+IxH2IsxV4HbnTrSWgMAQj0UEo61hDA4Ny8h8PCX0MLXiibqHbqIOVneqdocemSBc22VpBKxt4J6FQzy9HarQ==}
-    engines: {node: '>=6.0.0'}
-    hasBin: true
-    dependencies:
-      '@babel/types': 7.21.5
-
   /@babel/parser@7.22.4:
     resolution: {integrity: sha512-VLLsx06XkEYqBtE5YGPwfSGwfrjnyPP5oiGty3S8pQLFDFLaS8VwWSIxkTXpcvr5zeYLE6+MBNl2npl/YnfofA==}
     engines: {node: '>=6.0.0'}
     hasBin: true
     dependencies:
       '@babel/types': 7.22.4
-    dev: true
 
   /@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@7.13.12(@babel/core@7.21.5):
     resolution: {integrity: sha512-d0u3zWKcoZf379fOeJdr1a5WPDny4aOFZ6hlfKivgK0LY7ZxNfoaHL2fWwdGtHyVvra38FC+HVYkO+byfSA8AQ==}
···
       '@babel/helper-module-imports': 7.21.4
       '@babel/helper-plugin-utils': 7.21.5
       '@babel/plugin-syntax-jsx': 7.21.4(@babel/core@7.21.5)
-      '@babel/types': 7.21.5
+      '@babel/types': 7.22.4
 
   /@babel/plugin-transform-react-pure-annotations@7.12.1(@babel/core@7.21.5):
     resolution: {integrity: sha512-RqeaHiwZtphSIUZ5I85PEH19LOSzxfuEazoY7/pWASCAIBuATQzpSVD+eT6MebeeZT2F4eSL0u4vw6n4Nm0Mjg==}
···
       babel-plugin-polyfill-corejs2: 0.2.0(@babel/core@7.21.5)
       babel-plugin-polyfill-corejs3: 0.2.0(@babel/core@7.21.5)
       babel-plugin-polyfill-regenerator: 0.2.0(@babel/core@7.21.5)
-      semver: 6.3.0
+      semver: 6.3.1
     transitivePeerDependencies:
       - supports-color
 
···
       '@babel/plugin-transform-unicode-escapes': 7.12.13(@babel/core@7.21.5)
       '@babel/plugin-transform-unicode-regex': 7.12.13(@babel/core@7.21.5)
       '@babel/preset-modules': 0.1.4(@babel/core@7.21.5)
-      '@babel/types': 7.21.5
+      '@babel/types': 7.22.4
       babel-plugin-polyfill-corejs2: 0.2.0(@babel/core@7.21.5)
       babel-plugin-polyfill-corejs3: 0.2.0(@babel/core@7.21.5)
       babel-plugin-polyfill-regenerator: 0.2.0(@babel/core@7.21.5)
       core-js-compat: 3.11.1
-      semver: 6.3.0
+      semver: 6.3.1
     transitivePeerDependencies:
       - supports-color
 
···
       '@babel/helper-plugin-utils': 7.21.5
       '@babel/plugin-proposal-unicode-property-regex': 7.12.13(@babel/core@7.21.5)
       '@babel/plugin-transform-dotall-regex': 7.12.13(@babel/core@7.21.5)
-      '@babel/types': 7.21.5
+      '@babel/types': 7.22.4
       esutils: 2.0.3
 
   /@babel/preset-react@7.13.13(@babel/core@7.21.5):
···
     engines: {node: '>=6.9.0'}
     dependencies:
       regenerator-runtime: 0.13.11
+    dev: false
 
   /@babel/runtime@7.22.5:
     resolution: {integrity: sha512-ecjvYlnAaZ/KVneE/OdKYBYfgXV3Ptu6zQWmgEF7vwKhQnvVS6bjMD2XYgj+SNvQ1GfK/pjgokfPkC/2CO8CuA==}
     engines: {node: '>=6.9.0'}
     dependencies:
       regenerator-runtime: 0.13.11
-    dev: true
 
   /@babel/template@7.20.7:
     resolution: {integrity: sha512-8SegXApWe6VoNw0r9JHpSteLKTpTiLZ4rMlGIm9JQ18KiCtyQiAMEazujAHrUS5flrcqYZa75ukev3P6QmUwUw==}
     engines: {node: '>=6.9.0'}
     dependencies:
-      '@babel/code-frame': 7.21.4
-      '@babel/parser': 7.21.5
-      '@babel/types': 7.21.5
+      '@babel/code-frame': 7.22.5
+      '@babel/parser': 7.22.4
+      '@babel/types': 7.22.4
 
   /@babel/traverse@7.21.5(supports-color@5.5.0):
     resolution: {integrity: sha512-AhQoI3YjWi6u/y/ntv7k48mcrCXmus0t79J9qPNlk/lAsFlCiJ047RmbfMOawySTHtywXhbXgpx/8nXMYd+oFw==}
     engines: {node: '>=6.9.0'}
     dependencies:
-      '@babel/code-frame': 7.21.4
+      '@babel/code-frame': 7.22.5
       '@babel/generator': 7.21.5
       '@babel/helper-environment-visitor': 7.21.5
       '@babel/helper-function-name': 7.21.0
       '@babel/helper-hoist-variables': 7.18.6
       '@babel/helper-split-export-declaration': 7.18.6
-      '@babel/parser': 7.21.5
-      '@babel/types': 7.21.5
+      '@babel/parser': 7.22.4
+      '@babel/types': 7.22.4
       debug: 4.3.4(supports-color@5.5.0)
       globals: 11.12.0
     transitivePeerDependencies:
       - supports-color
 
-  /@babel/types@7.21.5:
-    resolution: {integrity: sha512-m4AfNvVF2mVC/F7fDEdH2El3HzUg9It/XsCxZiOTTA3m3qYfcSVSbTfM6Q9xG+hYDniZssYhlXKKUMD5m8tF4Q==}
-    engines: {node: '>=6.9.0'}
-    dependencies:
-      '@babel/helper-string-parser': 7.21.5
-      '@babel/helper-validator-identifier': 7.19.1
-      to-fast-properties: 2.0.0
-
   /@babel/types@7.22.4:
     resolution: {integrity: sha512-Tx9x3UBHTTsMSW85WB2kphxYQVvrZ/t1FxD88IpSgIjiUJlCm9z+xWIDwyo1vffTwSqteqyznB8ZE9vYYk16zA==}
     engines: {node: '>=6.9.0'}
···
       '@babel/helper-string-parser': 7.21.5
       '@babel/helper-validator-identifier': 7.22.5
       to-fast-properties: 2.0.0
-    dev: true
 
   /@changesets/apply-release-plan@6.1.4:
     resolution: {integrity: sha512-FMpKF1fRlJyCZVYHr3CbinpZZ+6MwvOtWUuO8uo+svcATEoc1zRDcj23pAurJ2TZ/uVz1wFHH6K3NlACy0PLew==}
···
       outdent: 0.5.0
       prettier: 2.8.8
       resolve-from: 5.0.0
-      semver: 7.5.3
+      semver: 7.5.4
     dev: true
 
   /@changesets/assemble-release-plan@5.2.4:
···
       '@changesets/get-dependents-graph': 1.3.6
       '@changesets/types': 5.2.1
       '@manypkg/get-packages': 1.1.3
-      semver: 7.5.3
+      semver: 7.5.4
     dev: true
 
   /@changesets/changelog-git@0.1.14:
···
       p-limit: 2.3.0
       preferred-pm: 3.0.3
       resolve-from: 5.0.0
-      semver: 7.5.3
+      semver: 7.5.4
       spawndamnit: 2.0.0
       term-size: 2.2.1
       tty-table: 4.2.1
···
       '@manypkg/get-packages': 1.1.3
       chalk: 2.4.2
       fs-extra: 7.0.1
-      semver: 7.5.3
+      semver: 7.5.4
     dev: true
 
   /@changesets/get-github-info@0.5.2:
···
     dev: true
     optional: true
 
-  /@eslint-community/eslint-utils@4.4.0(eslint@8.39.0):
+  /@eslint-community/eslint-utils@4.4.0(eslint@8.46.0):
     resolution: {integrity: sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     peerDependencies:
       eslint: ^6.0.0 || ^7.0.0 || >=8.0.0
     dependencies:
-      eslint: 8.39.0
-      eslint-visitor-keys: 3.4.0
+      eslint: 8.46.0
+      eslint-visitor-keys: 3.4.2
     dev: true
 
-  /@eslint-community/regexpp@4.5.0:
-    resolution: {integrity: sha512-vITaYzIcNmjn5tF5uxcZ/ft7/RXGrMUIS9HalWckEOF6ESiwXKoMzAQf2UW0aVd6rnOeExTJVd5hmWXucBKGXQ==}
+  /@eslint-community/regexpp@4.6.2:
+    resolution: {integrity: sha512-pPTNuaAG3QMH+buKyBIGJs3g/S5y0caxw0ygM3YyE6yJFySwiGGSzA+mM3KJ8QQvzeLh3blwgSonkFjgQdxzMw==}
     engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0}
     dev: true
 
-  /@eslint/eslintrc@2.0.2:
-    resolution: {integrity: sha512-3W4f5tDUra+pA+FzgugqL2pRimUTDJWKr7BINqOpkZrC0uYI0NIc0/JFgBROCU07HR6GieA5m3/rsPIhDmCXTQ==}
+  /@eslint/eslintrc@2.1.1:
+    resolution: {integrity: sha512-9t7ZA7NGGK8ckelF0PQCfcxIUzs1Md5rrO6U/c+FIQNanea5UZC0wqKXH4vHBccmu4ZJgZ2idtPeW7+Q2npOEA==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     dependencies:
       ajv: 6.12.6
       debug: 4.3.4(supports-color@5.5.0)
-      espree: 9.5.1
+      espree: 9.6.1
       globals: 13.20.0
       ignore: 5.2.4
       import-fresh: 3.3.0
···
       - supports-color
     dev: true
 
-  /@eslint/js@8.39.0:
-    resolution: {integrity: sha512-kf9RB0Fg7NZfap83B3QOqOGg9QmD9yBudqQXzzOtn3i4y7ZUXe5ONeW34Gwi+TxhH4mvj72R1Zc300KUMa9Bng==}
+  /@eslint/js@8.46.0:
+    resolution: {integrity: sha512-a8TLtmPi8xzPkCbp/OGFUo5yhRkHM2Ko9kOWP4znJr0WAhWyThaw3PnwX4vOTWOAMsV2uRt32PPDcEz63esSaA==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     dev: true
 
···
     resolution: {integrity: sha512-k2Ty1JcVojjJFwrg/ThKi2ujJ7XNLYaFGNB/bWT9wGR+oSMJHMa5w+CUq6p/pVrKeNNgA7pCqEcjSnHVoqJQFw==}
     dev: true
 
-  /@humanwhocodes/config-array@0.11.8:
-    resolution: {integrity: sha512-UybHIJzJnR5Qc/MsD9Kr+RpO2h+/P1GhOwdiLPXK5TWk5sgTdu88bTD9UP+CKbPPh5Rni1u0GjAdYQLemG8g+g==}
+  /@humanwhocodes/config-array@0.11.10:
+    resolution: {integrity: sha512-KVVjQmNUepDVGXNuoRRdmmEjruj0KfiGSbS8LVc12LMsWDQzRXJ0qdhN8L8uUigKpfEHRhlaQFY0ib1tnUbNeQ==}
     engines: {node: '>=10.10.0'}
     dependencies:
       '@humanwhocodes/object-schema': 1.2.1
···
       promise-all-reject-late: 1.0.1
       promise-call-limit: 1.0.1
       read-package-json-fast: 3.0.2
-      semver: 7.5.0
+      semver: 7.5.4
       ssri: 10.0.1
       treeverse: 3.0.0
       walk-up-path: 1.0.0
···
     engines: {node: ^12.13.0 || ^14.15.0 || >=16.0.0}
     dependencies:
       '@gar/promisify': 1.1.3
-      semver: 7.5.0
+      semver: 7.5.4
     dev: true
 
   /@npmcli/fs@3.1.0:
     resolution: {integrity: sha512-7kZUAaLscfgbwBQRbvdMYaZOWyMEcPTH/tJjnyAWJ/dvvs9Ef+CERx/qJb9GExJpl1qipaDGn7KqHnFGGixd0w==}
     engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
     dependencies:
-      semver: 7.5.0
+      semver: 7.5.4
     dev: true
 
   /@npmcli/git@4.0.3:
···
       proc-log: 3.0.0
       promise-inflight: 1.0.1(bluebird@3.7.2)
       promise-retry: 2.0.1
-      semver: 7.5.0
-      which: 3.0.0
+      semver: 7.5.4
+      which: 3.0.1
     transitivePeerDependencies:
       - bluebird
     dev: true
···
       cacache: 17.0.4
       json-parse-even-better-errors: 3.0.0
       pacote: 15.1.1
-      semver: 7.5.0
+      semver: 7.5.4
     transitivePeerDependencies:
       - bluebird
       - supports-color
···
     resolution: {integrity: sha512-gGq0NJkIGSwdbUt4yhdF8ZrmkGKVz9vAdVzpOfnom+V8PLSmSOVhZwbNvZZS1EYcJN5hzzKBxmmVVAInM6HQLg==}
     engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
     dependencies:
-      which: 3.0.0
+      which: 3.0.1
     dev: true
 
   /@npmcli/query@3.0.0:
···
       '@npmcli/promise-spawn': 6.0.2
       node-gyp: 9.3.1
       read-package-json-fast: 3.0.2
-      which: 3.0.0
+      which: 3.0.1
     transitivePeerDependencies:
       - bluebird
       - supports-color
···
       '@octokit/openapi-types': 12.11.0
     dev: false
 
+  /@pkgr/utils@2.4.2:
+    resolution: {integrity: sha512-POgTXhjrTfbTV63DiFXav4lBHiICLKKwDeaKn9Nphwj7WH6m0hMMCaJkMyRWjgtPFyRKRVoMXXjczsTQRDEhYw==}
+    engines: {node: ^12.20.0 || ^14.18.0 || >=16.0.0}
+    dependencies:
+      cross-spawn: 7.0.3
+      fast-glob: 3.3.1
+      is-glob: 4.0.3
+      open: 9.1.0
+      picocolors: 1.0.0
+      tslib: 2.6.1
+    dev: true
+
   /@reach/router@1.3.4(react-dom@17.0.2)(react@17.0.2):
     resolution: {integrity: sha512-+mtn9wjlB9NN2CNnnC/BRYtwdKBfSyyasPYraNAyvaV1occr/5NnB4CVzjEZipNHwYebQwcndGUmpFzxAUoqSA==}
     peerDependencies:
···
       rollup:
         optional: true
     dependencies:
-      '@types/estree': 1.0.0
+      '@types/estree': 1.0.1
       estree-walker: 2.0.2
       picomatch: 2.3.1
       rollup: 3.21.1
···
   /@swc/helpers@0.4.11:
     resolution: {integrity: sha512-rEUrBSGIoSFuYxwBYtlUFMlE2CwGhmW+w9355/5oduSw8e5h2+Tj4UrAGNNgP9915++wj5vkQo0UuOBqOAq4nw==}
     dependencies:
-      tslib: 2.5.0
+      tslib: 2.6.1
     dev: true
 
   /@testing-library/dom@7.30.4:
···
     engines: {node: '>=10'}
     dependencies:
       '@babel/code-frame': 7.22.5
-      '@babel/runtime': 7.21.0
+      '@babel/runtime': 7.22.5
       '@types/aria-query': 4.2.1
       aria-query: 4.2.2
       chalk: 4.1.2
···
       react-test-renderer:
         optional: true
     dependencies:
-      '@babel/runtime': 7.21.0
+      '@babel/runtime': 7.22.5
       '@types/react': 17.0.52
       '@types/react-dom': 18.2.4
       '@types/react-test-renderer': 17.0.1
···
       react: '*'
       react-dom: '*'
     dependencies:
-      '@babel/runtime': 7.21.0
+      '@babel/runtime': 7.22.5
       '@testing-library/dom': 7.30.4
       react: 17.0.2
       react-dom: 17.0.2(react@17.0.2)
···
 
   /@types/chai@4.3.4:
     resolution: {integrity: sha512-KnRanxnpfpjUTqTCXslZSEdLfXExwgNxYPdiO2WGUj8+HDjFi8R3k5RVKPeSCzLjCcshCAtVO2QBbVuAV4kTnw==}
-    dev: true
-
-  /@types/estree@1.0.0:
-    resolution: {integrity: sha512-WulqXMDUTYAXCjZnk6JtIHPigp55cVtDgDrO2gHRwhyJto21+1zbVCtOYB2L1F9w4qCQ0rOGWBnBe0FNTiEJIQ==}
     dev: true
 
   /@types/estree@1.0.1:
···
       '@types/istanbul-lib-report': 3.0.0
     dev: true
 
-  /@types/json-schema@7.0.11:
-    resolution: {integrity: sha512-wOuvG1SN4Us4rez+tylwwwCV1psiNVOkJeM3AUWUNWg/jDQY2+HE/444y5gc+jBmRqASOm2Oeh5c1axHobwRKQ==}
+  /@types/json-schema@7.0.12:
+    resolution: {integrity: sha512-Hr5Jfhc9eYOQNPYO5WLDq/n4jqijdHNlDXjuAQkkt+mWdQR+XJToOHrsD4cPaMXpn6KO7y2+wM8AZEs8VpBLVA==}
 
   /@types/keyv@3.1.4:
     resolution: {integrity: sha512-BQ5aZNSCpj7D6K2ksrRCTmKRLEpnPvWDiLPfoGyhZ++8YtiK9d/3DBKPJgry359X/P1PfruyYwvnvwFjuEiEIg==}
     dependencies:
-      '@types/node': 20.3.2
+      '@types/node': 18.16.3
 
   /@types/mdast@3.0.3:
     resolution: {integrity: sha512-SXPBMnFVQg1s00dlMCc/jCdvPqdE4mXaMMCeRlxLDmTAEoegHT53xKtkDnzDTOcmMHUfcjyf36/YYZ6SxRdnsw==}
···
 
   /@types/node@18.16.3:
     resolution: {integrity: sha512-OPs5WnnT1xkCBiuQrZA4+YAV4HEJejmHneyraIaxsbev5yCEr6KMwINNFP9wQeFIw8FWcoTqF3vQsa5CDaI+8Q==}
-
-  /@types/node@20.3.2:
-    resolution: {integrity: sha512-vOBLVQeCQfIcF/2Y7eKFTqrMnizK5lRNQ7ykML/5RuwVXVWxYkgwS7xbt4B6fKCUPgbSL5FSsjHQpaGQP/dQmw==}
 
   /@types/normalize-package-data@2.4.1:
     resolution: {integrity: sha512-Gj7cI7z+98M282Tqmp2K5EIsoouUEzbBJhQQzDE3jSIRk6r9gsz0oUokqIUR4u1R3dMHo0pDHM7sNOHyhulypw==}
···
   /@types/responselike@1.0.0:
     resolution: {integrity: sha512-85Y2BjiufFzaMIlvJDvTTB8Fxl2xfLo4HgmHzVBz08w4wDePCTjYw66PdrolO0kzli3yam/YCgRufyo1DdQVTA==}
     dependencies:
-      '@types/node': 20.3.2
+      '@types/node': 18.16.3
 
   /@types/scheduler@0.16.1:
     resolution: {integrity: sha512-EaCxbanVeyxDRTQBkdLb3Bvl/HK7PBK6UJjsSixB0iHKoWxE5uu2Q/DgtpOhPIojN0Zl1whvOd7PoHs2P0s5eA==}
-    dev: true
-
-  /@types/semver@7.3.13:
-    resolution: {integrity: sha512-21cFJr9z3g5dW8B0CVI9g2O9beqaThGQ6ZFBqHfwhzLDKUxaqTIy3vnfah/UPkfOiF2pLq+tGz+W8RyCskuslw==}
     dev: true
 
   /@types/semver@7.5.0:
···
     dev: true
     optional: true
 
-  /@typescript-eslint/eslint-plugin@5.59.1(@typescript-eslint/parser@5.59.1)(eslint@8.39.0)(typescript@5.0.4):
-    resolution: {integrity: sha512-AVi0uazY5quFB9hlp2Xv+ogpfpk77xzsgsIEWyVS7uK/c7MZ5tw7ZPbapa0SbfkqE0fsAMkz5UwtgMLVk2BQAg==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+  /@typescript-eslint/eslint-plugin@6.2.1(@typescript-eslint/parser@6.2.1)(eslint@8.46.0)(typescript@5.1.6):
+    resolution: {integrity: sha512-iZVM/ALid9kO0+I81pnp1xmYiFyqibAHzrqX4q5YvvVEyJqY+e6rfTXSCsc2jUxGNqJqTfFSSij/NFkZBiBzLw==}
+    engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
-      '@typescript-eslint/parser': ^5.0.0
-      eslint: ^6.0.0 || ^7.0.0 || ^8.0.0
+      '@typescript-eslint/parser': ^6.0.0 || ^6.0.0-alpha
+      eslint: ^7.0.0 || ^8.0.0
       typescript: '*'
     peerDependenciesMeta:
       typescript:
         optional: true
     dependencies:
-      '@eslint-community/regexpp': 4.5.0
-      '@typescript-eslint/parser': 5.59.1(eslint@8.39.0)(typescript@5.0.4)
-      '@typescript-eslint/scope-manager': 5.59.1
-      '@typescript-eslint/type-utils': 5.59.1(eslint@8.39.0)(typescript@5.0.4)
-      '@typescript-eslint/utils': 5.59.1(eslint@8.39.0)(typescript@5.0.4)
+      '@eslint-community/regexpp': 4.6.2
+      '@typescript-eslint/parser': 6.2.1(eslint@8.46.0)(typescript@5.1.6)
+      '@typescript-eslint/scope-manager': 6.2.1
+      '@typescript-eslint/type-utils': 6.2.1(eslint@8.46.0)(typescript@5.1.6)
+      '@typescript-eslint/utils': 6.2.1(eslint@8.46.0)(typescript@5.1.6)
+      '@typescript-eslint/visitor-keys': 6.2.1
       debug: 4.3.4(supports-color@5.5.0)
-      eslint: 8.39.0
-      grapheme-splitter: 1.0.4
+      eslint: 8.46.0
+      graphemer: 1.4.0
       ignore: 5.2.4
+      natural-compare: 1.4.0
       natural-compare-lite: 1.4.0
-      semver: 7.5.0
-      tsutils: 3.21.0(typescript@5.0.4)
-      typescript: 5.0.4
+      semver: 7.5.4
+      ts-api-utils: 1.0.1(typescript@5.1.6)
+      typescript: 5.1.6
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /@typescript-eslint/parser@5.59.1(eslint@8.39.0)(typescript@5.0.4):
-    resolution: {integrity: sha512-nzjFAN8WEu6yPRDizIFyzAfgK7nybPodMNFGNH0M9tei2gYnYszRDqVA0xlnRjkl7Hkx2vYrEdb6fP2a21cG1g==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+  /@typescript-eslint/parser@6.2.1(eslint@8.46.0)(typescript@5.1.6):
+    resolution: {integrity: sha512-Ld+uL1kYFU8e6btqBFpsHkwQ35rw30IWpdQxgOqOh4NfxSDH6uCkah1ks8R/RgQqI5hHPXMaLy9fbFseIe+dIg==}
+    engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
-      eslint: ^6.0.0 || ^7.0.0 || ^8.0.0
+      eslint: ^7.0.0 || ^8.0.0
       typescript: '*'
     peerDependenciesMeta:
       typescript:
         optional: true
     dependencies:
-      '@typescript-eslint/scope-manager': 5.59.1
-      '@typescript-eslint/types': 5.59.1
-      '@typescript-eslint/typescript-estree': 5.59.1(typescript@5.0.4)
+      '@typescript-eslint/scope-manager': 6.2.1
+      '@typescript-eslint/types': 6.2.1
+      '@typescript-eslint/typescript-estree': 6.2.1(typescript@5.1.6)
+      '@typescript-eslint/visitor-keys': 6.2.1
       debug: 4.3.4(supports-color@5.5.0)
-      eslint: 8.39.0
-      typescript: 5.0.4
+      eslint: 8.46.0
+      typescript: 5.1.6
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /@typescript-eslint/scope-manager@5.59.1:
-    resolution: {integrity: sha512-mau0waO5frJctPuAzcxiNWqJR5Z8V0190FTSqRw1Q4Euop6+zTwHAf8YIXNwDOT29tyUDrQ65jSg9aTU/H0omA==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+  /@typescript-eslint/scope-manager@6.2.1:
+    resolution: {integrity: sha512-UCqBF9WFqv64xNsIEPfBtenbfodPXsJ3nPAr55mGPkQIkiQvgoWNo+astj9ZUfJfVKiYgAZDMnM6dIpsxUMp3Q==}
+    engines: {node: ^16.0.0 || >=18.0.0}
     dependencies:
-      '@typescript-eslint/types': 5.59.1
-      '@typescript-eslint/visitor-keys': 5.59.1
+      '@typescript-eslint/types': 6.2.1
+      '@typescript-eslint/visitor-keys': 6.2.1
     dev: true
 
-  /@typescript-eslint/type-utils@5.59.1(eslint@8.39.0)(typescript@5.0.4):
-    resolution: {integrity: sha512-ZMWQ+Oh82jWqWzvM3xU+9y5U7MEMVv6GLioM3R5NJk6uvP47kZ7YvlgSHJ7ERD6bOY7Q4uxWm25c76HKEwIjZw==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+  /@typescript-eslint/type-utils@6.2.1(eslint@8.46.0)(typescript@5.1.6):
+    resolution: {integrity: sha512-fTfCgomBMIgu2Dh2Or3gMYgoNAnQm3RLtRp+jP7A8fY+LJ2+9PNpi5p6QB5C4RSP+U3cjI0vDlI3mspAkpPVbQ==}
+    engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
-      eslint: '*'
+      eslint: ^7.0.0 || ^8.0.0
       typescript: '*'
     peerDependenciesMeta:
       typescript:
         optional: true
     dependencies:
-      '@typescript-eslint/typescript-estree': 5.59.1(typescript@5.0.4)
-      '@typescript-eslint/utils': 5.59.1(eslint@8.39.0)(typescript@5.0.4)
+      '@typescript-eslint/typescript-estree': 6.2.1(typescript@5.1.6)
+      '@typescript-eslint/utils': 6.2.1(eslint@8.46.0)(typescript@5.1.6)
       debug: 4.3.4(supports-color@5.5.0)
-      eslint: 8.39.0
-      tsutils: 3.21.0(typescript@5.0.4)
-      typescript: 5.0.4
+      eslint: 8.46.0
+      ts-api-utils: 1.0.1(typescript@5.1.6)
+      typescript: 5.1.6
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /@typescript-eslint/types@5.59.1:
-    resolution: {integrity: sha512-dg0ICB+RZwHlysIy/Dh1SP+gnXNzwd/KS0JprD3Lmgmdq+dJAJnUPe1gNG34p0U19HvRlGX733d/KqscrGC1Pg==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+  /@typescript-eslint/types@6.2.1:
+    resolution: {integrity: sha512-528bGcoelrpw+sETlyM91k51Arl2ajbNT9L4JwoXE2dvRe1yd8Q64E4OL7vHYw31mlnVsf+BeeLyAZUEQtqahQ==}
+    engines: {node: ^16.0.0 || >=18.0.0}
     dev: true
 
-  /@typescript-eslint/typescript-estree@5.59.1(typescript@5.0.4):
-    resolution: {integrity: sha512-lYLBBOCsFltFy7XVqzX0Ju+Lh3WPIAWxYpmH/Q7ZoqzbscLiCW00LeYCdsUnnfnj29/s1WovXKh2gwCoinHNGA==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+  /@typescript-eslint/typescript-estree@6.2.1(typescript@5.1.6):
+    resolution: {integrity: sha512-G+UJeQx9AKBHRQBpmvr8T/3K5bJa485eu+4tQBxFq0KoT22+jJyzo1B50JDT9QdC1DEmWQfdKsa8ybiNWYsi0Q==}
+    engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
       typescript: '*'
     peerDependenciesMeta:
       typescript:
         optional: true
     dependencies:
-      '@typescript-eslint/types': 5.59.1
-      '@typescript-eslint/visitor-keys': 5.59.1
+      '@typescript-eslint/types': 6.2.1
+      '@typescript-eslint/visitor-keys': 6.2.1
       debug: 4.3.4(supports-color@5.5.0)
       globby: 11.1.0
       is-glob: 4.0.3
-      semver: 7.5.0
-      tsutils: 3.21.0(typescript@5.0.4)
-      typescript: 5.0.4
+      semver: 7.5.4
+      ts-api-utils: 1.0.1(typescript@5.1.6)
+      typescript: 5.1.6
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /@typescript-eslint/utils@5.59.1(eslint@8.39.0)(typescript@5.0.4):
-    resolution: {integrity: sha512-MkTe7FE+K1/GxZkP5gRj3rCztg45bEhsd8HYjczBuYm+qFHP5vtZmjx3B0yUCDotceQ4sHgTyz60Ycl225njmA==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+  /@typescript-eslint/utils@6.2.1(eslint@8.46.0)(typescript@5.1.6):
+    resolution: {integrity: sha512-eBIXQeupYmxVB6S7x+B9SdBeB6qIdXKjgQBge2J+Ouv8h9Cxm5dHf/gfAZA6dkMaag+03HdbVInuXMmqFB/lKQ==}
+    engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
-      eslint: ^6.0.0 || ^7.0.0 || ^8.0.0
+      eslint: ^7.0.0 || ^8.0.0
     dependencies:
-      '@eslint-community/eslint-utils': 4.4.0(eslint@8.39.0)
-      '@types/json-schema': 7.0.11
-      '@types/semver': 7.3.13
-      '@typescript-eslint/scope-manager': 5.59.1
-      '@typescript-eslint/types': 5.59.1
-      '@typescript-eslint/typescript-estree': 5.59.1(typescript@5.0.4)
-      eslint: 8.39.0
-      eslint-scope: 5.1.1
-      semver: 7.5.0
+      '@eslint-community/eslint-utils': 4.4.0(eslint@8.46.0)
+      '@types/json-schema': 7.0.12
+      '@types/semver': 7.5.0
+      '@typescript-eslint/scope-manager': 6.2.1
+      '@typescript-eslint/types': 6.2.1
+      '@typescript-eslint/typescript-estree': 6.2.1(typescript@5.1.6)
+      eslint: 8.46.0
+      semver: 7.5.4
     transitivePeerDependencies:
       - supports-color
       - typescript
     dev: true
 
-  /@typescript-eslint/visitor-keys@5.59.1:
-    resolution: {integrity: sha512-6waEYwBTCWryx0VJmP7JaM4FpipLsFl9CvYf2foAE8Qh/Y0s+bxWysciwOs0LTBED4JCaNxTZ5rGadB14M6dwA==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+  /@typescript-eslint/visitor-keys@6.2.1:
+    resolution: {integrity: sha512-iTN6w3k2JEZ7cyVdZJTVJx2Lv7t6zFA8DCrJEHD2mwfc16AEvvBWVhbFh34XyG2NORCd0viIgQY1+u7kPI0WpA==}
+    engines: {node: ^16.0.0 || >=18.0.0}
     dependencies:
-      '@typescript-eslint/types': 5.59.1
-      eslint-visitor-keys: 3.4.0
+      '@typescript-eslint/types': 6.2.1
+      eslint-visitor-keys: 3.4.2
     dev: true
 
   /@vitest/expect@0.30.1:
···
   /@vue/compiler-sfc@3.2.47:
     resolution: {integrity: sha512-rog05W+2IFfxjMcFw10tM9+f7i/+FFpZJJ5XHX72NP9eC2uRD+42M3pYcQqDXVYoj74kHMSEdQ/WmCjt8JFksQ==}
     dependencies:
-      '@babel/parser': 7.21.5
+      '@babel/parser': 7.22.4
       '@vue/compiler-core': 3.2.47
       '@vue/compiler-dom': 3.2.47
       '@vue/compiler-ssr': 3.2.47
···
   /@vue/reactivity-transform@3.2.47:
     resolution: {integrity: sha512-m8lGXw8rdnPVVIdIFhf0LeQ/ixyHkH5plYuS83yop5n7ggVJU+z5v0zecwEnX7fa7HNLBhh2qngJJkxpwEEmYA==}
     dependencies:
-      '@babel/parser': 7.21.5
+      '@babel/parser': 7.22.4
       '@vue/compiler-core': 3.2.47
       '@vue/shared': 3.2.47
       estree-walker: 2.0.2
···
   /acorn-globals@7.0.1:
     resolution: {integrity: sha512-umOSDSDrfHbTNPuNpC2NSnnA3LUrqpevPb4T9jRx4MagXNS0rs+gwiTcAvqCRmsD6utzsrzNt+ebm00SNWiC3Q==}
     dependencies:
-      acorn: 8.8.2
+      acorn: 8.10.0
       acorn-walk: 8.2.0
     dev: true
 
-  /acorn-jsx@5.3.2(acorn@8.8.2):
+  /acorn-jsx@5.3.2(acorn@8.10.0):
     resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==}
     peerDependencies:
       acorn: ^6.0.0 || ^7.0.0 || ^8.0.0
     dependencies:
-      acorn: 8.8.2
+      acorn: 8.10.0
     dev: true
 
   /acorn-walk@7.2.0:
···
     engines: {node: '>=0.4.0'}
     hasBin: true
 
-  /acorn@8.8.2:
-    resolution: {integrity: sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw==}
+  /acorn@8.10.0:
+    resolution: {integrity: sha512-F0SAmZ8iUtS//m8DmCTA0jlh6TDKkHQyK6xc6V4KDTyZKA9dnvX9/3sRTVQrWm79glUAZbnmmNcdYwUIHWVybw==}
     engines: {node: '>=0.4.0'}
     hasBin: true
 
···
     resolution: {integrity: sha512-+O9Jct8wf++lXxxFc4hc8LsjaSq0HFzzL7cVsw8pRDIPdjKD2mT4ytDZlLuSBZ4cLKZFXIrMGO7DbQCtMJJMKw==}
     engines: {node: '>=4'}
 
-  /ansi-regex@4.1.0:
-    resolution: {integrity: sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==}
+  /ansi-regex@4.1.1:
+    resolution: {integrity: sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==}
     engines: {node: '>=6'}
 
   /ansi-regex@5.0.1:
···
     resolution: {integrity: sha512-o/HelwhuKpTj/frsOsbNLNgnNGVIFsVP/SW2BSF14gVl7kAfMOJ6/8wUAUvG1R1NHKrfG+2sHZTu0yauT1qBrA==}
     engines: {node: '>=6.0'}
     dependencies:
-      '@babel/runtime': 7.21.0
+      '@babel/runtime': 7.22.5
       '@babel/runtime-corejs3': 7.13.17
     dev: true
 
···
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
-      get-intrinsic: 1.2.0
+      es-abstract: 1.22.1
+      get-intrinsic: 1.2.1
       is-string: 1.0.7
     dev: true
 
···
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
+      es-abstract: 1.22.1
       es-shim-unscopables: 1.0.0
     dev: true
 
···
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
+      es-abstract: 1.22.1
       es-shim-unscopables: 1.0.0
     dev: true
 
···
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
+      es-abstract: 1.22.1
       es-shim-unscopables: 1.0.0
-      get-intrinsic: 1.2.0
+      get-intrinsic: 1.2.1
     dev: true
 
+  /arraybuffer.prototype.slice@1.0.1:
+    resolution: {integrity: sha512-09x0ZWFEjj4WD8PDbykUwo3t9arLn8NIzmmYEJFpYekOAQjpkGSyrQhNoRTcwwcFRu+ycWF78QZ63oWTqSjBcw==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      array-buffer-byte-length: 1.0.0
+      call-bind: 1.0.2
+      define-properties: 1.2.0
+      get-intrinsic: 1.2.1
+      is-array-buffer: 3.0.2
+      is-shared-array-buffer: 1.0.2
+
   /arraybuffer.slice@0.0.7:
     resolution: {integrity: sha512-wGUIVQXuehL5TCqQun8OW81jGzAWycqzFF8lFp+GOM5BXLYj3bKNsYC4daB7n6XjCqxQA/qgTJ+8ANR3acjrog==}
 
···
   /babel-plugin-macros@2.8.0:
     resolution: {integrity: sha512-SEP5kJpfGYqYKpBrj5XU3ahw5p5GOHJ0U5ssOSQ/WBVdwkD2Dzlce95exQTs3jOVWPPKLBN2rlEWkCK7dSmLvg==}
     dependencies:
-      '@babel/runtime': 7.21.0
+      '@babel/runtime': 7.22.5
       cosmiconfig: 6.0.0
-      resolve: 1.22.1
+      resolve: 1.22.2
 
   /babel-plugin-polyfill-corejs2@0.2.0(@babel/core@7.21.5):
     resolution: {integrity: sha512-9bNwiR0dS881c5SHnzCmmGlMkJLl0OUZvxrxHo9w/iNoRuqaPjqlvBf4HrovXtQs/au5yKkpcdgfT1cC5PAZwg==}
···
       '@babel/compat-data': 7.21.5
       '@babel/core': 7.21.5
       '@babel/helper-define-polyfill-provider': 0.2.0(@babel/core@7.21.5)
-      semver: 6.3.0
+      semver: 6.3.1
     transitivePeerDependencies:
       - supports-color
 
···
       hoopy: 0.1.4
       tryer: 1.0.1
 
+  /big-integer@1.6.51:
+    resolution: {integrity: sha512-GPEid2Y9QU1Exl1rpO9B2IPJGHPSupF5GnVIP0blYvNOMer2bTvSWs1jGOUg04hTmu67nmLsQ9TBo1puaotBHg==}
+    engines: {node: '>=0.6'}
+    dev: true
+
   /big.js@3.2.0:
     resolution: {integrity: sha512-+hN/Zh2D08Mx65pZ/4g5bsmNiZUuChDiQfTUQ7qJr4/kuopCr88xZsAXv6mBoZEsUI4OuGHlX59qE94K2mMW8Q==}
 
···
       term-size: 1.2.0
       widest-line: 2.0.1
 
+  /bplist-parser@0.2.0:
+    resolution: {integrity: sha512-z0M+byMThzQmD9NILRniCUXYsYpjwnlO8N5uCFaCqIOpqRsJCrQL9NK3JsD67CN5a08nF5oIL2bD6loTdHOuKw==}
+    engines: {node: '>= 5.10.0'}
+    dependencies:
+      big-integer: 1.6.51
+    dev: true
+
   /brace-expansion@1.1.11:
     resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==}
     dependencies:
···
   /builtins@5.0.1:
     resolution: {integrity: sha512-qwVpFEHNfhYJIzNRBvd2C1kyo6jz3ZSMPyyuR47OPdiKWlbYnZNyDWuyR175qDnAJLiCo5fBBqPb3RiXgWlkOQ==}
     dependencies:
-      semver: 7.5.0
+      semver: 7.5.4
+    dev: true
+
+  /bundle-name@3.0.0:
+    resolution: {integrity: sha512-PKA4BeSvBpQKQ8iPOGCSiell+N8P+Tf1DlwqmYhpe2gAhKPHn8EYOxVT+ShuGmhg8lN8XiSlS80yiExKXrURlw==}
+    engines: {node: '>=12'}
+    dependencies:
+      run-applescript: 5.0.0
     dev: true
 
   /bytes@3.0.0:
···
     resolution: {integrity: sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==}
     dependencies:
       function-bind: 1.1.1
-      get-intrinsic: 1.2.0
+      get-intrinsic: 1.2.1
 
   /caller-callsite@2.0.0:
     resolution: {integrity: sha512-JuG3qI4QOftFsZyOn1qq87fq5grLIyk1JYd5lJmdA+fG7aQ9pA/i3JIJGcO3q0MrRcHlOt1U+ZeHW8Dq9axALQ==}
···
     dependencies:
       date-time: 3.1.0
       esutils: 2.0.3
-      fast-diff: 1.2.0
+      fast-diff: 1.3.0
       js-string-escape: 1.0.1
       lodash: 4.17.21
       md5-hex: 3.0.1
-      semver: 7.5.0
+      semver: 7.5.4
       well-known-symbols: 2.0.0
     dev: true
 
···
     dependencies:
       nice-try: 1.0.5
       path-key: 2.0.1
-      semver: 5.7.1
+      semver: 5.7.2
       shebang-command: 1.2.0
       which: 1.3.1
 
···
       pretty-bytes: 5.6.0
       proxy-from-env: 1.0.0
       request-progress: 3.0.0
-      semver: 7.5.0
+      semver: 7.5.4
       supports-color: 8.1.1
       tmp: 0.2.1
       untildify: 4.0.0
···
       is-regex: 1.1.4
       object-is: 1.1.5
       object-keys: 1.1.1
-      regexp.prototype.flags: 1.4.3
+      regexp.prototype.flags: 1.5.0
 
   /deep-extend@0.6.0:
     resolution: {integrity: sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==}
···
     engines: {node: '>=0.10.0'}
     dev: true
 
+  /default-browser-id@3.0.0:
+    resolution: {integrity: sha512-OZ1y3y0SqSICtE8DE4S8YOE9UZOJ8wO16fKWVP5J1Qz42kV9jcnMVFrEE/noXb/ss3Q4pZIH79kxofzyNNtUNA==}
+    engines: {node: '>=12'}
+    dependencies:
+      bplist-parser: 0.2.0
+      untildify: 4.0.0
+    dev: true
+
+  /default-browser@4.0.0:
+    resolution: {integrity: sha512-wX5pXO1+BrhMkSbROFsyxUm0i/cJEScyNhA4PPxc41ICuv05ZZB/MX28s8aZx6xjmatvebIapF6hLEKEcpneUA==}
+    engines: {node: '>=14.16'}
+    dependencies:
+      bundle-name: 3.0.0
+      default-browser-id: 3.0.0
+      execa: 7.1.1
+      titleize: 3.0.0
+    dev: true
+
   /default-gateway@4.2.0:
     resolution: {integrity: sha512-h6sMrVB1VMWVrW13mSc6ia/DwYYw5MN6+exNu1OaJeFac5aSAvwM7lZ0NVfTABuSkQelr4h5oebg3KB1XPdjgA==}
     engines: {node: '>=6'}
···
   /define-lazy-prop@2.0.0:
     resolution: {integrity: sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og==}
     engines: {node: '>=8'}
+    dev: true
+
+  /define-lazy-prop@3.0.0:
+    resolution: {integrity: sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==}
+    engines: {node: '>=12'}
     dev: true
 
   /define-properties@1.2.0:
···
     dependencies:
       commander: 2.20.3
       lru-cache: 4.1.5
-      semver: 5.7.1
+      semver: 5.7.2
       sigmund: 1.0.1
     dev: true
 
···
     resolution: {integrity: sha512-Nv9m36S/vxpsI+Hc4/ZGRs0n9mXqSWGGq49zxb/cJfPAQMbUtttJAlNPS4AQzaBdw/pKskw5bMbekT/Y7W/Wlg==}
     engines: {node: '>=6.9.0'}
     dependencies:
-      graceful-fs: 4.2.10
+      graceful-fs: 4.2.11
       memory-fs: 0.5.0
       tapable: 1.1.3
 
···
     dependencies:
       is-arrayish: 0.2.1
 
-  /es-abstract@1.21.2:
-    resolution: {integrity: sha512-y/B5POM2iBnIxCiernH1G7rC9qQoM77lLIMQLuob0zhp8C56Po81+2Nj0WFKnd0pNReDTnkYryc+zhOzpEIROg==}
+  /es-abstract@1.22.1:
+    resolution: {integrity: sha512-ioRRcXMO6OFyRpyzV3kE1IIBd4WG5/kltnzdxSCqoP8CMGs/Li+M1uF5o7lOkZVFjDs+NLesthnF66Pg/0q0Lw==}
     engines: {node: '>= 0.4'}
     dependencies:
       array-buffer-byte-length: 1.0.0
+      arraybuffer.prototype.slice: 1.0.1
       available-typed-arrays: 1.0.5
       call-bind: 1.0.2
       es-set-tostringtag: 2.0.1
       es-to-primitive: 1.2.1
       function.prototype.name: 1.1.5
-      get-intrinsic: 1.2.0
+      get-intrinsic: 1.2.1
       get-symbol-description: 1.0.0
       globalthis: 1.0.3
       gopd: 1.0.1
···
       is-regex: 1.1.4
       is-shared-array-buffer: 1.0.2
       is-string: 1.0.7
-      is-typed-array: 1.1.10
+      is-typed-array: 1.1.12
       is-weakref: 1.0.2
       object-inspect: 1.12.3
       object-keys: 1.1.1
       object.assign: 4.1.4
-      regexp.prototype.flags: 1.4.3
+      regexp.prototype.flags: 1.5.0
+      safe-array-concat: 1.0.0
       safe-regex-test: 1.0.0
       string.prototype.trim: 1.2.7
       string.prototype.trimend: 1.0.6
       string.prototype.trimstart: 1.0.6
+      typed-array-buffer: 1.0.0
+      typed-array-byte-length: 1.0.0
+      typed-array-byte-offset: 1.0.0
       typed-array-length: 1.0.4
       unbox-primitive: 1.0.2
-      which-typed-array: 1.1.9
+      which-typed-array: 1.1.11
 
   /es-set-tostringtag@2.0.1:
     resolution: {integrity: sha512-g3OMbtlwY3QewlqAiMLI47KywjWZoEytKr8pf6iTC8uJq5bIAH52Z9pnQ8pVL6whrCto53JZDuUIsifGeLorTg==}
     engines: {node: '>= 0.4'}
     dependencies:
-      get-intrinsic: 1.2.0
+      get-intrinsic: 1.2.1
       has: 1.0.3
       has-tostringtag: 1.0.0
 
···
       source-map: 0.6.1
     dev: true
 
-  /eslint-config-prettier@8.8.0(eslint@8.39.0):
-    resolution: {integrity: sha512-wLbQiFre3tdGgpDv67NQKnJuTlcUVYHas3k+DZCc2U2BadthoEY4B7hLPvAxaqdyOGCzuLfii2fqGph10va7oA==}
+  /eslint-config-prettier@8.9.0(eslint@8.46.0):
+    resolution: {integrity: sha512-+sbni7NfVXnOpnRadUA8S28AUlsZt9GjgFvABIRL9Hkn8KqNzOp+7Lw4QWtrwn20KzU3wqu1QoOj2m+7rKRqkA==}
     hasBin: true
     peerDependencies:
       eslint: '>=7.0.0'
     dependencies:
-      eslint: 8.39.0
+      eslint: 8.46.0
     dev: true
 
-  /eslint-plugin-es5@1.5.0(eslint@8.39.0):
+  /eslint-plugin-es5@1.5.0(eslint@8.46.0):
     resolution: {integrity: sha512-Qxmfo7v2B7SGAEURJo0dpBweFf+JU15kSyALfiB2rXWcBuJ96r6X9kFHXFnhdopPHCaHjoQs1xQPUJVbGMb1AA==}
     peerDependencies:
       eslint: '>= 3.0.0'
     dependencies:
-      eslint: 8.39.0
+      eslint: 8.46.0
     dev: true
 
-  /eslint-plugin-prettier@4.2.1(eslint-config-prettier@8.8.0)(eslint@8.39.0)(prettier@2.8.8):
-    resolution: {integrity: sha512-f/0rXLXUt0oFYs8ra4w49wYZBG5GKZpAYsJSm6rnYL5uVDjd+zowwMwVZHnAjf4edNrKpCDYfXDgmRE/Ak7QyQ==}
-    engines: {node: '>=12.0.0'}
+  /eslint-plugin-prettier@5.0.0(eslint-config-prettier@8.9.0)(eslint@8.46.0)(prettier@3.0.0):
+    resolution: {integrity: sha512-AgaZCVuYDXHUGxj/ZGu1u8H8CYgDY3iG6w5kUFw4AzMVXzB7VvbKgYR4nATIN+OvUrghMbiDLeimVjVY5ilq3w==}
+    engines: {node: ^14.18.0 || >=16.0.0}
     peerDependencies:
-      eslint: '>=7.28.0'
+      '@types/eslint': '>=8.0.0'
+      eslint: '>=8.0.0'
       eslint-config-prettier: '*'
-      prettier: '>=2.0.0'
+      prettier: '>=3.0.0'
     peerDependenciesMeta:
+      '@types/eslint':
+        optional: true
       eslint-config-prettier:
         optional: true
     dependencies:
-      eslint: 8.39.0
-      eslint-config-prettier: 8.8.0(eslint@8.39.0)
-      prettier: 2.8.8
+      eslint: 8.46.0
+      eslint-config-prettier: 8.9.0(eslint@8.46.0)
+      prettier: 3.0.0
       prettier-linter-helpers: 1.0.0
+      synckit: 0.8.5
     dev: true
 
-  /eslint-plugin-react-hooks@4.6.0(eslint@8.39.0):
+  /eslint-plugin-react-hooks@4.6.0(eslint@8.46.0):
     resolution: {integrity: sha512-oFc7Itz9Qxh2x4gNHStv3BqJq54ExXmfC+a1NjAta66IAN87Wu0R/QArgIS9qKzX3dXKPI9H5crl9QchNMY9+g==}
     engines: {node: '>=10'}
     peerDependencies:
       eslint: ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0
     dependencies:
-      eslint: 8.39.0
+      eslint: 8.46.0
     dev: true
 
-  /eslint-plugin-react@7.32.2(eslint@8.39.0):
-    resolution: {integrity: sha512-t2fBMa+XzonrrNkyVirzKlvn5RXzzPwRHtMvLAtVZrt8oxgnTQaYbU6SXTOO1mwQgp1y5+toMSKInnzGr0Knqg==}
+  /eslint-plugin-react@7.33.1(eslint@8.46.0):
+    resolution: {integrity: sha512-L093k0WAMvr6VhNwReB8VgOq5s2LesZmrpPdKz/kZElQDzqS7G7+DnKoqT+w4JwuiGeAhAvHO0fvy0Eyk4ejDA==}
     engines: {node: '>=4'}
     peerDependencies:
       eslint: ^3 || ^4 || ^5 || ^6 || ^7 || ^8
···
       array.prototype.flatmap: 1.3.1
       array.prototype.tosorted: 1.1.1
       doctrine: 2.1.0
-      eslint: 8.39.0
+      eslint: 8.46.0
       estraverse: 5.3.0
-      jsx-ast-utils: 3.3.3
+      jsx-ast-utils: 3.3.5
       minimatch: 3.1.2
       object.entries: 1.1.6
       object.fromentries: 2.0.6
···
       object.values: 1.1.6
       prop-types: 15.8.1
       resolve: 2.0.0-next.4
-      semver: 6.3.0
+      semver: 6.3.1
       string.prototype.matchall: 4.0.8
     dev: true
 
···
       esrecurse: 4.3.0
       estraverse: 4.3.0
 
-  /eslint-scope@5.1.1:
-    resolution: {integrity: sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==}
-    engines: {node: '>=8.0.0'}
-    dependencies:
-      esrecurse: 4.3.0
-      estraverse: 4.3.0
-    dev: true
-
-  /eslint-scope@7.2.0:
-    resolution: {integrity: sha512-DYj5deGlHBfMt15J7rdtyKNq/Nqlv5KfU4iodrQ019XESsRnwXH9KAE0y3cwtUHDo2ob7CypAnCqefh6vioWRw==}
+  /eslint-scope@7.2.2:
+    resolution: {integrity: sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     dependencies:
       esrecurse: 4.3.0
       estraverse: 5.3.0
     dev: true
 
-  /eslint-visitor-keys@3.4.0:
-    resolution: {integrity: sha512-HPpKPUBQcAsZOsHAFwTtIKcYlCje62XB7SEAcxjtmW6TD1WVpkS6i6/hOVtTZIl4zGj/mBqpFVGvaDneik+VoQ==}
+  /eslint-visitor-keys@3.4.2:
+    resolution: {integrity: sha512-8drBzUEyZ2llkpCA67iYrgEssKDUu68V8ChqqOfFupIaG/LCVPUT+CoGJpT77zJprs4T/W7p07LP7zAIMuweVw==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     dev: true
 
-  /eslint@8.39.0:
-    resolution: {integrity: sha512-mwiok6cy7KTW7rBpo05k6+p4YVZByLNjAZ/ACB9DRCu4YDRwjXI01tWHp6KAUWelsBetTxKK/2sHB0vdS8Z2Og==}
+  /eslint@8.46.0:
+    resolution: {integrity: sha512-cIO74PvbW0qU8e0mIvk5IV3ToWdCq5FYG6gWPHHkx6gNdjlbAYvtfHmlCMXxjcoVaIdwy/IAt3+mDkZkfvb2Dg==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     hasBin: true
     dependencies:
-      '@eslint-community/eslint-utils': 4.4.0(eslint@8.39.0)
-      '@eslint-community/regexpp': 4.5.0
-      '@eslint/eslintrc': 2.0.2
-      '@eslint/js': 8.39.0
-      '@humanwhocodes/config-array': 0.11.8
+      '@eslint-community/eslint-utils': 4.4.0(eslint@8.46.0)
+      '@eslint-community/regexpp': 4.6.2
+      '@eslint/eslintrc': 2.1.1
+      '@eslint/js': 8.46.0
+      '@humanwhocodes/config-array': 0.11.10
       '@humanwhocodes/module-importer': 1.0.1
       '@nodelib/fs.walk': 1.2.8
       ajv: 6.12.6
···
       debug: 4.3.4(supports-color@5.5.0)
       doctrine: 3.0.0
       escape-string-regexp: 4.0.0
-      eslint-scope: 7.2.0
-      eslint-visitor-keys: 3.4.0
-      espree: 9.5.1
+      eslint-scope: 7.2.2
+      eslint-visitor-keys: 3.4.2
+      espree: 9.6.1
       esquery: 1.5.0
       esutils: 2.0.3
       fast-deep-equal: 3.1.3
···
       find-up: 5.0.0
       glob-parent: 6.0.2
       globals: 13.20.0
-      grapheme-splitter: 1.0.4
+      graphemer: 1.4.0
       ignore: 5.2.4
-      import-fresh: 3.3.0
       imurmurhash: 0.1.4
       is-glob: 4.0.3
       is-path-inside: 3.0.3
-      js-sdsl: 4.4.0
       js-yaml: 4.1.0
       json-stable-stringify-without-jsonify: 1.0.1
       levn: 0.4.1
       lodash.merge: 4.6.2
       minimatch: 3.1.2
       natural-compare: 1.4.0
-      optionator: 0.9.1
+      optionator: 0.9.3
       strip-ansi: 6.0.1
-      strip-json-comments: 3.1.1
       text-table: 0.2.0
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /espree@9.5.1:
-    resolution: {integrity: sha512-5yxtHSZXRSW5pvv3hAlXM5+/Oswi1AUFqBmbibKb5s6bp3rGIDkyXU6xCoyuuLhijr4SFwPrXRoZjz0AZDN9tg==}
+  /espree@9.6.1:
+    resolution: {integrity: sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     dependencies:
-      acorn: 8.8.2
-      acorn-jsx: 5.3.2(acorn@8.8.2)
-      eslint-visitor-keys: 3.4.0
+      acorn: 8.10.0
+      acorn-jsx: 5.3.2(acorn@8.10.0)
+      eslint-visitor-keys: 3.4.2
     dev: true
 
   /esprima@4.0.1:
···
       cross-spawn: 7.0.3
       get-stream: 5.2.0
       human-signals: 1.1.1
+      is-stream: 2.0.1
+      merge-stream: 2.0.0
+      npm-run-path: 4.0.1
+      onetime: 5.1.2
+      signal-exit: 3.0.7
+      strip-final-newline: 2.0.0
+    dev: true
+
+  /execa@5.1.1:
+    resolution: {integrity: sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==}
+    engines: {node: '>=10'}
+    dependencies:
+      cross-spawn: 7.0.3
+      get-stream: 6.0.1
+      human-signals: 2.1.0
       is-stream: 2.0.1
       merge-stream: 2.0.0
       npm-run-path: 4.0.1
···
   /fast-deep-equal@3.1.3:
     resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==}
 
-  /fast-diff@1.2.0:
-    resolution: {integrity: sha512-xJuoT5+L99XlZ8twedaRf6Ax2TgQVxvgZOYoPKqZufmJib0tL2tegPBOZb1pVNgIhlqDlA0eO0c3wBvQcmzx4w==}
+  /fast-diff@1.3.0:
+    resolution: {integrity: sha512-VxPP4NqbUjj6MaAOafWeUn2cXWLcCtljklUtZf0Ind4XQ+QPtmA0b18zZy0jIQx+ExRVCR/ZQpBmik5lXshNsw==}
     dev: true
 
-  /fast-glob@3.2.12:
-    resolution: {integrity: sha512-DVj4CQIYYow0BlaelwK1pHl5n5cRSJfM60UA0zK891sVInoPri2Ekj7+e1CT3/3qxXenpI+nBBmQAcJPJgaj4w==}
+  /fast-glob@3.3.1:
+    resolution: {integrity: sha512-kNFPyjhh5cKjrUltxs+wFx+ZkbRaxxmZ+X0ZU31SOsxCEtP9VPgtq2teZw1DebupL5GmDaNQ6yKMMVcM41iqDg==}
     engines: {node: '>=8.6.0'}
     dependencies:
       '@nodelib/fs.stat': 2.0.5
···
     resolution: {integrity: sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==}
     engines: {node: '>=6 <7 || >=8'}
     dependencies:
-      graceful-fs: 4.2.10
+      graceful-fs: 4.2.11
       jsonfile: 4.0.0
       universalify: 0.1.2
     dev: true
···
     engines: {node: '>=10'}
     dependencies:
       at-least-node: 1.0.0
-      graceful-fs: 4.2.10
+      graceful-fs: 4.2.11
       jsonfile: 6.1.0
       universalify: 2.0.0
     dev: true
···
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
+      es-abstract: 1.22.1
       functions-have-names: 1.2.3
 
   /functions-have-names@1.2.3:
···
     resolution: {integrity: sha512-Hm0ixYtaSZ/V7C8FJrtZIuBBI+iSgL+1Aq82zSu8VQNB4S3Gk8e7Qs3VwBDJAhmRZcFqkl3tQu36g/Foh5I5ig==}
     dev: true
 
-  /get-intrinsic@1.2.0:
-    resolution: {integrity: sha512-L049y6nFOuom5wGyRc3/gdTLO94dySVKRACj1RmJZBQXlbTMhtNIgkWkUHq+jYmZvKf14EW1EoJnnjbmoHij0Q==}
+  /get-intrinsic@1.2.1:
+    resolution: {integrity: sha512-2DcsyfABl+gVHEfCOaTrWgyt+tb6MSEGmKq+kI5HwLbIYgjgmMcV8KQ41uaKz1xxUcn9tJtgFbQUEVcEbd0FYw==}
     dependencies:
       function-bind: 1.1.1
       has: 1.0.3
+      has-proto: 1.0.1
       has-symbols: 1.0.3
 
   /get-proxy@2.1.0:
···
     engines: {node: '>= 0.4'}
     dependencies:
       call-bind: 1.0.2
-      get-intrinsic: 1.2.0
+      get-intrinsic: 1.2.1
 
   /get-value@2.0.6:
     resolution: {integrity: sha512-Ln0UQDlxH1BapMu3GPtf7CuYNwRZf2gwCuPqbyG6pB8WfmFpzqcy4xtAaAMUhnNqjMKTiCPZG2oMT3YSx8U2NA==}
···
       is-glob: 4.0.3
     dev: true
 
-  /glob@7.1.6:
-    resolution: {integrity: sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==}
-    dependencies:
-      fs.realpath: 1.0.0
-      inflight: 1.0.6
-      inherits: 2.0.4
-      minimatch: 3.1.2
-      once: 1.4.0
-      path-is-absolute: 1.0.1
-
   /glob@7.2.3:
     resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==}
     dependencies:
···
     dependencies:
       array-union: 2.1.0
       dir-glob: 3.0.1
-      fast-glob: 3.2.12
+      fast-glob: 3.3.1
       ignore: 5.2.4
       merge2: 1.4.1
       slash: 3.0.0
···
     engines: {node: '>=0.10.0'}
     dependencies:
       array-union: 1.0.2
-      glob: 7.1.6
+      glob: 7.2.3
       object-assign: 4.1.1
       pify: 2.3.0
       pinkie-promise: 2.0.1
···
   /gopd@1.0.1:
     resolution: {integrity: sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==}
     dependencies:
-      get-intrinsic: 1.2.0
+      get-intrinsic: 1.2.1
 
   /got@8.3.2:
     resolution: {integrity: sha512-qjUJ5U/hawxosMryILofZCkm3C84PLJS/0grRIpjAwu+Lkxxj5cxeCU25BG0/3mDSpXKTyZr8oh8wIgLaH0QCw==}
···
       url-parse-lax: 3.0.0
       url-to-options: 1.0.1
 
-  /graceful-fs@4.2.10:
-    resolution: {integrity: sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==}
-
   /graceful-fs@4.2.11:
     resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==}
 
   /grapheme-splitter@1.0.4:
     resolution: {integrity: sha512-bzh50DW9kTPM00T8y4o8vQg89Di9oLJVLW/KaOGIXJWP/iqCN6WKYkbNOF04vFLJhwcpYUh9ydh/+5vpOqV4YQ==}
+    dev: true
+
+  /graphemer@1.4.0:
+    resolution: {integrity: sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==}
     dev: true
 
   /graphql@16.6.0:
···
   /has-property-descriptors@1.0.0:
     resolution: {integrity: sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ==}
     dependencies:
-      get-intrinsic: 1.2.0
+      get-intrinsic: 1.2.1
 
   /has-proto@1.0.1:
     resolution: {integrity: sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg==}
···
   /history@4.10.1:
     resolution: {integrity: sha512-36nwAD620w12kuzPAsyINPWJqlNbij+hpK1k9XRloDtym8mxzGYl2c17LnV6IAGB2Dmg4tEa7G7DlawS0+qjew==}
     dependencies:
-      '@babel/runtime': 7.21.0
+      '@babel/runtime': 7.22.5
       loose-envify: 1.4.0
       resolve-pathname: 3.0.0
       tiny-invariant: 1.1.0
···
     engines: {node: '>=8.12.0'}
     dev: true
 
+  /human-signals@2.1.0:
+    resolution: {integrity: sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==}
+    engines: {node: '>=10.17.0'}
+    dev: true
+
   /human-signals@4.3.0:
     resolution: {integrity: sha512-zyzVyMjpGBX2+6cDVZeFPCdtOtdsxOeseRhB9tkQ6xXmGUNrcnBzdEKPy3VPNYz+4gy1oukVOXcrJCunSyc6QQ==}
     engines: {node: '>=14.18.0'}
···
     resolution: {integrity: sha512-Y+R5hJrzs52QCG2laLn4udYVnxsfny9CpOhNhUvk/SSSVyF6T27FzRbF0sroPidSu3X8oEAkOn2K804mjpt6UQ==}
     engines: {node: '>= 0.4'}
     dependencies:
-      get-intrinsic: 1.2.0
+      get-intrinsic: 1.2.1
       has: 1.0.3
       side-channel: 1.0.4
 
···
     resolution: {integrity: sha512-y+FyyR/w8vfIRq4eQcM1EYgSTnmHXPqaF+IgzgraytCFq5Xh8lllDVmAZolPJiZttZLeFSINPYMaEJ7/vWUa1w==}
     dependencies:
       call-bind: 1.0.2
-      get-intrinsic: 1.2.0
-      is-typed-array: 1.1.10
+      get-intrinsic: 1.2.1
+      is-typed-array: 1.1.12
 
   /is-arrayish@0.2.1:
     resolution: {integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==}
···
       rgb-regex: 1.0.1
       rgba-regex: 1.0.0
 
-  /is-core-module@2.11.0:
-    resolution: {integrity: sha512-RRjxlvLDkD1YJwDbroBHMb+cukurkDWNyHx7D3oNB5x9rb5ogcksMC5wHCadcXoo67gVr/+3GFySh3134zi6rw==}
-    dependencies:
-      has: 1.0.3
-
   /is-core-module@2.12.1:
     resolution: {integrity: sha512-Q4ZuBAe2FUsKtyQJoQHlvP8OvBERxO3jEmy1I7hcRXcJBGGHFh/aJBswbXuS9sgrDH2QUO8ilkwNPHvHMd8clg==}
     dependencies:
···
     hasBin: true
     dev: true
 
+  /is-docker@3.0.0:
+    resolution: {integrity: sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+    hasBin: true
+    dev: true
+
   /is-domain@0.0.1:
     resolution: {integrity: sha512-hLm9uZUDm/sk0+xZgxyJluSf4B37sg3ivzv4ndTxNCAMnWFUUsHh1u4eh2maEcEvQl3mc65a9pJ/KURGItbLIg==}
     dev: true
···
   /is-hexadecimal@1.0.4:
     resolution: {integrity: sha512-gyPJuv83bHMpocVYoqof5VDiZveEoGoFL8m3BXNb2VW8Xs+rz9kqO8LOQ5DH6EsuvilT1ApazU0pyl+ytbPtlw==}
 
+  /is-inside-container@1.0.0:
+    resolution: {integrity: sha512-KIYLCCJghfHZxqjYBE7rEy0OBuTd5xCHS7tHVgvCLkx7StIoaxwNW3hCALgEUjFfeRk+MG/Qxmp/vtETEF3tRA==}
+    engines: {node: '>=14.16'}
+    hasBin: true
+    dependencies:
+      is-docker: 3.0.0
+    dev: true
+
   /is-installed-globally@0.4.0:
     resolution: {integrity: sha512-iwGqO3J21aaSkC7jWnHP/difazwS7SFeIqxv6wEtLU8Y5KlzFTjyqcSIT0d8s4+dDhKytsk9PJZ2BkS5eZwQRQ==}
     engines: {node: '>=10'}
···
     dependencies:
       has-symbols: 1.0.3
 
-  /is-typed-array@1.1.10:
-    resolution: {integrity: sha512-PJqgEHiWZvMpaFZ3uTc8kHPM4+4ADTlDniuQL7cU/UDA0Ql7F70yGfHph3cLNe+c9toaigv+DFzTJKhc2CtO6A==}
+  /is-typed-array@1.1.12:
+    resolution: {integrity: sha512-Z14TF2JNG8Lss5/HMqt0//T9JeHXttXy5pH/DBU4vi98ozO2btxzq9MwYDZYnKwU8nRsz/+GVFVRDq3DkVuSPg==}
     engines: {node: '>= 0.4'}
     dependencies:
-      available-typed-arrays: 1.0.5
-      call-bind: 1.0.2
-      for-each: 0.3.3
-      gopd: 1.0.1
-      has-tostringtag: 1.0.0
+      which-typed-array: 1.1.11
 
   /is-typedarray@1.0.0:
     resolution: {integrity: sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==}
···
   /isarray@2.0.1:
     resolution: {integrity: sha512-c2cu3UxbI+b6kR3fy0nRnAhodsvR9dx7U5+znCOzdj6IfP3upFURTr0Xl5BlQZNKZjEtxrmVyfSdeE3O57smoQ==}
 
+  /isarray@2.0.5:
+    resolution: {integrity: sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==}
+
   /isexe@2.0.0:
     resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==}
 
···
       nopt: 6.0.0
     dev: true
 
-  /js-sdsl@4.4.0:
-    resolution: {integrity: sha512-FfVSdx6pJ41Oa+CF7RDaFmTnCaFhua+SNYQX74riGOpl96x+2jQCqEfQ2bnXu/5DPCqlRuiqyvTJM0Qjz26IVg==}
-    dev: true
-
   /js-string-escape@1.0.1:
     resolution: {integrity: sha512-Smw4xcfIQ5LVjAOuJCvN/zIodzA/BBSsluuoSykP+lUvScIi4U6RJLfwHet5cxFnCswUjISV8oAXaqaJDY3chg==}
     engines: {node: '>= 0.8'}
···
         optional: true
     dependencies:
       abab: 2.0.6
-      acorn: 8.8.2
+      acorn: 8.10.0
       acorn-globals: 7.0.1
       cssstyle: 3.0.0
       data-urls: 4.0.0
···
       verror: 1.10.0
     dev: true
 
-  /jsx-ast-utils@3.3.3:
-    resolution: {integrity: sha512-fYQHZTZ8jSfmWZ0iyzfwiU4WDX4HpHbMCZ3gPlWYiCl3BoeOTsqKBqnTVfH2rYT7eP5c3sVbeSPHnnJOaTrWiw==}
+  /jsx-ast-utils@3.3.5:
+    resolution: {integrity: sha512-ZZow9HBI5O6EPgSJLUb8n2NKgmVWTwCvHGwFuJlMjvLFqlGG6pjirPhtdsseaLZjSibD8eegzmYpUZwoIlj2cQ==}
     engines: {node: '>=4.0'}
     dependencies:
       array-includes: 3.1.6
+      array.prototype.flat: 1.3.1
       object.assign: 4.1.4
+      object.values: 1.1.6
     dev: true
 
   /just-diff-apply@5.5.0:
···
     engines: {node: '>=6'}
     dependencies:
       pify: 4.0.1
-      semver: 5.7.1
+      semver: 5.7.2
 
   /make-dir@3.1.0:
     resolution: {integrity: sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==}
     engines: {node: '>=8'}
     dependencies:
-      semver: 6.3.0
+      semver: 6.3.1
 
   /make-fetch-happen@10.2.1:
     resolution: {integrity: sha512-NgOPbRiaQM10DYXvN3/hhGVI2M5MtITFryzBGxHM5p4wnFxsVCbxkrBrDsk+EZ5OB4jEOT7AjDxtdF+KVEFT7w==}
···
       prop-types: ^15.0.0
       react: ^0.14.0 || ^15.0.0 || ^16.0.0 || ^17.0.0 || 17
     dependencies:
-      '@babel/runtime': 7.21.0
+      '@babel/runtime': 7.22.5
       prop-types: 15.8.1
       react: 17.0.2
       tiny-warning: 1.0.3
···
   /mlly@1.2.0:
     resolution: {integrity: sha512-+c7A3CV0KGdKcylsI6khWyts/CYrGTrRVo4R/I7u/cUsy0Conxa6LUhiEzVKIw14lc2L5aiO4+SeVe4TeGRKww==}
     dependencies:
-      acorn: 8.8.2
+      acorn: 8.10.0
       pathe: 1.1.0
       pkg-types: 1.0.2
       ufo: 1.1.1
···
     dependencies:
       env-paths: 2.2.1
       glob: 7.2.3
-      graceful-fs: 4.2.10
+      graceful-fs: 4.2.11
       make-fetch-happen: 10.2.1
       nopt: 6.0.0
       npmlog: 6.0.2
       rimraf: 3.0.2
-      semver: 7.5.0
+      semver: 7.5.4
       tar: 6.1.13
       which: 2.0.2
     transitivePeerDependencies:
···
     resolution: {integrity: sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==}
     dependencies:
       hosted-git-info: 2.8.9
-      resolve: 1.22.1
-      semver: 5.7.1
+      resolve: 1.22.2
+      semver: 5.7.2
       validate-npm-package-license: 3.0.4
     dev: true
 
···
     engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
     dependencies:
       hosted-git-info: 6.1.1
-      is-core-module: 2.11.0
-      semver: 7.5.0
+      is-core-module: 2.12.1
+      semver: 7.5.4
       validate-npm-package-license: 3.0.4
     dev: true
 
···
     resolution: {integrity: sha512-SBU9oFglRVZnfElwAtF14NivyulDqF1VKqqwNsFW9HDcbHMAPHpRSsVFgKuwFGq/hVvWZExz62Th0kvxn/XE7Q==}
     engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
     dependencies:
-      semver: 7.5.0
+      semver: 7.5.4
     dev: true
 
   /npm-normalize-package-bin@3.0.0:
···
     dependencies:
       hosted-git-info: 6.1.1
       proc-log: 3.0.0
-      semver: 7.5.0
+      semver: 7.5.4
       validate-npm-package-name: 5.0.0
     dev: true
 
···
       npm-install-checks: 6.0.0
       npm-normalize-package-bin: 3.0.0
       npm-package-arg: 10.1.0
-      semver: 7.5.0
+      semver: 7.5.4
     dev: true
 
   /npm-registry-fetch@14.0.3:
···
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
+      es-abstract: 1.22.1
     dev: true
 
   /object.fromentries@2.0.6:
···
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
+      es-abstract: 1.22.1
     dev: true
 
   /object.getownpropertydescriptors@2.1.2:
···
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
+      es-abstract: 1.22.1
 
   /object.hasown@1.1.2:
     resolution: {integrity: sha512-B5UIT3J1W+WuWIU55h0mjlwaqxiE5vYENJXIXZ4VFe05pNYrkKuK0U/6aFcb0pKywYJh7IhfoqUfKVmrJJHZHw==}
     dependencies:
       define-properties: 1.2.0
-      es-abstract: 1.21.2
+      es-abstract: 1.22.1
     dev: true
 
   /object.pick@1.3.0:
···
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
+      es-abstract: 1.22.1
 
   /obuf@1.1.2:
     resolution: {integrity: sha512-PX1wu0AmAdPqOL1mWhqmlOd8kOIZQwGZw6rh7uby9fTc5lhaOWFLX3I6R1hrF9k3zUY40e6igsLGkDXK92LJNg==}
···
       is-wsl: 2.2.0
     dev: true
 
+  /open@9.1.0:
+    resolution: {integrity: sha512-OS+QTnw1/4vrf+9hh1jc1jnYjzSG4ttTBB8UxOwAnInG3Uo4ssetzC1ihqaIHjLJnA5GGlRl6QlZXOTQhRBUvg==}
+    engines: {node: '>=14.16'}
+    dependencies:
+      default-browser: 4.0.0
+      define-lazy-prop: 3.0.0
+      is-inside-container: 1.0.0
+      is-wsl: 2.2.0
+    dev: true
+
   /opencollective-postinstall@2.0.3:
     resolution: {integrity: sha512-8AV/sCtuzUeTo8gQK5qDZzARrulB3egtLzFgteqB2tcT4Mw7B8Kt7JcDHmltjz6FOAHsvTevk70gZEbhM4ZS9Q==}
     hasBin: true
···
       word-wrap: 1.2.3
     dev: true
 
-  /optionator@0.9.1:
-    resolution: {integrity: sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw==}
+  /optionator@0.9.3:
+    resolution: {integrity: sha512-JjCoypp+jKn1ttEFExxhetCKeJt9zhAgAve5FXHixTvFDW/5aEktX9bufBKLRRMdU7bNtpLfcGu94B3cdEJgjg==}
     engines: {node: '>= 0.8.0'}
     dependencies:
+      '@aashutoshrathi/word-wrap': 1.2.6
       deep-is: 0.1.4
       fast-levenshtein: 2.0.6
       levn: 0.4.1
       prelude-ls: 1.2.1
       type-check: 0.4.0
-      word-wrap: 1.2.3
     dev: true
 
   /original@1.0.2:
···
     resolution: {integrity: sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w==}
     engines: {node: '>=6.0.0'}
     dependencies:
-      fast-diff: 1.2.0
+      fast-diff: 1.3.0
     dev: true
 
   /prettier@2.8.8:
     resolution: {integrity: sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==}
     engines: {node: '>=10.13.0'}
+    hasBin: true
+    dev: true
+
+  /prettier@3.0.0:
+    resolution: {integrity: sha512-zBf5eHpwHOGPC47h0zrPyNn+eAEIdEzfywMoYn2XPi0P44Zp0tSq64rq0xAREh4auw2cJZHo9QUob+NqCQky4g==}
+    engines: {node: '>=14'}
     hasBin: true
     dev: true
 
···
     peerDependencies:
       react: '>=16.13.1 || 17'
     dependencies:
-      '@babel/runtime': 7.21.0
+      '@babel/runtime': 7.22.5
       react: 17.0.2
     dev: true
 
···
     peerDependencies:
       react: '>=15 || 17'
     dependencies:
-      '@babel/runtime': 7.21.0
+      '@babel/runtime': 7.22.5
       history: 4.10.1
       loose-envify: 1.4.0
       prop-types: 15.8.1
···
     peerDependencies:
       react: '>=15 || 17'
     dependencies:
-      '@babel/runtime': 7.21.0
+      '@babel/runtime': 7.22.5
       history: 4.10.1
       hoist-non-react-statics: 3.3.2
       loose-envify: 1.4.0
···
       '@mdx-js/mdx': 1.6.22
       '@mdx-js/react': 1.6.22(react@17.0.2)
       github-slugger: 1.3.0
-      glob: 7.1.6
+      glob: 7.2.3
       loader-utils: 1.4.0
       mdast-util-to-string: 1.1.0
       react-static: 7.3.0(react-hot-loader@4.13.0)
···
       '@babel/preset-react': 7.13.13(@babel/core@7.21.5)
       '@babel/preset-stage-0': 7.8.3
       '@babel/register': 7.13.16(@babel/core@7.21.5)
-      '@babel/runtime': 7.21.0
+      '@babel/runtime': 7.22.5
       '@reach/router': 1.3.4(react-dom@17.0.2)(react@17.0.2)
       autoprefixer: 9.8.6
       axios: 0.19.2
···
       file-loader: 3.0.1(webpack@4.46.0)
       fs-extra: 7.0.1
       git-promise: 0.3.1
-      glob: 7.1.6
+      glob: 7.2.3
       gunzip-maybe: 1.4.2
       html-webpack-plugin: 3.2.0(webpack@4.46.0)
       inquirer: 6.5.2
···
   /regenerator-transform@0.14.5:
     resolution: {integrity: sha512-eOf6vka5IO151Jfsw2NO9WpGX58W6wWmefK3I1zEGr0lOD0u8rwPaNqQL1aRxUaxLeKO3ArNh3VYg1KbaD+FFw==}
     dependencies:
-      '@babel/runtime': 7.21.0
+      '@babel/runtime': 7.22.5
 
   /regex-not@1.0.2:
     resolution: {integrity: sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A==}
···
       extend-shallow: 3.0.2
       safe-regex: 1.1.0
 
-  /regexp.prototype.flags@1.4.3:
-    resolution: {integrity: sha512-fjggEOO3slI6Wvgjwflkc4NFRCTZAu5CnNfBd5qOMYhWdn67nJBBu34/TkD++eeFmd8C9r9jfXJ27+nSiRkSUA==}
+  /regexp.prototype.flags@1.5.0:
+    resolution: {integrity: sha512-0SutC3pNudRKgquxGoRGIz946MZVHqbNfPjBdxeOhBrdgDKlRoXmYLQN9xRbrR09ZXWeGAdPuif7egofn6v5LA==}
     engines: {node: '>= 0.4'}
     dependencies:
       call-bind: 1.0.2
···
     resolution: {integrity: sha512-ZuF55hVUQaaczgOIwqWzkEcEidmlD/xl44x1UZnhOXcYuFN2S6+rcxpG+C1N3So0wvNI3DmJICUFfu2SxhBmvg==}
     deprecated: https://github.com/lydell/resolve-url#deprecated
 
-  /resolve@1.22.1:
-    resolution: {integrity: sha512-nBpuuYuY5jFsli/JIs1oldw6fOQCBioohqWZg/2hiaOybXOft4lonv85uDOKXdf8rhyK159cxU5cDcK/NKk8zw==}
-    hasBin: true
-    dependencies:
-      is-core-module: 2.11.0
-      path-parse: 1.0.7
-      supports-preserve-symlinks-flag: 1.0.0
-
   /resolve@1.22.2:
     resolution: {integrity: sha512-Sb+mjNHOULsBv818T40qSPeRiuWLyaGMa5ewydRLFimneixmVy2zdivRl+AF6jaYPC8ERxGDmFSiqui6SfPd+g==}
     hasBin: true
···
     resolution: {integrity: sha512-iMDbmAWtfU+MHpxt/I5iWI7cY6YVEZUQ3MBgPQ++XD1PELuJHIl82xBmObyP2KyQmkNB2dsqF7seoQQiAn5yDQ==}
     hasBin: true
     dependencies:
-      is-core-module: 2.11.0
+      is-core-module: 2.12.1
       path-parse: 1.0.7
       supports-preserve-symlinks-flag: 1.0.0
     dev: true
···
     resolution: {integrity: sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==}
     hasBin: true
     dependencies:
-      glob: 7.1.6
+      glob: 7.2.3
 
   /rimraf@3.0.2:
     resolution: {integrity: sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==}
···
       rollup: 3.21.1
     dev: true
 
-  /rollup-plugin-dts@5.3.0(rollup@3.21.1)(typescript@5.0.4):
+  /rollup-plugin-dts@5.3.0(rollup@3.21.1)(typescript@5.1.6):
     resolution: {integrity: sha512-8FXp0ZkyZj1iU5klkIJYLjIq/YZSwBoERu33QBDxm/1yw5UU4txrEtcmMkrq+ZiKu3Q4qvPCNqc3ovX6rjqzbQ==}
     engines: {node: '>=v14'}
     peerDependencies:
···
     dependencies:
       magic-string: 0.30.0
       rollup: 3.21.1
-      typescript: 5.0.4
+      typescript: 5.1.6
     optionalDependencies:
       '@babel/code-frame': 7.22.5
     dev: true
···
       picomatch: 2.3.1
       rollup: 3.21.1
       source-map: 0.7.4
-      yargs: 17.7.1
+      yargs: 17.7.2
     dev: true
 
   /rollup@2.79.1:
···
     resolution: {integrity: sha512-APM0Gt1KoXBz0iIkkdB/kfvGOwC4UuJFeG/c+yV7wSc7q96cG/kJ0HiYCnzivD9SB53cLV1MlHFNfOuPaadYSw==}
     dev: true
 
+  /run-applescript@5.0.0:
+    resolution: {integrity: sha512-XcT5rBksx1QdIhlFOCtgZkB99ZEouFZ1E2Kc2LHqNW13U3/74YGdkQRmThTwxy4QIyookibDKYZOPqX//6BlAg==}
+    engines: {node: '>=12'}
+    dependencies:
+      execa: 5.1.1
+    dev: true
+
   /run-async@2.4.1:
     resolution: {integrity: sha512-tvVnVv01b8c1RrA6Ep7JkStj85Guv/YrMcwqYQnwjsAS2cTmmPGBBjAjpCW7RrSodNSoE2/qg9O4bceNvUuDgQ==}
     engines: {node: '>=0.12.0'}
···
   /rxjs@7.8.1:
     resolution: {integrity: sha512-AA3TVj+0A2iuIoQkWEK/tqFjBq2j+6PO6Y0zJcvzLAFhEFIO3HL0vls9hWLncZbAAbK0mar7oZ4V079I/qPMxg==}
     dependencies:
-      tslib: 2.5.0
+      tslib: 2.6.1
     dev: true
 
+  /safe-array-concat@1.0.0:
+    resolution: {integrity: sha512-9dVEFruWIsnie89yym+xWTAYASdpw3CJV7Li/6zBewGf9z2i1j31rP6jnY0pHEO4QZh6N0K11bFjWmdR8UGdPQ==}
+    engines: {node: '>=0.4'}
+    dependencies:
+      call-bind: 1.0.2
+      get-intrinsic: 1.2.1
+      has-symbols: 1.0.3
+      isarray: 2.0.5
+
   /safe-buffer@5.1.2:
     resolution: {integrity: sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==}
 
···
     resolution: {integrity: sha512-JBUUzyOgEwXQY1NuPtvcj/qcBDbDmEvWufhlnXZIm75DEHp+afM1r1ujJpJsV/gSM4t59tpDyPi1sd6ZaPFfsA==}
     dependencies:
       call-bind: 1.0.2
-      get-intrinsic: 1.2.0
+      get-intrinsic: 1.2.1
       is-regex: 1.1.4
 
   /safe-regex@1.1.0:
···
     resolution: {integrity: sha512-SHiNtMOUGWBQJwzISiVYKu82GiV4QYGePp3odlY1tuKO7gPtphAT5R/py0fA6xtbgLL/RvtJZnU9b8s0F1q0Xg==}
     engines: {node: '>= 8.9.0'}
     dependencies:
-      '@types/json-schema': 7.0.11
+      '@types/json-schema': 7.0.12
       ajv: 6.12.6
       ajv-keywords: 3.5.2(ajv@6.12.6)
 
···
     engines: {node: '>=8'}
     dev: true
 
-  /semver@5.7.1:
-    resolution: {integrity: sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==}
+  /semver@5.7.2:
+    resolution: {integrity: sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==}
     hasBin: true
 
-  /semver@6.3.0:
-    resolution: {integrity: sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==}
+  /semver@6.3.1:
+    resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==}
     hasBin: true
 
   /semver@7.0.0:
     resolution: {integrity: sha512-+GB6zVA9LWh6zovYQLALHwv5rb2PHGlJi3lfiqIHxR0uuwCgefcOJc59v9fv1w8GbStwxuuqqAjI9NMAOOgq1A==}
     hasBin: true
 
-  /semver@7.5.0:
-    resolution: {integrity: sha512-+XC0AD/R7Q2mPSRuy2Id0+CGTZ98+8f+KvwirxOKIEyid+XSx6HbC63p+O4IndTHuX5Z+JxQ0TghCkO5Cg/2HA==}
-    engines: {node: '>=10'}
-    hasBin: true
-    dependencies:
-      lru-cache: 6.0.0
-    dev: true
-
-  /semver@7.5.3:
-    resolution: {integrity: sha512-QBlUtyVk/5EeHbi7X0fw6liDZc7BBmEaSYn01fMU1OUYbf6GPsbTtd8WmnqbI20SeycoHSeiybkE/q1Q+qlThQ==}
+  /semver@7.5.4:
+    resolution: {integrity: sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==}
     engines: {node: '>=10'}
     hasBin: true
     dependencies:
···
     resolution: {integrity: sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==}
     dependencies:
       call-bind: 1.0.2
-      get-intrinsic: 1.2.0
+      get-intrinsic: 1.2.1
       object-inspect: 1.12.3
 
   /siginfo@2.0.0:
···
     dependencies:
       eastasianwidth: 0.2.0
       emoji-regex: 9.2.2
-      strip-ansi: 7.0.1
+      strip-ansi: 7.1.0
     dev: true
 
   /string.prototype.matchall@4.0.8:
···
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
-      get-intrinsic: 1.2.0
+      es-abstract: 1.22.1
+      get-intrinsic: 1.2.1
       has-symbols: 1.0.3
       internal-slot: 1.0.5
-      regexp.prototype.flags: 1.4.3
+      regexp.prototype.flags: 1.5.0
       side-channel: 1.0.4
     dev: true
 
···
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
+      es-abstract: 1.22.1
     dev: true
 
   /string.prototype.trim@1.2.7:
···
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
+      es-abstract: 1.22.1
 
   /string.prototype.trimend@1.0.6:
     resolution: {integrity: sha512-JySq+4mrPf9EsDBEDYMOb/lM7XQLulwg5R/m1r0PXEFqrV0qHvl58sdTilSXtKOflCsK2E8jxf+GKC0T07RWwQ==}
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
+      es-abstract: 1.22.1
 
   /string.prototype.trimstart@1.0.6:
     resolution: {integrity: sha512-omqjMDaY92pbn5HOX7f9IccLA+U1tA9GvtU4JrodiXFfYB7jPzzHpRzpglLAjtUV6bB557zwClJezTqnAiYnQA==}
     dependencies:
       call-bind: 1.0.2
       define-properties: 1.2.0
-      es-abstract: 1.21.2
+      es-abstract: 1.22.1
 
   /string_decoder@1.1.1:
     resolution: {integrity: sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==}
···
     resolution: {integrity: sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==}
     engines: {node: '>=6'}
     dependencies:
-      ansi-regex: 4.1.0
+      ansi-regex: 4.1.1
 
   /strip-ansi@6.0.1:
     resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==}
···
       ansi-regex: 5.0.1
     dev: true
 
-  /strip-ansi@7.0.1:
-    resolution: {integrity: sha512-cXNxvT8dFNRVfhVME3JAe98mkXDYN2O1l7jmcwMnOslDeESg1rF/OZMtK0nRAhiari1unG5cD4jG3rapUAkLbw==}
+  /strip-ansi@7.1.0:
+    resolution: {integrity: sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==}
     engines: {node: '>=12'}
     dependencies:
       ansi-regex: 6.0.1
···
   /strip-literal@1.0.1:
     resolution: {integrity: sha512-QZTsipNpa2Ppr6v1AmJHESqJ3Uz247MUS0OjrnnZjFAvEoWqxuyFuXn2xLgMtRnijJShAa1HL0gtJyUs7u7n3Q==}
     dependencies:
-      acorn: 8.8.2
+      acorn: 8.10.0
     dev: true
 
   /strip-outer@1.0.1:
···
     resolution: {integrity: sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==}
     dev: true
 
+  /synckit@0.8.5:
+    resolution: {integrity: sha512-L1dapNV6vu2s/4Sputv8xGsCdAVlb5nRDMFU/E27D44l5U6cw1g0dGd45uLc+OXjNMmF4ntiMdCimzcjFKQI8Q==}
+    engines: {node: ^14.18.0 || >=16.0.0}
+    dependencies:
+      '@pkgr/utils': 2.4.2
+      tslib: 2.6.1
+    dev: true
+
   /tapable@1.1.3:
     resolution: {integrity: sha512-4WK/bYZmj8xLr+HUCODHGF1ZFzsYffasLUgEiMBY4fgtltdO6B4WJtlSbPaDTLpYTcGVwM2qLnFTICEcNxs3kA==}
     engines: {node: '>=6'}
···
     engines: {node: '>=6.0.0'}
     hasBin: true
     dependencies:
-      acorn: 8.8.2
+      acorn: 8.10.0
       commander: 2.20.3
       source-map: 0.6.1
       source-map-support: 0.5.21
···
     hasBin: true
     dependencies:
       '@jridgewell/source-map': 0.3.2
-      acorn: 8.8.2
+      acorn: 8.10.0
       commander: 2.20.3
       source-map-support: 0.5.21
     dev: true
···
   /tinyspy@2.1.0:
     resolution: {integrity: sha512-7eORpyqImoOvkQJCSkL0d0mB4NHHIFAy4b1u8PHdDa7SjGS2njzl6/lyGoZLm+eyYEtlUmFGE0rFj66SWxZgQQ==}
     engines: {node: '>=14.0.0'}
+    dev: true
+
+  /titleize@3.0.0:
+    resolution: {integrity: sha512-KxVu8EYHDPBdUYdKZdKtU2aj2XfEx9AfjXxE/Aj0vT06w2icA09Vus1rh6eSu1y01akYg6BjIK/hxyLJINoMLQ==}
+    engines: {node: '>=12'}
     dev: true
 
   /tmp-promise@3.0.3:
···
   /tryer@1.0.1:
     resolution: {integrity: sha512-c3zayb8/kWWpycWYg87P71E1S1ZL6b6IJxfb5fvsUgsf0S2MVGaDhDXXjDMpdCpfWXqptc+4mXwmiy1ypXqRAA==}
 
-  /tsconfck@2.1.1(typescript@5.0.4):
+  /ts-api-utils@1.0.1(typescript@5.1.6):
+    resolution: {integrity: sha512-lC/RGlPmwdrIBFTX59wwNzqh7aR2otPNPR/5brHZm/XKFYKsfqxihXUe9pU3JI+3vGkl+vyCoNNnPhJn3aLK1A==}
+    engines: {node: '>=16.13.0'}
+    peerDependencies:
+      typescript: '>=4.2.0'
+    dependencies:
+      typescript: 5.1.6
+    dev: true
+
+  /tsconfck@2.1.1(typescript@5.1.6):
     resolution: {integrity: sha512-ZPCkJBKASZBmBUNqGHmRhdhM8pJYDdOXp4nRgj/O0JwUwsMq50lCDRQP/M5GBNAA0elPrq4gAeu4dkaVCuKWww==}
     engines: {node: ^14.13.1 || ^16 || >=18}
     hasBin: true
···
       typescript:
         optional: true
     dependencies:
-      typescript: 5.0.4
+      typescript: 5.1.6
     dev: true
 
   /tslib@1.14.1:
     resolution: {integrity: sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==}
 
-  /tslib@2.5.0:
-    resolution: {integrity: sha512-336iVw3rtn2BUK7ORdIAHTyxHGRIHVReokCR3XjbckJMK7ms8FysBfhLR8IXnAgy7T0PTPNBWKiH514FOW/WSg==}
-    dev: true
-
-  /tsutils@3.21.0(typescript@5.0.4):
-    resolution: {integrity: sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==}
-    engines: {node: '>= 6'}
-    peerDependencies:
-      typescript: '>=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta'
-    dependencies:
-      tslib: 1.14.1
-      typescript: 5.0.4
+  /tslib@2.6.1:
+    resolution: {integrity: sha512-t0hLfiEKfMUoqhG+U1oid7Pva4bbDPHYfJNiB7BiIjRkj1pyC++4N3huJfqY6aRH6VTB0rvtzQwjM4K6qpfOig==}
     dev: true
 
   /tty-browserify@0.0.0:
···
       media-typer: 0.3.0
       mime-types: 2.1.35
 
+  /typed-array-buffer@1.0.0:
+    resolution: {integrity: sha512-Y8KTSIglk9OZEr8zywiIHG/kmQ7KWyjseXs1CbSo8vC42w7hg2HgYTxSWwP0+is7bWDc1H+Fo026CpHFwm8tkw==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind: 1.0.2
+      get-intrinsic: 1.2.1
+      is-typed-array: 1.1.12
+
+  /typed-array-byte-length@1.0.0:
+    resolution: {integrity: sha512-Or/+kvLxNpeQ9DtSydonMxCx+9ZXOswtwJn17SNLvhptaXYDJvkFFP5zbfU/uLmvnBJlI4yrnXRxpdWH/M5tNA==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind: 1.0.2
+      for-each: 0.3.3
+      has-proto: 1.0.1
+      is-typed-array: 1.1.12
+
+  /typed-array-byte-offset@1.0.0:
+    resolution: {integrity: sha512-RD97prjEt9EL8YgAgpOkf3O4IF9lhJFr9g0htQkm0rchFp/Vx7LW5Q8fSXXub7BXAODyUQohRMyOc3faCPd0hg==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      available-typed-arrays: 1.0.5
+      call-bind: 1.0.2
+      for-each: 0.3.3
+      has-proto: 1.0.1
+      is-typed-array: 1.1.12
+
   /typed-array-length@1.0.4:
     resolution: {integrity: sha512-KjZypGq+I/H7HI5HlOoGHkWUUGq+Q0TPhQurLbyrVrvnKTBgzLhIJ7j6J/XTQOi0d1RjyZ0wdas8bKs2p0x3Ng==}
     dependencies:
       call-bind: 1.0.2
       for-each: 0.3.3
-      is-typed-array: 1.1.10
+      is-typed-array: 1.1.12
 
   /typedarray@0.0.6:
     resolution: {integrity: sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==}
 
-  /typescript@5.0.4:
-    resolution: {integrity: sha512-cW9T5W9xY37cc+jfEnaUvX91foxtHkza3Nw3wkoF4sSlKn0MONdkdEndig/qPBWXNkmplh3NzayQzCiHM4/hqw==}
-    engines: {node: '>=12.20'}
+  /typescript@5.1.6:
+    resolution: {integrity: sha512-zaWCozRZ6DLEWAWFrVDz1H6FVXzUSfTy5FUMWsQlU8Ym5JP9eO4xkTIROFCQvhQf61z6O/G6ugw3SgAnvvm+HA==}
+    engines: {node: '>=14.17'}
     hasBin: true
     dev: true
 
···
     resolution: {integrity: sha512-g9JpC/3He3bm38zsLupWryXHoEcS22YHthuPQSJdMy6KNrzIRzWqcsHzD/WUnqe45whVou4VIsPew37DoXWNrA==}
     dependencies:
       define-properties: 1.2.0
-      es-abstract: 1.21.2
+      es-abstract: 1.22.1
       has-symbols: 1.0.3
       object.getownpropertydescriptors: 2.1.2
 
···
       - terser
     dev: true
 
-  /vite-tsconfig-paths@4.2.0(typescript@5.0.4)(vite@3.2.5):
+  /vite-tsconfig-paths@4.2.0(typescript@5.1.6)(vite@3.2.5):
     resolution: {integrity: sha512-jGpus0eUy5qbbMVGiTxCL1iB9ZGN6Bd37VGLJU39kTDD6ZfULTTb1bcc5IeTWqWJKiWV5YihCaibeASPiGi8kw==}
     peerDependencies:
       vite: '*'
···
     dependencies:
       debug: 4.3.4(supports-color@5.5.0)
       globrex: 0.1.2
-      tsconfck: 2.1.1(typescript@5.0.4)
+      tsconfck: 2.1.1(typescript@5.1.6)
       vite: 3.2.5(@types/node@18.16.3)(terser@5.17.1)
     transitivePeerDependencies:
       - supports-color
···
       '@types/node': 18.16.3
       esbuild: 0.15.18
       postcss: 8.4.21
-      resolve: 1.22.1
+      resolve: 1.22.2
       rollup: 2.79.1
       terser: 5.17.1
     optionalDependencies:
···
       '@vitest/snapshot': 0.30.1
       '@vitest/spy': 0.30.1
       '@vitest/utils': 0.30.1
-      acorn: 8.8.2
+      acorn: 8.10.0
       acorn-walk: 8.2.0
       cac: 6.7.14
       chai: 4.3.7
···
   /watchpack@1.7.5:
     resolution: {integrity: sha512-9P3MWk6SrKjHsGkLT2KHXdQ/9SNkyoJbabxnKOoJepsvJjJG8uYTR3yTPxPQvNDI3w4Nz1xnE0TLHK4RIVe/MQ==}
     dependencies:
-      graceful-fs: 4.2.10
+      graceful-fs: 4.2.11
       neo-async: 2.6.2
     optionalDependencies:
       chokidar: 3.5.3
···
       portfinder: 1.0.28(supports-color@6.1.0)
       schema-utils: 1.0.0
       selfsigned: 1.10.8
-      semver: 6.3.0
+      semver: 6.3.1
       serve-index: 1.9.1(supports-color@6.1.0)
       sockjs: 0.3.21
       sockjs-client: 1.5.1(supports-color@6.1.0)
···
       is-string: 1.0.7
       is-symbol: 1.0.4
 
-  /which-module@2.0.0:
-    resolution: {integrity: sha512-B+enWhmw6cjfVC7kS8Pj9pCrKSc5txArRyaYGe088shv/FGWH+0Rjx/xPgtsWfsUtS27FkP697E4DDhgrgoc0Q==}
-
   /which-module@2.0.1:
     resolution: {integrity: sha512-iBdZ57RDvnOR9AGBhML2vFZf7h8vmBjhoaZqODJBFWHVtKkDmKuHai3cx5PgVMrX5YDNp27AofYbAwctSS+vhQ==}
-    dev: true
 
   /which-pm-runs@1.1.0:
     resolution: {integrity: sha512-n1brCuqClxfFfq/Rb0ICg9giSZqCS+pLtccdag6C2HyufBrh3fBOiy9nb6ggRMvWOVH5GrdJskj5iGTZNxd7SA==}
···
       path-exists: 4.0.0
     dev: true
 
-  /which-typed-array@1.1.9:
-    resolution: {integrity: sha512-w9c4xkx6mPidwp7180ckYWfMmvxpjlZuIudNtDf4N/tTAUB8VJbX25qZoAsrtGuYNnGw3pa0AXgbGKRB8/EceA==}
+  /which-typed-array@1.1.11:
+    resolution: {integrity: sha512-qe9UWWpkeG5yzZ0tNYxDmd7vo58HDBc39mZ0xWWpolAGADdFOzkfamWLDxkOWcvHQKVmdTyQdLD4NOfjLWTKew==}
     engines: {node: '>= 0.4'}
     dependencies:
       available-typed-arrays: 1.0.5
···
       for-each: 0.3.3
       gopd: 1.0.1
       has-tostringtag: 1.0.0
-      is-typed-array: 1.1.10
 
   /which@1.3.1:
     resolution: {integrity: sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==}
···
       isexe: 2.0.0
     dev: true
 
-  /which@3.0.0:
-    resolution: {integrity: sha512-nla//68K9NU6yRiwDY/Q8aU6siKlSs64aEC7+IV56QoAuyQT2ovsJcgGYGyqMOmI/CGN1BOR6mM5EN0FBO+zyQ==}
+  /which@3.0.1:
+    resolution: {integrity: sha512-XA1b62dzQzLfaEOSQFTCOd5KFf/1VSzZo7/7TUjnya6u0vGGKzU96UQBZTAThCb2j4/xjBAyii1OhRLJEivHvg==}
     engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
     hasBin: true
     dependencies:
···
       require-main-filename: 2.0.0
       set-blocking: 2.0.0
       string-width: 3.1.0
-      which-module: 2.0.0
+      which-module: 2.0.1
       y18n: 4.0.3
       yargs-parser: 13.1.2
 
···
       which-module: 2.0.1
       y18n: 4.0.3
       yargs-parser: 18.1.3
-    dev: true
-
-  /yargs@17.7.1:
-    resolution: {integrity: sha512-cwiTb08Xuv5fqF4AovYacTFNxk62th7LKJ6BL9IGUpTJrWoU7/7WdQGTP2SjKf1dUNBGzDd28p/Yfs/GI6JrLw==}
-    engines: {node: '>=12'}
-    dependencies:
-      cliui: 8.0.1
-      escalade: 3.1.1
-      get-caller-file: 2.0.5
-      require-directory: 2.1.1
-      string-width: 4.2.3
-      y18n: 5.0.8
-      yargs-parser: 21.1.1
     dev: true
 
   /yargs@17.7.2:

scripts/changesets/changelog.js

···
     lines = lines.map(l => l.trim()).filter(Boolean);
     const size = lines.length;
     if (size > 0) {
-      lines[size - 1] = lines[size - 1]
-        .replace(TRAILING_CHAR, '');
+      lines[size - 1] = lines[size - 1].replace(TRAILING_CHAR, '');
     }
   }
   return lines;
···
 
 /** Creates a "(See X)" string from a template */
 const templateSeeRef = links => {
-  const humanReadableLinks = links
-    .filter(Boolean)
-    .map(link => {
-      if (typeof link === 'string') return link;
-      return link.pull || link.commit;
-    });
+  const humanReadableLinks = links.filter(Boolean).map(link => {
+    if (typeof link === 'string') return link;
+    return link.pull || link.commit;
+  });
 
   const size = humanReadableLinks.length;
   if (size === 0) return '';
···
 };
 
 const changelogFunctions = {
-  getDependencyReleaseLine: async (
-    changesets,
-    dependenciesUpdated,
-  ) => {
+  getDependencyReleaseLine: async (changesets, dependenciesUpdated) => {
     if (dependenciesUpdated.length === 0) return '';
 
     const dependenciesLinks = await Promise.all(
···
 
         const { links } = await getInfo({
           repo: REPO,
-          commit: cs.commit
+          commit: cs.commit,
         });
 
         return links;
···
     if (changeset.commit && !pull) {
       const { links } = await getInfo({
         repo: REPO,
-        commit: changeset.commit
+        commit: changeset.commit,
       });
 
       pull = links.pull || undefined;
···
     }
 
     return str;
-  }
+  },
 };
 
 module.exports = {
   ...changelogFunctions,
-  default: changelogFunctions
+  default: changelogFunctions,
 };

scripts/eslint/preset.js

···
     'build/',
     'coverage/',
     'benchmark/',
-    'scripts/',
     'docs/',
   ],
 
···
 
   extends: ['eslint:recommended', 'prettier'],
 
-  plugins: [
-    '@typescript-eslint',
-    'prettier',
-    'es5',
-  ],
+  plugins: ['@typescript-eslint', 'prettier', 'es5'],
 
   rules: {
     'no-undef': 'off',
···
     'es5/no-generators': 'off',
     'es5/no-typeof-symbol': 'warn',
 
-    'no-unused-vars': ['warn', {
-      argsIgnorePattern: '^_',
-    }],
+    'no-unused-vars': [
+      'warn',
+      {
+        argsIgnorePattern: '^_',
+      },
+    ],
 
-    'prettier/prettier': ['error', {
-      singleQuote: true,
-      arrowParens: 'avoid',
-      trailingComma: 'es5',
-    }],
+    'prettier/prettier': [
+      'error',
+      {
+        singleQuote: true,
+        arrowParens: 'avoid',
+        trailingComma: 'es5',
+      },
+    ],
   },
 
   overrides: [
     {
       extends: ['plugin:@typescript-eslint/recommended'],
-      files: ['*.ts'],
+      files: ['*.ts', '*.tsx'],
       rules: {
         '@typescript-eslint/explicit-module-boundary-types': 'off',
         '@typescript-eslint/no-use-before-define': 'off',
···
         'import/no-internal-modules': 'off',
 
         'no-restricted-syntax': [
-          "error",
+          'error',
           {
-            "selector": "PropertyDefinition[value]",
-            "message": "Property definitions with value initializers aren’t transpiled"
+            selector: 'PropertyDefinition[value]',
+            message:
+              'Property definitions with value initializers aren’t transpiled',
+          },
+          {
+            selector: 'MemberExpression[optional=true]',
+            message:
+              'Optional chaining (?.) operator is outside of specified browser support',
+          },
+          {
+            selector: 'LogicalExpression[operator="??"]',
+            message:
+              'Nullish coalescing (??) operator is outside of specified browser support',
+          },
+          {
+            selector: 'AssignmentExpression[operator="??="]',
+            message:
+              'Nullish coalescing assignment (??=) is outside of specified browser support',
+          },
+          {
+            selector: 'SequenceExpression',
+            message:
+              'Sequence expressions are to be avoided since they can be confusing',
+          },
+          {
+            selector:
+              ':not(ForStatement) > VariableDeclaration[declarations.length>1]',
+            message:
+              'Only one variable declarator per variable declaration is preferred',
           },
         ],
 
-        '@typescript-eslint/no-unused-vars': ['error', {
-          argsIgnorePattern: '^_',
-        }],
+        '@typescript-eslint/no-import-type-side-effects': 'error',
+        '@typescript-eslint/consistent-type-imports': [
+          'error',
+          {
+            disallowTypeAnnotations: false,
+            fixStyle: 'separate-type-imports',
+          },
+        ],
+
+        '@typescript-eslint/no-unused-vars': [
+          'error',
+          {
+            argsIgnorePattern: '^_',
+          },
+        ],
       },
     },
 
     {
-      extends: ['plugin:@typescript-eslint/recommended'],
+      extends: ['plugin:react/recommended'],
       files: ['*.tsx'],
-      extends: ['plugin:react/recommended'],
       plugins: ['react-hooks'],
       rules: {
         'react-hooks/rules-of-hooks': 'error',
···
       files: ['*.test.ts', '*.test.tsx', '*.spec.ts', '*.spec.tsx'],
       globals: { vi: true },
       rules: {
+        'no-restricted-syntax': 'off',
         '@typescript-eslint/ban-ts-comment': 'off',
+        '@typescript-eslint/no-import-type-side-effects': 'off',
+        '@typescript-eslint/consistent-type-imports': 'off',
         'react-hooks/rules-of-hooks': 'off',
         'react-hooks/exhaustive-deps': 'off',
         'es5/no-for-of': 'off',
         'es5/no-generators': 'off',
         'es5/no-typeof-symbol': 'off',
-      }
+      },
     },
 
     {

scripts/prepare/index.js

···
   'dependencies',
   'optionalDependencies',
   'peerDependencies',
-].some((dep) => pkg[dep] && pkg[dep].react);
+].some(dep => pkg[dep] && pkg[dep].react);
 
 const hasNext = [
   'dependencies',
   'optionalDependencies',
   'peerDependencies',
-].some((dep) => pkg[dep] && pkg[dep].next);
+].some(dep => pkg[dep] && pkg[dep].next);
 
-const normalize = name => name
-  .replace(/[@\s\/\.]+/g, ' ')
-  .trim()
-  .replace(/\s+/, '-')
-  .toLowerCase();
+const normalize = name =>
+  name
+    .replace(/[@\s/.]+/g, ' ')
+    .trim()
+    .replace(/\s+/, '-')
+    .toLowerCase();
 
 const name = normalize(pkg.name);
 
-const posixPath = x =>
-  path.normalize(x).split(path.sep).join('/');
+const posixPath = x => path.normalize(x).split(path.sep).join('/');
 
 const is = (a, b) => posixPath(a) === posixPath(b);
 
···
   );
 }
 
-invariant(
-  !is(cwd, workspaceRoot),
-  'prepare-pkg must be run in a package.'
-);
+invariant(!is(cwd, workspaceRoot), 'prepare-pkg must be run in a package.');
 
 invariant(
   fs.existsSync(pkg.source || 'src/index.ts'),
···
 );
 
 invariant(
-  is(
-    pkg.repository.directory,
-    path.relative(workspaceRoot, cwd)
-  ),
+  is(pkg.repository.directory, path.relative(workspaceRoot, cwd)),
   'package.json:repository.directory path is invalid'
 );
 
-invariant(
-  pkg.sideEffects === false,
-  'package.json:sideEffects must be false'
-);
+invariant(pkg.sideEffects === false, 'package.json:sideEffects must be false');
 
-invariant(
-  !!pkg.author,
-  'package.json:author must be defined'
-);
+invariant(!!pkg.author, 'package.json:author must be defined');
 
-invariant(
-  pkg.license === 'MIT',
-  'package.json:license must be "MIT"'
-);
+invariant(pkg.license === 'MIT', 'package.json:license must be "MIT"');
 
 invariant(
   Array.isArray(pkg.files) &&
···
 );
 
 if (hasReact && !hasNext) {
-  invariant(!pkg.exports, 'package.json:exports must not be added for packages depending on React.');
+  invariant(
+    !pkg.exports,
+    'package.json:exports must not be added for packages depending on React.'
+  );
 } else {
-  invariant(!!pkg.exports, 'package.json:exports must be added and have a "." entry');
+  invariant(
+    !!pkg.exports,
+    'package.json:exports must be added and have a "." entry'
+  );
   invariant(!!pkg.exports['.'], 'package.json:exports must have a "." entry');
-  invariant(!!pkg.exports['./package.json'], 'package.json:exports must have a "./package.json" entry')
+  invariant(
+    !!pkg.exports['./package.json'],
+    'package.json:exports must have a "./package.json" entry'
+  );
 
   for (const key in pkg.exports) {
     const entry = pkg.exports[key];

scripts/prepare/postinstall.js

···
 const path = require('path');
 const fs = require('fs');
 
-const hookSource = path.resolve(__dirname, '../../node_modules/husky-v4/sh/husky.sh');
+const hookSource = path.resolve(
+  __dirname,
+  '../../node_modules/husky-v4/sh/husky.sh'
+);
 const hook = path.resolve(__dirname, '../../.git/hooks/husky.sh');
 const localHook = path.resolve(__dirname, '../../.git/hooks/husky.local.sh');
 const gitConfig = path.resolve(__dirname, '../../.git/config');
···
 fs.writeFileSync(hook, script);
 fs.writeFileSync(gitConfig, config);
 
-fs.writeFileSync(
-  localHook,
-  'packageManager=yarn\n' +
-    'cd "."\n'
-);
+fs.writeFileSync(localHook, 'packageManager=yarn\n' + 'cd "."\n');

scripts/vitest/setup.js

···
 const originalConsole = console;
 global.console = {
   ...originalConsole,
-  warn: vi.SpyInstance = () => { /* noop */ },
-  error: vi.SpyInstance = (message) => { throw new Error(message); }
+  warn: (vi.SpyInstance = () => {
+    /* noop */
+  }),
+  error: (vi.SpyInstance = message => {
+    throw new Error(message);
+  }),
 };
 
 vi.spyOn(console, 'log');