@adobe/data 0.1.3 → 0.2.0

package/src/typed-buffer/typed-buffer.test.ts

@@ -0,0 +1,253 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import { describe, it, expect } from 'vitest';
+import { createTypedBuffer } from './create-typed-buffer.js';
+import { createNumberBuffer } from './create-number-buffer.js';
+import { createArrayBuffer } from './create-array-buffer.js';
+import { createStructBuffer } from './create-struct-buffer.js';
+
+describe('TypedBuffer copyWithin', () => {
+    describe('NumberBuffer', () => {
+        it('should copy elements within the same buffer', () => {
+            const buffer = createNumberBuffer({
+                schema: { type: 'number', precision: 1 },
+                length: 5
+            });
+            
+            // Initialize with values
+            for (let i = 0; i < 5; i++) {
+                buffer.set(i, i + 1);
+            }
+            
+            // Copy elements 0-2 to position 2
+            buffer.copyWithin(2, 0, 3);
+            expect(buffer.get(0)).toBe(1);
+            expect(buffer.get(1)).toBe(2);
+            expect(buffer.get(2)).toBe(1);
+            expect(buffer.get(3)).toBe(2);
+            expect(buffer.get(4)).toBe(3);
+        });
+
+        it('should handle negative indices', () => {
+            const buffer = createNumberBuffer({
+                schema: { type: 'number', precision: 1 },
+                length: 5
+            });
+            
+            // Initialize with values
+            for (let i = 0; i < 5; i++) {
+                buffer.set(i, i + 1);
+            }
+            
+            // Copy last 2 elements to start (from index -2 to end of array)
+            buffer.copyWithin(0, -2, buffer.size);
+            expect(buffer.get(0)).toBe(4);
+            expect(buffer.get(1)).toBe(5);
+            expect(buffer.get(2)).toBe(3);
+            expect(buffer.get(3)).toBe(4);
+            expect(buffer.get(4)).toBe(5);
+        });
+
+        it('should handle out of bounds indices', () => {
+            const buffer = createNumberBuffer({
+                schema: { type: 'number', precision: 1 },
+                length: 5
+            });
+            
+            // Initialize with values
+            for (let i = 0; i < 5; i++) {
+                buffer.set(i, i + 1);
+            }
+            
+            // Copy with out of bounds target
+            buffer.copyWithin(10, 0, 2);
+            expect(buffer.get(0)).toBe(1);
+            expect(buffer.get(1)).toBe(2);
+            expect(buffer.get(2)).toBe(3);
+            expect(buffer.get(3)).toBe(4);
+            expect(buffer.get(4)).toBe(5);
+        });
+    });
+
+    describe('ArrayBuffer', () => {
+        it('should copy elements within the same buffer', () => {
+            const buffer = createArrayBuffer<string>({ length: 5 });
+            
+            // Initialize with values
+            for (let i = 0; i < 5; i++) {
+                buffer.set(i, `value${i + 1}`);
+            }
+            
+            // Copy elements 0-2 to position 2
+            buffer.copyWithin(2, 0, 3);
+            expect(buffer.get(0)).toBe('value1');
+            expect(buffer.get(1)).toBe('value2');
+            expect(buffer.get(2)).toBe('value1');
+            expect(buffer.get(3)).toBe('value2');
+            expect(buffer.get(4)).toBe('value3');
+        });
+
+        it('should handle negative indices', () => {
+            const buffer = createArrayBuffer<string>({ length: 5 });
+            
+            // Initialize with values
+            for (let i = 0; i < 5; i++) {
+                buffer.set(i, `value${i + 1}`);
+            }
+            
+            // Copy last 2 elements to start (from index -2 to end of array)
+            buffer.copyWithin(0, -2, buffer.size);
+            expect(buffer.get(0)).toBe('value4');
+            expect(buffer.get(1)).toBe('value5');
+            expect(buffer.get(2)).toBe('value3');
+            expect(buffer.get(3)).toBe('value4');
+            expect(buffer.get(4)).toBe('value5');
+        });
+
+        it('should handle out of bounds indices', () => {
+            const buffer = createArrayBuffer<string>({ length: 5 });
+            
+            // Initialize with values
+            for (let i = 0; i < 5; i++) {
+                buffer.set(i, `value${i + 1}`);
+            }
+            
+            // Copy with out of bounds target
+            buffer.copyWithin(10, 0, 2);
+            expect(buffer.get(0)).toBe('value1');
+            expect(buffer.get(1)).toBe('value2');
+            expect(buffer.get(2)).toBe('value3');
+            expect(buffer.get(3)).toBe('value4');
+            expect(buffer.get(4)).toBe('value5');
+        });
+    });
+
+    describe('StructBuffer', () => {
+        const vec2Schema = {
+            type: 'object',
+            properties: {
+                x: { type: 'number', precision: 1 },
+                y: { type: 'number', precision: 1 }
+            }
+        } as const;
+
+        it('should copy elements within the same buffer', () => {
+            const buffer = createStructBuffer({
+                schema: vec2Schema,
+                length: 5
+            });
+            
+            // Initialize with values
+            for (let i = 0; i < 5; i++) {
+                buffer.set(i, { x: i + 1, y: i + 2 });
+            }
+            
+            // Copy elements 0-2 to position 2
+            buffer.copyWithin(2, 0, 3);
+            expect(buffer.get(0)).toEqual({ x: 1, y: 2 });
+            expect(buffer.get(1)).toEqual({ x: 2, y: 3 });
+            expect(buffer.get(2)).toEqual({ x: 1, y: 2 });
+            expect(buffer.get(3)).toEqual({ x: 2, y: 3 });
+            expect(buffer.get(4)).toEqual({ x: 3, y: 4 });
+        });
+
+        it('should handle negative indices', () => {
+            const buffer = createStructBuffer({
+                schema: vec2Schema,
+                length: 5
+            });
+            
+            // Initialize with values
+            for (let i = 0; i < 5; i++) {
+                buffer.set(i, { x: i + 1, y: i + 2 });
+            }
+            
+            // Copy last 2 elements to start (from index -2 to end of array)
+            buffer.copyWithin(0, -2, buffer.size);
+            expect(buffer.get(0)).toEqual({ x: 4, y: 5 });
+            expect(buffer.get(1)).toEqual({ x: 5, y: 6 });
+            expect(buffer.get(2)).toEqual({ x: 3, y: 4 });
+            expect(buffer.get(3)).toEqual({ x: 4, y: 5 });
+            expect(buffer.get(4)).toEqual({ x: 5, y: 6 });
+        });
+
+        it('should handle out of bounds indices', () => {
+            const buffer = createStructBuffer({
+                schema: vec2Schema,
+                length: 5
+            });
+            
+            // Initialize with values
+            for (let i = 0; i < 5; i++) {
+                buffer.set(i, { x: i + 1, y: i + 2 });
+            }
+            
+            // Copy with out of bounds target
+            buffer.copyWithin(10, 0, 2);
+            expect(buffer.get(0)).toEqual({ x: 1, y: 2 });
+            expect(buffer.get(1)).toEqual({ x: 2, y: 3 });
+            expect(buffer.get(2)).toEqual({ x: 3, y: 4 });
+            expect(buffer.get(3)).toEqual({ x: 4, y: 5 });
+            expect(buffer.get(4)).toEqual({ x: 5, y: 6 });
+        });
+    });
+
+    describe('createTypedBuffer', () => {
+        it('should create appropriate buffer type and handle copyWithin', () => {
+            // Test number buffer
+            const numberBuffer = createTypedBuffer({
+                schema: { type: 'number', precision: 1 }
+            });
+            numberBuffer.set(0, 1);
+            numberBuffer.set(1, 2);
+            numberBuffer.copyWithin(2, 0, 2);
+            expect(numberBuffer.get(2)).toBe(1);
+            expect(numberBuffer.get(3)).toBe(2);
+
+            // Test array buffer
+            const arrayBuffer = createTypedBuffer({
+                schema: { type: 'array', items: { type: 'string' }, minItems: 2, maxItems: 2 } as const
+            });
+            arrayBuffer.set(0, ['a', 'b']);
+            arrayBuffer.set(1, ['c', 'd']);
+            arrayBuffer.copyWithin(2, 0, 2);
+            expect(arrayBuffer.get(2)).toEqual(['a', 'b']);
+            expect(arrayBuffer.get(3)).toEqual(['c', 'd']);
+
+            // Test struct buffer
+            const structBuffer = createTypedBuffer({
+                schema: {
+                    type: 'object',
+                    properties: {
+                        x: { type: 'number', precision: 1 },
+                        y: { type: 'number', precision: 1 }
+                    }
+                }
+            });
+            structBuffer.set(0, { x: 1, y: 2 });
+            structBuffer.set(1, { x: 3, y: 4 });
+            structBuffer.copyWithin(2, 0, 2);
+            expect(structBuffer.get(2)).toEqual({ x: 1, y: 2 });
+            expect(structBuffer.get(3)).toEqual({ x: 3, y: 4 });
+        });
+    });
+}); 

