@loaders.gl/loader-utils 4.0.0-alpha.1 → 4.0.0-alpha.11

package/dist/esm/lib/binary-utils/memory-conversion-utils.js

@@ -0,0 +1,31 @@
+import * as node from '../node/buffer';
+export function isBuffer(value) {
+  return value && typeof value === 'object' && value.isBuffer;
+}
+export function toBuffer(data) {
+  return node.toBuffer ? node.toBuffer(data) : data;
+}
+export function toArrayBuffer(data) {
+  if (isBuffer(data)) {
+    return node.toArrayBuffer(data);
+  }
+  if (data instanceof ArrayBuffer) {
+    return data;
+  }
+  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;
+  }
+  if (data && typeof data === 'object' && data._toArrayBuffer) {
+    return data._toArrayBuffer();
+  }
+  throw new Error('toArrayBuffer');
+}
+//# sourceMappingURL=memory-conversion-utils.js.map

package/dist/esm/lib/binary-utils/memory-conversion-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-conversion-utils.js","names":["node","isBuffer","value","toBuffer","data","toArrayBuffer","ArrayBuffer","isView","byteOffset","byteLength","buffer","slice","text","uint8Array","TextEncoder","encode","_toArrayBuffer","Error"],"sources":["../../../../src/lib/binary-utils/memory-conversion-utils.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport * as node from '../node/buffer';\n\n/**\n * Check for Node.js `Buffer` (without triggering bundler to include Buffer polyfill on browser)\n */\nexport function isBuffer(value: any): boolean {\n  return value && typeof value === 'object' && value.isBuffer;\n}\n\n/**\n * Converts to Node.js `Buffer` (without triggering bundler to include Buffer polyfill on browser)\n * @todo better data type\n */\nexport function toBuffer(data: any): Buffer {\n  return node.toBuffer ? node.toBuffer(data) : data;\n}\n\n/**\n * Convert an object to an array buffer\n */\nexport function toArrayBuffer(data: unknown): ArrayBuffer {\n  // Note: Should be called first, Buffers can trigger other detections below\n  if (isBuffer(data)) {\n    return node.toArrayBuffer(data);\n  }\n\n  if (data instanceof ArrayBuffer) {\n    return data;\n  }\n\n  // Careful - Node Buffers look like Uint8Arrays (keep after isBuffer)\n  if (ArrayBuffer.isView(data)) {\n    if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {\n      return data.buffer;\n    }\n    return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);\n  }\n\n  if (typeof data === 'string') {\n    const text = data;\n    const uint8Array = new TextEncoder().encode(text);\n    return uint8Array.buffer;\n  }\n\n  // HACK to support Blob polyfill\n  if (data && typeof data === 'object' && (data as any)._toArrayBuffer) {\n    return (data as any)._toArrayBuffer();\n  }\n\n  throw new Error('toArrayBuffer');\n}\n"],"mappings":"AAEA,OAAO,KAAKA,IAAI,MAAM,gBAAgB;AAKtC,OAAO,SAASC,QAAQA,CAACC,KAAU,EAAW;EAC5C,OAAOA,KAAK,IAAI,OAAOA,KAAK,KAAK,QAAQ,IAAIA,KAAK,CAACD,QAAQ;AAC7D;AAMA,OAAO,SAASE,QAAQA,CAACC,IAAS,EAAU;EAC1C,OAAOJ,IAAI,CAACG,QAAQ,GAAGH,IAAI,CAACG,QAAQ,CAACC,IAAI,CAAC,GAAGA,IAAI;AACnD;AAKA,OAAO,SAASC,aAAaA,CAACD,IAAa,EAAe;EAExD,IAAIH,QAAQ,CAACG,IAAI,CAAC,EAAE;IAClB,OAAOJ,IAAI,CAACK,aAAa,CAACD,IAAI,CAAC;EACjC;EAEA,IAAIA,IAAI,YAAYE,WAAW,EAAE;IAC/B,OAAOF,IAAI;EACb;EAGA,IAAIE,WAAW,CAACC,MAAM,CAACH,IAAI,CAAC,EAAE;IAC5B,IAAIA,IAAI,CAACI,UAAU,KAAK,CAAC,IAAIJ,IAAI,CAACK,UAAU,KAAKL,IAAI,CAACM,MAAM,CAACD,UAAU,EAAE;MACvE,OAAOL,IAAI,CAACM,MAAM;IACpB;IACA,OAAON,IAAI,CAACM,MAAM,CAACC,KAAK,CAACP,IAAI,CAACI,UAAU,EAAEJ,IAAI,CAACI,UAAU,GAAGJ,IAAI,CAACK,UAAU,CAAC;EAC9E;EAEA,IAAI,OAAOL,IAAI,KAAK,QAAQ,EAAE;IAC5B,MAAMQ,IAAI,GAAGR,IAAI;IACjB,MAAMS,UAAU,GAAG,IAAIC,WAAW,CAAC,CAAC,CAACC,MAAM,CAACH,IAAI,CAAC;IACjD,OAAOC,UAAU,CAACH,MAAM;EAC1B;EAGA,IAAIN,IAAI,IAAI,OAAOA,IAAI,KAAK,QAAQ,IAAKA,IAAI,CAASY,cAAc,EAAE;IACpE,OAAQZ,IAAI,CAASY,cAAc,CAAC,CAAC;EACvC;EAEA,MAAM,IAAIC,KAAK,CAAC,eAAe,CAAC;AAClC"}

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

@@ -0,0 +1,26 @@
+import { assert } from '../env-utils/assert';
+export function padToNBytes(byteLength, padding) {
+  assert(byteLength >= 0);
+  assert(padding > 0);
+  return byteLength + (padding - 1) & ~(padding - 1);
+}
+export function copyArrayBuffer(targetBuffer, sourceBuffer, byteOffset) {
+  let byteLength = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : sourceBuffer.byteLength;
+  const targetArray = new Uint8Array(targetBuffer, byteOffset, byteLength);
+  const sourceArray = new Uint8Array(sourceBuffer);
+  targetArray.set(sourceArray);
+  return targetBuffer;
+}
+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);
+}
+//# sourceMappingURL=memory-copy-utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memory-copy-utils.js","names":["assert","padToNBytes","byteLength","padding","copyArrayBuffer","targetBuffer","sourceBuffer","byteOffset","arguments","length","undefined","targetArray","Uint8Array","sourceArray","set","copyToArray","source","target","targetOffset","ArrayBuffer","srcByteOffset","srcByteLength","buffer","arrayBuffer"],"sources":["../../../../src/lib/binary-utils/memory-copy-utils.ts"],"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"],"mappings":"AAAA,SAAQA,MAAM,QAAO,qBAAqB;AAS1C,OAAO,SAASC,WAAWA,CAACC,UAAkB,EAAEC,OAAe,EAAU;EACvEH,MAAM,CAACE,UAAU,IAAI,CAAC,CAAC;EACvBF,MAAM,CAACG,OAAO,GAAG,CAAC,CAAC;EACnB,OAAQD,UAAU,IAAIC,OAAO,GAAG,CAAC,CAAC,GAAI,EAAEA,OAAO,GAAG,CAAC,CAAC;AACtD;AAQA,OAAO,SAASC,eAAeA,CAC7BC,YAAyB,EACzBC,YAAyB,EACzBC,UAAkB,EAEL;EAAA,IADbL,UAAkB,GAAAM,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAGF,YAAY,CAACJ,UAAU;EAE5C,MAAMS,WAAW,GAAG,IAAIC,UAAU,CAACP,YAAY,EAAEE,UAAU,EAAEL,UAAU,CAAC;EACxE,MAAMW,WAAW,GAAG,IAAID,UAAU,CAACN,YAAY,CAAC;EAChDK,WAAW,CAACG,GAAG,CAACD,WAAW,CAAC;EAC5B,OAAOR,YAAY;AACrB;AAUA,OAAO,SAASU,WAAWA,CAACC,MAAyB,EAAEC,MAAW,EAAEC,YAAoB,EAAU;EAChG,IAAIL,WAAW;EAEf,IAAIG,MAAM,YAAYG,WAAW,EAAE;IACjCN,WAAW,GAAG,IAAID,UAAU,CAACI,MAAM,CAAC;EACtC,CAAC,MAAM;IAOL,MAAMI,aAAa,GAAGJ,MAAM,CAACT,UAAU;IACvC,MAAMc,aAAa,GAAGL,MAAM,CAACd,UAAU;IAGvCW,WAAW,GAAG,IAAID,UAAU,CAACI,MAAM,CAACM,MAAM,IAAIN,MAAM,CAACO,WAAW,EAAEH,aAAa,EAAEC,aAAa,CAAC;EACjG;EAGAJ,MAAM,CAACH,GAAG,CAACD,WAAW,EAAEK,YAAY,CAAC;EAErC,OAAOA,YAAY,GAAGjB,WAAW,CAACY,WAAW,CAACX,UAAU,EAAE,CAAC,CAAC;AAC9D"}

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

