loro-crdt 0.15.4 → 0.16.1

package/src/index.ts

@@ -1,567 +0,0 @@
-export * from "loro-wasm";
-import {
-  Container,
-  ContainerID,
-  Delta,
-  Loro,
-  LoroList,
-  LoroMap,
-  LoroText,
-  LoroTree,
-  OpId,
-  TreeID,
-  Value,
-} from "loro-wasm";
-export { Awareness } from "./awareness";
-
-export type Frontiers = OpId[];
-
-/**
- * Represents a path to identify the exact location of an event's target.
- * The path is composed of numbers (e.g., indices of a list container) strings
- * (e.g., keys of a map container) and TreeID (the node of a tree container),
- * indicating the absolute position of the event's source within a loro document.
- */
-export type Path = (number | string | TreeID)[];
-
-/**
- * A batch of events that created by a single `import`/`transaction`/`checkout`.
- *
- * @prop by - How the event is triggered.
- * @prop origin - (Optional) Provides information about the origin of the event.
- * @prop diff - Contains the differential information related to the event.
- * @prop target - Identifies the container ID of the event's target.
- * @prop path - Specifies the absolute path of the event's emitter, which can be an index of a list container or a key of a map container.
- */
-export interface LoroEventBatch {
-  /**
-   * How the event is triggered.
-   *
-   * - `local`: The event is triggered by a local transaction.
-   * - `import`: The event is triggered by an import operation.
-   * - `checkout`: The event is triggered by a checkout operation.
-   */
-  by: "local" | "import" | "checkout";
-  origin?: string;
-  /**
-   * The container ID of the current event receiver.
-   * It's undefined if the subscriber is on the root document.
-   */
-  currentTarget?: ContainerID;
-  events: LoroEvent[];
-}
-
-/**
- * The concrete event of Loro.
- */
-export interface LoroEvent {
-  /**
-   * The container ID of the event's target.
-   */
-  target: ContainerID;
-  diff: Diff;
-  /**
-   * The absolute path of the event's emitter, which can be an index of a list container or a key of a map container.
-   */
-  path: Path;
-}
-
-export type ListDiff = {
-  type: "list";
-  diff: Delta<(Value | Container)[]>[];
-};
-
-export type TextDiff = {
-  type: "text";
-  diff: Delta<string>[];
-};
-
-export type MapDiff = {
-  type: "map";
-  updated: Record<string, Value | Container | undefined>;
-};
-
-export type TreeDiffItem =
-  | { target: TreeID; action: "create"; parent: TreeID | undefined }
-  | { target: TreeID; action: "delete" }
-  | { target: TreeID; action: "move"; parent: TreeID | undefined };
-
-export type TreeDiff = {
-  type: "tree";
-  diff: TreeDiffItem[];
-};
-
-export type Diff = ListDiff | TextDiff | MapDiff | TreeDiff;
-
-interface Listener {
-  (event: LoroEventBatch): void;
-}
-
-const CONTAINER_TYPES = ["Map", "Text", "List", "Tree"];
-
-export function isContainerId(s: string): s is ContainerID {
-  return s.startsWith("cid:");
-}
-
-export { Loro };
-
-/**  Whether the value is a container.
- *
- * # Example
- *
- * ```ts
- * const doc = new Loro();
- * const map = doc.getMap("map");
- * const list = doc.getList("list");
- * const text = doc.getText("text");
- * isContainer(map); // true
- * isContainer(list); // true
- * isContainer(text); // true
- * isContainer(123); // false
- * isContainer("123"); // false
- * isContainer({}); // false
- */
-export function isContainer(value: any): value is Container {
-  if (typeof value !== "object" || value == null) {
-    return false;
-  }
-
-  const p = Object.getPrototypeOf(value);
-  if (p == null || typeof p !== "object" || typeof p["kind"] !== "function") {
-    return false;
-  }
-
-  return CONTAINER_TYPES.includes(value.kind());
-}
-
-/**  Get the type of a value that may be a container.
- *
- * # Example
- *
- * ```ts
- * const doc = new Loro();
- * const map = doc.getMap("map");
- * const list = doc.getList("list");
- * const text = doc.getText("text");
- * getType(map); // "Map"
- * getType(list); // "List"
- * getType(text); // "Text"
- * getType(123); // "Json"
- * getType("123"); // "Json"
- * getType({}); // "Json"
- * ```
- */
-export function getType<T>(
-  value: T,
-): T extends LoroText ? "Text"
-  : T extends LoroMap<any> ? "Map"
-  : T extends LoroTree<any> ? "Tree"
-  : T extends LoroList<any> ? "List"
-  : "Json" {
-  if (isContainer(value)) {
-    return value.kind() as unknown as any;
-  }
-
-  return "Json" as any;
-}
-
-declare module "loro-wasm" {
-  interface Loro {
-    subscribe(listener: Listener): number;
-  }
-
-  interface Loro<
-    T extends Record<string, Container> = Record<string, Container>,
-  > {
-    /**
-     * Get a LoroMap by container id
-     *
-     * The object returned is a new js object each time because it need to cross
-     * the WASM boundary.
-     *
-     * @example
-     * ```ts
-     * import { Loro } from "loro-crdt";
-     *
-     * const doc = new Loro();
-     * const map = doc.getMap("map");
-     * ```
-     */
-    getMap<Key extends (keyof T) | ContainerID>(
-      name: Key,
-    ): T[Key] extends LoroMap ? T[Key] : LoroMap;
-    /**
-     * Get a LoroList by container id
-     *
-     * The object returned is a new js object each time because it need to cross
-     * the WASM boundary.
-     *
-     * @example
-     * ```ts
-     * import { Loro } from "loro-crdt";
-     *
-     * const doc = new Loro();
-     * const list = doc.getList("list");
-     * ```
-     */
-    getList<Key extends (keyof T) | ContainerID>(
-      name: Key,
-    ): T[Key] extends LoroList ? T[Key] : LoroList;
-    /**
-     * Get a LoroMovableList by container id
-     *
-     * The object returned is a new js object each time because it need to cross
-     * the WASM boundary.
-     *
-     * @example
-     * ```ts
-     * import { Loro } from "loro-crdt";
-     *
-     * const doc = new Loro();
-     * const list = doc.getList("list");
-     * ```
-     */
-    getMovableList<Key extends (keyof T) | ContainerID>(
-      name: Key,
-    ): T[Key] extends LoroMovableList ? T[Key] : LoroMovableList;
-    /**
-     * Get a LoroTree by container id
-     *
-     *  The object returned is a new js object each time because it need to cross
-     *  the WASM boundary.
-     *
-     *  @example
-     *  ```ts
-     *  import { Loro } from "loro-crdt";
-     *
-     *  const doc = new Loro();
-     *  const tree = doc.getTree("tree");
-     *  ```
-     */
-    getTree<Key extends (keyof T) | ContainerID>(
-      name: Key,
-    ): T[Key] extends LoroTree ? T[Key] : LoroTree;
-    getText(key: string | ContainerID): LoroText;
-  }
-
-  interface LoroList<T = unknown> {
-    new (): LoroList<T>;
-    /**
-     *  Get elements of the list. If the value is a child container, the corresponding
-     *  `Container` will be returned.
-     *
-     *  @example
-     *  ```ts
-     *  import { Loro } from "loro-crdt";
-     *
-     *  const doc = new Loro();
-     *  const list = doc.getList("list");
-     *  list.insert(0, 100);
-     *  list.insert(1, "foo");
-     *  list.insert(2, true);
-     *  list.insertContainer(3, new LoroText());
-     *  console.log(list.value);  // [100, "foo", true, LoroText];
-     *  ```
-     */
-    toArray(): T[];
-    /**
-     * Insert a container at the index.
-     *
-     *  @example
-     *  ```ts
-     *  import { Loro, LoroText } from "loro-crdt";
-     *
-     *  const doc = new Loro();
-     *  const list = doc.getList("list");
-     *  list.insert(0, 100);
-     *  const text = list.insertContainer(1, new LoroText());
-     *  text.insert(0, "Hello");
-     *  console.log(list.toJSON());  // [100, "Hello"];
-     *  ```
-     */
-    insertContainer<C extends Container>(
-      pos: number,
-      child: C,
-    ): T extends C ? T : C;
-    /**
-     * Get the value at the index. If the value is a container, the corresponding handler will be returned.
-     *
-     *  @example
-     *  ```ts
-     *  import { Loro } from "loro-crdt";
-     *
-     *  const doc = new Loro();
-     *  const list = doc.getList("list");
-     *  list.insert(0, 100);
-     *  console.log(list.get(0));  // 100
-     *  console.log(list.get(1));  // undefined
-     *  ```
-     */
-    get(index: number): T;
-    /**
-     *  Insert a value at index.
-     *
-     *  @example
-     *  ```ts
-     *  import { Loro } from "loro-crdt";
-     *
-     *  const doc = new Loro();
-     *  const list = doc.getList("list");
-     *  list.insert(0, 100);
-     *  list.insert(1, "foo");
-     *  list.insert(2, true);
-     *  console.log(list.value);  // [100, "foo", true];
-     *  ```
-     */
-    insert<V extends T>(pos: number, value: Exclude<V, Container>): void;
-    delete(pos: number, len: number): void;
-    push<V extends T>(value: Exclude<V, Container>): void;
-    subscribe(listener: Listener): number;
-    getAttached(): undefined | LoroList<T>;
-  }
-
-  interface LoroMovableList<T = unknown> {
-    new (): LoroMovableList<T>;
-    /**
-     *  Get elements of the list. If the value is a child container, the corresponding
-     *  `Container` will be returned.
-     *
-     *  @example
-     *  ```ts
-     *  import { Loro, LoroText } from "loro-crdt";
-     *
-     *  const doc = new Loro();
-     *  const list = doc.getMovableList("list");
-     *  list.insert(0, 100);
-     *  list.insert(1, "foo");
-     *  list.insert(2, true);
-     *  list.insertContainer(3, new LoroText());
-     *  console.log(list.value);  // [100, "foo", true, LoroText];
-     *  ```
-     */
-    toArray(): T[];
-    /**
-     * Insert a container at the index.
-     *
-     *  @example
-     *  ```ts
-     *  import { Loro } from "loro-crdt";
-     *
-     *  const doc = new Loro();
-     *  const list = doc.getMovableList("list");
-     *  list.insert(0, 100);
-     *  const text = list.insertContainer(1, new LoroText());
-     *  text.insert(0, "Hello");
-     *  console.log(list.toJSON());  // [100, "Hello"];
-     *  ```
-     */
-    insertContainer<C extends Container>(
-      pos: number,
-      child: C,
-    ): T extends C ? T : C;
-    /**
-     * Get the value at the index. If the value is a container, the corresponding handler will be returned.
-     *
-     *  @example
-     *  ```ts
-     *  import { Loro } from "loro-crdt";
-     *
-     *  const doc = new Loro();
-     *  const list = doc.getMoableList("list");
-     *  list.insert(0, 100);
-     *  console.log(list.get(0));  // 100
-     *  console.log(list.get(1));  // undefined
-     *  ```
-     */
-    get(index: number): T;
-    /**
-     *  Insert a value at index.
-     *
-     *  @example
-     *  ```ts
-     *  import { Loro } from "loro-crdt";
-     *
-     *  const doc = new Loro();
-     *  const list = doc.getMovableList("list");
-     *  list.insert(0, 100);
-     *  list.insert(1, "foo");
-     *  list.insert(2, true);
-     *  console.log(list.value);  // [100, "foo", true];
-     *  ```
-     */
-    insert<V extends T>(pos: number, value: Exclude<V, Container>): void;
-    delete(pos: number, len: number): void;
-    push<V extends T>(value: Exclude<V, Container>): void;
-    subscribe(listener: Listener): number;
-    getAttached(): undefined | LoroMovableList<T>;
-    /**
-     *  Set the value at the given position.
-     *
-     *  It's different from `delete` + `insert` that it will replace the value at the position.
-     *
-     *  For example, if you have a list `[1, 2, 3]`, and you call `set(1, 100)`, the list will be `[1, 100, 3]`.
-     *  If concurrently someone call `set(1, 200)`, the list will be `[1, 200, 3]` or `[1, 100, 3]`.
-     *
-     *  But if you use `delete` + `insert` to simulate the set operation, they may create redundant operations
-     *  and the final result will be `[1, 100, 200, 3]` or `[1, 200, 100, 3]`.
-     *
-     *  @example
-     *  ```ts
-     *  import { Loro } from "loro-crdt";
-     *
-     *  const doc = new Loro();
-     *  const list = doc.getList("list");
-     *  list.insert(0, 100);
-     *  list.insert(1, "foo");
-     *  list.insert(2, true);
-     *  list.set(1, "bar");
-     *  console.log(list.value);  // [100, "bar", true];
-     *  ```
-     */
-    set<V extends T>(pos: number, value: Exclude<V, Container>): void;
-    /**
-     * Set a container at the index.
-     *
-     *  @example
-     *  ```ts
-     *  import { Loro } from "loro-crdt";
-     *
-     *  const doc = new Loro();
-     *  const list = doc.getMovableList("list");
-     *  list.insert(0, 100);
-     *  const text = list.setContainer(0, new LoroText());
-     *  text.insert(0, "Hello");
-     *  console.log(list.toJSON());  // ["Hello"];
-     *  ```
-     */
-    setContainer<C extends Container>(
-      pos: number,
-      child: C,
-    ): T extends C ? T : C;
-  }
-
-  interface LoroMap<
-    T extends Record<string, unknown> = Record<string, unknown>,
-  > {
-    new (): LoroMap<T>;
-    /**
-     *  Get the value of the key. If the value is a child container, the corresponding
-     *  `Container` will be returned.
-     *
-     *  The object returned is a new js object each time because it need to cross
-     *
-     *  @example
-     *  ```ts
-     *  import { Loro } from "loro-crdt";
-     *
-     *  const doc = new Loro();
-     *  const map = doc.getMap("map");
-     *  map.set("foo", "bar");
-     *  const bar = map.get("foo");
-     *  ```
-     */
-    getOrCreateContainer<C extends Container>(key: string, child: C): C;
-    /**
-     * Set the key with a container.
-     *
-     *  @example
-     *  ```ts
-     *  import { Loro } from "loro-crdt";
-     *
-     *  const doc = new Loro();
-     *  const map = doc.getMap("map");
-     *  map.set("foo", "bar");
-     *  const text = map.setContainer("text", new LoroText());
-     *  const list = map.setContainer("list", new LoroText());
-     *  ```
-     */
-    setContainer<C extends Container, Key extends keyof T>(
-      key: Key,
-      child: C,
-    ): NonNullableType<T[Key]> extends C ? NonNullableType<T[Key]> : C;
-    /**
-     *  Get the value of the key. If the value is a child container, the corresponding
-     *  `Container` will be returned.
-     *
-     *  The object/value returned is a new js object/value each time because it need to cross
-     *  the WASM boundary.
-     *
-     *  @example
-     *  ```ts
-     *  import { Loro } from "loro-crdt";
-     *
-     *  const doc = new Loro();
-     *  const map = doc.getMap("map");
-     *  map.set("foo", "bar");
-     *  const bar = map.get("foo");
-     *  ```
-     */
-    get<Key extends keyof T>(key: Key): T[Key];
-    /**
-     * Set the key with the value.
-     *
-     *  If the value of the key is exist, the old value will be updated.
-     *
-     *  @example
-     *  ```ts
-     *  import { Loro } from "loro-crdt";
-     *
-     *  const doc = new Loro();
-     *  const map = doc.getMap("map");
-     *  map.set("foo", "bar");
-     *  map.set("foo", "baz");
-     *  ```
-     */
-    set<Key extends keyof T, V extends T[Key]>(
-      key: Key,
-      value: Exclude<V, Container>,
-    ): void;
-    delete(key: string): void;
-    subscribe(listener: Listener): number;
-  }
-
-  interface LoroText {
-    new (): LoroText;
-    insert(pos: number, text: string): void;
-    delete(pos: number, len: number): void;
-    subscribe(listener: Listener): number;
-  }
-
-  interface LoroTree<
-    T extends Record<string, unknown> = Record<string, unknown>,
-  > {
-    new (): LoroTree<T>;
-    createNode(parent: TreeID | undefined): LoroTreeNode<T>;
-    move(target: TreeID, parent: TreeID | undefined): void;
-    delete(target: TreeID): void;
-    has(target: TreeID): boolean;
-    getNodeByID(target: TreeID): LoroTreeNode;
-    subscribe(listener: Listener): number;
-  }
-
-  interface LoroTreeNode<
-    T extends Record<string, unknown> = Record<string, unknown>,
-  > {
-    /**
-     * Get the associated metadata map container of a tree node.
-     */
-    readonly data: LoroMap<T>;
-    createNode(): LoroTreeNode<T>;
-    setAsRoot(): void;
-    moveTo(parent: LoroTreeNode<T>): void;
-    parent(): LoroTreeNode<T> | undefined;
-    children(): Array<LoroTreeNode<T>>;
-  }
-
-  interface AwarenessWasm<
-    T extends Value = Value,
-  > {
-    getState(peer: PeerID): T | undefined;
-    getTimestamp(peer: PeerID): number | undefined;
-    getAllStates(): Record<PeerID, T>;
-    setLocalState(value: T): void;
-    removeOutdated(): PeerID[];
-  }
-}
-
-type NonNullableType<T> = Exclude<T, null | undefined>;

