@loaders.gl/loader-utils 3.1.0-alpha.4 → 3.1.0-beta.3

package/dist/json-loader.d.ts

@@ -0,0 +1,22 @@
+import type { LoaderWithParser } from './types';
+/**
+ * A JSON Micro loader (minimal bundle size)
+ * Alternative to `@loaders.gl/json`
+ */
+export declare const JSONLoader: {
+    name: string;
+    id: string;
+    module: string;
+    version: any;
+    extensions: string[];
+    mimeTypes: string[];
+    category: string;
+    text: boolean;
+    parseTextSync: typeof parseTextSync;
+    parse: (arrayBuffer: any) => Promise<any>;
+    options: {};
+};
+declare function parseTextSync(text: any): any;
+export declare const _typecheckJSONLoader: LoaderWithParser;
+export {};
+//# sourceMappingURL=json-loader.d.ts.map

package/dist/json-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-loader.d.ts","sourceRoot":"","sources":["../src/json-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,SAAS,CAAC;AAM9C;;;GAGG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;CAYtB,CAAC;AAGF,iBAAS,aAAa,CAAC,IAAI,KAAA,OAE1B;AAED,eAAO,MAAM,oBAAoB,EAAE,gBAA6B,CAAC"}

package/dist/json-loader.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._typecheckJSONLoader = exports.JSONLoader = void 0;
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+/**
+ * A JSON Micro loader (minimal bundle size)
+ * Alternative to `@loaders.gl/json`
+ */
+exports.JSONLoader = {
+    name: 'JSON',
+    id: 'json',
+    module: 'json',
+    version: VERSION,
+    extensions: ['json', 'geojson'],
+    mimeTypes: ['application/json'],
+    category: 'json',
+    text: true,
+    parseTextSync,
+    parse: async (arrayBuffer) => parseTextSync(new TextDecoder().decode(arrayBuffer)),
+    options: {}
+};
+// TODO - deprecated
+function parseTextSync(text) {
+    return JSON.parse(text);
+}
+exports._typecheckJSONLoader = exports.JSONLoader;

package/dist/lib/binary-utils/array-buffer-utils.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Convert an object to an array buffer
+ */
+export declare function toArrayBuffer(data: any): ArrayBuffer;
+/**
+ * compare two binary arrays for equality
+ * @param {ArrayBuffer} a
+ * @param {ArrayBuffer} b
+ * @param {number} byteLength
+ */
+export declare function compareArrayBuffers(arrayBuffer1: ArrayBuffer, arrayBuffer2: ArrayBuffer, byteLength?: number): boolean;
+/**
+ * Concatenate a sequence of ArrayBuffers
+ * @return A concatenated ArrayBuffer
+ */
+export declare function concatenateArrayBuffers(...sources: (ArrayBuffer | Uint8Array)[]): ArrayBuffer;
+/**
+ * Concatenate arbitrary count of typed arrays
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays
+ * @param {...*} arrays - list of arrays. All arrays should be the same type
+ * @return A concatenated TypedArray
+ */
+export declare function concatenateTypedArrays<T>(...typedArrays: T[]): T;
+/**
+ * Copy a view of an ArrayBuffer into new ArrayBuffer with byteOffset = 0
+ * @param arrayBuffer
+ * @param byteOffset
+ * @param byteLength
+ */
+export declare function sliceArrayBuffer(arrayBuffer: ArrayBuffer, byteOffset: number, byteLength?: number): ArrayBuffer;
+//# sourceMappingURL=array-buffer-utils.d.ts.map

package/dist/lib/binary-utils/array-buffer-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-buffer-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/binary-utils/array-buffer-utils.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,GAAG,GAAG,WAAW,CA8BpD;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,WAAW,EACzB,YAAY,EAAE,WAAW,EACzB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAaT;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,OAAO,EAAE,CAAC,WAAW,GAAG,UAAU,CAAC,EAAE,GAAG,WAAW,CAqB7F;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,GAAG,WAAW,EAAE,CAAC,EAAE,GAAG,CAAC,CAoBhE;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,EAClB,UAAU,CAAC,EAAE,MAAM,GAClB,WAAW,CAOb"}