@@ -0,0 +1,6 @@
+export function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message || 'loader assertion failed.');
+  }
+}
+//# sourceMappingURL=assert.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"assert.js","names":["assert","condition","message","Error"],"sources":["../../../../src/lib/env-utils/assert.ts"],"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"],"mappings":"AAIA,OAAO,SAASA,MAAMA,CAACC,SAAc,EAAEC,OAAgB,EAAQ;EAC7D,IAAI,CAACD,SAAS,EAAE;IACd,MAAM,IAAIE,KAAK,CAACD,OAAO,IAAI,0BAA0B,CAAC;EACxD;AACF"}

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

@@ -0,0 +1,16 @@
+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 || {};
+const window_ = globals.window || globals.self || globals.global || {};
+const global_ = globals.global || globals.self || globals.window || {};
+const document_ = globals.document || {};
+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);
+export const nodeVersion = matches && parseFloat(matches[1]) || 0;
+//# sourceMappingURL=globals.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"globals.js","names":["globals","self","window","global","document","self_","window_","global_","document_","isBrowser","Boolean","process","String","browser","isWorker","importScripts","matches","version","exec","nodeVersion","parseFloat"],"sources":["../../../../src/lib/env-utils/globals.ts"],"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"],"mappings":"AAIA,MAAMA,OAAO,GAAG;EACdC,IAAI,EAAE,OAAOA,IAAI,KAAK,WAAW,IAAIA,IAAI;EACzCC,MAAM,EAAE,OAAOA,MAAM,KAAK,WAAW,IAAIA,MAAM;EAC/CC,MAAM,EAAE,OAAOA,MAAM,KAAK,WAAW,IAAIA,MAAM;EAC/CC,QAAQ,EAAE,OAAOA,QAAQ,KAAK,WAAW,IAAIA;AAC/C,CAAC;AAGD,MAAMC,KAAU,GAAGL,OAAO,CAACC,IAAI,IAAID,OAAO,CAACE,MAAM,IAAIF,OAAO,CAACG,MAAM,IAAI,CAAC,CAAC;AACzE,MAAMG,OAAY,GAAGN,OAAO,CAACE,MAAM,IAAIF,OAAO,CAACC,IAAI,IAAID,OAAO,CAACG,MAAM,IAAI,CAAC,CAAC;AAC3E,MAAMI,OAAY,GAAGP,OAAO,CAACG,MAAM,IAAIH,OAAO,CAACC,IAAI,IAAID,OAAO,CAACE,MAAM,IAAI,CAAC,CAAC;AAC3E,MAAMM,SAAc,GAAGR,OAAO,CAACI,QAAQ,IAAI,CAAC,CAAC;AAE7C,SAAQC,KAAK,IAAIJ,IAAI,EAAEK,OAAO,IAAIJ,MAAM,EAAEK,OAAO,IAAIJ,MAAM,EAAEK,SAAS,IAAIJ,QAAQ;AAGlF,OAAO,MAAMK,SAAkB,GAE7BC,OAAO,CAAC,OAAOC,OAAO,KAAK,QAAQ,IAAIC,MAAM,CAACD,OAAO,CAAC,KAAK,kBAAkB,IAAIA,OAAO,CAACE,OAAO,CAAC;AAGnG,OAAO,MAAMC,QAAiB,GAAG,OAAOC,aAAa,KAAK,UAAU;AAGpE,MAAMC,OAAO,GACX,OAAOL,OAAO,KAAK,WAAW,IAAIA,OAAO,CAACM,OAAO,IAAI,WAAW,CAACC,IAAI,CAACP,OAAO,CAACM,OAAO,CAAC;AAExF,OAAO,MAAME,WAAmB,GAAIH,OAAO,IAAII,UAAU,CAACJ,OAAO,CAAC,CAAC,CAAC,CAAC,IAAK,CAAC"}

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

@@ -0,0 +1,53 @@
+import * as fs from '../node/fs';
+export default class NodeFileSystem {
+  constructor(options) {
+    this.fetch = options._fetch;
+  }
+  async readdir() {
+    let dirname = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '.';
+    let options = arguments.length > 1 ? arguments[1] : undefined;
+    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, _ref) {
+    let {
+      buffer = null,
+      offset = 0,
+      length = buffer.byteLength,
+      position = null
+    } = _ref;
+    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
+    };
+  }
+}
+//# sourceMappingURL=node-filesystem.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"node-filesystem.js","names":["fs","NodeFileSystem","constructor","options","fetch","_fetch","readdir","dirname","arguments","length","undefined","stat","path","info","size","Number","isDirectory","fallbackFetch","open","flags","mode","close","fd","fstat","read","_ref","buffer","offset","byteLength","position","totalBytesRead","bytesRead"],"sources":["../../../../src/lib/filesystems/node-filesystem.ts"],"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"],"mappings":"AAAA,OAAO,KAAKA,EAAE,MAAM,YAAY;AAuBhC,eAAe,MAAMC,cAAc,CAAqD;EAEtFC,WAAWA,CAACC,OAA6B,EAAE;IACzC,IAAI,CAACC,KAAK,GAAGD,OAAO,CAACE,MAAM;EAC7B;EAEA,MAAMC,OAAOA,CAAA,EAA8C;IAAA,IAA7CC,OAAO,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,GAAG;IAAA,IAAEL,OAAY,GAAAK,SAAA,CAAAC,MAAA,OAAAD,SAAA,MAAAE,SAAA;IACvC,OAAO,MAAMV,EAAE,CAACM,OAAO,CAACC,OAAO,EAAEJ,OAAO,CAAC;EAC3C;EAEA,MAAMQ,IAAIA,CAACC,IAAY,EAAET,OAAY,EAAiB;IACpD,MAAMU,IAAI,GAAG,MAAMb,EAAE,CAACW,IAAI,CAACC,IAAI,EAAET,OAAO,CAAC;IACzC,OAAO;MAACW,IAAI,EAAEC,MAAM,CAACF,IAAI,CAACC,IAAI,CAAC;MAAEE,WAAW,EAAEA,CAAA,KAAM,KAAK;MAAEH;IAAI,CAAC;EAClE;EAEA,MAAMT,KAAKA,CAACQ,IAAY,EAAET,OAA6B,EAAE;IAGvD,MAAMc,aAAa,GAAGd,OAAO,CAACC,KAAK,IAAI,IAAI,CAACA,KAAK;IACjD,OAAOa,aAAa,CAACL,IAAI,EAAET,OAAO,CAAC;EACrC;EAGA,MAAMe,IAAIA,CAACN,IAAY,EAAEO,KAAsB,EAAEC,IAAU,EAAmB;IAC5E,OAAO,MAAMpB,EAAE,CAACkB,IAAI,CAACN,IAAI,EAAEO,KAAK,CAAC;EACnC;EAEA,MAAME,KAAKA,CAACC,EAAU,EAAiB;IACrC,OAAO,MAAMtB,EAAE,CAACqB,KAAK,CAACC,EAAE,CAAC;EAC3B;EAEA,MAAMC,KAAKA,CAACD,EAAU,EAAiB;IACrC,MAAMT,IAAI,GAAG,MAAMb,EAAE,CAACuB,KAAK,CAACD,EAAE,CAAC;IAC/B,OAAOT,IAAI;EACb;EAEA,MAAMW,IAAIA,CACRF,EAAU,EAAAG,IAAA,EAGoC;IAAA,IAD9C;MAACC,MAAM,GAAG,IAAI;MAAEC,MAAM,GAAG,CAAC;MAAElB,MAAM,GAAGiB,MAAM,CAACE,UAAU;MAAEC,QAAQ,GAAG;IAAiB,CAAC,GAAAJ,IAAA;IAErF,IAAIK,cAAc,GAAG,CAAC;IAEtB,OAAOA,cAAc,GAAGrB,MAAM,EAAE;MAC9B,MAAM;QAACsB;MAAS,CAAC,GAAG,MAAM/B,EAAE,CAACwB,IAAI,CAC/BF,EAAE,EACFI,MAAM,EACNC,MAAM,GAAGG,cAAc,EACvBrB,MAAM,GAAGqB,cAAc,EACvBD,QAAQ,GAAGC,cACb,CAAC;MACDA,cAAc,IAAIC,SAAS;IAC7B;IACA,OAAO;MAACA,SAAS,EAAED,cAAc;MAAEJ;IAAM,CAAC;EAC5C;AACF"}

