@manycore/aholo-splat-transform 1.2.7 → 1.2.9

package/dist/utils/BufferReader.d.ts

@@ -1,12 +1,12 @@
-export declare class BufferReader {
-    head: number;
-    tail: number;
-    buffer: Uint8Array;
-    view: DataView;
-    get remaining(): number;
-    constructor(buffer?: Uint8Array);
-    private grow;
-    private compact;
-    write(chunk: Uint8Array): void;
-    read(counts: number): Uint8Array;
-}
+export declare class BufferReader {
+    head: number;
+    tail: number;
+    buffer: Uint8Array;
+    view: DataView;
+    get remaining(): number;
+    constructor(buffer?: Uint8Array);
+    private grow;
+    private compact;
+    write(chunk: Uint8Array): void;
+    read(counts: number): Uint8Array;
+}

package/dist/utils/BufferReader.js

@@ -1,47 +1,45 @@
-export class BufferReader {
-    head = 0;
-    tail = 0;
-    buffer;
-    view;
-    get remaining() {
-        return this.tail - this.head;
-    }
-    constructor(buffer = new Uint8Array()) {
-        this.buffer = buffer;
-        this.view = new DataView(this.buffer.buffer);
-    }
-    grow(required) {
-        const newCap = Math.max(required, this.buffer.length * 2);
-        const next = new Uint8Array(newCap);
-        next.set(this.buffer.subarray(this.head, this.tail), 0);
-        this.tail -= this.head;
-        this.head = 0;
-        this.buffer = next;
-        this.view = new DataView(next.buffer);
-    }
-    compact() {
-        if (this.head === 0) {
-            return;
-        }
-        this.buffer.copyWithin(0, this.head, this.tail);
-        this.tail -= this.head;
-        this.head = 0;
-    }
-    write(chunk) {
-        const remaining = this.tail - this.head;
-        const required = remaining + chunk.length;
-        if (this.buffer.length < required) {
-            this.grow(required);
-        }
-        else if (this.head > 0 && this.buffer.length - this.tail < chunk.length) {
-            this.compact();
-        }
-        this.buffer.set(chunk, this.tail);
-        this.tail += chunk.length;
-    }
-    read(counts) {
-        const head = this.head;
-        const tail = this.head = head + counts;
-        return this.buffer.subarray(head, tail);
-    }
-}
+export class BufferReader {
+    get remaining() {
+        return this.tail - this.head;
+    }
+    constructor(buffer = new Uint8Array()) {
+        this.head = 0;
+        this.tail = 0;
+        this.buffer = buffer;
+        this.view = new DataView(this.buffer.buffer);
+    }
+    grow(required) {
+        const newCap = Math.max(required, this.buffer.length * 2);
+        const next = new Uint8Array(newCap);
+        next.set(this.buffer.subarray(this.head, this.tail), 0);
+        this.tail -= this.head;
+        this.head = 0;
+        this.buffer = next;
+        this.view = new DataView(next.buffer);
+    }
+    compact() {
+        if (this.head === 0) {
+            return;
+        }
+        this.buffer.copyWithin(0, this.head, this.tail);
+        this.tail -= this.head;
+        this.head = 0;
+    }
+    write(chunk) {
+        const remaining = this.tail - this.head;
+        const required = remaining + chunk.length;
+        if (this.buffer.length < required) {
+            this.grow(required);
+        }
+        else if (this.head > 0 && this.buffer.length - this.tail < chunk.length) {
+            this.compact();
+        }
+        this.buffer.set(chunk, this.tail);
+        this.tail += chunk.length;
+    }
+    read(counts) {
+        const head = this.head;
+        const tail = (this.head = head + counts);
+        return this.buffer.subarray(head, tail);
+    }
+}

package/dist/utils/Logger.d.ts

@@ -1,11 +1,11 @@
-export declare class Logger {
-    prefix: string;
-    silent: boolean;
-    private format;
-    info(msg: string, force?: boolean): void;
-    warn(msg: string, force?: boolean): void;
-    error(msg: string, force?: boolean): void;
-    time(label: string): void;
-    timeEnd(label: string): void;
-}
-export declare const logger: Logger;
+export declare class Logger {
+    prefix: string;
+    silent: boolean;
+    private format;
+    info(msg: string, force?: boolean): void;
+    warn(msg: string, force?: boolean): void;
+    error(msg: string, force?: boolean): void;
+    time(label: string): void;
+    timeEnd(label: string): void;
+}
+export declare const logger: Logger;

package/dist/utils/Logger.js

