npm - @daneren2005/shared-memory-objects - Versions diffs - 0.0.9 → 0.0.11 - Mend

@daneren2005/shared-memory-objects 0.0.9 → 0.0.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (44) hide show

package/dist/shared-memory-objects.js +1325 -0
package/dist/shared-memory-objects.umd.cjs +1 -0
package/dist/src/allocated-memory.d.ts +26 -0
package/dist/src/cached-item-list.d.ts +37 -0
package/{src/interfaces/pow2.ts → dist/src/interfaces/pow2.d.ts} +2 -3
package/dist/src/interfaces/typed-array-constructor.d.ts +5 -0
package/{src/interfaces/typed-array.ts → dist/src/interfaces/typed-array.d.ts} +1 -1
package/dist/src/lock/read-write-lock.d.ts +5 -0
package/dist/src/lock/simple-lock.d.ts +3 -0
package/dist/src/main.d.ts +18 -0
package/dist/src/memory-buffer.d.ts +185 -0
package/dist/src/memory-heap.d.ts +34 -0
package/dist/src/serialize-object.d.ts +5 -0
package/dist/src/shared-list.d.ts +44 -0
package/dist/src/shared-map.d.ts +25 -0
package/dist/src/shared-pointer-list.d.ts +21 -0
package/dist/src/shared-string.d.ts +23 -0
package/dist/src/shared-vector.d.ts +40 -0
package/dist/src/utils/16-from-32-array.d.ts +4 -0
package/dist/src/utils/16-from-64-array.d.ts +2 -0
package/dist/src/utils/float32-atomics.d.ts +5 -0
package/dist/src/utils/pointer.d.ts +19 -0
package/package.json +17 -5
package/src/allocated-memory.ts +0 -89
package/src/cached-item-list.ts +0 -143
package/src/interfaces/typed-array-constructor.ts +0 -6
package/src/lock/read-write-lock.ts +0 -41
package/src/lock/simple-lock.ts +0 -21
package/src/main.ts +0 -40
package/src/memory-buffer.ts +0 -666
package/src/memory-heap.ts +0 -191
package/src/serialize-object.ts +0 -95
package/src/shared-list.ts +0 -339
package/src/shared-map.ts +0 -252
package/src/shared-pointer-list.ts +0 -80
package/src/shared-string.ts +0 -144
package/src/shared-vector.ts +0 -236
package/src/utils/16-from-32-array.ts +0 -23
package/src/utils/16-from-64-array.ts +0 -18
package/src/utils/float32-atomics.ts +0 -26
package/src/utils/pointer.ts +0 -40
package/src/utils/typedarray.js +0 -162
package/src/vite-env.d.ts +0 -1
/package/{src → dist/src}/utils/typedarray.d.ts +0 -0

package/dist/shared-memory-objects.umd.cjs ADDED Viewed

@@ -0,0 +1 @@

package/dist/src/allocated-memory.d.ts ADDED Viewed

@@ -0,0 +1,26 @@
+import { TypedArray } from './interfaces/typed-array';
+import { TypedArrayConstructor } from './interfaces/typed-array-constructor';
+import { default as MemoryBuffer } from './memory-buffer';
+import { default as MemoryHeap } from './memory-heap';
+export default class AllocatedMemory {
+    private readonly memory;
+    readonly bufferPosition: number;
+    get bufferByteOffset(): number;
+    get pointer(): number;
+    private buffer;
+    data: Uint32Array;
+    constructor(memory: MemoryHeap, config: AllocatedMemoryConfig | SharedAllocatedMemory);
+    getArray<T extends TypedArray>(type: TypedArrayConstructor<T>, offset: number, length: number): T;
+    getArrayMemory(offset: number, length: number): SharedAllocatedMemory;
+    free(): void;
+    getSharedMemory(): SharedAllocatedMemory;
+}
+interface AllocatedMemoryConfig {
+    data: Uint32Array;
+    buffer: MemoryBuffer;
+}
+interface SharedAllocatedMemory {
+    bufferPosition: number;
+    bufferByteOffset: number;
+}
+export type { SharedAllocatedMemory };