package/dist/esm/lib/filesystems/readable-file.js

@@ -0,0 +1,20 @@
+export function makeReadableFile(data) {
+  if (data instanceof ArrayBuffer) {
+    const arrayBuffer = data;
+    return {
+      read: async (start, length) => Buffer.from(data, start, length),
+      close: async () => {},
+      size: arrayBuffer.byteLength
+    };
+  }
+  const blob = data;
+  return {
+    read: async (start, length) => {
+      const arrayBuffer = await blob.slice(start, start + length).arrayBuffer();
+      return Buffer.from(arrayBuffer);
+    },
+    close: async () => {},
+    size: blob.size
+  };
+}
+//# sourceMappingURL=readable-file.js.map

package/dist/esm/lib/filesystems/readable-file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readable-file.js","names":["makeReadableFile","data","ArrayBuffer","arrayBuffer","read","start","length","Buffer","from","close","size","byteLength","blob","slice"],"sources":["../../../../src/lib/filesystems/readable-file.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nexport type ReadableFile = {\n  read: (position: number, length: number) => Promise<Buffer>;\n  close: () => Promise<void>;\n  /** Length of file in bytes */\n  size: number;\n};\n\n/** Helper function to create an envelope reader for a binary memory input */\nexport function makeReadableFile(data: Blob | ArrayBuffer): ReadableFile {\n  if (data instanceof ArrayBuffer) {\n    const arrayBuffer: ArrayBuffer = data;\n    return {\n      read: async (start: number, length: number) => Buffer.from(data, start, length),\n      close: async () => {},\n      size: arrayBuffer.byteLength\n    };\n  }\n\n  const blob: Blob = data;\n  return {\n    read: async (start: number, length: number) => {\n      const arrayBuffer = await blob.slice(start, start + length).arrayBuffer();\n      return Buffer.from(arrayBuffer);\n    },\n    close: async () => {},\n    size: blob.size\n  };\n}\n"],"mappings":"AAUA,OAAO,SAASA,gBAAgBA,CAACC,IAAwB,EAAgB;EACvE,IAAIA,IAAI,YAAYC,WAAW,EAAE;IAC/B,MAAMC,WAAwB,GAAGF,IAAI;IACrC,OAAO;MACLG,IAAI,EAAE,MAAAA,CAAOC,KAAa,EAAEC,MAAc,KAAKC,MAAM,CAACC,IAAI,CAACP,IAAI,EAAEI,KAAK,EAAEC,MAAM,CAAC;MAC/EG,KAAK,EAAE,MAAAA,CAAA,KAAY,CAAC,CAAC;MACrBC,IAAI,EAAEP,WAAW,CAACQ;IACpB,CAAC;EACH;EAEA,MAAMC,IAAU,GAAGX,IAAI;EACvB,OAAO;IACLG,IAAI,EAAE,MAAAA,CAAOC,KAAa,EAAEC,MAAc,KAAK;MAC7C,MAAMH,WAAW,GAAG,MAAMS,IAAI,CAACC,KAAK,CAACR,KAAK,EAAEA,KAAK,GAAGC,MAAM,CAAC,CAACH,WAAW,CAAC,CAAC;MACzE,OAAOI,MAAM,CAACC,IAAI,CAACL,WAAW,CAAC;IACjC,CAAC;IACDM,KAAK,EAAE,MAAAA,CAAA,KAAY,CAAC,CAAC;IACrBC,IAAI,EAAEE,IAAI,CAACF;EACb,CAAC;AACH"}

package/dist/esm/lib/filesystems/writable-file.js

@@ -0,0 +1,20 @@
+import { isBrowser } from '../env-utils/globals';
+import * as fs from '../node/fs';
+export function makeWritableFile(pathOrStream, options) {
+  if (isBrowser) {
+    return {
+      write: async () => {},
+      close: async () => {}
+    };
+  }
+  const outputStream = typeof pathOrStream === 'string' ? fs.createWriteStream(pathOrStream, options) : pathOrStream;
+  return {
+    write: async buffer => new Promise((resolve, reject) => {
+      outputStream.write(buffer, err => err ? reject(err) : resolve());
+    }),
+    close: () => new Promise((resolve, reject) => {
+      outputStream.close(err => err ? reject(err) : resolve());
+    })
+  };
+}
+//# sourceMappingURL=writable-file.js.map

package/dist/esm/lib/filesystems/writable-file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"writable-file.js","names":["isBrowser","fs","makeWritableFile","pathOrStream","options","write","close","outputStream","createWriteStream","buffer","Promise","resolve","reject","err"],"sources":["../../../../src/lib/filesystems/writable-file.ts"],"sourcesContent":["// Forked from https://github.com/kbajalc/parquets under MIT license (Copyright (c) 2017 ironSource Ltd.)\nimport {isBrowser} from '../env-utils/globals';\nimport * as fs from '../node/fs';\nimport type {Writable} from 'stream';\n\nexport type WritableFile = {\n  write: (buf: Buffer) => Promise<void>;\n  close: () => Promise<void>;\n};\n\nexport interface WriteStreamOptions {\n  flags?: string;\n  encoding?: 'utf8';\n  fd?: number;\n  mode?: number;\n  autoClose?: boolean;\n  start?: number;\n}\n\n/** Helper function to create an envelope reader for a binary memory input */\nexport function makeWritableFile(\n  pathOrStream: string | Writable,\n  options?: WriteStreamOptions\n): WritableFile {\n  if (isBrowser) {\n    return {\n      write: async () => {},\n      close: async () => {}\n    };\n  }\n\n  const outputStream: Writable =\n    typeof pathOrStream === 'string' ? fs.createWriteStream(pathOrStream, options) : pathOrStream;\n  return {\n    write: async (buffer: Buffer) =>\n      new Promise((resolve, reject) => {\n        outputStream.write(buffer, (err) => (err ? reject(err) : resolve()));\n      }),\n    close: () =>\n      new Promise((resolve, reject) => {\n        (outputStream as any).close((err) => (err ? reject(err) : resolve()));\n      })\n  };\n}\n"],"mappings":"AACA,SAAQA,SAAS,QAAO,sBAAsB;AAC9C,OAAO,KAAKC,EAAE,MAAM,YAAY;AAkBhC,OAAO,SAASC,gBAAgBA,CAC9BC,YAA+B,EAC/BC,OAA4B,EACd;EACd,IAAIJ,SAAS,EAAE;IACb,OAAO;MACLK,KAAK,EAAE,MAAAA,CAAA,KAAY,CAAC,CAAC;MACrBC,KAAK,EAAE,MAAAA,CAAA,KAAY,CAAC;IACtB,CAAC;EACH;EAEA,MAAMC,YAAsB,GAC1B,OAAOJ,YAAY,KAAK,QAAQ,GAAGF,EAAE,CAACO,iBAAiB,CAACL,YAAY,EAAEC,OAAO,CAAC,GAAGD,YAAY;EAC/F,OAAO;IACLE,KAAK,EAAE,MAAOI,MAAc,IAC1B,IAAIC,OAAO,CAAC,CAACC,OAAO,EAAEC,MAAM,KAAK;MAC/BL,YAAY,CAACF,KAAK,CAACI,MAAM,EAAGI,GAAG,IAAMA,GAAG,GAAGD,MAAM,CAACC,GAAG,CAAC,GAAGF,OAAO,CAAC,CAAE,CAAC;IACtE,CAAC,CAAC;IACJL,KAAK,EAAEA,CAAA,KACL,IAAII,OAAO,CAAC,CAACC,OAAO,EAAEC,MAAM,KAAK;MAC9BL,YAAY,CAASD,KAAK,CAAEO,GAAG,IAAMA,GAAG,GAAGD,MAAM,CAACC,GAAG,CAAC,GAAGF,OAAO,CAAC,CAAE,CAAC;IACvE,CAAC;EACL,CAAC;AACH"}

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

