@loaders.gl/loader-utils 3.1.3 → 4.0.0-alpha.5

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

@@ -1,35 +1,31 @@
-"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 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;
 }
-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));
-        }
+export 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;
 }
-exports.copyStringToDataView = copyStringToDataView;
-function copyBinaryToDataView(dataView, byteOffset, binary, byteLength) {
-    if (dataView) {
-        for (let i = 0; i < byteLength; i++) {
-            dataView.setUint8(byteOffset + i, binary[i]);
-        }
+export 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;
 }
-exports.copyBinaryToDataView = copyBinaryToDataView;
+//# sourceMappingURL=encode-utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/binary-utils/encode-utils.ts"],"names":["padStringToByteAlignment","string","byteAlignment","length","paddedLength","Math","ceil","padding","whitespace","i","copyStringToDataView","dataView","byteOffset","byteLength","setUint8","charCodeAt","copyBinaryToDataView","binary"],"mappings":"AAIA,OAAO,SAASA,wBAAT,CAAkCC,MAAlC,EAA0CC,aAA1C,EAAyD;AAC9D,QAAMC,MAAM,GAAGF,MAAM,CAACE,MAAtB;AACA,QAAMC,YAAY,GAAGC,IAAI,CAACC,IAAL,CAAUH,MAAM,GAAGD,aAAnB,IAAoCA,aAAzD;AACA,QAAMK,OAAO,GAAGH,YAAY,GAAGD,MAA/B;AACA,MAAIK,UAAU,GAAG,EAAjB;;AACA,OAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGF,OAApB,EAA6B,EAAEE,CAA/B,EAAkC;AAChCD,IAAAA,UAAU,IAAI,GAAd;AACD;;AACD,SAAOP,MAAM,GAAGO,UAAhB;AACD;AAED,OAAO,SAASE,oBAAT,CAA8BC,QAA9B,EAAwCC,UAAxC,EAAoDX,MAApD,EAA4DY,UAA5D,EAAwE;AAC7E,MAAIF,QAAJ,EAAc;AACZ,SAAK,IAAIF,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGI,UAApB,EAAgCJ,CAAC,EAAjC,EAAqC;AACnCE,MAAAA,QAAQ,CAACG,QAAT,CAAkBF,UAAU,GAAGH,CAA/B,EAAkCR,MAAM,CAACc,UAAP,CAAkBN,CAAlB,CAAlC;AACD;AACF;;AACD,SAAOG,UAAU,GAAGC,UAApB;AACD;AAED,OAAO,SAASG,oBAAT,CAA8BL,QAA9B,EAAwCC,UAAxC,EAAoDK,MAApD,EAA4DJ,UAA5D,EAAwE;AAC7E,MAAIF,QAAJ,EAAc;AACZ,SAAK,IAAIF,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGI,UAApB,EAAgCJ,CAAC,EAAjC,EAAqC;AACnCE,MAAAA,QAAQ,CAACG,QAAT,CAAkBF,UAAU,GAAGH,CAA/B,EAAkCQ,MAAM,CAACR,CAAD,CAAxC;AACD;AACF;;AACD,SAAOG,UAAU,GAAGC,UAApB;AACD","sourcesContent":["// Note: These were broken out from gltf loader...\n// eslint-disable-next-line complexity\n\n// PERFORMANCE IDEA: No need to copy string twice...\nexport function padStringToByteAlignment(string, byteAlignment) {\n  const length = string.length;\n  const paddedLength = Math.ceil(length / byteAlignment) * byteAlignment; // Round up to the required alignment\n  const padding = paddedLength - length;\n  let whitespace = '';\n  for (let i = 0; i < padding; ++i) {\n    whitespace += ' ';\n  }\n  return string + whitespace;\n}\n\nexport function copyStringToDataView(dataView, byteOffset, string, byteLength) {\n  if (dataView) {\n    for (let i = 0; i < byteLength; i++) {\n      dataView.setUint8(byteOffset + i, string.charCodeAt(i));\n    }\n  }\n  return byteOffset + byteLength;\n}\n\nexport function copyBinaryToDataView(dataView, byteOffset, binary, byteLength) {\n  if (dataView) {\n    for (let i = 0; i < byteLength; i++) {\n      dataView.setUint8(byteOffset + i, binary[i]);\n    }\n  }\n  return byteOffset + byteLength;\n}\n"],"file":"encode-utils.js"}

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

@@ -1,30 +1,27 @@
-"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 '';
+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 '';
 }