package/dist/src/cached-item-list.d.ts ADDED Viewed

@@ -0,0 +1,37 @@
+import { SharedAllocatedMemory } from './allocated-memory';
+import { default as MemoryHeap } from './memory-heap';
+import { default as SharedList, SharedListMemory } from './shared-list';
+export default abstract class CachedItemList<T extends Item> implements Iterable<{
+    item: T;
+    deleteCurrent: () => void;
+}> {
+    static readonly ALLOCATE_COUNT = 4;
+    protected heap: MemoryHeap;
+    protected list: SharedList;
+    protected cache: Map<number, T>;
+    constructor(heap: MemoryHeap, config?: CachedListConfig | SharedListMemory);
+    get length(): number;
+    clear(): void;
+    insert(item: T): void;
+    delete(item: T): boolean;
+    getByPointer(pointer: number): T | undefined;
+    protected abstract initItem(pointer: number): T | undefined;
+    [Symbol.iterator](): Generator<{
+        item: T;
+        deleteCurrent: () => void;
+    }, void, unknown>;
+    forEach(callback: (item: T) => void, filter?: (item: T) => boolean): void;
+    find(callback: (item: T) => boolean): T | undefined;
+    filter(callback: (entity: T) => boolean): Array<T>;
+    map<X>(callback: (item: T) => X): Array<X>;
+    getSharedMemory(): SharedListMemory;
+    free(): void;
+}
+export interface CachedListConfig {
+    initWithBlock: SharedAllocatedMemory;
+}
+interface Item {
+    pointer: number;
+    free: () => void;
+}
+export {};

package/{src/interfaces/pow2.ts → dist/src/interfaces/pow2.d.ts} RENAMED Viewed

@@ -1,3 +1,2 @@
-type Pow2 = 0x1 | 0x2 | 0x4 | 0x8 | 0x10 | 0x20 | 0x40 | 0x80 | 0x100 | 0x200 | 0x400 | 0x800 | 0x1000 | 0x2000 | 0x4000 | 0x8000 | 0x10000 | 0x20000 | 0x40000 | 0x80000 | 0x100000 | 0x200000 | 0x400000 | 0x800000 | 0x1000000 | 0x2000000 | 0x4000000 | 0x8000000 | 0x10000000 | 0x20000000 | 0x40000000 | 0x80000000;
-export type { Pow2 };
+type Pow2 = 0x1 | 0x2 | 0x4 | 0x8 | 0x10 | 0x20 | 0x40 | 0x80 | 0x100 | 0x200 | 0x400 | 0x800 | 0x1000 | 0x2000 | 0x4000 | 0x8000 | 0x10000 | 0x20000 | 0x40000 | 0x80000 | 0x100000 | 0x200000 | 0x400000 | 0x800000 | 0x1000000 | 0x2000000 | 0x4000000 | 0x8000000 | 0x10000000 | 0x20000000 | 0x40000000 | 0x80000000;
+export type { Pow2 };

package/dist/src/interfaces/typed-array-constructor.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+interface TypedArrayConstructor<T> {
+    new (buffer: ArrayBufferLike, byteOffset: number, length: number): T;
+    BYTES_PER_ELEMENT: number;
+}
+export type { TypedArrayConstructor };

package/{src/interfaces/typed-array.ts → dist/src/interfaces/typed-array.d.ts} RENAMED Viewed

	@@ -1 +1 @@
1	- export type TypedArray = Float32Array \| Float64Array \| Int8Array \| Int16Array \| Int32Array \| Uint8Array \| Uint8ClampedArray \| Uint16Array \| Uint32Array;
1	+ export type TypedArray = Float32Array \| Float64Array \| Int8Array \| Int16Array \| Int32Array \| Uint8Array \| Uint8ClampedArray \| Uint16Array \| Uint32Array;