package/src/typed-buffer/typed-buffer.ts

@@ -0,0 +1,41 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import { TypedArray } from "../internal/typed-array/index.js";
+
+export interface ReadonlyTypedBuffer<T> {
+    readonly size: number;
+    get(index: number): T;
+    [Symbol.iterator](): IterableIterator<T>;
+}
+
+export interface TypedBuffer<T> extends ReadonlyTypedBuffer<T> {
+    size: number;                 // drops `readonly`
+    set(index: number, value: T): void;
+    copyWithin(target: number, start: number, end: number): void;
+
+    /**
+     * Returns the typed array of the buffer.
+     * @throws If the buffer is not backed by a typed array.
+     */
+    getTypedArray(): TypedArray;
+}
+

package/src/types/assert.ts

@@ -0,0 +1,22 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+export type Assert<T extends true> = T; 

package/src/types/equal.ts

@@ -0,0 +1,24 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+export type Equal<X, Y> =
+    (<T>() => T extends X ? 1 : 2) extends
+    (<T>() => T extends Y ? 1 : 2) ? true : false; 

package/{types/index.js → src/types/index.ts}

@@ -19,5 +19,7 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.*/
+
 export * from "./types.js";
-//# sourceMappingURL=index.js.map
+export * from "./assert.js";
+export * from "./equal.js";