-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;
+export 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;
+//# sourceMappingURL=get-first-characters.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/binary-utils/get-first-characters.ts"],"names":["getFirstCharacters","data","length","slice","ArrayBuffer","isView","getMagicString","buffer","byteOffset","arrayBuffer","byteLength","dataView","DataView","magic","i","String","fromCharCode","getUint8"],"mappings":"AAAA,OAAO,SAASA,kBAAT,CAA4BC,IAA5B,EAAkCC,MAAM,GAAG,CAA3C,EAAsD;AAC3D,MAAI,OAAOD,IAAP,KAAgB,QAApB,EAA8B;AAC5B,WAAOA,IAAI,CAACE,KAAL,CAAW,CAAX,EAAcD,MAAd,CAAP;AACD,GAFD,MAEO,IAAIE,WAAW,CAACC,MAAZ,CAAmBJ,IAAnB,CAAJ,EAA8B;AAEnC,WAAOK,cAAc,CAACL,IAAI,CAACM,MAAN,EAAcN,IAAI,CAACO,UAAnB,EAA+BN,MAA/B,CAArB;AACD,GAHM,MAGA,IAAID,IAAI,YAAYG,WAApB,EAAiC;AACtC,UAAMI,UAAU,GAAG,CAAnB;AACA,WAAOF,cAAc,CAACL,IAAD,EAAOO,UAAP,EAAmBN,MAAnB,CAArB;AACD;;AACD,SAAO,EAAP;AACD;AAED,OAAO,SAASI,cAAT,CACLG,WADK,EAELD,UAFK,EAGLN,MAHK,EAIG;AACR,MAAIO,WAAW,CAACC,UAAZ,IAA0BF,UAAU,GAAGN,MAA3C,EAAmD;AACjD,WAAO,EAAP;AACD;;AACD,QAAMS,QAAQ,GAAG,IAAIC,QAAJ,CAAaH,WAAb,CAAjB;AACA,MAAII,KAAK,GAAG,EAAZ;;AACA,OAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGZ,MAApB,EAA4BY,CAAC,EAA7B,EAAiC;AAC/BD,IAAAA,KAAK,IAAIE,MAAM,CAACC,YAAP,CAAoBL,QAAQ,CAACM,QAAT,CAAkBT,UAAU,GAAGM,CAA/B,CAApB,CAAT;AACD;;AACD,SAAOD,KAAP;AACD","sourcesContent":["export function getFirstCharacters(data, length = 5): string {\n  if (typeof data === 'string') {\n    return data.slice(0, length);\n  } else if (ArrayBuffer.isView(data)) {\n    // Typed Arrays can have offsets into underlying buffer\n    return getMagicString(data.buffer, data.byteOffset, length);\n  } else if (data instanceof ArrayBuffer) {\n    const byteOffset = 0;\n    return getMagicString(data, byteOffset, length);\n  }\n  return '';\n}\n\nexport function getMagicString(\n  arrayBuffer: ArrayBuffer,\n  byteOffset: number,\n  length: number\n): string {\n  if (arrayBuffer.byteLength <= byteOffset + length) {\n    return '';\n  }\n  const dataView = new DataView(arrayBuffer);\n  let magic = '';\n  for (let i = 0; i < length; i++) {\n    magic += String.fromCharCode(dataView.getUint8(byteOffset + i));\n  }\n  return magic;\n}\n"],"file":"get-first-characters.js"}

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

@@ -1,61 +1,27 @@
-"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);
+import { assert } from '../env-utils/assert';
+export function padToNBytes(byteLength, padding) {
+  assert(byteLength >= 0);
+  assert(padding > 0);
+  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;
+export 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);
+export function copyToArray(source, target, targetOffset) {
+  let sourceArray;
+
+  if (source instanceof ArrayBuffer) {
+    sourceArray = new Uint8Array(source);
+  } else {
+    const srcByteOffset = source.byteOffset;
+    const srcByteLength = source.byteLength;
+    sourceArray = new Uint8Array(source.buffer || source.arrayBuffer, srcByteOffset, srcByteLength);
+  }
+
+  target.set(sourceArray, targetOffset);
+  return targetOffset + padToNBytes(sourceArray.byteLength, 4);
 }