package/dist/src/lock/read-write-lock.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+export declare function readLock(data: Int32Array, index?: number): void;
+export declare function writeLock(data: Int32Array, index?: number): void;
+export declare function readUnlock(data: Int32Array, index?: number): void;
+export declare function writeUnlock(data: Int32Array, index?: number): void;
+export declare const READ_WRITE_LOCK_ALLOCATE_COUNT = 2;

package/dist/src/lock/simple-lock.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+export declare function lock(data: Int32Array, index?: number): void;
+export declare function unlock(data: Int32Array, index?: number): void;
+export declare const SIMPLE_LOCK_ALLOCATE_COUNT = 1;

package/dist/src/main.d.ts ADDED Viewed

@@ -0,0 +1,18 @@
+import { default as AllocatedMemory, SharedAllocatedMemory } from './allocated-memory';
+import { default as MemoryBuffer } from './memory-buffer';
+import { default as MemoryHeap, MemoryHeapMemory, GrowBufferData } from './memory-heap';
+import { default as SharedList, SharedListMemory } from './shared-list';
+import { default as SharedMap, SharedMapMemory } from './shared-map';
+import { default as SharedPointerList } from './shared-pointer-list';
+import { default as SharedString } from './shared-string';
+import { default as SharedVector, SharedVectorMemory } from './shared-vector';
+import { default as CachedItemList, CachedListConfig } from './cached-item-list';
+export * from './interfaces/typed-array';
+export * from './interfaces/typed-array-constructor';
+export * from './utils/16-from-32-array';
+export * from './utils/16-from-64-array';
+export * from './utils/float32-atomics';
+export * from './utils/pointer';
+export * from './lock/simple-lock';
+export * from './lock/read-write-lock';
+export { AllocatedMemory, type SharedAllocatedMemory, MemoryBuffer, MemoryHeap, type MemoryHeapMemory, type GrowBufferData, SharedList, type SharedListMemory, SharedMap, type SharedMapMemory, SharedPointerList, SharedString, SharedVector, type SharedVectorMemory, CachedItemList, type CachedListConfig };

package/dist/src/memory-buffer.d.ts ADDED Viewed

