@loaders.gl/loader-utils 3.3.0-alpha.12 → 3.3.0-alpha.14

package/src/lib/binary-utils/memory-conversion-utils.ts

@@ -0,0 +1,53 @@
+// loaders.gl, MIT license
+
+import * as node from '../node/buffer';
+
+/**
+ * Check for Node.js `Buffer` (without triggering bundler to include Buffer polyfill on browser)
+ */
+export function isBuffer(value: any): boolean {
+  return value && typeof value === 'object' && value.isBuffer;
+}
+
+/**
+ * Converts to Node.js `Buffer` (without triggering bundler to include Buffer polyfill on browser)
+ * @todo better data type
+ */
+export function toBuffer(data: any): Buffer {
+  return node.toBuffer ? node.toBuffer(data) : data;
+}
+
+/**
+ * Convert an object to an array buffer
+ */
+export function toArrayBuffer(data: unknown): ArrayBuffer {
+  // Note: Should be called first, Buffers can trigger other detections below
+  if (isBuffer(data)) {
+    return node.toArrayBuffer(data);
+  }
+
+  if (data instanceof ArrayBuffer) {
+    return data;
+  }
+
+  // Careful - Node Buffers look like Uint8Arrays (keep after isBuffer)
+  if (ArrayBuffer.isView(data)) {
+    if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
+      return data.buffer;
+    }
+    return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+  }
+
+  if (typeof data === 'string') {
+    const text = data;
+    const uint8Array = new TextEncoder().encode(text);
+    return uint8Array.buffer;
+  }
+
+  // HACK to support Blob polyfill
+  if (data && typeof data === 'object' && (data as any)._toArrayBuffer) {
+    return (data as any)._toArrayBuffer();
+  }
+
+  throw new Error('toArrayBuffer');
+}

package/src/lib/filesystems/readable-file.ts

@@ -0,0 +1,30 @@
+// loaders.gl, MIT license
+
+export type ReadableFile = {
+  read: (position: number, length: number) => Promise<Buffer>;
+  close: () => Promise<void>;
+  /** Length of file in bytes */
+  size: number;
+};
+
+/** Helper function to create an envelope reader for a binary memory input */
+export function makeReadableFile(data: Blob | ArrayBuffer): ReadableFile {
+  if (data instanceof ArrayBuffer) {
+    const arrayBuffer: ArrayBuffer = data;
+    return {
+      read: async (start: number, length: number) => Buffer.from(data, start, length),
+      close: async () => {},
+      size: arrayBuffer.byteLength
+    };
+  }
+
+  const blob: Blob = data;
+  return {
+    read: async (start: number, length: number) => {
+      const arrayBuffer = await blob.slice(start, start + length).arrayBuffer();
+      return Buffer.from(arrayBuffer);
+    },
+    close: async () => {},
+    size: blob.size
+  };
+}

package/src/lib/filesystems/writable-file.ts

@@ -0,0 +1,44 @@
+// Forked from https://github.com/kbajalc/parquets under MIT license (Copyright (c) 2017 ironSource Ltd.)
+import {isBrowser} from '@loaders.gl/loader-utils';
+import * as fs from '../node/fs';
+import type {Writable} from 'stream';
+
+export type WritableFile = {
+  write: (buf: Buffer) => Promise<void>;
+  close: () => Promise<void>;
+};
+
+export interface WriteStreamOptions {
+  flags?: string;
+  encoding?: 'utf8';
+  fd?: number;
+  mode?: number;
+  autoClose?: boolean;
+  start?: number;
+}
+
+/** Helper function to create an envelope reader for a binary memory input */
+export function makeWritableFile(
+  pathOrStream: string | Writable,
+  options?: WriteStreamOptions
+): WritableFile {
+  if (isBrowser) {
+    return {
+      write: async () => {},
+      close: async () => {}
+    };
+  }
+
+  const outputStream: Writable =
+    typeof pathOrStream === 'string' ? fs.createWriteStream(pathOrStream, options) : pathOrStream;
+  return {
+    write: async (buffer: Buffer) =>
+      new Promise((resolve, reject) => {
+        outputStream.write(buffer, (err) => (err ? reject(err) : resolve()));
+      }),
+    close: () =>
+      new Promise((resolve, reject) => {
+        (outputStream as any).close((err) => (err ? reject(err) : resolve()));
+      })
+  };
+}

package/src/lib/loader-utils/buffer-utils.ts