@@ -0,0 +1,32 @@
+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;
+    }
+    const cancel = visitor(value);
+    if (cancel) {
+      return;
+    }
+  }
+}
+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('');
+}
+//# sourceMappingURL=async-iteration.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"async-iteration.js","names":["concatenateArrayBuffers","forEach","iterator","visitor","done","value","next","return","cancel","concatenateArrayBuffersAsync","asyncIterator","arrayBuffers","chunk","push","concatenateStringsAsync","strings","join"],"sources":["../../../../src/lib/iterators/async-iteration.ts"],"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"],"mappings":"AAAA,SAAQA,uBAAuB,QAAO,oCAAoC;AAgB1E,OAAO,eAAeC,OAAOA,CAACC,QAAQ,EAAEC,OAAO,EAAE;EAE/C,OAAO,IAAI,EAAE;IACX,MAAM;MAACC,IAAI;MAAEC;IAAK,CAAC,GAAG,MAAMH,QAAQ,CAACI,IAAI,CAAC,CAAC;IAC3C,IAAIF,IAAI,EAAE;MACRF,QAAQ,CAACK,MAAM,CAAC,CAAC;MACjB;IACF;IACA,MAAMC,MAAM,GAAGL,OAAO,CAACE,KAAK,CAAC;IAC7B,IAAIG,MAAM,EAAE;MACV;IACF;EACF;AACF;AASA,OAAO,eAAeC,4BAA4BA,CAChDC,aAAiE,EAC3C;EACtB,MAAMC,YAA2B,GAAG,EAAE;EACtC,WAAW,MAAMC,KAAK,IAAIF,aAAa,EAAE;IACvCC,YAAY,CAACE,IAAI,CAACD,KAAK,CAAC;EAC1B;EACA,OAAOZ,uBAAuB,CAAC,GAAGW,YAAY,CAAC;AACjD;AAEA,OAAO,eAAeG,uBAAuBA,CAC3CJ,aAAuD,EACtC;EACjB,MAAMK,OAAiB,GAAG,EAAE;EAC5B,WAAW,MAAMH,KAAK,IAAIF,aAAa,EAAE;IACvCK,OAAO,CAACF,IAAI,CAACD,KAAK,CAAC;EACrB;EACA,OAAOG,OAAO,CAACC,IAAI,CAAC,EAAE,CAAC;AACzB"}

package/dist/esm/lib/iterators/text-iterators.js

@@ -0,0 +1,47 @@
+export function makeTextDecoderIterator(arrayBufferIterator) {
+  try {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    return async function* () {
+      const textDecoder = new TextDecoder(undefined, options);
+      for await (const arrayBuffer of arrayBufferIterator) {
+        yield typeof arrayBuffer === 'string' ? arrayBuffer : textDecoder.decode(arrayBuffer, {
+          stream: true
+        });
+      }
+    }();
+  } catch (e) {
+    return Promise.reject(e);
+  }
+}
+export async function* makeTextEncoderIterator(textIterator) {
+  const textEncoder = new TextEncoder();
+  for await (const text of textIterator) {
+    yield typeof text === 'string' ? textEncoder.encode(text) : text;
+  }
+}
+export async function* makeLineIterator(textIterator) {
+  let previous = '';
+  for await (const textChunk of textIterator) {
+    previous += textChunk;
+    let eolIndex;
+    while ((eolIndex = previous.indexOf('\n')) >= 0) {
+      const line = previous.slice(0, eolIndex + 1);
+      previous = previous.slice(eolIndex + 1);
+      yield line;
+    }
+  }
+  if (previous.length > 0) {
+    yield previous;
+  }
+}
+export async function* makeNumberedLineIterator(lineIterator) {
+  let counter = 1;
+  for await (const line of lineIterator) {
+    yield {
+      counter,
+      line
+    };
+    counter++;
+  }
+}
+//# sourceMappingURL=text-iterators.js.map

package/dist/esm/lib/iterators/text-iterators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-iterators.js","names":["makeTextDecoderIterator","arrayBufferIterator","options","arguments","length","undefined","textDecoder","TextDecoder","arrayBuffer","decode","stream","e","Promise","reject","makeTextEncoderIterator","textIterator","textEncoder","TextEncoder","text","encode","makeLineIterator","previous","textChunk","eolIndex","indexOf","line","slice","makeNumberedLineIterator","lineIterator","counter"],"sources":["../../../../src/lib/iterators/text-iterators.ts"],"sourcesContent":["// TextDecoder iterators\n// TextDecoder will keep any partial undecoded bytes between calls to `decode`\n\nexport async function* makeTextDecoderIterator(\n  arrayBufferIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,\n  options: TextDecoderOptions = {}\n): AsyncIterable<string> {\n  const textDecoder = new TextDecoder(undefined, options);\n  for await (const arrayBuffer of arrayBufferIterator) {\n    yield typeof arrayBuffer === 'string'\n      ? arrayBuffer\n      : textDecoder.decode(arrayBuffer, {stream: true});\n  }\n}\n\n// TextEncoder iterator\n// TODO - this is not useful unless min chunk size is given\n// TextEncoder will keep any partial undecoded bytes between calls to `encode`\n// If iterator does not yield strings, assume arrayBuffer and return unencoded\n\nexport async function* makeTextEncoderIterator(\n  textIterator: AsyncIterable<string> | Iterable<ArrayBuffer>\n): AsyncIterable<ArrayBuffer> {\n  const textEncoder = new TextEncoder();\n  for await (const text of textIterator) {\n    yield typeof text === 'string' ? textEncoder.encode(text) : text;\n  }\n}\n\n/**\n * @param textIterator async iterable yielding strings\n * @returns an async iterable over lines\n * See http://2ality.com/2018/04/async-iter-nodejs.html\n */\n\nexport async function* makeLineIterator(\n  textIterator: AsyncIterable<string>\n): AsyncIterable<string> {\n  let previous = '';\n  for await (const textChunk of textIterator) {\n    previous += textChunk;\n    let eolIndex;\n    while ((eolIndex = previous.indexOf('\\n')) >= 0) {\n      // line includes the EOL\n      const line = previous.slice(0, eolIndex + 1);\n      previous = previous.slice(eolIndex + 1);\n      yield line;\n    }\n  }\n\n  if (previous.length > 0) {\n    yield previous;\n  }\n}\n\n/**\n * @param lineIterator async iterable yielding lines\n * @returns async iterable yielding numbered lines\n *\n * See http://2ality.com/2018/04/async-iter-nodejs.html\n */\nexport async function* makeNumberedLineIterator(\n  lineIterator: AsyncIterable<string>\n): AsyncIterable<{counter: number; line: string}> {\n  let counter = 1;\n  for await (const line of lineIterator) {\n    yield {counter, line};\n    counter++;\n  }\n}\n"],"mappings":"AAGA,OAAO,SAAgBA,uBAAuBA,CAC5CC,mBAAuE;EAAA;IAAA,IACvEC,OAA2B,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;IAAA,0BACT;MACvB,MAAMG,WAAW,GAAG,IAAIC,WAAW,CAACF,SAAS,EAAEH,OAAO,CAAC;MACvD,WAAW,MAAMM,WAAW,IAAIP,mBAAmB,EAAE;QACnD,MAAM,OAAOO,WAAW,KAAK,QAAQ,GACjCA,WAAW,GACXF,WAAW,CAACG,MAAM,CAACD,WAAW,EAAE;UAACE,MAAM,EAAE;QAAI,CAAC,CAAC;MACrD;IACF,CAAC;EAAA,SAAAC,CAAA;IAAA,OAAAC,OAAA,CAAAC,MAAA,CAAAF,CAAA;EAAA;AAAA;AAOD,OAAO,gBAAgBG,uBAAuBA,CAC5CC,YAA2D,EAC/B;EAC5B,MAAMC,WAAW,GAAG,IAAIC,WAAW,CAAC,CAAC;EACrC,WAAW,MAAMC,IAAI,IAAIH,YAAY,EAAE;IACrC,MAAM,OAAOG,IAAI,KAAK,QAAQ,GAAGF,WAAW,CAACG,MAAM,CAACD,IAAI,CAAC,GAAGA,IAAI;EAClE;AACF;AAQA,OAAO,gBAAgBE,gBAAgBA,CACrCL,YAAmC,EACZ;EACvB,IAAIM,QAAQ,GAAG,EAAE;EACjB,WAAW,MAAMC,SAAS,IAAIP,YAAY,EAAE;IAC1CM,QAAQ,IAAIC,SAAS;IACrB,IAAIC,QAAQ;IACZ,OAAO,CAACA,QAAQ,GAAGF,QAAQ,CAACG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;MAE/C,MAAMC,IAAI,GAAGJ,QAAQ,CAACK,KAAK,CAAC,CAAC,EAAEH,QAAQ,GAAG,CAAC,CAAC;MAC5CF,QAAQ,GAAGA,QAAQ,CAACK,KAAK,CAACH,QAAQ,GAAG,CAAC,CAAC;MACvC,MAAME,IAAI;IACZ;EACF;EAEA,IAAIJ,QAAQ,CAACjB,MAAM,GAAG,CAAC,EAAE;IACvB,MAAMiB,QAAQ;EAChB;AACF;AAQA,OAAO,gBAAgBM,wBAAwBA,CAC7CC,YAAmC,EACa;EAChD,IAAIC,OAAO,GAAG,CAAC;EACf,WAAW,MAAMJ,IAAI,IAAIG,YAAY,EAAE;IACrC,MAAM;MAACC,OAAO;MAAEJ;IAAI,CAAC;IACrBI,OAAO,EAAE;EACX;AACF"}