@@ -0,0 +1,185 @@
+import { Pow2 } from './interfaces/pow2';
+import { TypedArray } from './interfaces/typed-array';
+export default class MemoryBuffer {
+    buf: ArrayBufferLike;
+    protected readonly start: number;
+    protected u8: Uint8Array;
+    protected u32: Uint32Array;
+    protected state: Uint32Array;
+    protected lock: Int32Array;
+    constructor(opts?: Partial<MemoryBufferConfig>);
+    stats(): Readonly<MemoryBufferStats>;
+    callocAs<T extends Type>(type: T, num: number, fill?: number): import('./utils/typedarray').TypedArrayTypeMap[T] | undefined;
+    mallocAs<T extends Type>(type: T, num: number): import('./utils/typedarray').TypedArrayTypeMap[T] | undefined;
+    calloc(bytes: number, fill?: number): number;
+    malloc(bytes: number): number;
+    private mallocTop;
+    realloc(ptr: number, bytes: number): number;
+    private reallocBlock;
+    reallocArray<T extends TypedArray>(array: T, num: number): T | undefined;
+    bytesFor(ptrOrArray: number | TypedArray): number | undefined;
+    lengthOf(ptrOrArray: number | TypedArray): number | undefined;
+    free(ptrOrArray: number | TypedArray): boolean;
+    freeAll(): void;
+    release(): boolean;
+    protected get align(): Pow2;
+    protected set align(x: Pow2);
+    get end(): number;
+    protected set end(x: number);
+    get top(): number;
+    protected set top(x: number);
+    protected get _free(): number;
+    protected set _free(block: number);
+    protected get _used(): number;
+    protected set _used(block: number);
+    protected get doCompact(): boolean;
+    protected set doCompact(flag: boolean);
+    protected get doSplit(): boolean;
+    protected set doSplit(flag: boolean);
+    protected get minSplit(): number;
+    protected set minSplit(x: number);
+    protected blockSize(block: number): number;
+    /**
+     * Sets & returns given block size.
+     *
+     * @param block -
+     * @param size -
+     */
+    protected setBlockSize(block: number, size: number): number;
+    protected blockNext(block: number): number;
+    /**
+     * Sets block next pointer to `next`. Use zero to indicate list end.
+     *
+     * @param block -
+     */
+    protected setBlockNext(block: number, next: number): void;
+    /**
+     * Initializes block header with given `size` and `next` pointer. Returns `block`.
+     *
+     * @param block -
+     * @param size -
+     * @param next -
+     */
+    protected initBlock(block: number, size: number, next: number): number;
+    protected unlinkBlock(prev: number, block: number): void;
+    protected splitBlock(block: number, blockSize: number, excess: number): void;
+    protected initialTop(_align?: Pow2): number;
+    /**
+     * Traverses free list and attempts to recursively merge blocks
+     * occupying consecutive memory regions. Returns true if any blocks
+     * have been merged. Only called if `compact` option is enabled.
+     */
+    protected compact(): boolean;
+    /**
+     * Inserts given block into list of free blocks, sorted by address.
+     *
+     * @param block -
+     */
+    protected insert(block: number): void;
+}
+type Type = 'u8' | 'u8c' | 'i8' | 'u16' | 'i16' | 'u32' | 'i32' | 'f32' | 'f64';
+interface MemoryBufferConfig {
+    /**
+     * Backing ArrayBuffer (or SharedArrayBuffer). If not given, a new
+     * one will be created with given `size`.
+     */
+    buf: ArrayBufferLike;
+    /**
+     * Byte size for newly created ArrayBuffers (if `buf` is not given).
+     *
+     * @defaultValue 0x1000 (4KB)
+     */
+    size: number;
+    /**
+     * Anchor index (byte address) inside the array buffer. The MemPool
+     * stores its internal state from the given address and heap space
+     * starts at least 32 bytes later (depending on chosen `align`
+     * value). Unlike allocator state variables, `start`` cannot be
+     * saved inside the array buffer itself. If the ArrayBuffer is
+     * passed to other consumers they must use the same start value.
+     * MUST be multiple of 4.
+     *
+     * @defaultValue 0
+     */
+    start: number;
+    /**
+     * Byte address (+1) of the end of the memory region managed by the
+     * {@link MemPool}.
+     *
+     * @defaultValue end of the backing ArrayBuffer
+     */
+    end: number;
+    /**
+     * Number of bytes to align memory blocks to. MUST be a power of 2
+     * and >= 8. Use 16 if the pool is being used for allocating memory
+     * used in SIMD operations.
+     *
+     * @defaultValue 8
+     */
+    align: Pow2;
+    /**
+     * Flag to configure memory block compaction. If true,
+     * adjoining free blocks (in terms of address space) will be merged
+     * to minimize fragementation.
+     *
+     * @defaultValue true
+     */
+    compact: boolean;
+    /**
+     * Flag to configure memory block splitting. If true, and when the
+     * allocator is re-using a previously freed block larger than the
+     * requested size, the block will be split to minimize wasted/unused
+     * memory. The splitting behavior can further customized via the
+     * `minSplit` option.
+     *
+     * @defaultValue true
+     */
+    split: boolean;
+    /**
+     * Only used if `split` behavior is enabled. Defines min number of
+     * excess bytes available in a block for memory block splitting to
+     * occur.
+     *
+     * @defaultValue 16, MUST be > 8
+     */
+    minSplit: number;
+    /**
+     * Only needed when sharing the underlying ArrayBuffer. If true, the
+     * {@link MemPool} constructor will NOT initialize its internal state and
+     * assume the underlying ArrayBuffer has already been initialized by
+     * another {@link MemPool} instance. If this option is used, `buf` MUST be
+     * given.
+     *
+     * @defaultValue false
+     */
+    skipInitialization: boolean;
+}
+interface MemoryBufferStats {
+    /**
+     * Free block stats.
+     */
+    free: {
+        count: number;
+        size: number;
+    };
+    /**
+     * Used block stats.
+     */
+    used: {
+        count: number;
+        size: number;
+    };
+    /**
+     * Current top address.
+     */
+    top: number;
+    /**
+     * Bytes available
+     */
+    available: number;
+    /**
+     * Total pool size.
+     */
+    total: number;
+}
+export {};