package/dist/lib/binary-utils/array-buffer-utils.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sliceArrayBuffer = exports.concatenateTypedArrays = exports.concatenateArrayBuffers = exports.compareArrayBuffers = exports.toArrayBuffer = void 0;
+const buffer_utils_1 = require("./buffer-utils");
+/**
+ * Convert an object to an array buffer
+ */
+function toArrayBuffer(data) {
+    // Note: Should be called first, Buffers can trigger other detections below
+    if ((0, buffer_utils_1.isBuffer)(data)) {
+        return (0, buffer_utils_1.bufferToArrayBuffer)(data);
+    }
+    if (data instanceof ArrayBuffer) {
+        return data;
+    }
+    // Careful - Node Buffers look like Uint8Arrays (keep after isBuffer)
+    if (ArrayBuffer.isView(data)) {
+        if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
+            return data.buffer;
+        }
+        return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+    }
+    if (typeof data === 'string') {
+        const text = data;
+        const uint8Array = new TextEncoder().encode(text);
+        return uint8Array.buffer;
+    }
+    // HACK to support Blob polyfill
+    if (data && typeof data === 'object' && data._toArrayBuffer) {
+        return data._toArrayBuffer();
+    }
+    throw new Error('toArrayBuffer');
+}
+exports.toArrayBuffer = toArrayBuffer;
+/**
+ * compare two binary arrays for equality
+ * @param {ArrayBuffer} a
+ * @param {ArrayBuffer} b
+ * @param {number} byteLength
+ */
+function compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) {
+    byteLength = byteLength || arrayBuffer1.byteLength;
+    if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) {
+        return false;
+    }
+    const array1 = new Uint8Array(arrayBuffer1);
+    const array2 = new Uint8Array(arrayBuffer2);
+    for (let i = 0; i < array1.length; ++i) {
+        if (array1[i] !== array2[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.compareArrayBuffers = compareArrayBuffers;
+/**
+ * Concatenate a sequence of ArrayBuffers
+ * @return A concatenated ArrayBuffer
+ */
+function concatenateArrayBuffers(...sources) {
+    // Make sure all inputs are wrapped in typed arrays
+    const sourceArrays = sources.map((source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2);
+    // Get length of all inputs
+    const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);
+    // Allocate array with space for all inputs
+    const result = new Uint8Array(byteLength);
+    // Copy the subarrays
+    let offset = 0;
+    for (const sourceArray of sourceArrays) {
+        result.set(sourceArray, offset);
+        offset += sourceArray.byteLength;
+    }
+    // We work with ArrayBuffers, discard the typed array wrapper
+    return result.buffer;
+}
+exports.concatenateArrayBuffers = concatenateArrayBuffers;
+/**
+ * Concatenate arbitrary count of typed arrays
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays
+ * @param {...*} arrays - list of arrays. All arrays should be the same type
+ * @return A concatenated TypedArray
+ */
+function concatenateTypedArrays(...typedArrays) {
+    // @ts-ignore
+    const arrays = typedArrays;
+    // @ts-ignore
+    const TypedArrayConstructor = (arrays && arrays.length > 1 && arrays[0].constructor) || null;
+    if (!TypedArrayConstructor) {
+        throw new Error('"concatenateTypedArrays" - incorrect quantity of arguments or arguments have incompatible data types');
+    }
+    const sumLength = arrays.reduce((acc, value) => acc + value.length, 0);
+    // @ts-ignore typescript does not like dynamic constructors
+    const result = new TypedArrayConstructor(sumLength);
+    let offset = 0;
+    for (const array of arrays) {
+        result.set(array, offset);
+        offset += array.length;
+    }
+    return result;
+}
+exports.concatenateTypedArrays = concatenateTypedArrays;
+/**
+ * Copy a view of an ArrayBuffer into new ArrayBuffer with byteOffset = 0
+ * @param arrayBuffer
+ * @param byteOffset
+ * @param byteLength
+ */
+function sliceArrayBuffer(arrayBuffer, byteOffset, byteLength) {
+    const subArray = byteLength !== undefined
+        ? new Uint8Array(arrayBuffer).subarray(byteOffset, byteOffset + byteLength)
+        : new Uint8Array(arrayBuffer).subarray(byteOffset);
+    const arrayCopy = new Uint8Array(subArray);
+    return arrayCopy.buffer;
+}
+exports.sliceArrayBuffer = sliceArrayBuffer;

package/dist/lib/binary-utils/binary-copy-utils.d.ts

@@ -0,0 +1,24 @@
+import { TypedArray } from '../../types';
+/**
+ * Copy sourceBuffer to dataView with some padding
+ *
+ * @param {DataView | null} dataView - destination data container. If null - only new offset is calculated
+ * @param {number} byteOffset - destination byte offset to copy to
+ * @param {Array | TypedArray} sourceBuffer - source data buffer
+ * @param {number} padding - pad the resulting array to multiple of "padding" bytes. Additional bytes are filled with 0x20 (ASCII space)
+ *
+ * @return new byteOffset of resulting dataView
+ */
+export declare function copyPaddedArrayBufferToDataView(dataView: DataView | null, byteOffset: number, sourceBuffer: TypedArray, padding: number): number;
+/**
+ * Copy string to dataView with some padding
+ *
+ * @param {DataView | null} dataView - destination data container. If null - only new offset is calculated
+ * @param {number} byteOffset - destination byte offset to copy to
+ * @param {string} string - source string
+ * @param {number} padding - pad the resulting array to multiple of "padding" bytes. Additional bytes are filled with 0x20 (ASCII space)
+ *
+ * @return new byteOffset of resulting dataView
+ */
+export declare function copyPaddedStringToDataView(dataView: DataView | null, byteOffset: number, string: string, padding: number): number;
+//# sourceMappingURL=binary-copy-utils.d.ts.map

package/dist/lib/binary-utils/binary-copy-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-copy-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/binary-utils/binary-copy-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,aAAa,CAAC;AAGvC;;;;;;;;;GASG;AACH,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,QAAQ,GAAG,IAAI,EACzB,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,UAAU,EACxB,OAAO,EAAE,MAAM,UAuBhB;AAED;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,QAAQ,GAAG,IAAI,EACzB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,GACd,MAAM,CASR"}

package/dist/lib/binary-utils/binary-copy-utils.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyPaddedStringToDataView = exports.copyPaddedArrayBufferToDataView = void 0;
+const memory_copy_utils_1 = require("./memory-copy-utils");
+/**
+ * Copy sourceBuffer to dataView with some padding
+ *
+ * @param {DataView | null} dataView - destination data container. If null - only new offset is calculated
+ * @param {number} byteOffset - destination byte offset to copy to
+ * @param {Array | TypedArray} sourceBuffer - source data buffer
+ * @param {number} padding - pad the resulting array to multiple of "padding" bytes. Additional bytes are filled with 0x20 (ASCII space)
+ *
+ * @return new byteOffset of resulting dataView
+ */
+function copyPaddedArrayBufferToDataView(dataView, byteOffset, sourceBuffer, padding) {
+    const paddedLength = (0, memory_copy_utils_1.padToNBytes)(sourceBuffer.byteLength, padding);
+    const padLength = paddedLength - sourceBuffer.byteLength;
+    if (dataView) {
+        // Copy array
+        const targetArray = new Uint8Array(dataView.buffer, dataView.byteOffset + byteOffset, sourceBuffer.byteLength);
+        const sourceArray = new Uint8Array(sourceBuffer);
+        targetArray.set(sourceArray);
+        // Add PADDING
+        for (let i = 0; i < padLength; ++i) {
+            // json chunk is padded with spaces (ASCII 0x20)
+            dataView.setUint8(byteOffset + sourceBuffer.byteLength + i, 0x20);
+        }
+    }
+    byteOffset += paddedLength;
+    return byteOffset;
+}
+exports.copyPaddedArrayBufferToDataView = copyPaddedArrayBufferToDataView;
+/**
+ * Copy string to dataView with some padding
+ *
+ * @param {DataView | null} dataView - destination data container. If null - only new offset is calculated
+ * @param {number} byteOffset - destination byte offset to copy to
+ * @param {string} string - source string
+ * @param {number} padding - pad the resulting array to multiple of "padding" bytes. Additional bytes are filled with 0x20 (ASCII space)
+ *
+ * @return new byteOffset of resulting dataView
+ */
+function copyPaddedStringToDataView(dataView, byteOffset, string, padding) {
+    const textEncoder = new TextEncoder();
+    // PERFORMANCE IDEA: We encode twice, once to get size and once to store
+    // PERFORMANCE IDEA: Use TextEncoder.encodeInto() to avoid temporary copy
+    const stringBuffer = textEncoder.encode(string);
+    byteOffset = copyPaddedArrayBufferToDataView(dataView, byteOffset, stringBuffer, padding);
+    return byteOffset;
+}
+exports.copyPaddedStringToDataView = copyPaddedStringToDataView;

package/dist/lib/binary-utils/buffer-utils.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+/**
+ * Check for Node.js `Buffer` (without triggering bundler to include Buffer polyfill on browser)
+ */
+export declare function isBuffer(value: any): boolean;
+/**
+ * Converts to Node.js `Buffer` (without triggering bundler to include Buffer polyfill on browser)
+ * @todo better data type
+ */
+export declare function toBuffer(data: any): Buffer;
+/**
+ * Converts Node.js `Buffer` to `ArrayBuffer` (without triggering bundler to include Buffer polyfill on browser)
+ * @todo better data type
+ */
+export declare function bufferToArrayBuffer(buffer: any): ArrayBuffer;
+//# sourceMappingURL=buffer-utils.d.ts.map

package/dist/lib/binary-utils/buffer-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/binary-utils/buffer-utils.ts"],"names":[],"mappings":";AAEA;;GAEG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CAE5C;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,GAAG,GAAG,MAAM,CAE1C;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,GAAG,GAAG,WAAW,CAM5D"}

package/dist/lib/binary-utils/buffer-utils.js

@@ -0,0 +1,50 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bufferToArrayBuffer = exports.toBuffer = exports.isBuffer = void 0;
+const node = __importStar(require("../node/buffer"));
+/**
+ * Check for Node.js `Buffer` (without triggering bundler to include Buffer polyfill on browser)
+ */
+function isBuffer(value) {
+    return value && typeof value === 'object' && value.isBuffer;
+}
+exports.isBuffer = isBuffer;
+/**
+ * Converts to Node.js `Buffer` (without triggering bundler to include Buffer polyfill on browser)
+ * @todo better data type
+ */
+function toBuffer(data) {
+    return node.toBuffer ? node.toBuffer(data) : data;
+}
+exports.toBuffer = toBuffer;
+/**
+ * Converts Node.js `Buffer` to `ArrayBuffer` (without triggering bundler to include Buffer polyfill on browser)
+ * @todo better data type
+ */
+function bufferToArrayBuffer(buffer) {
+    if (isBuffer(buffer)) {
+        const typedArray = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.length);
+        return typedArray.slice().buffer;
+    }
+    return buffer;
+}
+exports.bufferToArrayBuffer = bufferToArrayBuffer;

package/dist/lib/binary-utils/encode-utils.d.ts

@@ -0,0 +1,4 @@
+export declare function padStringToByteAlignment(string: any, byteAlignment: any): string;
+export declare function copyStringToDataView(dataView: any, byteOffset: any, string: any, byteLength: any): any;
+export declare function copyBinaryToDataView(dataView: any, byteOffset: any, binary: any, byteLength: any): any;
+//# sourceMappingURL=encode-utils.d.ts.map

package/dist/lib/binary-utils/encode-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/binary-utils/encode-utils.ts"],"names":[],"mappings":"AAIA,wBAAgB,wBAAwB,CAAC,MAAM,KAAA,EAAE,aAAa,KAAA,UAS7D;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,KAAA,EAAE,UAAU,KAAA,EAAE,MAAM,KAAA,EAAE,UAAU,KAAA,OAO5E;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,KAAA,EAAE,UAAU,KAAA,EAAE,MAAM,KAAA,EAAE,UAAU,KAAA,OAO5E"}

package/dist/lib/binary-utils/encode-utils.js

@@ -0,0 +1,35 @@
+"use strict";
+// Note: These were broken out from gltf loader...
+// eslint-disable-next-line complexity
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyBinaryToDataView = exports.copyStringToDataView = exports.padStringToByteAlignment = void 0;
+// PERFORMANCE IDEA: No need to copy string twice...
+function padStringToByteAlignment(string, byteAlignment) {
+    const length = string.length;
+    const paddedLength = Math.ceil(length / byteAlignment) * byteAlignment; // Round up to the required alignment
+    const padding = paddedLength - length;
+    let whitespace = '';
+    for (let i = 0; i < padding; ++i) {
+        whitespace += ' ';
+    }
+    return string + whitespace;
+}
+exports.padStringToByteAlignment = padStringToByteAlignment;
+function copyStringToDataView(dataView, byteOffset, string, byteLength) {
+    if (dataView) {
+        for (let i = 0; i < byteLength; i++) {
+            dataView.setUint8(byteOffset + i, string.charCodeAt(i));
+        }
+    }
+    return byteOffset + byteLength;
+}
+exports.copyStringToDataView = copyStringToDataView;
+function copyBinaryToDataView(dataView, byteOffset, binary, byteLength) {
+    if (dataView) {
+        for (let i = 0; i < byteLength; i++) {
+            dataView.setUint8(byteOffset + i, binary[i]);
+        }
+    }
+    return byteOffset + byteLength;
+}
+exports.copyBinaryToDataView = copyBinaryToDataView;

package/dist/lib/binary-utils/get-first-characters.d.ts

@@ -0,0 +1,3 @@
+export declare function getFirstCharacters(data: any, length?: number): string;
+export declare function getMagicString(arrayBuffer: ArrayBuffer, byteOffset: number, length: number): string;
+//# sourceMappingURL=get-first-characters.d.ts.map

package/dist/lib/binary-utils/get-first-characters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-first-characters.d.ts","sourceRoot":"","sources":["../../../src/lib/binary-utils/get-first-characters.ts"],"names":[],"mappings":"AAAA,wBAAgB,kBAAkB,CAAC,IAAI,KAAA,EAAE,MAAM,SAAI,GAAG,MAAM,CAW3D;AAED,wBAAgB,cAAc,CAC5B,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,GACb,MAAM,CAUR"}

package/dist/lib/binary-utils/get-first-characters.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMagicString = exports.getFirstCharacters = void 0;
+function getFirstCharacters(data, length = 5) {
+    if (typeof data === 'string') {
+        return data.slice(0, length);
+    }
+    else if (ArrayBuffer.isView(data)) {
+        // Typed Arrays can have offsets into underlying buffer
+        return getMagicString(data.buffer, data.byteOffset, length);
+    }
+    else if (data instanceof ArrayBuffer) {
+        const byteOffset = 0;
+        return getMagicString(data, byteOffset, length);
+    }
+    return '';
+}
+exports.getFirstCharacters = getFirstCharacters;
+function getMagicString(arrayBuffer, byteOffset, length) {
+    if (arrayBuffer.byteLength <= byteOffset + length) {
+        return '';
+    }
+    const dataView = new DataView(arrayBuffer);
+    let magic = '';
+    for (let i = 0; i < length; i++) {
+        magic += String.fromCharCode(dataView.getUint8(byteOffset + i));
+    }
+    return magic;
+}
+exports.getMagicString = getMagicString;

package/dist/lib/binary-utils/memory-copy-utils.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Calculate new size of an arrayBuffer to be aligned to an n-byte boundary
+ * This function increases `byteLength` by the minimum delta,
+ * allowing the total length to be divided by `padding`
+ * @param byteLength
+ * @param padding
+ */
+export declare function padToNBytes(byteLength: number, padding: number): number;
+/**
+ * Creates a new Uint8Array based on two different ArrayBuffers
+ * @param targetBuffer The first buffer.
+ * @param sourceBuffer The second buffer.
+ * @return The new ArrayBuffer created out of the two.
+ */
+export declare function copyArrayBuffer(targetBuffer: ArrayBuffer, sourceBuffer: ArrayBuffer, byteOffset: number, byteLength?: number): ArrayBuffer;
+/**
+ * Copy from source to target at the targetOffset
+ *
+ * @param source - The data to copy
+ * @param target - The destination to copy data into
+ * @param targetOffset - The start offset into target to place the copied data
+ * @returns the new offset taking into account proper padding
+ */
+export declare function copyToArray(source: ArrayBuffer | any, target: any, targetOffset: number): number;
+//# sourceMappingURL=memory-copy-utils.d.ts.map

package/dist/lib/binary-utils/memory-copy-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-copy-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/binary-utils/memory-copy-utils.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAIvE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,YAAY,EAAE,WAAW,EACzB,YAAY,EAAE,WAAW,EACzB,UAAU,EAAE,MAAM,EAClB,UAAU,GAAE,MAAgC,GAC3C,WAAW,CAKb;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAuBhG"}

package/dist/lib/binary-utils/memory-copy-utils.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyToArray = exports.copyArrayBuffer = exports.padToNBytes = void 0;
+const assert_1 = require("../env-utils/assert");
+/**
+ * Calculate new size of an arrayBuffer to be aligned to an n-byte boundary
+ * This function increases `byteLength` by the minimum delta,
+ * allowing the total length to be divided by `padding`
+ * @param byteLength
+ * @param padding
+ */
+function padToNBytes(byteLength, padding) {
+    (0, assert_1.assert)(byteLength >= 0); // `Incorrect 'byteLength' value: ${byteLength}`
+    (0, assert_1.assert)(padding > 0); // `Incorrect 'padding' value: ${padding}`
+    return (byteLength + (padding - 1)) & ~(padding - 1);
+}
+exports.padToNBytes = padToNBytes;
+/**
+ * Creates a new Uint8Array based on two different ArrayBuffers
+ * @param targetBuffer The first buffer.
+ * @param sourceBuffer The second buffer.
+ * @return The new ArrayBuffer created out of the two.
+ */
+function copyArrayBuffer(targetBuffer, sourceBuffer, byteOffset, byteLength = sourceBuffer.byteLength) {
+    const targetArray = new Uint8Array(targetBuffer, byteOffset, byteLength);
+    const sourceArray = new Uint8Array(sourceBuffer);
+    targetArray.set(sourceArray);
+    return targetBuffer;
+}
+exports.copyArrayBuffer = copyArrayBuffer;
+/**
+ * Copy from source to target at the targetOffset
+ *
+ * @param source - The data to copy
+ * @param target - The destination to copy data into
+ * @param targetOffset - The start offset into target to place the copied data
+ * @returns the new offset taking into account proper padding
+ */
+function copyToArray(source, target, targetOffset) {
+    let sourceArray;
+    if (source instanceof ArrayBuffer) {
+        sourceArray = new Uint8Array(source);
+    }
+    else {
+        // Pack buffer onto the big target array
+        //
+        // 'source.data.buffer' could be a view onto a larger buffer.
+        // We MUST use this constructor to ensure the byteOffset and byteLength is
+        // set to correct values from 'source.data' and not the underlying
+        // buffer for target.set() to work properly.
+        const srcByteOffset = source.byteOffset;
+        const srcByteLength = source.byteLength;
+        // In gltf parser it is set as "arrayBuffer" instead of "buffer"
+        // https://github.com/visgl/loaders.gl/blob/1e3a82a0a65d7b6a67b1e60633453e5edda2960a/modules/gltf/src/lib/parse-gltf.js#L85
+        sourceArray = new Uint8Array(source.buffer || source.arrayBuffer, srcByteOffset, srcByteLength);
+    }
+    // Pack buffer onto the big target array
+    target.set(sourceArray, targetOffset);
+    return targetOffset + padToNBytes(sourceArray.byteLength, 4);
+}
+exports.copyToArray = copyToArray;

package/dist/lib/env-utils/assert.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Throws an `Error` with the optional `message` if `condition` is falsy
+ * @note Replacement for the external assert method to reduce bundle size
+ */
+export declare function assert(condition: any, message?: string): void;
+//# sourceMappingURL=assert.d.ts.map

package/dist/lib/env-utils/assert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../src/lib/env-utils/assert.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,MAAM,CAAC,SAAS,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAI7D"}

package/dist/lib/env-utils/assert.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = void 0;
+/**
+ * Throws an `Error` with the optional `message` if `condition` is falsy
+ * @note Replacement for the external assert method to reduce bundle size
+ */
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message || 'loader assertion failed.');
+    }
+}
+exports.assert = assert;