package/dist/esm/lib/node/buffer.browser.js

@@ -0,0 +1,7 @@
+export function toArrayBuffer(buffer) {
+  return buffer;
+}
+export function toBuffer(binaryData) {
+  throw new Error('Buffer not supported in browser');
+}
+//# sourceMappingURL=buffer.browser.js.map

package/dist/esm/lib/node/buffer.browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer.browser.js","names":["toArrayBuffer","buffer","toBuffer","binaryData","Error"],"sources":["../../../../src/lib/node/buffer.browser.ts"],"sourcesContent":["// loaders.gl, MIT license\n\n// Isolates Buffer references to ensure they are only bundled under Node.js (avoids big webpack polyfill)\n// this file is selected by the package.json \"browser\" field).\n\n/**\n * Convert Buffer to ArrayBuffer\n * Converts Node.js `Buffer` to `ArrayBuffer` (without triggering bundler to include Buffer polyfill on browser)\n * @todo better data type\n */\nexport function toArrayBuffer(buffer) {\n  return buffer;\n}\n\n/**\n * Convert (copy) ArrayBuffer to Buffer\n */\nexport function toBuffer(binaryData: ArrayBuffer | ArrayBuffer | Buffer): Buffer {\n  throw new Error('Buffer not supported in browser');\n}\n"],"mappings":"AAUA,OAAO,SAASA,aAAaA,CAACC,MAAM,EAAE;EACpC,OAAOA,MAAM;AACf;AAKA,OAAO,SAASC,QAAQA,CAACC,UAA8C,EAAU;EAC/E,MAAM,IAAIC,KAAK,CAAC,iCAAiC,CAAC;AACpD"}

package/dist/esm/lib/node/buffer.js

@@ -0,0 +1,20 @@
+export function toArrayBuffer(buffer) {
+  if (Buffer.isBuffer(buffer)) {
+    const typedArray = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.length);
+    return typedArray.slice().buffer;
+  }
+  return buffer;
+}
+export function toBuffer(binaryData) {
+  if (Buffer.isBuffer(binaryData)) {
+    return binaryData;
+  }
+  if (ArrayBuffer.isView(binaryData)) {
+    binaryData = binaryData.buffer;
+  }
+  if (typeof Buffer !== 'undefined' && binaryData instanceof ArrayBuffer) {
+    return Buffer.from(binaryData);
+  }
+  throw new Error('toBuffer');
+}
+//# sourceMappingURL=buffer.js.map

package/dist/esm/lib/node/buffer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer.js","names":["toArrayBuffer","buffer","Buffer","isBuffer","typedArray","Uint8Array","byteOffset","length","slice","toBuffer","binaryData","ArrayBuffer","isView","from","Error"],"sources":["../../../../src/lib/node/buffer.ts"],"sourcesContent":["// loaders.gl, MIT license\n\n// Isolates Buffer references to ensure they are only bundled under Node.js (avoids big webpack polyfill)\n// this file is selected by the package.json \"browser\" field).\n\n/**\n * Convert Buffer to ArrayBuffer\n * Converts Node.js `Buffer` to `ArrayBuffer` (without triggering bundler to include Buffer polyfill on browser)\n * @todo better data type\n */\nexport function toArrayBuffer(buffer) {\n  // TODO - per docs we should just be able to call buffer.buffer, but there are issues\n  if (Buffer.isBuffer(buffer)) {\n    const typedArray = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.length);\n    return typedArray.slice().buffer;\n  }\n  return buffer;\n}\n\n/**\n * Convert (copy) ArrayBuffer to Buffer\n */\nexport function toBuffer(binaryData: ArrayBuffer | ArrayBuffer | Buffer): Buffer {\n  if (Buffer.isBuffer(binaryData)) {\n    return binaryData;\n  }\n\n  if (ArrayBuffer.isView(binaryData)) {\n    binaryData = binaryData.buffer;\n  }\n\n  if (typeof Buffer !== 'undefined' && binaryData instanceof ArrayBuffer) {\n    return Buffer.from(binaryData);\n  }\n\n  throw new Error('toBuffer');\n}\n"],"mappings":"AAUA,OAAO,SAASA,aAAaA,CAACC,MAAM,EAAE;EAEpC,IAAIC,MAAM,CAACC,QAAQ,CAACF,MAAM,CAAC,EAAE;IAC3B,MAAMG,UAAU,GAAG,IAAIC,UAAU,CAACJ,MAAM,CAACA,MAAM,EAAEA,MAAM,CAACK,UAAU,EAAEL,MAAM,CAACM,MAAM,CAAC;IAClF,OAAOH,UAAU,CAACI,KAAK,CAAC,CAAC,CAACP,MAAM;EAClC;EACA,OAAOA,MAAM;AACf;AAKA,OAAO,SAASQ,QAAQA,CAACC,UAA8C,EAAU;EAC/E,IAAIR,MAAM,CAACC,QAAQ,CAACO,UAAU,CAAC,EAAE;IAC/B,OAAOA,UAAU;EACnB;EAEA,IAAIC,WAAW,CAACC,MAAM,CAACF,UAAU,CAAC,EAAE;IAClCA,UAAU,GAAGA,UAAU,CAACT,MAAM;EAChC;EAEA,IAAI,OAAOC,MAAM,KAAK,WAAW,IAAIQ,UAAU,YAAYC,WAAW,EAAE;IACtE,OAAOT,MAAM,CAACW,IAAI,CAACH,UAAU,CAAC;EAChC;EAEA,MAAM,IAAII,KAAK,CAAC,UAAU,CAAC;AAC7B"}

package/dist/esm/lib/node/fs.js

@@ -0,0 +1,40 @@
+import fs from 'fs';
+import { toArrayBuffer } from './buffer';
+import { promisify2, promisify3 } from './promisify';
+export let readdir;
+export let stat;
+export let readFile;
+export let readFileSync;
+export let writeFile;
+export let writeFileSync;
+export let open;
+export let close;
+export let read;
+export let fstat;
+export let createWriteStream;
+export let isSupported = Boolean(fs);
+try {
+  readdir = promisify2(fs.readdir);
+  stat = promisify2(fs.stat);
+  readFile = fs.readFile;
+  readFileSync = fs.readFileSync;
+  writeFile = promisify3(fs.writeFile);
+  writeFileSync = fs.writeFileSync;
+  open = fs.open;
+  close = fd => new Promise((resolve, reject) => fs.close(fd, err => err ? reject(err) : resolve()));
+  read = fs.read;
+  fstat = fs.fstat;
+  createWriteStream = fs.createWriteStream;
+  isSupported = Boolean(fs);
+} catch {}
+export async function _readToArrayBuffer(fd, start, length) {
+  const buffer = Buffer.alloc(length);
+  const {
+    bytesRead
+  } = await read(fd, buffer, 0, length, start);
+  if (bytesRead !== length) {
+    throw new Error('fs.read failed');
+  }
+  return toArrayBuffer(buffer);
+}
+//# sourceMappingURL=fs.js.map