package/src/types/types.ts

@@ -0,0 +1,166 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+
+/* eslint-disable @typescript-eslint/no-unused-vars -- we have many compile time checks which are unused */
+
+/**
+ * Excludes all properties that have value type never.
+ */
+export type NoNever<T> = {
+  [K in keyof T as T[K] extends never ? never : K]: T[K];
+};
+
+/**
+ * Expands the type so when viewing in the editor, it shows all properties.
+ */
+export type Expand<T> = T extends {} ? T extends infer O ? { [K in keyof O]: O[K] } : T : T;
+
+/**
+ * Extracts all function properties that return void.
+ */
+export type VoidFunctions<T> = NoNever<{
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- safe usage.
+  [K in keyof T]: T[K] extends (...args: any[]) => infer R
+  ? IsVoid<R> extends true
+  ? T[K]
+  : never
+  : never;
+}>;
+
+/**
+ * @internal
+ */
+export type Primitive = string | number | boolean | null | undefined;
+
+
+/* eslint-disable @typescript-eslint/no-unused-vars -- we have many compile time checks which are unused */
+
+export type KeysWithValueType<T, U> = {
+  [K in keyof T]: T[K] extends U ? K : never;
+}[keyof T];
+
+export type StringKeyof<T> = Extract<keyof T, string>;
+
+export type IsVoid<T> = [void] extends [T]
+  ? T extends void
+  ? true
+  : false
+  : false;
+//  tuple types prevent typescript from distributing over union types
+export type IsTrue<T> = [T] extends [true]
+  ? [true] extends [T]
+  ? true
+  : false
+  : false;
+{
+  type CheckIsTrueTrueIsTrue = True<IsTrue<true>>;
+  type CheckIsTrueFalseIsFalse = False<IsTrue<false>>;
+  type CheckIsTrueBooleanIsFalse = False<IsTrue<boolean>>;
+}
+
+export type Not<T> = [T] extends [false]
+  ? true
+  : [T] extends [true]
+  ? false
+  : boolean;
+{
+  type CheckNotFalseIsTrue = True<Not<false>>;
+  type CheckNotTrueIsFalse = False<Not<true>>;
+  type CheckNotBooleanIsBoolean = True<EquivalentTypes<Not<boolean>, boolean>>;
+}
+
+export type False<A extends false> = A extends boolean ? true : true;
+export type True<A extends true> = A extends boolean ? true : true;
+export type Extends<A, B> = [A] extends [B] ? true : false;
+
+export type EquivalentTypes<A, B> = [A] extends [B]
+  ? [B] extends [A]
+  ? true
+  : false
+  : false;
+
+export type AnyFunction = (...args: unknown[]) => unknown;
+
+/**
+ * @internal
+ */
+export type IsUnknown<T> = unknown extends T
+  ? T extends unknown
+  ? T extends
+  | string
+  | number
+  | boolean
+  | symbol
+  | bigint
+  | null
+  | undefined
+  | object
+  | AnyFunction
+  ? false
+  : true
+  : never
+  : false;
+
+
+export type DeepReadonly<T> = T extends Function
+  ? T
+  : T extends Array<infer U>
+  ? IsTuple<T> extends true
+  ? { readonly [K in keyof T]: DeepReadonly<T[K]> } // T is a tuple
+  : ReadonlyArray<DeepReadonly<U>> // T is an array
+  : T extends object
+  ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
+  : T;
+
+type IsTuple<T> = T extends readonly [...infer Elements]
+  ? number extends T['length']
+  ? false
+  : true
+  : false;
+
+export type Simplify<T> = T extends object ? { [K in keyof T]: T[K] } : T;
+
+export type IsNever<T> = [T] extends [never] ? true : false;
+
+export type RequiredKeys<T extends object> = {
+  // eslint-disable-next-line @typescript-eslint/ban-types -- we need {} to represent object
+  [K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K;
+}[keyof T];
+
+export type OptionalKeys<T extends object> = Exclude<
+  {
+    [K in keyof T]: T extends Record<K, T[K]> ? never : K;
+  }[keyof T],
+  undefined
+>;
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- needed for dynamic type
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
+  k: infer I
+) => void
+  ? I
+  : never;
+
+export type NoUnion<Key> = [Key] extends [UnionToIntersection<Key>]
+  ? Key
+  : never;
+