package/dist/lib/env-utils/globals.d.ts

@@ -0,0 +1,15 @@
+declare type obj = {
+    [key: string]: any;
+};
+declare const self_: obj;
+declare const window_: obj;
+declare const global_: obj;
+declare const document_: obj;
+export { self_ as self, window_ as window, global_ as global, document_ as document };
+/** true if running in a browser */
+export declare const isBrowser: boolean;
+/** true if running in a worker thread */
+export declare const isWorker: boolean;
+/** Major Node version (as a number) */
+export declare const nodeVersion: number;
+//# sourceMappingURL=globals.d.ts.map

package/dist/lib/env-utils/globals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"globals.d.ts","sourceRoot":"","sources":["../../../src/lib/env-utils/globals.ts"],"names":[],"mappings":"AAWA,aAAK,GAAG,GAAG;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAC,CAAC;AAChC,QAAA,MAAM,KAAK,EAAE,GAA4D,CAAC;AAC1E,QAAA,MAAM,OAAO,EAAE,GAA4D,CAAC;AAC5E,QAAA,MAAM,OAAO,EAAE,GAA4D,CAAC;AAC5E,QAAA,MAAM,SAAS,EAAE,GAA4B,CAAC;AAE9C,OAAO,EAAC,KAAK,IAAI,IAAI,EAAE,OAAO,IAAI,MAAM,EAAE,OAAO,IAAI,MAAM,EAAE,SAAS,IAAI,QAAQ,EAAC,CAAC;AAEpF,mCAAmC;AACnC,eAAO,MAAM,SAAS,EAAE,OAE2E,CAAC;AAEpG,yCAAyC;AACzC,eAAO,MAAM,QAAQ,EAAE,OAA6C,CAAC;AAKrE,uCAAuC;AACvC,eAAO,MAAM,WAAW,EAAE,MAAiD,CAAC"}