package/dist/esm/lib/node/fs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs.js","names":["fs","toArrayBuffer","promisify2","promisify3","readdir","stat","readFile","readFileSync","writeFile","writeFileSync","open","close","read","fstat","createWriteStream","isSupported","Boolean","fd","Promise","resolve","reject","err","_readToArrayBuffer","start","length","buffer","Buffer","alloc","bytesRead","Error"],"sources":["../../../../src/lib/node/fs.ts"],"sourcesContent":["// fs wrapper (promisified fs + avoids bundling fs in browsers)\nimport fs from 'fs';\nimport {toArrayBuffer} from './buffer';\nimport {promisify2, promisify3} from './promisify';\n\nexport type {Stats, WriteStream} from 'fs';\n\nexport let readdir;\n/** Wrapper for Node.js fs method */\nexport let stat;\n\n/** Wrapper for Node.js fs method */\nexport let readFile;\n/** Wrapper for Node.js fs method */\nexport let readFileSync;\n/** Wrapper for Node.js fs method */\nexport let writeFile;\n/** Wrapper for Node.js fs method */\nexport let writeFileSync;\n\n// file descriptors\n\n/** Wrapper for Node.js fs method */\nexport let open;\n/** Wrapper for Node.js fs method */\nexport let close: (fd: number) => Promise<void>;\n/** Wrapper for Node.js fs method */\nexport let read;\n/** Wrapper for Node.js fs method */\nexport let fstat;\n\nexport let createWriteStream: typeof fs.createWriteStream;\n\nexport let isSupported = Boolean(fs);\n\n// paths\n\ntry {\n  /** Wrapper for Node.js fs method */\n  readdir = promisify2(fs.readdir);\n  /** Wrapper for Node.js fs method */\n  stat = promisify2(fs.stat);\n\n  /** Wrapper for Node.js fs method */\n  readFile = fs.readFile;\n  /** Wrapper for Node.js fs method */\n  readFileSync = fs.readFileSync;\n  /** Wrapper for Node.js fs method */\n  writeFile = promisify3(fs.writeFile);\n  /** Wrapper for Node.js fs method */\n  writeFileSync = fs.writeFileSync;\n\n  // file descriptors\n\n  /** Wrapper for Node.js fs method */\n  open = fs.open;\n  /** Wrapper for Node.js fs method */\n  close = (fd: number) =>\n    new Promise((resolve, reject) => fs.close(fd, (err) => (err ? reject(err) : resolve())));\n  /** Wrapper for Node.js fs method */\n  read = fs.read;\n  /** Wrapper for Node.js fs method */\n  fstat = fs.fstat;\n\n  createWriteStream = fs.createWriteStream;\n\n  isSupported = Boolean(fs);\n} catch {\n  // ignore\n}\n\nexport async function _readToArrayBuffer(fd: number, start: number, length: number) {\n  const buffer = Buffer.alloc(length);\n  const {bytesRead} = await read(fd, buffer, 0, length, start);\n  if (bytesRead !== length) {\n    throw new Error('fs.read failed');\n  }\n  return toArrayBuffer(buffer);\n}\n"],"mappings":"AACA,OAAOA,EAAE,MAAM,IAAI;AACnB,SAAQC,aAAa,QAAO,UAAU;AACtC,SAAQC,UAAU,EAAEC,UAAU,QAAO,aAAa;AAIlD,OAAO,IAAIC,OAAO;AAElB,OAAO,IAAIC,IAAI;AAGf,OAAO,IAAIC,QAAQ;AAEnB,OAAO,IAAIC,YAAY;AAEvB,OAAO,IAAIC,SAAS;AAEpB,OAAO,IAAIC,aAAa;AAKxB,OAAO,IAAIC,IAAI;AAEf,OAAO,IAAIC,KAAoC;AAE/C,OAAO,IAAIC,IAAI;AAEf,OAAO,IAAIC,KAAK;AAEhB,OAAO,IAAIC,iBAA8C;AAEzD,OAAO,IAAIC,WAAW,GAAGC,OAAO,CAAChB,EAAE,CAAC;AAIpC,IAAI;EAEFI,OAAO,GAAGF,UAAU,CAACF,EAAE,CAACI,OAAO,CAAC;EAEhCC,IAAI,GAAGH,UAAU,CAACF,EAAE,CAACK,IAAI,CAAC;EAG1BC,QAAQ,GAAGN,EAAE,CAACM,QAAQ;EAEtBC,YAAY,GAAGP,EAAE,CAACO,YAAY;EAE9BC,SAAS,GAAGL,UAAU,CAACH,EAAE,CAACQ,SAAS,CAAC;EAEpCC,aAAa,GAAGT,EAAE,CAACS,aAAa;EAKhCC,IAAI,GAAGV,EAAE,CAACU,IAAI;EAEdC,KAAK,GAAIM,EAAU,IACjB,IAAIC,OAAO,CAAC,CAACC,OAAO,EAAEC,MAAM,KAAKpB,EAAE,CAACW,KAAK,CAACM,EAAE,EAAGI,GAAG,IAAMA,GAAG,GAAGD,MAAM,CAACC,GAAG,CAAC,GAAGF,OAAO,CAAC,CAAE,CAAC,CAAC;EAE1FP,IAAI,GAAGZ,EAAE,CAACY,IAAI;EAEdC,KAAK,GAAGb,EAAE,CAACa,KAAK;EAEhBC,iBAAiB,GAAGd,EAAE,CAACc,iBAAiB;EAExCC,WAAW,GAAGC,OAAO,CAAChB,EAAE,CAAC;AAC3B,CAAC,CAAC,MAAM,CAER;AAEA,OAAO,eAAesB,kBAAkBA,CAACL,EAAU,EAAEM,KAAa,EAAEC,MAAc,EAAE;EAClF,MAAMC,MAAM,GAAGC,MAAM,CAACC,KAAK,CAACH,MAAM,CAAC;EACnC,MAAM;IAACI;EAAS,CAAC,GAAG,MAAMhB,IAAI,CAACK,EAAE,EAAEQ,MAAM,EAAE,CAAC,EAAED,MAAM,EAAED,KAAK,CAAC;EAC5D,IAAIK,SAAS,KAAKJ,MAAM,EAAE;IACxB,MAAM,IAAIK,KAAK,CAAC,gBAAgB,CAAC;EACnC;EACA,OAAO5B,aAAa,CAACwB,MAAM,CAAC;AAC9B"}

package/dist/esm/lib/node/promisify.js

@@ -0,0 +1,10 @@
+export function promisify1(fn) {
+  return args => new Promise((resolve, reject) => fn(args, (error, callbackArgs) => error ? reject(error) : resolve(callbackArgs)));
+}
+export function promisify2(fn) {
+  return (arg1, arg2) => new Promise((resolve, reject) => fn(arg1, arg2, (error, callbackArgs) => error ? reject(error) : resolve(callbackArgs)));
+}
+export function promisify3(fn) {
+  return (arg1, arg2, arg3) => new Promise((resolve, reject) => fn(arg1, arg2, arg3, (error, callbackArgs) => error ? reject(error) : resolve(callbackArgs)));
+}
+//# sourceMappingURL=promisify.js.map