package/dist/src/memory-heap.d.ts ADDED Viewed

@@ -0,0 +1,34 @@
+import { default as AllocatedMemory, SharedAllocatedMemory } from './allocated-memory';
+import { default as MemoryBuffer } from './memory-buffer';
+export default class MemoryHeap {
+    buffers: Array<MemoryBuffer>;
+    private onGrowBufferHandlers;
+    isClone: boolean;
+    private memory;
+    get bufferSize(): number;
+    constructor(config?: MemoryHeapConfig | MemoryHeapMemory);
+    addSharedBuffer(data: GrowBufferData): void;
+    private growBuffer;
+    private createBuffer;
+    addOnGrowBufferHandlers(handler: OnGrowBuffer): void;
+    allocUI32(count: number): AllocatedMemory;
+    getSharedAlloc(shared: SharedAllocatedMemory): AllocatedMemory | undefined;
+    get currentUsed(): number;
+    get totalAllocated(): number;
+    prettyMemory(): string;
+    getSharedMemory(): MemoryHeapMemory;
+}
+type OnGrowBuffer = (newBuffer: GrowBufferData) => void;
+interface GrowBufferData {
+    bufferPosition: number;
+    buffer: SharedArrayBuffer;
+}
+interface MemoryHeapConfig {
+    bufferSize?: number;
+    initialBuffers?: number;
+    autoGrowSize?: number;
+}
+interface MemoryHeapMemory {
+    buffers: Array<SharedArrayBuffer>;
+}
+export type { MemoryHeapConfig, MemoryHeapMemory, GrowBufferData };

package/dist/src/serialize-object.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+import { default as AllocatedMemory } from './allocated-memory';
+import { default as MemoryHeap } from './memory-heap';
+export declare function serializeObjectToMemory<T extends object>(heap: MemoryHeap, object: T): AllocatedMemory;
+export declare function createObjectFromPointer<T extends object>(heap: MemoryHeap, pointer: number): T;
+export declare function createObjectFromMemory<T extends object>(memory: AllocatedMemory): T;

package/dist/src/shared-list.d.ts ADDED Viewed

@@ -0,0 +1,44 @@
+import { SharedAllocatedMemory } from './allocated-memory';
+import { TypedArrayConstructor } from './interfaces/typed-array-constructor';
+import { default as MemoryHeap } from './memory-heap';
+export default class SharedList<T extends Uint32Array | Int32Array | Float32Array = Uint32Array> implements Iterable<SharedListIterable<T>> {
+    static readonly ALLOCATE_COUNT = 4;
+    private memory;
+    private firstBlock;
+    private uint16Array;
+    onDelete?: (data: T) => void;
+    get length(): number;
+    get type(): number;
+    private set type(value);
+    get dataLength(): number;
+    private set dataLength(value);
+    constructor(memory: MemoryHeap, config?: SharedListConfig<T> | SharedListMemory);
+    insert(values: number | Array<number>): void;
+    deleteMatch(callback: (values: T, index: number) => boolean): boolean;
+    deleteIndex(deleteIndex: number): boolean;
+    deleteValue(deleteValues: number | Array<number>): boolean;
+    clear(): void;
+    [Symbol.iterator](): Generator<{
+        data: T;
+        index: number;
+        deleteCurrent: () => void;
+    }, void, unknown>;
+    forEach(callback: (data: T) => void): void;
+    getSharedMemory(): SharedListMemory;
+    private getDataBlock;
+    free(): void;
+}
+interface SharedListConfig<T extends Uint32Array | Int32Array | Float32Array> {
+    initWithBlock?: SharedAllocatedMemory;
+    type?: TypedArrayConstructor<T>;
+    dataLength?: number;
+}
+interface SharedListMemory {
+    firstBlock: SharedAllocatedMemory;
+}
+interface SharedListIterable<T extends Uint32Array | Int32Array | Float32Array> {
+    data: T;
+    index: number;
+    deleteCurrent: () => void;
+}
+export { type SharedListMemory };