@@ -1,38 +1,40 @@
-export class Logger {
-    prefix = '';
-    silent = false;
-    format(msg) {
-        return this.prefix ? `${this.prefix} ${msg}` : msg;
-    }
-    info(msg, force = false) {
-        if (this.silent && !force) {
-            return;
-        }
-        console.log(this.format(msg));
-    }
-    warn(msg, force = false) {
-        if (this.silent && !force) {
-            return;
-        }
-        console.warn(this.format(msg));
-    }
-    error(msg, force = false) {
-        if (this.silent && !force) {
-            return;
-        }
-        console.error(this.format(msg));
-    }
-    time(label) {
-        if (this.silent) {
-            return;
-        }
-        console.time(this.format(label));
-    }
-    timeEnd(label) {
-        if (this.silent) {
-            return;
-        }
-        console.timeEnd(this.format(label));
-    }
-}
-export const logger = new Logger();
+export class Logger {
+    constructor() {
+        this.prefix = '';
+        this.silent = false;
+    }
+    format(msg) {
+        return this.prefix ? `${this.prefix} ${msg}` : msg;
+    }
+    info(msg, force = false) {
+        if (this.silent && !force) {
+            return;
+        }
+        console.log(this.format(msg));
+    }
+    warn(msg, force = false) {
+        if (this.silent && !force) {
+            return;
+        }
+        console.warn(this.format(msg));
+    }
+    error(msg, force = false) {
+        if (this.silent && !force) {
+            return;
+        }
+        console.error(this.format(msg));
+    }
+    time(label) {
+        if (this.silent) {
+            return;
+        }
+        console.time(this.format(label));
+    }
+    timeEnd(label) {
+        if (this.silent) {
+            return;
+        }
+        console.timeEnd(this.format(label));
+    }
+}
+export const logger = new Logger();

package/dist/utils/StreamChunkDecoder.d.ts

@@ -1,16 +1,16 @@
-import { BufferReader } from './BufferReader.js';
-export interface ChunkDecoder {
-    init(): [number, number];
-    decode(offset: number, counts: number, buffer: Uint8Array): void;
-}
-export declare class StreamChunkDecoder {
-    private reader;
-    private decoders;
-    private decodedTotals;
-    private currentIndex;
-    private currentTotals;
-    private currentItemSize;
-    constructor(reader: BufferReader);
-    setDecoders(decoders: ChunkDecoder[]): void;
-    flush(): void;
-}
+import type { BufferReader } from './BufferReader.js';
+export interface ChunkDecoder {
+    init(): [number, number];
+    decode(offset: number, counts: number, buffer: Uint8Array): void;
+}
+export declare class StreamChunkDecoder {
+    private reader;
+    private decoders;
+    private decodedTotals;
+    private currentIndex;
+    private currentTotals;
+    private currentItemSize;
+    constructor(reader: BufferReader);
+    setDecoders(decoders: ChunkDecoder[]): void;
+    flush(): void;
+}

package/dist/utils/StreamChunkDecoder.js

@@ -1,36 +1,31 @@
-export class StreamChunkDecoder {
-    reader;
-    decoders;
-    decodedTotals;
-    currentIndex = 0;
-    currentTotals;
-    currentItemSize;
-    constructor(reader) {
-        this.reader = reader;
-    }
-    setDecoders(decoders) {
-        this.decoders = decoders;
-        this.decodedTotals = new Uint32Array(decoders.length);
-        const [totals, itemSize] = decoders[this.currentIndex].init();
-        this.currentTotals = totals;
-        this.currentItemSize = itemSize;
-    }
-    flush() {
-        const { reader, decoders, decodedTotals, currentIndex, currentTotals, currentItemSize } = this;
-        const stage = decoders[currentIndex];
-        const decoded = decodedTotals[currentIndex];
-        const counts = Math.min(currentTotals - decoded, (reader.remaining / currentItemSize) | 0);
-        const buf = reader.read(counts * currentItemSize);
-        stage.decode(decoded, counts, buf);
-        decodedTotals[currentIndex] += counts;
-        if (decodedTotals[currentIndex] === currentTotals) {
-            this.currentIndex++;
-            if (this.currentIndex < decoders.length) {
-                const [totals, itemSize] = decoders[this.currentIndex].init();
-                this.currentTotals = totals;
-                this.currentItemSize = itemSize;
-                this.flush();
-            }
-        }
-    }
-}
+export class StreamChunkDecoder {
+    constructor(reader) {
+        this.currentIndex = 0;
+        this.reader = reader;
+    }
+    setDecoders(decoders) {
+        this.decoders = decoders;
+        this.decodedTotals = new Uint32Array(decoders.length);
+        const [totals, itemSize] = decoders[this.currentIndex].init();
+        this.currentTotals = totals;
+        this.currentItemSize = itemSize;
+    }
+    flush() {
+        const { reader, decoders, decodedTotals, currentIndex, currentTotals, currentItemSize } = this;
+        const stage = decoders[currentIndex];
+        const decoded = decodedTotals[currentIndex];
+        const counts = Math.min(currentTotals - decoded, (reader.remaining / currentItemSize) | 0);
+        const buf = reader.read(counts * currentItemSize);
+        stage.decode(decoded, counts, buf);
+        decodedTotals[currentIndex] += counts;
+        if (decodedTotals[currentIndex] === currentTotals) {
+            this.currentIndex++;
+            if (this.currentIndex < decoders.length) {
+                const [totals, itemSize] = decoders[this.currentIndex].init();
+                this.currentTotals = totals;
+                this.currentItemSize = itemSize;
+                this.flush();
+            }
+        }
+    }
+}