package/dist/esm/lib/node/promisify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"promisify.js","names":["promisify1","fn","args","Promise","resolve","reject","error","callbackArgs","promisify2","arg1","arg2","promisify3","arg3"],"sources":["../../../../src/lib/node/promisify.ts"],"sourcesContent":["// @loaders.gl, MIT license\n\n// type Parameter1<T extends (arg1: any, ...args: unknown[]) => unknown> = T extends (\n//   arg1: infer P,\n//   ...args: unknown[]\n// ) => unknown\n//   ? P\n//   : never;\n\n//   type Parameter2<T extends (arg1: unknown, arg2: any, ...args: unknown[]) => unknown> = T extends (\n//   arg1: unknown,\n//   arg2: infer P,\n//   ...args: unknown[]\n// ) => unknown\n//   ? P\n//   : never;\n\n// type CallbackParameter2<\n//   T extends (arg: unknown, cb: (error: any, value: any) => void) => unknown\n// > = T extends (arg: unknown, cb: (error: any, value: infer P) => void) => unknown ? P : never;\n\n// type CallbackParameter3<\n//   T extends (arg: unknown, arg2: unknown, cb: (error: any, value: any) => void) => unknown\n// > = T extends (arg: unknown, arg2: unknown, cb: (error: any, value: infer P) => void) => unknown\n//   ? P\n//   : never;\n\n// /** Extract the parameters of a function type in a tuple */\n// export type Promisified<F extends (arg1, cb: (error: unknown, value: any) => void) => any> = (\n//   arg1: Parameter1<F>\n// ) => Promise<CallbackParameter2<F>>;\n// /** Extract the parameters of a function type in a tuple */\n// export type Promisified2<F extends (arg1, arg2, cb: (error: unknown, value: any) => void) => any> = (\n//   arg1: Parameter1<F>,\n//   arg2: Parameter2<F>\n// ) => Promise<CallbackParameter3<F>>;\n\n/** Wrapper for Node.js promisify */\ntype Callback<A> = (error: unknown, args: A) => void;\n\n/**\n * Typesafe promisify implementation\n * @link https://dev.to/_gdelgado/implement-a-type-safe-version-of-node-s-promisify-in-7-lines-of-code-in-typescript-2j34\n * @param fn\n * @returns\n */\nexport function promisify1<T, A>(fn: (args: T, cb: Callback<A>) => void): (args: T) => Promise<A> {\n  return (args: T) =>\n    new Promise((resolve, reject) =>\n      fn(args, (error, callbackArgs) => (error ? reject(error) : resolve(callbackArgs)))\n    );\n}\n\nexport function promisify2<T1, T2, A>(\n  fn: (arg1: T1, arg2: T2, cb: Callback<A>) => void\n): (arg1: T1, arg2: T2) => Promise<A> {\n  return (arg1: T1, arg2: T2) =>\n    new Promise((resolve, reject) =>\n      fn(arg1, arg2, (error, callbackArgs) => (error ? reject(error) : resolve(callbackArgs)))\n    );\n}\n\nexport function promisify3<T1, T2, T3, A>(\n  fn: (arg1: T1, arg2: T2, arg3: T3, cb: Callback<A>) => void\n): (arg1: T1, arg2: T2, arg3: T3) => Promise<A> {\n  return (arg1: T1, arg2: T2, arg3: T3) =>\n    new Promise((resolve, reject) =>\n      fn(arg1, arg2, arg3, (error, callbackArgs) => (error ? reject(error) : resolve(callbackArgs)))\n    );\n}\n"],"mappings":"AA8CA,OAAO,SAASA,UAAUA,CAAOC,EAAsC,EAA2B;EAChG,OAAQC,IAAO,IACb,IAAIC,OAAO,CAAC,CAACC,OAAO,EAAEC,MAAM,KAC1BJ,EAAE,CAACC,IAAI,EAAE,CAACI,KAAK,EAAEC,YAAY,KAAMD,KAAK,GAAGD,MAAM,CAACC,KAAK,CAAC,GAAGF,OAAO,CAACG,YAAY,CAAE,CACnF,CAAC;AACL;AAEA,OAAO,SAASC,UAAUA,CACxBP,EAAiD,EACb;EACpC,OAAO,CAACQ,IAAQ,EAAEC,IAAQ,KACxB,IAAIP,OAAO,CAAC,CAACC,OAAO,EAAEC,MAAM,KAC1BJ,EAAE,CAACQ,IAAI,EAAEC,IAAI,EAAE,CAACJ,KAAK,EAAEC,YAAY,KAAMD,KAAK,GAAGD,MAAM,CAACC,KAAK,CAAC,GAAGF,OAAO,CAACG,YAAY,CAAE,CACzF,CAAC;AACL;AAEA,OAAO,SAASI,UAAUA,CACxBV,EAA2D,EACb;EAC9C,OAAO,CAACQ,IAAQ,EAAEC,IAAQ,EAAEE,IAAQ,KAClC,IAAIT,OAAO,CAAC,CAACC,OAAO,EAAEC,MAAM,KAC1BJ,EAAE,CAACQ,IAAI,EAAEC,IAAI,EAAEE,IAAI,EAAE,CAACN,KAAK,EAAEC,YAAY,KAAMD,KAAK,GAAGD,MAAM,CAACC,KAAK,CAAC,GAAGF,OAAO,CAACG,YAAY,CAAE,CAC/F,CAAC;AACL"}

package/dist/esm/lib/node/stream.js

@@ -0,0 +1,7 @@
+import stream from 'stream';
+export let Transform;
+export const isSupported = Boolean(stream);
+try {
+  Transform = stream.Transform;
+} catch {}
+//# sourceMappingURL=stream.js.map

package/dist/esm/lib/node/stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.js","names":["stream","Transform","isSupported","Boolean"],"sources":["../../../../src/lib/node/stream.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport stream from 'stream';\n\nexport type {Writable} from 'stream';\n\nexport let Transform;\n\nexport const isSupported = Boolean(stream);\n\n// paths\n\ntry {\n  /** Wrapper for Node.js fs method */\n  Transform = stream.Transform;\n} catch {\n  // ignore\n}\n"],"mappings":"AAEA,OAAOA,MAAM,MAAM,QAAQ;AAI3B,OAAO,IAAIC,SAAS;AAEpB,OAAO,MAAMC,WAAW,GAAGC,OAAO,CAACH,MAAM,CAAC;AAI1C,IAAI;EAEFC,SAAS,GAAGD,MAAM,CAACC,SAAS;AAC9B,CAAC,CAAC,MAAM,CAER"}

package/dist/esm/lib/option-utils/merge-loader-options.js

@@ -0,0 +1,17 @@
+export function mergeLoaderOptions(baseOptions, newOptions) {
+  return mergeOptionsRecursively(baseOptions || {}, newOptions);
+}
+function mergeOptionsRecursively(baseOptions, newOptions) {
+  const options = {
+    ...baseOptions
+  };
+  for (const [key, newValue] of Object.entries(newOptions)) {
+    if (newValue && typeof newValue === 'object') {
+      options[key] = mergeOptionsRecursively(options[key] || {}, newOptions[key]);
+    } else {
+      options[key] = newOptions[key];
+    }
+  }
+  return options;
+}
+//# sourceMappingURL=merge-loader-options.js.map