package/dist/src/shared-map.d.ts ADDED Viewed

@@ -0,0 +1,25 @@
+import { SharedAllocatedMemory } from './allocated-memory';
+import { default as MemoryHeap } from './memory-heap';
+export default class SharedMap<K extends string | number> {
+    static readonly ALLOCATE_COUNT = 4;
+    private memory;
+    private pointerMemory;
+    private lock;
+    private get hashMemory();
+    get length(): number;
+    get maxHash(): number;
+    constructor(memory: MemoryHeap, clone?: SharedMapMemory);
+    set(key: K, value: number): void;
+    private setHashKey;
+    get(key: K): number | undefined;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    private growHashTable;
+    private hash;
+    free(): void;
+    getSharedMemory(): SharedMapMemory;
+}
+interface SharedMapMemory {
+    firstBlock: SharedAllocatedMemory;
+}
+export type { SharedMapMemory };

package/dist/src/shared-pointer-list.d.ts ADDED Viewed

@@ -0,0 +1,21 @@
+import { default as AllocatedMemory } from './allocated-memory';
+import { default as MemoryHeap } from './memory-heap';
+import { SharedListMemory } from './shared-list';
+export default abstract class SharedPointerList<T extends PointerItem> implements Iterable<T> {
+    private memory;
+    private list;
+    constructor(heap: MemoryHeap, memory?: SharedListMemory);
+    get length(): number;
+    insert(item: T): void;
+    delete(item: T): boolean;
+    [Symbol.iterator](): Generator<T, void, unknown>;
+    forEach(callback: (item: T) => void): void;
+    find(callback: (item: T) => boolean): T | undefined;
+    getSharedMemory(): SharedListMemory;
+    protected abstract createItem(allocatedMemory: AllocatedMemory): T;
+    free(): void;
+}
+interface PointerItem {
+    readonly memory: AllocatedMemory;
+}
+export {};

package/dist/src/shared-string.d.ts ADDED Viewed

@@ -0,0 +1,23 @@
+import { SharedAllocatedMemory } from './allocated-memory';
+import { default as MemoryHeap } from './memory-heap';
+export default class SharedString {
+    static readonly ALLOCATE_COUNT = 4;
+    private memory;
+    private allocatedMemory;
+    private lock;
+    private cachedPointer?;
+    private cachedString?;
+    constructor(memory: MemoryHeap, value: string | SharedStringConfig | SharedStringMemory);
+    private updateString;
+    private createString;
+    get value(): string;
+    set value(value: string);
+    getSharedMemory(): SharedStringMemory;
+    get pointer(): number;
+    free(): void;
+}
+interface SharedStringConfig extends SharedStringMemory {
+    value: string;
+}
+type SharedStringMemory = SharedAllocatedMemory;
+export {};

package/dist/src/shared-vector.d.ts ADDED Viewed

