@loaders.gl/loader-utils 3.1.0-alpha.2 → 3.1.0-beta.1

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

@@ -1,86 +1,115 @@
-import { isBuffer, bufferToArrayBuffer } from './buffer-utils';
-export function toArrayBuffer(data) {
-  if (isBuffer(data)) {
-    return bufferToArrayBuffer(data);
-  }
-
-  if (data instanceof ArrayBuffer) {
-    return data;
-  }
-
-  if (ArrayBuffer.isView(data)) {
-    if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
-      return data.buffer;
+"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);
     }
-
-    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;
-  }
-
-  if (data && typeof data === 'object' && data._toArrayBuffer) {
-    return data._toArrayBuffer();
-  }
-
-  throw new Error('toArrayBuffer');
+    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');
 }
-export 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;
+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;
     }
-  }
-
-  return true;
+    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;
 }
-export function concatenateArrayBuffers(...sources) {
-  const sourceArrays = sources.map(source2 => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2);
-  const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);
-  const result = new Uint8Array(byteLength);
-  let offset = 0;
-
-  for (const sourceArray of sourceArrays) {
-    result.set(sourceArray, offset);
-    offset += sourceArray.byteLength;
-  }
-
-  return result.buffer;
+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;
 }
-export function concatenateTypedArrays(...typedArrays) {
-  const arrays = typedArrays;
-  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);
-  const result = new TypedArrayConstructor(sumLength);
-  let offset = 0;
-
-  for (const array of arrays) {
-    result.set(array, offset);
-    offset += array.length;
-  }
-
-  return result;
+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;
 }
-export 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.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;
 }
-//# sourceMappingURL=array-buffer-utils.js.map
+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

@@ -1,25 +1,51 @@
-import { padToNBytes } from './memory-copy-utils';
-export function copyPaddedArrayBufferToDataView(dataView, byteOffset, sourceBuffer, padding) {
-  const paddedLength = padToNBytes(sourceBuffer.byteLength, padding);
-  const padLength = paddedLength - sourceBuffer.byteLength;
-
-  if (dataView) {
-    const targetArray = new Uint8Array(dataView.buffer, dataView.byteOffset + byteOffset, sourceBuffer.byteLength);
-    const sourceArray = new Uint8Array(sourceBuffer);
-    targetArray.set(sourceArray);
-
-    for (let i = 0; i < padLength; ++i) {
-      dataView.setUint8(byteOffset + sourceBuffer.byteLength + i, 0x20);
+"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;
+    byteOffset += paddedLength;
+    return byteOffset;
 }
-export function copyPaddedStringToDataView(dataView, byteOffset, string, padding) {
-  const textEncoder = new TextEncoder();
-  const stringBuffer = textEncoder.encode(string);
-  byteOffset = copyPaddedArrayBufferToDataView(dataView, byteOffset, stringBuffer, padding);
-  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;
 }
-//# sourceMappingURL=binary-copy-utils.js.map
+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

@@ -1,16 +1,50 @@
-import * as node from '../node/buffer-utils.node';
-export function isBuffer(value) {
-  return value && typeof value === 'object' && value.isBuffer;
+"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;
 }
-export function toBuffer(data) {
-  return node.toBuffer ? node.toBuffer(data) : data;
+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;
 }
-export function bufferToArrayBuffer(buffer) {
-  if (isBuffer(buffer)) {
-    const typedArray = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.length);
-    return typedArray.slice().buffer;
-  }
-
-  return buffer;
+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;
 }
-//# sourceMappingURL=buffer-utils.js.map
+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

@@ -1,31 +1,35 @@
-export function padStringToByteAlignment(string, byteAlignment) {
-  const length = string.length;
-  const paddedLength = Math.ceil(length / byteAlignment) * byteAlignment;
-  const padding = paddedLength - length;
-  let whitespace = '';
-
-  for (let i = 0; i < padding; ++i) {
-    whitespace += ' ';
-  }
-
-  return string + whitespace;
+"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;
 }
-export function copyStringToDataView(dataView, byteOffset, string, byteLength) {
-  if (dataView) {
-    for (let i = 0; i < byteLength; i++) {
-      dataView.setUint8(byteOffset + i, string.charCodeAt(i));
+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;
+    return byteOffset + byteLength;
 }
-export function copyBinaryToDataView(dataView, byteOffset, binary, byteLength) {
-  if (dataView) {
-    for (let i = 0; i < byteLength; i++) {
-      dataView.setUint8(byteOffset + i, binary[i]);
+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;
+    return byteOffset + byteLength;
 }
-//# sourceMappingURL=encode-utils.js.map
+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

@@ -1,27 +1,30 @@
-export function getFirstCharacters(data, length = 5) {
-  if (typeof data === 'string') {
-    return data.slice(0, length);
-  } else if (ArrayBuffer.isView(data)) {
-    return getMagicString(data.buffer, data.byteOffset, length);
-  } else if (data instanceof ArrayBuffer) {
-    const byteOffset = 0;
-    return getMagicString(data, byteOffset, length);
-  }
-
-  return '';
-}
-export function getMagicString(arrayBuffer, byteOffset, length) {
-  if (arrayBuffer.byteLength <= byteOffset + length) {
+"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 '';
-  }
-
-  const dataView = new DataView(arrayBuffer);
-  let magic = '';
-
-  for (let i = 0; i < length; i++) {
-    magic += String.fromCharCode(dataView.getUint8(byteOffset + i));
-  }
-
-  return magic;
 }
-//# sourceMappingURL=get-first-characters.js.map
+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"}