package/dist/utils/index.d.ts

@@ -1,27 +1,27 @@
-interface Deferred<T = void> {
-    resolve: (value: T | PromiseLike<T>) => void;
-    reject: (reason: any) => void;
-    promise: Promise<T>;
-}
-export declare function deferred<T = void>(): Deferred<T>;
-export declare function sleep(timeout: number): Promise<void>;
-export declare function clamp(v: number, min: number, max: number): number;
-export declare function isUrl(str: string): boolean;
-export declare function extractFromRootDir(entries: Record<string, Uint8Array>): Record<string, Uint8Array>;
-export declare function fromHalf(h: number): number;
-export * from './Logger.js';
-export * from './BufferReader.js';
-export * from './StreamChunkDecoder.js';
-export * from './math.js';
-export * from './sh-rotate.js';
-export * from './splat.js';
-export * from './k-means.js';
-export * from './quantize-1d.js';
-export * from './webgpu.js';
-export * from './voxel/common.js';
-export * from './voxel/voxelize.js';
-export * from './voxel/postprocess.js';
-export * from './voxel/nav.js';
-export * from './voxel/mesh.js';
-export * from './voxel/voxel-faces.js';
-export * from './voxel/gpu-dilation.js';
+interface Deferred<T = void> {
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason: any) => void;
+    promise: Promise<T>;
+}
+export declare function deferred<T = void>(): Deferred<T>;
+export declare function sleep(timeout: number): Promise<void>;
+export declare function clamp(v: number, min: number, max: number): number;
+export declare function isUrl(str: string): boolean;
+export declare function extractFromRootDir(entries: Record<string, Uint8Array>): Record<string, Uint8Array>;
+export declare function fromHalf(h: number): number;
+export * from './Logger.js';
+export * from './BufferReader.js';
+export * from './StreamChunkDecoder.js';
+export * from './math.js';
+export * from './sh-rotate.js';
+export * from './splat.js';
+export * from './k-means.js';
+export * from './quantize-1d.js';
+export * from './webgpu.js';
+export * from './voxel/common.js';
+export * from './voxel/voxelize.js';
+export * from './voxel/postprocess.js';
+export * from './voxel/nav.js';
+export * from './voxel/mesh.js';
+export * from './voxel/voxel-faces.js';
+export * from './voxel/gpu-dilation.js';

package/dist/utils/index.js