package/dist/esm/lib/option-utils/merge-loader-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-loader-options.js","names":["mergeLoaderOptions","baseOptions","newOptions","mergeOptionsRecursively","options","key","newValue","Object","entries"],"sources":["../../../../src/lib/option-utils/merge-loader-options.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport {LoaderOptions} from '../../types';\n\n/**\n *\n * @param baseOptions Can be undefined, in which case a fresh options object will be minted\n * @param newOptions\n * @returns\n */\nexport function mergeLoaderOptions<Options extends LoaderOptions>(\n  baseOptions: Options | undefined,\n  newOptions: Options\n): Options {\n  return mergeOptionsRecursively(baseOptions || {}, newOptions) as Options;\n}\n\nfunction mergeOptionsRecursively(\n  baseOptions: Record<string, unknown>,\n  newOptions: Record<string, unknown>\n): Record<string, unknown> {\n  const options = {...baseOptions};\n  for (const [key, newValue] of Object.entries(newOptions)) {\n    if (newValue && typeof newValue === 'object') {\n      options[key] = mergeOptionsRecursively(\n        (options[key] as Record<string, unknown>) || {},\n        newOptions[key] as Record<string, unknown>\n      );\n      // Object.assign(options[key] as object, newOptions[key]);\n    } else {\n      options[key] = newOptions[key];\n    }\n  }\n  return options as Record<string, unknown>;\n}\n"],"mappings":"AAUA,OAAO,SAASA,kBAAkBA,CAChCC,WAAgC,EAChCC,UAAmB,EACV;EACT,OAAOC,uBAAuB,CAACF,WAAW,IAAI,CAAC,CAAC,EAAEC,UAAU,CAAC;AAC/D;AAEA,SAASC,uBAAuBA,CAC9BF,WAAoC,EACpCC,UAAmC,EACV;EACzB,MAAME,OAAO,GAAG;IAAC,GAAGH;EAAW,CAAC;EAChC,KAAK,MAAM,CAACI,GAAG,EAAEC,QAAQ,CAAC,IAAIC,MAAM,CAACC,OAAO,CAACN,UAAU,CAAC,EAAE;IACxD,IAAII,QAAQ,IAAI,OAAOA,QAAQ,KAAK,QAAQ,EAAE;MAC5CF,OAAO,CAACC,GAAG,CAAC,GAAGF,uBAAuB,CACnCC,OAAO,CAACC,GAAG,CAAC,IAAgC,CAAC,CAAC,EAC/CH,UAAU,CAACG,GAAG,CAChB,CAAC;IAEH,CAAC,MAAM;MACLD,OAAO,CAACC,GAAG,CAAC,GAAGH,UAAU,CAACG,GAAG,CAAC;IAChC;EACF;EACA,OAAOD,OAAO;AAChB"}

package/dist/esm/lib/parser-utils/parse-json.js

@@ -0,0 +1,9 @@
+import { getFirstCharacters } from '../binary-utils/get-first-characters';
+export function parseJSON(string) {
+  try {
+    return JSON.parse(string);
+  } catch (_) {
+    throw new Error("Failed to parse JSON from data starting with \"".concat(getFirstCharacters(string), "\""));
+  }
+}
+//# sourceMappingURL=parse-json.js.map

package/dist/esm/lib/parser-utils/parse-json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-json.js","names":["getFirstCharacters","parseJSON","string","JSON","parse","_","Error","concat"],"sources":["../../../../src/lib/parser-utils/parse-json.ts"],"sourcesContent":["import {getFirstCharacters} from '../binary-utils/get-first-characters';\n\n/**\n * Minimal JSON parser that throws more meaningful error messages\n */\nexport function parseJSON(string: string): any {\n  try {\n    return JSON.parse(string);\n  } catch (_) {\n    throw new Error(`Failed to parse JSON from data starting with \"${getFirstCharacters(string)}\"`);\n  }\n}\n"],"mappings":"AAAA,SAAQA,kBAAkB,QAAO,sCAAsC;AAKvE,OAAO,SAASC,SAASA,CAACC,MAAc,EAAO;EAC7C,IAAI;IACF,OAAOC,IAAI,CAACC,KAAK,CAACF,MAAM,CAAC;EAC3B,CAAC,CAAC,OAAOG,CAAC,EAAE;IACV,MAAM,IAAIC,KAAK,mDAAAC,MAAA,CAAkDP,kBAAkB,CAACE,MAAM,CAAC,OAAG,CAAC;EACjG;AACF"}

package/dist/esm/lib/path-utils/file-aliases.js

@@ -0,0 +1,24 @@
+let pathPrefix = '';
+const fileAliases = {};
+export function setPathPrefix(prefix) {
+  pathPrefix = prefix;
+}
+export function getPathPrefix() {
+  return pathPrefix;
+}
+export function addAliases(aliases) {
+  Object.assign(fileAliases, aliases);
+}
+export function resolvePath(filename) {
+  for (const alias in fileAliases) {
+    if (filename.startsWith(alias)) {
+      const replacement = fileAliases[alias];
+      filename = filename.replace(alias, replacement);
+    }
+  }
+  if (!filename.startsWith('http://') && !filename.startsWith('https://')) {
+    filename = "".concat(pathPrefix).concat(filename);
+  }
+  return filename;
+}
+//# sourceMappingURL=file-aliases.js.map

package/dist/esm/lib/path-utils/file-aliases.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-aliases.js","names":["pathPrefix","fileAliases","setPathPrefix","prefix","getPathPrefix","addAliases","aliases","Object","assign","resolvePath","filename","alias","startsWith","replacement","replace","concat"],"sources":["../../../../src/lib/path-utils/file-aliases.ts"],"sourcesContent":["// Simple file alias mechanisms for tests.\n\nlet pathPrefix = '';\nconst fileAliases: {[aliasPath: string]: string} = {};\n\n/*\n * Set a relative path prefix\n */\nexport function setPathPrefix(prefix: string): void {\n  pathPrefix = prefix;\n}\n\n/*\n * Get the relative path prefix\n */\nexport function getPathPrefix(): string {\n  return pathPrefix;\n}\n\n/**\n *\n * @param aliases\n *\n * Note: addAliases are an experimental export, they are only for testing of loaders.gl loaders\n * not intended as a generic aliasing mechanism\n */\nexport function addAliases(aliases: {[aliasPath: string]: string}): void {\n  Object.assign(fileAliases, aliases);\n}\n\n/**\n * Resolves aliases and adds path-prefix to paths\n */\nexport function resolvePath(filename: string): string {\n  for (const alias in fileAliases) {\n    if (filename.startsWith(alias)) {\n      const replacement = fileAliases[alias];\n      filename = filename.replace(alias, replacement);\n    }\n  }\n  if (!filename.startsWith('http://') && !filename.startsWith('https://')) {\n    filename = `${pathPrefix}${filename}`;\n  }\n  return filename;\n}\n"],"mappings":"AAEA,IAAIA,UAAU,GAAG,EAAE;AACnB,MAAMC,WAA0C,GAAG,CAAC,CAAC;AAKrD,OAAO,SAASC,aAAaA,CAACC,MAAc,EAAQ;EAClDH,UAAU,GAAGG,MAAM;AACrB;AAKA,OAAO,SAASC,aAAaA,CAAA,EAAW;EACtC,OAAOJ,UAAU;AACnB;AASA,OAAO,SAASK,UAAUA,CAACC,OAAsC,EAAQ;EACvEC,MAAM,CAACC,MAAM,CAACP,WAAW,EAAEK,OAAO,CAAC;AACrC;AAKA,OAAO,SAASG,WAAWA,CAACC,QAAgB,EAAU;EACpD,KAAK,MAAMC,KAAK,IAAIV,WAAW,EAAE;IAC/B,IAAIS,QAAQ,CAACE,UAAU,CAACD,KAAK,CAAC,EAAE;MAC9B,MAAME,WAAW,GAAGZ,WAAW,CAACU,KAAK,CAAC;MACtCD,QAAQ,GAAGA,QAAQ,CAACI,OAAO,CAACH,KAAK,EAAEE,WAAW,CAAC;IACjD;EACF;EACA,IAAI,CAACH,QAAQ,CAACE,UAAU,CAAC,SAAS,CAAC,IAAI,CAACF,QAAQ,CAACE,UAAU,CAAC,UAAU,CAAC,EAAE;IACvEF,QAAQ,MAAAK,MAAA,CAAMf,UAAU,EAAAe,MAAA,CAAGL,QAAQ,CAAE;EACvC;EACA,OAAOA,QAAQ;AACjB"}

package/dist/esm/lib/path-utils/get-cwd.js

@@ -0,0 +1,9 @@
+export function getCWD() {
+  var _window$location;
+  if (typeof process !== 'undefined' && typeof process.cwd !== 'undefined') {
+    return process.cwd();
+  }
+  const pathname = (_window$location = window.location) === null || _window$location === void 0 ? void 0 : _window$location.pathname;
+  return (pathname === null || pathname === void 0 ? void 0 : pathname.slice(0, pathname.lastIndexOf('/') + 1)) || '';
+}
+//# sourceMappingURL=get-cwd.js.map

package/dist/esm/lib/path-utils/get-cwd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-cwd.js","names":["getCWD","_window$location","process","cwd","pathname","window","location","slice","lastIndexOf"],"sources":["../../../../src/lib/path-utils/get-cwd.ts"],"sourcesContent":["// loaders.gl MIT license\n\nexport function getCWD() {\n  if (typeof process !== 'undefined' && typeof process.cwd !== 'undefined') {\n    return process.cwd();\n  }\n  const pathname = window.location?.pathname;\n  return pathname?.slice(0, pathname.lastIndexOf('/') + 1) || '';\n}\n"],"mappings":"AAEA,OAAO,SAASA,MAAMA,CAAA,EAAG;EAAA,IAAAC,gBAAA;EACvB,IAAI,OAAOC,OAAO,KAAK,WAAW,IAAI,OAAOA,OAAO,CAACC,GAAG,KAAK,WAAW,EAAE;IACxE,OAAOD,OAAO,CAACC,GAAG,CAAC,CAAC;EACtB;EACA,MAAMC,QAAQ,IAAAH,gBAAA,GAAGI,MAAM,CAACC,QAAQ,cAAAL,gBAAA,uBAAfA,gBAAA,CAAiBG,QAAQ;EAC1C,OAAO,CAAAA,QAAQ,aAARA,QAAQ,uBAARA,QAAQ,CAAEG,KAAK,CAAC,CAAC,EAAEH,QAAQ,CAACI,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,KAAI,EAAE;AAChE"}