-exports.copyToArray = copyToArray;
+//# sourceMappingURL=memory-copy-utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/binary-utils/memory-copy-utils.ts"],"names":["assert","padToNBytes","byteLength","padding","copyArrayBuffer","targetBuffer","sourceBuffer","byteOffset","targetArray","Uint8Array","sourceArray","set","copyToArray","source","target","targetOffset","ArrayBuffer","srcByteOffset","srcByteLength","buffer","arrayBuffer"],"mappings":"AAAA,SAAQA,MAAR,QAAqB,qBAArB;AASA,OAAO,SAASC,WAAT,CAAqBC,UAArB,EAAyCC,OAAzC,EAAkE;AACvEH,EAAAA,MAAM,CAACE,UAAU,IAAI,CAAf,CAAN;AACAF,EAAAA,MAAM,CAACG,OAAO,GAAG,CAAX,CAAN;AACA,SAAQD,UAAU,IAAIC,OAAO,GAAG,CAAd,CAAX,GAA+B,EAAEA,OAAO,GAAG,CAAZ,CAAtC;AACD;AAQD,OAAO,SAASC,eAAT,CACLC,YADK,EAELC,YAFK,EAGLC,UAHK,EAILL,UAAkB,GAAGI,YAAY,CAACJ,UAJ7B,EAKQ;AACb,QAAMM,WAAW,GAAG,IAAIC,UAAJ,CAAeJ,YAAf,EAA6BE,UAA7B,EAAyCL,UAAzC,CAApB;AACA,QAAMQ,WAAW,GAAG,IAAID,UAAJ,CAAeH,YAAf,CAApB;AACAE,EAAAA,WAAW,CAACG,GAAZ,CAAgBD,WAAhB;AACA,SAAOL,YAAP;AACD;AAUD,OAAO,SAASO,WAAT,CAAqBC,MAArB,EAAgDC,MAAhD,EAA6DC,YAA7D,EAA2F;AAChG,MAAIL,WAAJ;;AAEA,MAAIG,MAAM,YAAYG,WAAtB,EAAmC;AACjCN,IAAAA,WAAW,GAAG,IAAID,UAAJ,CAAeI,MAAf,CAAd;AACD,GAFD,MAEO;AAOL,UAAMI,aAAa,GAAGJ,MAAM,CAACN,UAA7B;AACA,UAAMW,aAAa,GAAGL,MAAM,CAACX,UAA7B;AAGAQ,IAAAA,WAAW,GAAG,IAAID,UAAJ,CAAeI,MAAM,CAACM,MAAP,IAAiBN,MAAM,CAACO,WAAvC,EAAoDH,aAApD,EAAmEC,aAAnE,CAAd;AACD;;AAGDJ,EAAAA,MAAM,CAACH,GAAP,CAAWD,WAAX,EAAwBK,YAAxB;AAEA,SAAOA,YAAY,GAAGd,WAAW,CAACS,WAAW,CAACR,UAAb,EAAyB,CAAzB,CAAjC;AACD","sourcesContent":["import {assert} from '../env-utils/assert';\n\n/**\n * Calculate new size of an arrayBuffer to be aligned to an n-byte boundary\n * This function increases `byteLength` by the minimum delta,\n * allowing the total length to be divided by `padding`\n * @param byteLength\n * @param padding\n */\nexport function padToNBytes(byteLength: number, padding: number): number {\n  assert(byteLength >= 0); // `Incorrect 'byteLength' value: ${byteLength}`\n  assert(padding > 0); // `Incorrect 'padding' value: ${padding}`\n  return (byteLength + (padding - 1)) & ~(padding - 1);\n}\n\n/**\n * Creates a new Uint8Array based on two different ArrayBuffers\n * @param targetBuffer The first buffer.\n * @param sourceBuffer The second buffer.\n * @return The new ArrayBuffer created out of the two.\n */\nexport function copyArrayBuffer(\n  targetBuffer: ArrayBuffer,\n  sourceBuffer: ArrayBuffer,\n  byteOffset: number,\n  byteLength: number = sourceBuffer.byteLength\n): ArrayBuffer {\n  const targetArray = new Uint8Array(targetBuffer, byteOffset, byteLength);\n  const sourceArray = new Uint8Array(sourceBuffer);\n  targetArray.set(sourceArray);\n  return targetBuffer;\n}\n\n/**\n * Copy from source to target at the targetOffset\n *\n * @param source - The data to copy\n * @param target - The destination to copy data into\n * @param targetOffset - The start offset into target to place the copied data\n * @returns the new offset taking into account proper padding\n */\nexport function copyToArray(source: ArrayBuffer | any, target: any, targetOffset: number): number {\n  let sourceArray;\n\n  if (source instanceof ArrayBuffer) {\n    sourceArray = new Uint8Array(source);\n  } else {\n    // Pack buffer onto the big target array\n    //\n    // 'source.data.buffer' could be a view onto a larger buffer.\n    // We MUST use this constructor to ensure the byteOffset and byteLength is\n    // set to correct values from 'source.data' and not the underlying\n    // buffer for target.set() to work properly.\n    const srcByteOffset = source.byteOffset;\n    const srcByteLength = source.byteLength;\n    // In gltf parser it is set as \"arrayBuffer\" instead of \"buffer\"\n    // https://github.com/visgl/loaders.gl/blob/1e3a82a0a65d7b6a67b1e60633453e5edda2960a/modules/gltf/src/lib/parse-gltf.js#L85\n    sourceArray = new Uint8Array(source.buffer || source.arrayBuffer, srcByteOffset, srcByteLength);\n  }\n\n  // Pack buffer onto the big target array\n  target.set(sourceArray, targetOffset);\n\n  return targetOffset + padToNBytes(sourceArray.byteLength, 4);\n}\n"],"file":"memory-copy-utils.js"}

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