@@ -1,101 +1,101 @@
-export function deferred() {
-    let resolve = () => { };
-    let reject = () => { };
-    const promise = new Promise(function (resolveInner, rejectInner) {
-        resolve = resolveInner;
-        reject = rejectInner;
-    });
-    return {
-        promise,
-        resolve,
-        reject,
-    };
-}
-export function sleep(timeout) {
-    return new Promise(resolve => {
-        setTimeout(resolve, timeout);
-    });
-}
-export function clamp(v, min, max) {
-    return Math.min(Math.max(v, min), max);
-}
-export function isUrl(str) {
-    let url;
-    try {
-        url = new URL(str);
-    }
-    catch {
-        return false;
-    }
-    return url.protocol === 'http:' || url.protocol === 'https:';
-}
-export function extractFromRootDir(entries) {
-    let dir = '';
-    for (const path in entries) {
-        if (path.endsWith('/')) {
-            dir = path;
-            break;
-        }
-    }
-    const result = {};
-    for (const path in entries) {
-        result[path.replace(dir, '')] = entries[path];
-    }
-    return result;
-}
-const f32buffer = new Float32Array(1);
-const u32buffer = new Uint32Array(f32buffer.buffer);
-export function fromHalf(h) {
-    const sign = (h >> 15) & 0x1;
-    const exp = (h >> 10) & 0x1f;
-    const frac = h & 0x3ff;
-    let f32bits;
-    if (exp === 0) {
-        if (frac === 0) {
-            f32bits = sign << 31;
-        }
-        else {
-            let mant = frac;
-            let e = -14;
-            while ((mant & 0x400) === 0) {
-                mant <<= 1;
-                e--;
-            }
-            mant &= 0x3ff;
-            const newExp = e + 127;
-            const newFrac = mant << 13;
-            f32bits = (sign << 31) | (newExp << 23) | newFrac;
-        }
-    }
-    else if (exp === 0x1f) {
-        if (frac === 0) {
-            f32bits = (sign << 31) | 0x7f800000;
-        }
-        else {
-            f32bits = (sign << 31) | 0x7fc00000;
-        }
-    }
-    else {
-        const newExp = exp - 15 + 127;
-        const newFrac = frac << 13;
-        f32bits = (sign << 31) | (newExp << 23) | newFrac;
-    }
-    u32buffer[0] = f32bits;
-    return f32buffer[0];
-}
-export * from './Logger.js';
-export * from './BufferReader.js';
-export * from './StreamChunkDecoder.js';
-export * from './math.js';
-export * from './sh-rotate.js';
-export * from './splat.js';
-export * from './k-means.js';
-export * from './quantize-1d.js';
-export * from './webgpu.js';
-export * from './voxel/common.js';
-export * from './voxel/voxelize.js';
-export * from './voxel/postprocess.js';
-export * from './voxel/nav.js';
-export * from './voxel/mesh.js';
-export * from './voxel/voxel-faces.js';
-export * from './voxel/gpu-dilation.js';
+export function deferred() {
+    let resolve = () => { };
+    let reject = () => { };
+    const promise = new Promise(function (resolveInner, rejectInner) {
+        resolve = resolveInner;
+        reject = rejectInner;
+    });
+    return {
+        promise,
+        resolve,
+        reject,
+    };
+}
+export function sleep(timeout) {
+    return new Promise(resolve => {
+        setTimeout(resolve, timeout);
+    });
+}
+export function clamp(v, min, max) {
+    return Math.min(Math.max(v, min), max);
+}
+export function isUrl(str) {
+    let url;
+    try {
+        url = new URL(str);
+    }
+    catch {
+        return false;
+    }
+    return url.protocol === 'http:' || url.protocol === 'https:';
+}
+export function extractFromRootDir(entries) {
+    let dir = '';
+    for (const path in entries) {
+        if (path.endsWith('/')) {
+            dir = path;
+            break;
+        }
+    }
+    const result = {};
+    for (const path in entries) {
+        result[path.replace(dir, '')] = entries[path];
+    }
+    return result;
+}
+const f32buffer = new Float32Array(1);
+const u32buffer = new Uint32Array(f32buffer.buffer);
+export function fromHalf(h) {
+    const sign = (h >> 15) & 0x1;
+    const exp = (h >> 10) & 0x1f;
+    const frac = h & 0x3ff;
+    let f32bits;
+    if (exp === 0) {
+        if (frac === 0) {
+            f32bits = sign << 31;
+        }
+        else {
+            let mant = frac;
+            let e = -14;
+            while ((mant & 0x400) === 0) {
+                mant <<= 1;
+                e--;
+            }
+            mant &= 0x3ff;
+            const newExp = e + 127;
+            const newFrac = mant << 13;
+            f32bits = (sign << 31) | (newExp << 23) | newFrac;
+        }
+    }
+    else if (exp === 0x1f) {
+        if (frac === 0) {
+            f32bits = (sign << 31) | 0x7f800000;
+        }
+        else {
+            f32bits = (sign << 31) | 0x7fc00000;
+        }
+    }
+    else {
+        const newExp = exp - 15 + 127;
+        const newFrac = frac << 13;
+        f32bits = (sign << 31) | (newExp << 23) | newFrac;
+    }
+    u32buffer[0] = f32bits;
+    return f32buffer[0];
+}
+export * from './Logger.js';
+export * from './BufferReader.js';
+export * from './StreamChunkDecoder.js';
+export * from './math.js';
+export * from './sh-rotate.js';
+export * from './splat.js';
+export * from './k-means.js';
+export * from './quantize-1d.js';
+export * from './webgpu.js';
+export * from './voxel/common.js';
+export * from './voxel/voxelize.js';
+export * from './voxel/postprocess.js';
+export * from './voxel/nav.js';
+export * from './voxel/mesh.js';
+export * from './voxel/voxel-faces.js';
+export * from './voxel/gpu-dilation.js';

package/dist/utils/k-means.d.ts

@@ -1,4 +1,4 @@
-export declare function kmeans(points: Float32Array[], k: number, iterations: number, device: GPUDevice): Promise<{
-    centroids: Float32Array<ArrayBufferLike>[];
-    labels: Uint32Array<ArrayBuffer>;
-}>;
+export declare function kmeans(points: Float32Array[], k: number, iterations: number, device: GPUDevice): Promise<{
+    centroids: Float32Array<ArrayBufferLike>[];
+    labels: Uint32Array<ArrayBuffer>;
+}>;