@@ -0,0 +1,40 @@
+import { SharedAllocatedMemory } from './allocated-memory';
+import { TypedArrayConstructor } from './interfaces/typed-array-constructor';
+import { default as MemoryHeap } from './memory-heap';
+export default class SharedVector<T extends Uint32Array | Int32Array | Float32Array = Uint32Array> implements Iterable<T> {
+    static readonly ALLOCATE_COUNT = 4;
+    private memory;
+    private firstBlock;
+    private uint16Array;
+    get length(): number;
+    get type(): number;
+    private set type(value);
+    get dataLength(): number;
+    private set dataLength(value);
+    get bufferLength(): number;
+    private set bufferLength(value);
+    private cachedFullDataBlock?;
+    private cachedPointer;
+    constructor(memory: MemoryHeap, config?: SharedVectorConfig<T> | SharedVectorMemory);
+    at(index: number): T;
+    get(index: number, dataIndex?: number): number;
+    push(values: number | Array<number>): number;
+    pop(): T;
+    deleteIndex(index: number): void;
+    clear(): void;
+    [Symbol.iterator](): Generator<T, void, unknown>;
+    private getFullDataBlock;
+    private getDataBlock;
+    private growBuffer;
+    free(): void;
+    getSharedMemory(): SharedVectorMemory;
+}
+interface SharedVectorConfig<T extends Uint32Array | Int32Array | Float32Array> {
+    type?: TypedArrayConstructor<T>;
+    dataLength?: number;
+    bufferLength?: number;
+}
+interface SharedVectorMemory {
+    firstBlock: SharedAllocatedMemory;
+}
+export type { SharedVectorConfig, SharedVectorMemory };

package/dist/src/utils/16-from-32-array.d.ts ADDED Viewed

@@ -0,0 +1,4 @@
+export declare function load16From32(data: Uint32Array, index: number): [number, number];
+export declare function store16In32(data: Uint32Array, index: number, value1: number, value2: number): void;
+export declare function convert32To16(value: number): [number, number];
+export declare function convert16To32(value1: number, value2: number): number;

package/dist/src/utils/16-from-64-array.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export declare function load16From64(data: BigUint64Array, index: number): [number, number, number, number];
2	+ export declare function store16In64(data: BigUint64Array, index: number, value1: number, value2: number, value3: number, value4?: number): void;

package/dist/src/utils/float32-atomics.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+export declare function loadFloat32(data: Int32Array | Uint32Array, index: number): number;
+export declare function storeFloat32(data: Int32Array | Uint32Array, index: number, value: number): void;
+export declare function convertInt32ToFloat32(value: number): number;
+export declare function convertFloat32ToInt32(value: number): number;
+export declare function exchangeFloat32(data: Int32Array | Uint32Array, index: number, value: number): number;

package/dist/src/utils/pointer.d.ts ADDED Viewed

@@ -0,0 +1,19 @@
+declare const BYTE_OFFSET_BIT_COUNT = 20;
+declare const POSITION_BIT_COUNT: number;
+declare const MAX_BYTE_OFFSET_LENGTH: number;
+declare const MAX_POSITION_LENGTH: number;
+export declare function loadPointer(data: Uint32Array, index?: number): {
+    bufferPosition: number;
+    bufferByteOffset: number;
+};
+export declare function loadRawPointer(data: Uint32Array, index?: number): number;
+export declare function storePointer(data: Uint32Array, index: number | undefined, bufferPosition: number, bufferByteOffset: number): void;
+export declare function storeRawPointer(data: Uint32Array, index: number | undefined, pointer: number): void;
+export declare function replacePointer(data: Uint32Array, index: number, newBufferPosition: number, newBufferByteOffset: number, oldBufferPosition: number, oldBufferByteOffset: number): boolean;
+export declare function replaceRawPointer(data: Uint32Array, index: number, newPointer: number, oldPointer: number): boolean;
+export declare function getPointer(value: number): {
+    bufferPosition: number;
+    bufferByteOffset: number;
+};
+export declare function createPointer(bufferPosition: number, bufferByteOffset: number): number;
+export { BYTE_OFFSET_BIT_COUNT, POSITION_BIT_COUNT, MAX_BYTE_OFFSET_LENGTH, MAX_POSITION_LENGTH };