@@ -1,13 +1,6 @@
-"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.');
-    }
+export function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message || 'loader assertion failed.');
+  }
 }
-exports.assert = assert;
+//# sourceMappingURL=assert.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/env-utils/assert.ts"],"names":["assert","condition","message","Error"],"mappings":"AAIA,OAAO,SAASA,MAAT,CAAgBC,SAAhB,EAAgCC,OAAhC,EAAwD;AAC7D,MAAI,CAACD,SAAL,EAAgB;AACd,UAAM,IAAIE,KAAJ,CAAUD,OAAO,IAAI,0BAArB,CAAN;AACD;AACF","sourcesContent":["/**\n * Throws an `Error` with the optional `message` if `condition` is falsy\n * @note Replacement for the external assert method to reduce bundle size\n */\nexport function assert(condition: any, message?: string): void {\n  if (!condition) {\n    throw new Error(message || 'loader assertion failed.');\n  }\n}\n"],"file":"assert.js"}

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

@@ -1,30 +1,16 @@
-"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
+  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
+export { self_ as self, window_ as window, global_ as global, document_ as document };
+export const isBrowser = Boolean(typeof process !== 'object' || String(process) !== '[object process]' || process.browser);
+export const isWorker = typeof importScripts === 'function';
 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;
+export const nodeVersion = matches && parseFloat(matches[1]) || 0;
+//# sourceMappingURL=globals.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/env-utils/globals.ts"],"names":["globals","self","window","global","document","self_","window_","global_","document_","isBrowser","Boolean","process","String","browser","isWorker","importScripts","matches","version","exec","nodeVersion","parseFloat"],"mappings":"AAIA,MAAMA,OAAO,GAAG;AACdC,EAAAA,IAAI,EAAE,OAAOA,IAAP,KAAgB,WAAhB,IAA+BA,IADvB;AAEdC,EAAAA,MAAM,EAAE,OAAOA,MAAP,KAAkB,WAAlB,IAAiCA,MAF3B;AAGdC,EAAAA,MAAM,EAAE,OAAOA,MAAP,KAAkB,WAAlB,IAAiCA,MAH3B;AAIdC,EAAAA,QAAQ,EAAE,OAAOA,QAAP,KAAoB,WAApB,IAAmCA;AAJ/B,CAAhB;AAQA,MAAMC,KAAU,GAAGL,OAAO,CAACC,IAAR,IAAgBD,OAAO,CAACE,MAAxB,IAAkCF,OAAO,CAACG,MAA1C,IAAoD,EAAvE;AACA,MAAMG,OAAY,GAAGN,OAAO,CAACE,MAAR,IAAkBF,OAAO,CAACC,IAA1B,IAAkCD,OAAO,CAACG,MAA1C,IAAoD,EAAzE;AACA,MAAMI,OAAY,GAAGP,OAAO,CAACG,MAAR,IAAkBH,OAAO,CAACC,IAA1B,IAAkCD,OAAO,CAACE,MAA1C,IAAoD,EAAzE;AACA,MAAMM,SAAc,GAAGR,OAAO,CAACI,QAAR,IAAoB,EAA3C;AAEA,SAAQC,KAAK,IAAIJ,IAAjB,EAAuBK,OAAO,IAAIJ,MAAlC,EAA0CK,OAAO,IAAIJ,MAArD,EAA6DK,SAAS,IAAIJ,QAA1E;AAGA,OAAO,MAAMK,SAAkB,GAE7BC,OAAO,CAAC,OAAOC,OAAP,KAAmB,QAAnB,IAA+BC,MAAM,CAACD,OAAD,CAAN,KAAoB,kBAAnD,IAAyEA,OAAO,CAACE,OAAlF,CAFF;AAKP,OAAO,MAAMC,QAAiB,GAAG,OAAOC,aAAP,KAAyB,UAAnD;AAGP,MAAMC,OAAO,GACX,OAAOL,OAAP,KAAmB,WAAnB,IAAkCA,OAAO,CAACM,OAA1C,IAAqD,YAAYC,IAAZ,CAAiBP,OAAO,CAACM,OAAzB,CADvD;AAGA,OAAO,MAAME,WAAmB,GAAIH,OAAO,IAAII,UAAU,CAACJ,OAAO,CAAC,CAAD,CAAR,CAAtB,IAAuC,CAAnE","sourcesContent":["// Purpose: include this in your module to avoid\n// dependencies on micro modules like 'global' and 'is-browser';\n\n/* eslint-disable no-restricted-globals */\nconst globals = {\n  self: typeof self !== 'undefined' && self,\n  window: typeof window !== 'undefined' && window,\n  global: typeof global !== 'undefined' && global,\n  document: typeof document !== 'undefined' && document\n};\n\ntype obj = {[key: string]: any};\nconst self_: obj = globals.self || globals.window || globals.global || {};\nconst window_: obj = globals.window || globals.self || globals.global || {};\nconst global_: obj = globals.global || globals.self || globals.window || {};\nconst document_: obj = globals.document || {};\n\nexport {self_ as self, window_ as window, global_ as global, document_ as document};\n\n/** true if running in a browser */\nexport const isBrowser: boolean =\n  // @ts-ignore process does not exist on browser\n  Boolean(typeof process !== 'object' || String(process) !== '[object process]' || process.browser);\n\n/** true if running in a worker thread */\nexport const isWorker: boolean = typeof importScripts === 'function';\n\n// Extract node major version\nconst matches =\n  typeof process !== 'undefined' && process.version && /v([0-9]*)/.exec(process.version);\n/** Major Node version (as a number) */\nexport const nodeVersion: number = (matches && parseFloat(matches[1])) || 0;\n"],"file":"globals.js"}