package/tsconfig.json

@@ -1,106 +0,0 @@
-{
-  "compilerOptions": {
-    /* Visit https://aka.ms/tsconfig to read more about this file */
-    /* Projects */
-    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
-    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
-    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
-    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
-    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
-    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
-    /* Language and Environment */
-    "target": "ESNext" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
-    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
-    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
-    // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
-    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
-    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
-    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
-    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
-    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
-    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
-    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
-    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
-    /* Modules */
-    "module": "commonjs" /* Specify what module code is generated. */,
-    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
-    // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
-    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
-    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
-    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
-    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
-    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
-    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
-    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
-    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
-    // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
-    // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
-    // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
-    // "resolveJsonModule": true,                        /* Enable importing .json files. */
-    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
-    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
-    /* JavaScript Support */
-    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
-    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
-    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
-    /* Emit */
-    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
-    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
-    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
-    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
-    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
-    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
-    "outDir": "./dist" /* Specify an output folder for all emitted files. */,
-    // "removeComments": true,                           /* Disable emitting comments. */
-    "noEmit": true /* Disable emitting files from a compilation. */,
-    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
-    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
-    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
-    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
-    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
-    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
-    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
-    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
-    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
-    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
-    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
-    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
-    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
-    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
-    /* Interop Constraints */
-    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
-    // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
-    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
-    "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */,
-    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
-    "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
-    /* Type Checking */
-    "strict": true /* Enable all strict type-checking options. */,
-    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
-    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
-    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
-    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
-    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
-    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
-    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
-    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
-    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
-    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
-    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
-    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
-    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
-    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
-    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
-    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
-    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
-    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
-    /* Completeness */
-    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
-    "skipLibCheck": true /* Skip type checking all .d.ts files. */
-  },
-  "exclude": [
-    "node_modules",
-    "dist",
-    "deno"
-  ]
-}

package/vite.config.ts

@@ -1,12 +0,0 @@
-import { configDefaults, defineConfig } from 'vitest/config'
-import wasm from "vite-plugin-wasm";
-
-export default defineConfig({
-  plugins: [wasm()],
-  test: {
-    exclude: [
-      ...configDefaults.exclude,
-      "deno/*"
-    ]
-  },
-});