@@ -0,0 +1,18 @@
+/**
+ * Convert Buffer to ArrayBuffer
+ */
+export function toArrayBuffer(buffer: Buffer): ArrayBuffer {
+  // TODO - per docs we should just be able to call buffer.buffer, but there are issues
+  if (Buffer.isBuffer(buffer)) {
+    const typedArray = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.length);
+    return typedArray.slice().buffer;
+  }
+  return buffer;
+}
+
+/**
+ * Convert (copy) ArrayBuffer to Buffer
+ */
+export function toBuffer(arrayBuffer: ArrayBuffer): Buffer {
+  return Buffer.from(arrayBuffer);
+}

package/src/lib/node/buffer.ts

@@ -1,10 +1,10 @@
 // Isolates Buffer references to ensure they are only bundled under Node.js (avoids big webpack polyfill)
 // this file is not visible to webpack (it is excluded in the package.json "browser" field).
 
-import {assert} from '../env-utils/assert';
-
 /**
  * Convert Buffer to ArrayBuffer
+ * Converts Node.js `Buffer` to `ArrayBuffer` (without triggering bundler to include Buffer polyfill on browser)
+ * @todo better data type
  */
 export function toArrayBuffer(buffer) {
   // TODO - per docs we should just be able to call buffer.buffer, but there are issues
@@ -18,19 +18,18 @@ export function toArrayBuffer(buffer) {
 /**
  * Convert (copy) ArrayBuffer to Buffer
  */
-export function toBuffer(binaryData) {
+export function toBuffer(binaryData: ArrayBuffer | ArrayBuffer | Buffer): Buffer {
+  if (Buffer.isBuffer(binaryData)) {
+    return binaryData;
+  }
+
   if (ArrayBuffer.isView(binaryData)) {
     binaryData = binaryData.buffer;
   }
 
   if (typeof Buffer !== 'undefined' && binaryData instanceof ArrayBuffer) {
-    const buffer = new Buffer(binaryData.byteLength);
-    const view = new Uint8Array(binaryData);
-    for (let i = 0; i < buffer.length; ++i) {
-      buffer[i] = view[i];
-    }
-    return buffer;
+    return Buffer.from(binaryData);
   }
 
-  return assert(false);
+  throw new Error('toBuffer');
 }

package/src/lib/node/fs.ts

@@ -1,9 +1,9 @@
 // fs wrapper (promisified fs + avoids bundling fs in browsers)
 import fs from 'fs';
 import {toArrayBuffer} from './buffer';
-import {promisify1, promisify2} from './util';
+import {promisify2, promisify3} from './util';
 
-export type {Stats} from 'fs';
+export type {Stats, WriteStream} from 'fs';
 
 export let readdir;
 /** Wrapper for Node.js fs method */
@@ -23,41 +23,46 @@ export let writeFileSync;
 /** Wrapper for Node.js fs method */
 export let open;
 /** Wrapper for Node.js fs method */
-export let close;
+export let close: (fd: number) => Promise<void>;
 /** Wrapper for Node.js fs method */
 export let read;
 /** Wrapper for Node.js fs method */
 export let fstat;
 
+export let createWriteStream: typeof fs.createWriteStream;
+
 export let isSupported = Boolean(fs);
 
 // paths
 
 try {
   /** Wrapper for Node.js fs method */
-  readdir = promisify1(fs.readdir);
+  readdir = promisify2(fs.readdir);
   /** Wrapper for Node.js fs method */
-  stat = promisify1(fs.stat);
+  stat = promisify2(fs.stat);
 
   /** Wrapper for Node.js fs method */
-  readFile = promisify1(fs.readFile);
+  readFile = fs.readFile;
   /** Wrapper for Node.js fs method */
   readFileSync = fs.readFileSync;
   /** Wrapper for Node.js fs method */
-  writeFile = promisify2(fs.writeFile);
+  writeFile = promisify3(fs.writeFile);
   /** Wrapper for Node.js fs method */
   writeFileSync = fs.writeFileSync;
 
   // file descriptors
 
   /** Wrapper for Node.js fs method */
-  open = promisify1(fs.open);
+  open = fs.open;
   /** Wrapper for Node.js fs method */
-  close = promisify1(fs.close);
+  close = (fd: number) =>
+    new Promise((resolve, reject) => fs.close(fd, (err) => (err ? reject(err) : resolve())));
   /** Wrapper for Node.js fs method */
-  read = promisify1(fs.read);
+  read = fs.read;
   /** Wrapper for Node.js fs method */
-  fstat = promisify1(fs.fstat);
+  fstat = fs.fstat;
+
+  createWriteStream = fs.createWriteStream;
 
   isSupported = Boolean(fs);
 } catch {

package/src/lib/node/stream.ts

@@ -0,0 +1,18 @@
+// loaders.gl, MIT license
+
+import stream from 'stream';
+
+export type {Writable} from 'stream';
+
+export let Transform;
+
+export const isSupported = Boolean(stream);
+
+// paths
+
+try {
+  /** Wrapper for Node.js fs method */
+  Transform = stream.Transform;
+} catch {
+  // ignore
+}

package/src/lib/node/util.ts

@@ -1,7 +1,42 @@
 // @loaders.gl, MIT license
 
+// type Parameter1<T extends (arg1: any, ...args: unknown[]) => unknown> = T extends (
+//   arg1: infer P,
+//   ...args: unknown[]
+// ) => unknown
+//   ? P
+//   : never;
+
+//   type Parameter2<T extends (arg1: unknown, arg2: any, ...args: unknown[]) => unknown> = T extends (
+//   arg1: unknown,
+//   arg2: infer P,
+//   ...args: unknown[]
+// ) => unknown
+//   ? P
+//   : never;
+
+// type CallbackParameter2<
+//   T extends (arg: unknown, cb: (error: any, value: any) => void) => unknown
+// > = T extends (arg: unknown, cb: (error: any, value: infer P) => void) => unknown ? P : never;
+
+// type CallbackParameter3<
+//   T extends (arg: unknown, arg2: unknown, cb: (error: any, value: any) => void) => unknown
+// > = T extends (arg: unknown, arg2: unknown, cb: (error: any, value: infer P) => void) => unknown
+//   ? P
+//   : never;
+
+// /** Extract the parameters of a function type in a tuple */
+// export type Promisified<F extends (arg1, cb: (error: unknown, value: any) => void) => any> = (
+//   arg1: Parameter1<F>
+// ) => Promise<CallbackParameter2<F>>;
+// /** Extract the parameters of a function type in a tuple */
+// export type Promisified2<F extends (arg1, arg2, cb: (error: unknown, value: any) => void) => any> = (
+//   arg1: Parameter1<F>,
+//   arg2: Parameter2<F>
+// ) => Promise<CallbackParameter3<F>>;
+
 /** Wrapper for Node.js promisify */
-type Callback<A> = (args: A) => void;
+type Callback<A> = (error: unknown, args: A) => void;
 
 /**
  * Typesafe promisify implementation
@@ -11,20 +46,25 @@ type Callback<A> = (args: A) => void;
  */
 export function promisify1<T, A>(fn: (args: T, cb: Callback<A>) => void): (args: T) => Promise<A> {
   return (args: T) =>
-    new Promise((resolve) => {
-      fn(args, (callbackArgs) => {
-        resolve(callbackArgs);
-      });
-    });
+    new Promise((resolve, reject) =>
+      fn(args, (error, callbackArgs) => (error ? reject(error) : resolve(callbackArgs)))
+    );
 }
 
 export function promisify2<T1, T2, A>(
   fn: (arg1: T1, arg2: T2, cb: Callback<A>) => void
 ): (arg1: T1, arg2: T2) => Promise<A> {
   return (arg1: T1, arg2: T2) =>
-    new Promise((resolve) => {
-      fn(arg1, arg2, (callbackArgs) => {
-        resolve(callbackArgs);
-      });
-    });
+    new Promise((resolve, reject) =>
+      fn(arg1, arg2, (error, callbackArgs) => (error ? reject(error) : resolve(callbackArgs)))
+    );
+}
+
+export function promisify3<T1, T2, T3, A>(
+  fn: (arg1: T1, arg2: T2, arg3: T3, cb: Callback<A>) => void
+): (arg1: T1, arg2: T2, arg3: T3) => Promise<A> {
+  return (arg1: T1, arg2: T2, arg3: T3) =>
+    new Promise((resolve, reject) =>
+      fn(arg1, arg2, arg3, (error, callbackArgs) => (error ? reject(error) : resolve(callbackArgs)))
+    );
 }

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

@@ -1 +0,0 @@
-{"version":3,"file":"binary-copy-utils.js","names":["copyPaddedArrayBufferToDataView","dataView","byteOffset","sourceBuffer","padding","paddedLength","padToNBytes","byteLength","padLength","targetArray","Uint8Array","buffer","sourceArray","set","i","setUint8","copyPaddedStringToDataView","string","textEncoder","TextEncoder","stringBuffer","encode"],"sources":["../../../../src/lib/binary-utils/binary-copy-utils.ts"],"sourcesContent":["import {TypedArray} from '../../types';\nimport {padToNBytes} from './memory-copy-utils';\n\n/**\n * Copy sourceBuffer to dataView with some padding\n *\n * @param {DataView | null} dataView - destination data container. If null - only new offset is calculated\n * @param {number} byteOffset - destination byte offset to copy to\n * @param {Array | TypedArray} sourceBuffer - source data buffer\n * @param {number} padding - pad the resulting array to multiple of \"padding\" bytes. Additional bytes are filled with 0x20 (ASCII space)\n *\n * @return new byteOffset of resulting dataView\n */\nexport function copyPaddedArrayBufferToDataView(\n  dataView: DataView | null,\n  byteOffset: number,\n  sourceBuffer: TypedArray,\n  padding: number\n) {\n  const paddedLength = padToNBytes(sourceBuffer.byteLength, padding);\n  const padLength = paddedLength - sourceBuffer.byteLength;\n\n  if (dataView) {\n    // Copy array\n    const targetArray = new Uint8Array(\n      dataView.buffer,\n      dataView.byteOffset + byteOffset,\n      sourceBuffer.byteLength\n    );\n    const sourceArray = new Uint8Array(sourceBuffer);\n    targetArray.set(sourceArray);\n\n    // Add PADDING\n    for (let i = 0; i < padLength; ++i) {\n      // json chunk is padded with spaces (ASCII 0x20)\n      dataView.setUint8(byteOffset + sourceBuffer.byteLength + i, 0x20);\n    }\n  }\n  byteOffset += paddedLength;\n  return byteOffset;\n}\n\n/**\n * Copy string to dataView with some padding\n *\n * @param {DataView | null} dataView - destination data container. If null - only new offset is calculated\n * @param {number} byteOffset - destination byte offset to copy to\n * @param {string} string - source string\n * @param {number} padding - pad the resulting array to multiple of \"padding\" bytes. Additional bytes are filled with 0x20 (ASCII space)\n *\n * @return new byteOffset of resulting dataView\n */\nexport function copyPaddedStringToDataView(\n  dataView: DataView | null,\n  byteOffset: number,\n  string: string,\n  padding: number\n): number {\n  const textEncoder = new TextEncoder();\n  // PERFORMANCE IDEA: We encode twice, once to get size and once to store\n  // PERFORMANCE IDEA: Use TextEncoder.encodeInto() to avoid temporary copy\n  const stringBuffer = textEncoder.encode(string);\n\n  byteOffset = copyPaddedArrayBufferToDataView(dataView, byteOffset, stringBuffer, padding);\n\n  return byteOffset;\n}\n"],"mappings":";;;;;;;AACA;AAYO,SAASA,+BAA+B,CAC7CC,QAAyB,EACzBC,UAAkB,EAClBC,YAAwB,EACxBC,OAAe,EACf;EACA,IAAMC,YAAY,GAAG,IAAAC,4BAAW,EAACH,YAAY,CAACI,UAAU,EAAEH,OAAO,CAAC;EAClE,IAAMI,SAAS,GAAGH,YAAY,GAAGF,YAAY,CAACI,UAAU;EAExD,IAAIN,QAAQ,EAAE;IAEZ,IAAMQ,WAAW,GAAG,IAAIC,UAAU,CAChCT,QAAQ,CAACU,MAAM,EACfV,QAAQ,CAACC,UAAU,GAAGA,UAAU,EAChCC,YAAY,CAACI,UAAU,CACxB;IACD,IAAMK,WAAW,GAAG,IAAIF,UAAU,CAACP,YAAY,CAAC;IAChDM,WAAW,CAACI,GAAG,CAACD,WAAW,CAAC;;IAG5B,KAAK,IAAIE,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGN,SAAS,EAAE,EAAEM,CAAC,EAAE;MAElCb,QAAQ,CAACc,QAAQ,CAACb,UAAU,GAAGC,YAAY,CAACI,UAAU,GAAGO,CAAC,EAAE,IAAI,CAAC;IACnE;EACF;EACAZ,UAAU,IAAIG,YAAY;EAC1B,OAAOH,UAAU;AACnB;;AAYO,SAASc,0BAA0B,CACxCf,QAAyB,EACzBC,UAAkB,EAClBe,MAAc,EACdb,OAAe,EACP;EACR,IAAMc,WAAW,GAAG,IAAIC,WAAW,EAAE;EAGrC,IAAMC,YAAY,GAAGF,WAAW,CAACG,MAAM,CAACJ,MAAM,CAAC;EAE/Cf,UAAU,GAAGF,+BAA+B,CAACC,QAAQ,EAAEC,UAAU,EAAEkB,YAAY,EAAEhB,OAAO,CAAC;EAEzF,OAAOF,UAAU;AACnB"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"buffer-utils.js","names":["isBuffer","value","toBuffer","data","node","bufferToArrayBuffer","buffer","typedArray","Uint8Array","byteOffset","length","slice"],"sources":["../../../../src/lib/binary-utils/buffer-utils.ts"],"sourcesContent":["import * 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 * Converts Node.js `Buffer` to `ArrayBuffer` (without triggering bundler to include Buffer polyfill on browser)\n * @todo better data type\n */\nexport function bufferToArrayBuffer(buffer: any): ArrayBuffer {\n  if (isBuffer(buffer)) {\n    const typedArray = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.length);\n    return typedArray.slice().buffer;\n  }\n  return buffer;\n}\n"],"mappings":";;;;;;;;;;;AAAA;AAAuC;AAAA;AAKhC,SAASA,QAAQ,CAACC,KAAU,EAAW;EAC5C,OAAOA,KAAK,IAAI,sBAAOA,KAAK,MAAK,QAAQ,IAAIA,KAAK,CAACD,QAAQ;AAC7D;;AAMO,SAASE,QAAQ,CAACC,IAAS,EAAU;EAC1C,OAAOC,IAAI,CAACF,QAAQ,GAAGE,IAAI,CAACF,QAAQ,CAACC,IAAI,CAAC,GAAGA,IAAI;AACnD;;AAMO,SAASE,mBAAmB,CAACC,MAAW,EAAe;EAC5D,IAAIN,QAAQ,CAACM,MAAM,CAAC,EAAE;IACpB,IAAMC,UAAU,GAAG,IAAIC,UAAU,CAACF,MAAM,CAACA,MAAM,EAAEA,MAAM,CAACG,UAAU,EAAEH,MAAM,CAACI,MAAM,CAAC;IAClF,OAAOH,UAAU,CAACI,KAAK,EAAE,CAACL,MAAM;EAClC;EACA,OAAOA,MAAM;AACf"}

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

@@ -1,36 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.copyBinaryToDataView = copyBinaryToDataView;
-exports.copyStringToDataView = copyStringToDataView;
-exports.padStringToByteAlignment = padStringToByteAlignment;
-
-function padStringToByteAlignment(string, byteAlignment) {
-  var length = string.length;
-  var paddedLength = Math.ceil(length / byteAlignment) * byteAlignment;
-  var padding = paddedLength - length;
-  var whitespace = '';
-  for (var i = 0; i < padding; ++i) {
-    whitespace += ' ';
-  }
-  return string + whitespace;
-}
-function copyStringToDataView(dataView, byteOffset, string, byteLength) {
-  if (dataView) {
-    for (var i = 0; i < byteLength; i++) {
-      dataView.setUint8(byteOffset + i, string.charCodeAt(i));
-    }
-  }
-  return byteOffset + byteLength;
-}
-function copyBinaryToDataView(dataView, byteOffset, binary, byteLength) {
-  if (dataView) {
-    for (var i = 0; i < byteLength; i++) {
-      dataView.setUint8(byteOffset + i, binary[i]);
-    }
-  }
-  return byteOffset + byteLength;
-}
-//# sourceMappingURL=encode-utils.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"encode-utils.js","names":["padStringToByteAlignment","string","byteAlignment","length","paddedLength","Math","ceil","padding","whitespace","i","copyStringToDataView","dataView","byteOffset","byteLength","setUint8","charCodeAt","copyBinaryToDataView","binary"],"sources":["../../../../src/lib/binary-utils/encode-utils.ts"],"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"],"mappings":";;;;;;;;;AAIO,SAASA,wBAAwB,CAACC,MAAM,EAAEC,aAAa,EAAE;EAC9D,IAAMC,MAAM,GAAGF,MAAM,CAACE,MAAM;EAC5B,IAAMC,YAAY,GAAGC,IAAI,CAACC,IAAI,CAACH,MAAM,GAAGD,aAAa,CAAC,GAAGA,aAAa;EACtE,IAAMK,OAAO,GAAGH,YAAY,GAAGD,MAAM;EACrC,IAAIK,UAAU,GAAG,EAAE;EACnB,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGF,OAAO,EAAE,EAAEE,CAAC,EAAE;IAChCD,UAAU,IAAI,GAAG;EACnB;EACA,OAAOP,MAAM,GAAGO,UAAU;AAC5B;AAEO,SAASE,oBAAoB,CAACC,QAAQ,EAAEC,UAAU,EAAEX,MAAM,EAAEY,UAAU,EAAE;EAC7E,IAAIF,QAAQ,EAAE;IACZ,KAAK,IAAIF,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGI,UAAU,EAAEJ,CAAC,EAAE,EAAE;MACnCE,QAAQ,CAACG,QAAQ,CAACF,UAAU,GAAGH,CAAC,EAAER,MAAM,CAACc,UAAU,CAACN,CAAC,CAAC,CAAC;IACzD;EACF;EACA,OAAOG,UAAU,GAAGC,UAAU;AAChC;AAEO,SAASG,oBAAoB,CAACL,QAAQ,EAAEC,UAAU,EAAEK,MAAM,EAAEJ,UAAU,EAAE;EAC7E,IAAIF,QAAQ,EAAE;IACZ,KAAK,IAAIF,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGI,UAAU,EAAEJ,CAAC,EAAE,EAAE;MACnCE,QAAQ,CAACG,QAAQ,CAACF,UAAU,GAAGH,CAAC,EAAEQ,MAAM,CAACR,CAAC,CAAC,CAAC;IAC9C;EACF;EACA,OAAOG,UAAU,GAAGC,UAAU;AAChC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"binary-copy-utils.js","names":["padToNBytes","copyPaddedArrayBufferToDataView","dataView","byteOffset","sourceBuffer","padding","paddedLength","byteLength","padLength","targetArray","Uint8Array","buffer","sourceArray","set","i","setUint8","copyPaddedStringToDataView","string","textEncoder","TextEncoder","stringBuffer","encode"],"sources":["../../../../src/lib/binary-utils/binary-copy-utils.ts"],"sourcesContent":["import {TypedArray} from '../../types';\nimport {padToNBytes} from './memory-copy-utils';\n\n/**\n * Copy sourceBuffer to dataView with some padding\n *\n * @param {DataView | null} dataView - destination data container. If null - only new offset is calculated\n * @param {number} byteOffset - destination byte offset to copy to\n * @param {Array | TypedArray} sourceBuffer - source data buffer\n * @param {number} padding - pad the resulting array to multiple of \"padding\" bytes. Additional bytes are filled with 0x20 (ASCII space)\n *\n * @return new byteOffset of resulting dataView\n */\nexport function copyPaddedArrayBufferToDataView(\n  dataView: DataView | null,\n  byteOffset: number,\n  sourceBuffer: TypedArray,\n  padding: number\n) {\n  const paddedLength = padToNBytes(sourceBuffer.byteLength, padding);\n  const padLength = paddedLength - sourceBuffer.byteLength;\n\n  if (dataView) {\n    // Copy array\n    const targetArray = new Uint8Array(\n      dataView.buffer,\n      dataView.byteOffset + byteOffset,\n      sourceBuffer.byteLength\n    );\n    const sourceArray = new Uint8Array(sourceBuffer);\n    targetArray.set(sourceArray);\n\n    // Add PADDING\n    for (let i = 0; i < padLength; ++i) {\n      // json chunk is padded with spaces (ASCII 0x20)\n      dataView.setUint8(byteOffset + sourceBuffer.byteLength + i, 0x20);\n    }\n  }\n  byteOffset += paddedLength;\n  return byteOffset;\n}\n\n/**\n * Copy string to dataView with some padding\n *\n * @param {DataView | null} dataView - destination data container. If null - only new offset is calculated\n * @param {number} byteOffset - destination byte offset to copy to\n * @param {string} string - source string\n * @param {number} padding - pad the resulting array to multiple of \"padding\" bytes. Additional bytes are filled with 0x20 (ASCII space)\n *\n * @return new byteOffset of resulting dataView\n */\nexport function copyPaddedStringToDataView(\n  dataView: DataView | null,\n  byteOffset: number,\n  string: string,\n  padding: number\n): number {\n  const textEncoder = new TextEncoder();\n  // PERFORMANCE IDEA: We encode twice, once to get size and once to store\n  // PERFORMANCE IDEA: Use TextEncoder.encodeInto() to avoid temporary copy\n  const stringBuffer = textEncoder.encode(string);\n\n  byteOffset = copyPaddedArrayBufferToDataView(dataView, byteOffset, stringBuffer, padding);\n\n  return byteOffset;\n}\n"],"mappings":"AACA,SAAQA,WAAW,QAAO,qBAAqB;;AAY/C,OAAO,SAASC,+BAA+B,CAC7CC,QAAyB,EACzBC,UAAkB,EAClBC,YAAwB,EACxBC,OAAe,EACf;EACA,MAAMC,YAAY,GAAGN,WAAW,CAACI,YAAY,CAACG,UAAU,EAAEF,OAAO,CAAC;EAClE,MAAMG,SAAS,GAAGF,YAAY,GAAGF,YAAY,CAACG,UAAU;EAExD,IAAIL,QAAQ,EAAE;IAEZ,MAAMO,WAAW,GAAG,IAAIC,UAAU,CAChCR,QAAQ,CAACS,MAAM,EACfT,QAAQ,CAACC,UAAU,GAAGA,UAAU,EAChCC,YAAY,CAACG,UAAU,CACxB;IACD,MAAMK,WAAW,GAAG,IAAIF,UAAU,CAACN,YAAY,CAAC;IAChDK,WAAW,CAACI,GAAG,CAACD,WAAW,CAAC;;IAG5B,KAAK,IAAIE,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGN,SAAS,EAAE,EAAEM,CAAC,EAAE;MAElCZ,QAAQ,CAACa,QAAQ,CAACZ,UAAU,GAAGC,YAAY,CAACG,UAAU,GAAGO,CAAC,EAAE,IAAI,CAAC;IACnE;EACF;EACAX,UAAU,IAAIG,YAAY;EAC1B,OAAOH,UAAU;AACnB;;AAYA,OAAO,SAASa,0BAA0B,CACxCd,QAAyB,EACzBC,UAAkB,EAClBc,MAAc,EACdZ,OAAe,EACP;EACR,MAAMa,WAAW,GAAG,IAAIC,WAAW,EAAE;EAGrC,MAAMC,YAAY,GAAGF,WAAW,CAACG,MAAM,CAACJ,MAAM,CAAC;EAE/Cd,UAAU,GAAGF,+BAA+B,CAACC,QAAQ,EAAEC,UAAU,EAAEiB,YAAY,EAAEf,OAAO,CAAC;EAEzF,OAAOF,UAAU;AACnB"}

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

@@ -1,18 +0,0 @@
-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 bufferToArrayBuffer(buffer) {
-  if (isBuffer(buffer)) {
-    const typedArray = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.length);
-    return typedArray.slice().buffer;
-  }
-  return buffer;
-}
-//# sourceMappingURL=buffer-utils.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"buffer-utils.js","names":["node","isBuffer","value","toBuffer","data","bufferToArrayBuffer","buffer","typedArray","Uint8Array","byteOffset","length","slice"],"sources":["../../../../src/lib/binary-utils/buffer-utils.ts"],"sourcesContent":["import * 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 * Converts Node.js `Buffer` to `ArrayBuffer` (without triggering bundler to include Buffer polyfill on browser)\n * @todo better data type\n */\nexport function bufferToArrayBuffer(buffer: any): ArrayBuffer {\n  if (isBuffer(buffer)) {\n    const typedArray = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.length);\n    return typedArray.slice().buffer;\n  }\n  return buffer;\n}\n"],"mappings":"AAAA,OAAO,KAAKA,IAAI,MAAM,gBAAgB;;AAKtC,OAAO,SAASC,QAAQ,CAACC,KAAU,EAAW;EAC5C,OAAOA,KAAK,IAAI,OAAOA,KAAK,KAAK,QAAQ,IAAIA,KAAK,CAACD,QAAQ;AAC7D;;AAMA,OAAO,SAASE,QAAQ,CAACC,IAAS,EAAU;EAC1C,OAAOJ,IAAI,CAACG,QAAQ,GAAGH,IAAI,CAACG,QAAQ,CAACC,IAAI,CAAC,GAAGA,IAAI;AACnD;;AAMA,OAAO,SAASC,mBAAmB,CAACC,MAAW,EAAe;EAC5D,IAAIL,QAAQ,CAACK,MAAM,CAAC,EAAE;IACpB,MAAMC,UAAU,GAAG,IAAIC,UAAU,CAACF,MAAM,CAACA,MAAM,EAAEA,MAAM,CAACG,UAAU,EAAEH,MAAM,CAACI,MAAM,CAAC;IAClF,OAAOH,UAAU,CAACI,KAAK,EAAE,CAACL,MAAM;EAClC;EACA,OAAOA,MAAM;AACf"}

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

@@ -1,29 +0,0 @@
-
-
-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;
-}
-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;
-}
-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;
-}
-//# sourceMappingURL=encode-utils.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"encode-utils.js","names":["padStringToByteAlignment","string","byteAlignment","length","paddedLength","Math","ceil","padding","whitespace","i","copyStringToDataView","dataView","byteOffset","byteLength","setUint8","charCodeAt","copyBinaryToDataView","binary"],"sources":["../../../../src/lib/binary-utils/encode-utils.ts"],"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"],"mappings":";;AAIA,OAAO,SAASA,wBAAwB,CAACC,MAAM,EAAEC,aAAa,EAAE;EAC9D,MAAMC,MAAM,GAAGF,MAAM,CAACE,MAAM;EAC5B,MAAMC,YAAY,GAAGC,IAAI,CAACC,IAAI,CAACH,MAAM,GAAGD,aAAa,CAAC,GAAGA,aAAa;EACtE,MAAMK,OAAO,GAAGH,YAAY,GAAGD,MAAM;EACrC,IAAIK,UAAU,GAAG,EAAE;EACnB,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGF,OAAO,EAAE,EAAEE,CAAC,EAAE;IAChCD,UAAU,IAAI,GAAG;EACnB;EACA,OAAOP,MAAM,GAAGO,UAAU;AAC5B;AAEA,OAAO,SAASE,oBAAoB,CAACC,QAAQ,EAAEC,UAAU,EAAEX,MAAM,EAAEY,UAAU,EAAE;EAC7E,IAAIF,QAAQ,EAAE;IACZ,KAAK,IAAIF,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGI,UAAU,EAAEJ,CAAC,EAAE,EAAE;MACnCE,QAAQ,CAACG,QAAQ,CAACF,UAAU,GAAGH,CAAC,EAAER,MAAM,CAACc,UAAU,CAACN,CAAC,CAAC,CAAC;IACzD;EACF;EACA,OAAOG,UAAU,GAAGC,UAAU;AAChC;AAEA,OAAO,SAASG,oBAAoB,CAACL,QAAQ,EAAEC,UAAU,EAAEK,MAAM,EAAEJ,UAAU,EAAE;EAC7E,IAAIF,QAAQ,EAAE;IACZ,KAAK,IAAIF,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGI,UAAU,EAAEJ,CAAC,EAAE,EAAE;MACnCE,QAAQ,CAACG,QAAQ,CAACF,UAAU,GAAGH,CAAC,EAAEQ,MAAM,CAACR,CAAC,CAAC,CAAC;IAC9C;EACF;EACA,OAAOG,UAAU,GAAGC,UAAU;AAChC"}

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

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

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

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

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

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

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

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

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

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

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

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

package/src/lib/binary-utils/buffer-utils.ts

@@ -1,28 +0,0 @@
-import * as node from '../node/buffer';
-
-/**
- * Check for Node.js `Buffer` (without triggering bundler to include Buffer polyfill on browser)
- */
-export function isBuffer(value: any): boolean {
-  return value && typeof value === 'object' && value.isBuffer;
-}
-
-/**
- * Converts to Node.js `Buffer` (without triggering bundler to include Buffer polyfill on browser)
- * @todo better data type
- */
-export function toBuffer(data: any): Buffer {
-  return node.toBuffer ? node.toBuffer(data) : data;
-}
-
-/**
- * Converts Node.js `Buffer` to `ArrayBuffer` (without triggering bundler to include Buffer polyfill on browser)
- * @todo better data type
- */
-export function bufferToArrayBuffer(buffer: any): ArrayBuffer {
-  if (isBuffer(buffer)) {
-    const typedArray = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.length);
-    return typedArray.slice().buffer;
-  }
-  return buffer;
-}

package/src/lib/binary-utils/encode-utils.ts

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