package/dist/lib/filesystems/node-filesystem.js

@@ -1,69 +1,60 @@
-"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 });
-const fs = __importStar(require("../node/fs"));
-/**
- * FileSystem pass-through for Node.js
- * Compatible with BrowserFileSystem.
- * @param options
- */
-class NodeFileSystem {
-    // implements IFileSystem
-    constructor(options) {
-        this.fetch = options._fetch;
-    }
-    async readdir(dirname = '.', options) {
-        return await fs.readdir(dirname, options);
-    }
-    async stat(path, options) {
-        const info = await fs.stat(path, options);
-        return { size: Number(info.size), isDirectory: () => false, info };
-    }
-    async fetch(path, options) {
-        // Falls back to handle https:/http:/data: etc fetches
-        // eslint-disable-next-line
-        const fallbackFetch = options.fetch || this.fetch;
-        return fallbackFetch(path, options);
-    }
-    // implements IRandomAccessFileSystem
-    async open(path, flags, mode) {
-        return await fs.open(path, flags);
-    }
-    async close(fd) {
-        return await fs.close(fd);
-    }
-    async fstat(fd) {
-        const info = await fs.fstat(fd);
-        return info;
-    }
-    async read(fd, 
-    // @ts-ignore Possibly null
-    { buffer = null, offset = 0, length = buffer.byteLength, position = null }) {
-        let totalBytesRead = 0;
-        // Read in loop until we get required number of bytes
-        while (totalBytesRead < length) {
-            const { bytesRead } = await fs.read(fd, buffer, offset + totalBytesRead, length - totalBytesRead, position + totalBytesRead);
-            totalBytesRead += bytesRead;
-        }
-        return { bytesRead: totalBytesRead, buffer };
-    }
+import * as fs from '../node/fs';
+export default class NodeFileSystem {
+  constructor(options) {
+    this.fetch = options._fetch;
+  }
+
+  async readdir(dirname = '.', options) {
+    return await fs.readdir(dirname, options);
+  }
+
+  async stat(path, options) {
+    const info = await fs.stat(path, options);
+    return {
+      size: Number(info.size),
+      isDirectory: () => false,
+      info
+    };
+  }
+
+  async fetch(path, options) {
+    const fallbackFetch = options.fetch || this.fetch;
+    return fallbackFetch(path, options);
+  }
+
+  async open(path, flags, mode) {
+    return await fs.open(path, flags);
+  }
+
+  async close(fd) {
+    return await fs.close(fd);
+  }
+
+  async fstat(fd) {
+    const info = await fs.fstat(fd);
+    return info;
+  }
+
+  async read(fd, {
+    buffer = null,
+    offset = 0,
+    length = buffer.byteLength,
+    position = null
+  }) {
+    let totalBytesRead = 0;
+
+    while (totalBytesRead < length) {
+      const {
+        bytesRead
+      } = await fs.read(fd, buffer, offset + totalBytesRead, length - totalBytesRead, position + totalBytesRead);
+      totalBytesRead += bytesRead;
+    }
+
+    return {
+      bytesRead: totalBytesRead,
+      buffer
+    };
+  }
+
 }
-exports.default = NodeFileSystem;
+//# sourceMappingURL=node-filesystem.js.map

package/dist/lib/filesystems/node-filesystem.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/filesystems/node-filesystem.ts"],"names":["fs","NodeFileSystem","constructor","options","fetch","_fetch","readdir","dirname","stat","path","info","size","Number","isDirectory","fallbackFetch","open","flags","mode","close","fd","fstat","read","buffer","offset","length","byteLength","position","totalBytesRead","bytesRead"],"mappings":"AAAA,OAAO,KAAKA,EAAZ,MAAoB,YAApB;AAuBA,eAAe,MAAMC,cAAN,CAAyE;AAEtFC,EAAAA,WAAW,CAACC,OAAD,EAAgC;AACzC,SAAKC,KAAL,GAAaD,OAAO,CAACE,MAArB;AACD;;AAEY,QAAPC,OAAO,CAACC,OAAO,GAAG,GAAX,EAAgBJ,OAAhB,EAA8C;AACzD,WAAO,MAAMH,EAAE,CAACM,OAAH,CAAWC,OAAX,EAAoBJ,OAApB,CAAb;AACD;;AAES,QAAJK,IAAI,CAACC,IAAD,EAAeN,OAAf,EAA4C;AACpD,UAAMO,IAAI,GAAG,MAAMV,EAAE,CAACQ,IAAH,CAAQC,IAAR,EAAcN,OAAd,CAAnB;AACA,WAAO;AAACQ,MAAAA,IAAI,EAAEC,MAAM,CAACF,IAAI,CAACC,IAAN,CAAb;AAA0BE,MAAAA,WAAW,EAAE,MAAM,KAA7C;AAAoDH,MAAAA;AAApD,KAAP;AACD;;AAEU,QAALN,KAAK,CAACK,IAAD,EAAeN,OAAf,EAA8C;AAGvD,UAAMW,aAAa,GAAGX,OAAO,CAACC,KAAR,IAAiB,KAAKA,KAA5C;AACA,WAAOU,aAAa,CAACL,IAAD,EAAON,OAAP,CAApB;AACD;;AAGS,QAAJY,IAAI,CAACN,IAAD,EAAeO,KAAf,EAAuCC,IAAvC,EAAoE;AAC5E,WAAO,MAAMjB,EAAE,CAACe,IAAH,CAAQN,IAAR,EAAcO,KAAd,CAAb;AACD;;AAEU,QAALE,KAAK,CAACC,EAAD,EAA4B;AACrC,WAAO,MAAMnB,EAAE,CAACkB,KAAH,CAASC,EAAT,CAAb;AACD;;AAEU,QAALC,KAAK,CAACD,EAAD,EAA4B;AACrC,UAAMT,IAAI,GAAG,MAAMV,EAAE,CAACoB,KAAH,CAASD,EAAT,CAAnB;AACA,WAAOT,IAAP;AACD;;AAES,QAAJW,IAAI,CACRF,EADQ,EAGR;AAACG,IAAAA,MAAM,GAAG,IAAV;AAAgBC,IAAAA,MAAM,GAAG,CAAzB;AAA4BC,IAAAA,MAAM,GAAGF,MAAM,CAACG,UAA5C;AAAwDC,IAAAA,QAAQ,GAAG;AAAnE,GAHQ,EAIsC;AAC9C,QAAIC,cAAc,GAAG,CAArB;;AAEA,WAAOA,cAAc,GAAGH,MAAxB,EAAgC;AAC9B,YAAM;AAACI,QAAAA;AAAD,UAAc,MAAM5B,EAAE,CAACqB,IAAH,CACxBF,EADwB,EAExBG,MAFwB,EAGxBC,MAAM,GAAGI,cAHe,EAIxBH,MAAM,GAAGG,cAJe,EAKxBD,QAAQ,GAAGC,cALa,CAA1B;AAOAA,MAAAA,cAAc,IAAIC,SAAlB;AACD;;AACD,WAAO;AAACA,MAAAA,SAAS,EAAED,cAAZ;AAA4BL,MAAAA;AAA5B,KAAP;AACD;;AAtDqF","sourcesContent":["import * as fs from '../node/fs';\nimport {IFileSystem, IRandomAccessReadFileSystem} from '../../types';\n// import {fetchFile} from \"../fetch/fetch-file\"\n// import {selectLoader} from \"../api/select-loader\";\n\ntype Stat = {\n  size: number;\n  isDirectory: () => boolean;\n  info?: fs.Stats;\n};\n\ntype ReadOptions = {\n  buffer?: Buffer;\n  offset?: number;\n  length?: number;\n  position?: number;\n};\n\n/**\n * FileSystem pass-through for Node.js\n * Compatible with BrowserFileSystem.\n * @param options\n */\nexport default class NodeFileSystem implements IFileSystem, IRandomAccessReadFileSystem {\n  // implements IFileSystem\n  constructor(options: {[key: string]: any}) {\n    this.fetch = options._fetch;\n  }\n\n  async readdir(dirname = '.', options?: {}): Promise<any[]> {\n    return await fs.readdir(dirname, options);\n  }\n\n  async stat(path: string, options?: {}): Promise<Stat> {\n    const info = await fs.stat(path, options);\n    return {size: Number(info.size), isDirectory: () => false, info};\n  }\n\n  async fetch(path: string, options: {[key: string]: any}) {\n    // Falls back to handle https:/http:/data: etc fetches\n    // eslint-disable-next-line\n    const fallbackFetch = options.fetch || this.fetch;\n    return fallbackFetch(path, options);\n  }\n\n  // implements IRandomAccessFileSystem\n  async open(path: string, flags: string | number, mode?: any): Promise<number> {\n    return await fs.open(path, flags);\n  }\n\n  async close(fd: number): Promise<void> {\n    return await fs.close(fd);\n  }\n\n  async fstat(fd: number): Promise<Stat> {\n    const info = await fs.fstat(fd);\n    return info;\n  }\n\n  async read(\n    fd: number,\n    // @ts-ignore Possibly null\n    {buffer = null, offset = 0, length = buffer.byteLength, position = null}: ReadOptions\n  ): Promise<{bytesRead: number; buffer: Buffer}> {\n    let totalBytesRead = 0;\n    // Read in loop until we get required number of bytes\n    while (totalBytesRead < length) {\n      const {bytesRead} = await fs.read(\n        fd,\n        buffer,\n        offset + totalBytesRead,\n        length - totalBytesRead,\n        position + totalBytesRead\n      );\n      totalBytesRead += bytesRead;\n    }\n    return {bytesRead: totalBytesRead, buffer};\n  }\n}\n"],"file":"node-filesystem.js"}

package/dist/lib/iterators/async-iteration.js

@@ -1,53 +1,39 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.concatenateStringsAsync = exports.concatenateArrayBuffersAsync = exports.forEach = void 0;
-const array_buffer_utils_1 = require("../binary-utils/array-buffer-utils");
-// GENERAL UTILITIES
-/**
- * Iterate over async iterator, without resetting iterator if end is not reached
- * - forEach intentionally does not reset iterator if exiting loop prematurely
- *   so that iteration can continue in a second loop
- * - It is recommended to use a standard for-await as last loop to ensure
- *   iterator gets properly reset
- *
- * TODO - optimize using sync iteration if argument is an Iterable?
- *
- * @param iterator
- * @param visitor
- */
-async function forEach(iterator, visitor) {
-    // eslint-disable-next-line
-    while (true) {
-        const { done, value } = await iterator.next();
-        if (done) {
-            iterator.return();
-            return;
-        }
-        const cancel = visitor(value);
-        if (cancel) {
-            return;
-        }
+import { concatenateArrayBuffers } from '../binary-utils/array-buffer-utils';
+export async function forEach(iterator, visitor) {
+  while (true) {
+    const {
+      done,
+      value
+    } = await iterator.next();
+
+    if (done) {
+      iterator.return();
+      return;
     }
-}
-exports.forEach = forEach;
-// Breaking big data into iterable chunks, concatenating iterable chunks into big data objects
-/**
- * Concatenates all data chunks yielded by an (async) iterator
- * This function can e.g. be used to enable atomic parsers to work on (async) iterator inputs
- */
-async function concatenateArrayBuffersAsync(asyncIterator) {
-    const arrayBuffers = [];
-    for await (const chunk of asyncIterator) {
-        arrayBuffers.push(chunk);
+
+    const cancel = visitor(value);
+
+    if (cancel) {
+      return;
     }
-    return (0, array_buffer_utils_1.concatenateArrayBuffers)(...arrayBuffers);
+  }
 }
-exports.concatenateArrayBuffersAsync = concatenateArrayBuffersAsync;
-async function concatenateStringsAsync(asyncIterator) {
-    const strings = [];
-    for await (const chunk of asyncIterator) {
-        strings.push(chunk);
-    }
-    return strings.join('');
+export async function concatenateArrayBuffersAsync(asyncIterator) {
+  const arrayBuffers = [];
+
+  for await (const chunk of asyncIterator) {
+    arrayBuffers.push(chunk);
+  }
+
+  return concatenateArrayBuffers(...arrayBuffers);
+}
+export async function concatenateStringsAsync(asyncIterator) {
+  const strings = [];
+
+  for await (const chunk of asyncIterator) {
+    strings.push(chunk);
+  }
+
+  return strings.join('');
 }
-exports.concatenateStringsAsync = concatenateStringsAsync;
+//# sourceMappingURL=async-iteration.js.map

package/dist/lib/iterators/async-iteration.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/iterators/async-iteration.ts"],"names":["concatenateArrayBuffers","forEach","iterator","visitor","done","value","next","return","cancel","concatenateArrayBuffersAsync","asyncIterator","arrayBuffers","chunk","push","concatenateStringsAsync","strings","join"],"mappings":"AAAA,SAAQA,uBAAR,QAAsC,oCAAtC;AAgBA,OAAO,eAAeC,OAAf,CAAuBC,QAAvB,EAAiCC,OAAjC,EAA0C;AAE/C,SAAO,IAAP,EAAa;AACX,UAAM;AAACC,MAAAA,IAAD;AAAOC,MAAAA;AAAP,QAAgB,MAAMH,QAAQ,CAACI,IAAT,EAA5B;;AACA,QAAIF,IAAJ,EAAU;AACRF,MAAAA,QAAQ,CAACK,MAAT;AACA;AACD;;AACD,UAAMC,MAAM,GAAGL,OAAO,CAACE,KAAD,CAAtB;;AACA,QAAIG,MAAJ,EAAY;AACV;AACD;AACF;AACF;AASD,OAAO,eAAeC,4BAAf,CACLC,aADK,EAEiB;AACtB,QAAMC,YAA2B,GAAG,EAApC;;AACA,aAAW,MAAMC,KAAjB,IAA0BF,aAA1B,EAAyC;AACvCC,IAAAA,YAAY,CAACE,IAAb,CAAkBD,KAAlB;AACD;;AACD,SAAOZ,uBAAuB,CAAC,GAAGW,YAAJ,CAA9B;AACD;AAED,OAAO,eAAeG,uBAAf,CACLJ,aADK,EAEY;AACjB,QAAMK,OAAiB,GAAG,EAA1B;;AACA,aAAW,MAAMH,KAAjB,IAA0BF,aAA1B,EAAyC;AACvCK,IAAAA,OAAO,CAACF,IAAR,CAAaD,KAAb;AACD;;AACD,SAAOG,OAAO,CAACC,IAAR,CAAa,EAAb,CAAP;AACD","sourcesContent":["import {concatenateArrayBuffers} from '../binary-utils/array-buffer-utils';\n\n// GENERAL UTILITIES\n\n/**\n * Iterate over async iterator, without resetting iterator if end is not reached\n * - forEach intentionally does not reset iterator if exiting loop prematurely\n *   so that iteration can continue in a second loop\n * - It is recommended to use a standard for-await as last loop to ensure\n *   iterator gets properly reset\n *\n * TODO - optimize using sync iteration if argument is an Iterable?\n *\n * @param iterator\n * @param visitor\n */\nexport async function forEach(iterator, visitor) {\n  // eslint-disable-next-line\n  while (true) {\n    const {done, value} = await iterator.next();\n    if (done) {\n      iterator.return();\n      return;\n    }\n    const cancel = visitor(value);\n    if (cancel) {\n      return;\n    }\n  }\n}\n\n// Breaking big data into iterable chunks, concatenating iterable chunks into big data objects\n\n/**\n * Concatenates all data chunks yielded by an (async) iterator\n * This function can e.g. be used to enable atomic parsers to work on (async) iterator inputs\n */\n\nexport async function concatenateArrayBuffersAsync(\n  asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>\n): Promise<ArrayBuffer> {\n  const arrayBuffers: ArrayBuffer[] = [];\n  for await (const chunk of asyncIterator) {\n    arrayBuffers.push(chunk);\n  }\n  return concatenateArrayBuffers(...arrayBuffers);\n}\n\nexport async function concatenateStringsAsync(\n  asyncIterator: AsyncIterable<string> | Iterable<string>\n): Promise<string> {\n  const strings: string[] = [];\n  for await (const chunk of asyncIterator) {\n    strings.push(chunk);\n  }\n  return strings.join('');\n}\n"],"file":"async-iteration.js"}