package/tsconfig-base.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "target": "ESNext",
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "types": ["@webgpu/types"],
+    "skipLibCheck": true,
+    "rootDir": "src",
+    "outDir": "dist",
+    "declaration": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "strict": true,
+    "noFallthroughCasesInSwitch": true,
+    "stripInternal": true,
+    "sourceMap": true
+  },
+  "files": [],
+  "include": [],
+  "exclude": ["node_modules", "dist"]
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig-base.json",
+  "references": [
+    {
+      "path": "./src"
+    }
+  ]
+}

package/typedoc.json

@@ -0,0 +1,22 @@
+{
+    "entryPoints": [
+        "src/index.ts",
+        "src/cache/index.ts",
+        "src/ecs/index.ts",
+        "src/lit/index.ts",
+        "src/observe/index.ts",
+        "src/schema/index.ts",
+        "src/service/index.ts",
+        "src/table/index.ts",
+        "src/typed-buffer/index.ts",
+        "src/types/index.ts"
+    ],
+    "out": "docs/api",
+    "exclude": [
+        "**/__tests__/**",
+        "**/*.spec.ts"
+    ],
+    "excludePrivate": true,
+    "excludeProtected": true,
+    "includeVersion": true
+}

package/vite.config.js

@@ -0,0 +1,16 @@
+import { defineConfig } from 'vite'
+
+// we have to turn off the webdriverio test runner when running in vscode debug mode
+const IS_RUNNING_VSCODE_DEBUG = typeof process.env.VSCODE_INSPECTOR_OPTIONS === 'string';
+
+export default defineConfig({
+  test: {
+    tsconfig: './tsconfig-base.json',
+    browser: IS_RUNNING_VSCODE_DEBUG ? {} : {
+      provider: 'webdriverio', // or 'webdriverio'
+      enabled: true,
+      name: 'chrome', // browser name is required
+      headless: true,
+    },
+  }
+})

package/assembly/index.d.ts

@@ -1,30 +0,0 @@
-/** Exported memory */
-export declare const memory: WebAssembly.Memory;
-/**
- * assembly/index/add
- * @param a `i32`
- * @param b `i32`
- * @returns `i32`
- */
-export declare function add(a: number, b: number): number;
-/**
- * assembly/index/addF32Arrays
- * @param aPtr `usize`
- * @param bPtr `usize`
- * @param length `u32`
- */
-export declare function addF32Arrays(aPtr: number, bPtr: number, length: number): void;
-/**
- * assembly/index/addF32ArraysSimd4
- * @param aPtr `usize`
- * @param bPtr `usize`
- * @param length `u32`
- */
-export declare function addF32ArraysSimd4(aPtr: number, bPtr: number, length: number): void;
-/**
- * assembly/index/addF32ArraysSimd4Unrolled
- * @param aPtr `usize`
- * @param bPtr `usize`
- * @param length `u32`
- */
-export declare function addF32ArraysSimd4Unrolled(aPtr: number, bPtr: number, length: number): void;

package/assembly/index.js

@@ -1,18 +0,0 @@
-async function instantiate(module, imports = {}) {
-  const { exports } = await WebAssembly.instantiate(module, imports);
-  return exports;
-}
-export const {
-  memory,
-  add,
-  addF32Arrays,
-  addF32ArraysSimd4,
-  addF32ArraysSimd4Unrolled,
-} = await (async url => instantiate(
-  await (async () => {
-    const isNodeOrBun = typeof process != "undefined" && process.versions != null && (process.versions.node != null || process.versions.bun != null);
-    if (isNodeOrBun) { return globalThis.WebAssembly.compile(await (await import("node:fs/promises")).readFile(url)); }
-    else { return await globalThis.WebAssembly.compileStreaming(globalThis.fetch(url)); }
-  })(), {
-  }
-))(new URL("index.wasm", import.meta.url));