package/dist/lib/env-utils/globals.js

@@ -0,0 +1,30 @@
+"use strict";
+// Purpose: include this in your module to avoid
+// dependencies on micro modules like 'global' and 'is-browser';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeVersion = exports.isWorker = exports.isBrowser = exports.document = exports.global = exports.window = exports.self = void 0;
+/* eslint-disable no-restricted-globals */
+const globals = {
+    self: typeof self !== 'undefined' && self,
+    window: typeof window !== 'undefined' && window,
+    global: typeof global !== 'undefined' && global,
+    document: typeof document !== 'undefined' && document
+};
+const self_ = globals.self || globals.window || globals.global || {};
+exports.self = self_;
+const window_ = globals.window || globals.self || globals.global || {};
+exports.window = window_;
+const global_ = globals.global || globals.self || globals.window || {};
+exports.global = global_;
+const document_ = globals.document || {};
+exports.document = document_;
+/** true if running in a browser */
+exports.isBrowser = 
+// @ts-ignore process does not exist on browser
+Boolean(typeof process !== 'object' || String(process) !== '[object process]' || process.browser);
+/** true if running in a worker thread */
+exports.isWorker = typeof importScripts === 'function';
+// Extract node major version
+const matches = typeof process !== 'undefined' && process.version && /v([0-9]*)/.exec(process.version);
+/** Major Node version (as a number) */
+exports.nodeVersion = (matches && parseFloat(matches[1])) || 0;

package/dist/lib/filesystems/node-filesystem.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="node" />
+import * as fs from '../node/fs';
+import { IFileSystem, IRandomAccessReadFileSystem } from '../../types';
+declare type Stat = {
+    size: number;
+    isDirectory: () => boolean;
+    info?: fs.Stats;
+};
+declare type ReadOptions = {
+    buffer?: Buffer;
+    offset?: number;
+    length?: number;
+    position?: number;
+};
+/**
+ * FileSystem pass-through for Node.js
+ * Compatible with BrowserFileSystem.
+ * @param options
+ */
+export default class NodeFileSystem implements IFileSystem, IRandomAccessReadFileSystem {
+    constructor(options: {
+        [key: string]: any;
+    });
+    readdir(dirname?: string, options?: {}): Promise<any[]>;
+    stat(path: string, options?: {}): Promise<Stat>;
+    fetch(path: string, options: {
+        [key: string]: any;
+    }): Promise<any>;
+    open(path: string, flags: string | number, mode?: any): Promise<number>;
+    close(fd: number): Promise<void>;
+    fstat(fd: number): Promise<Stat>;
+    read(fd: number, { buffer, offset, length, position }: ReadOptions): Promise<{
+        bytesRead: number;
+        buffer: Buffer;
+    }>;
+}
+export {};
+//# sourceMappingURL=node-filesystem.d.ts.map