@loaders.gl/loader-utils 3.3.0 → 3.4.0-alpha.1

package/dist/lib/node/util.js

@@ -1,22 +1,29 @@
 "use strict";
-// @loaders.gl, MIT license
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.promisify3 = exports.promisify2 = exports.promisify1 = void 0;
-/**
- * Typesafe promisify implementation
- * @link https://dev.to/_gdelgado/implement-a-type-safe-version-of-node-s-promisify-in-7-lines-of-code-in-typescript-2j34
- * @param fn
- * @returns
- */
-function promisify1(fn) {
-    return (args) => new Promise((resolve, reject) => fn(args, (error, callbackArgs) => (error ? reject(error) : resolve(callbackArgs))));
-}
-exports.promisify1 = promisify1;
-function promisify2(fn) {
-    return (arg1, arg2) => new Promise((resolve, reject) => fn(arg1, arg2, (error, callbackArgs) => (error ? reject(error) : resolve(callbackArgs))));
-}
-exports.promisify2 = promisify2;
-function promisify3(fn) {
-    return (arg1, arg2, arg3) => new Promise((resolve, reject) => fn(arg1, arg2, arg3, (error, callbackArgs) => (error ? reject(error) : resolve(callbackArgs))));
-}
-exports.promisify3 = promisify3;
+exports.promisify = void 0;
+const util = __importStar(require("util"));
+/** Wrapper for Node.js promisify */
+exports.promisify = util.promisify;

package/dist/lib/worker-loader-utils/create-loader-worker.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLoaderWorker = void 0;
 const worker_utils_1 = require("@loaders.gl/worker-utils");
-// import {validateLoaderVersion} from './validate-loader-version.js';
+// import {validateLoaderVersion} from './validate-loader-version';
 let requestId = 0;
 /**
  * Set up a WebWorkerGlobalScope to talk with the main thread

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/loader-utils",
-  "version": "3.3.0",
+  "version": "3.4.0-alpha.1",
   "description": "Framework-independent loaders for 3D graphics formats",
   "license": "MIT",
   "publishConfig": {
@@ -40,14 +40,13 @@
     "./dist/es5/lib/node/util.js": false,
     "./dist/esm/lib/node/util.js": false,
     "fs": false,
-    "util": false,
-    "stream": false
+    "util": false
   },
   "scripts": {},
   "dependencies": {
     "@babel/runtime": "^7.3.1",
-    "@loaders.gl/worker-utils": "3.3.0",
+    "@loaders.gl/worker-utils": "3.4.0-alpha.1",
     "@probe.gl/stats": "^3.5.0"
   },
-  "gitHead": "566d194f175a03e042d3e588cdd514048f428cc1"
+  "gitHead": "4085b0323050e4361614471319a1fb4729547bbf"
 }

package/src/index.ts

@@ -35,6 +35,7 @@ export {parseJSON} from './lib/parser-utils/parse-json';
 
 // MEMORY COPY UTILS
 export {
+  toArrayBuffer,
   sliceArrayBuffer,
   concatenateArrayBuffers,
   concatenateTypedArrays,
@@ -42,12 +43,14 @@ export {
 } from './lib/binary-utils/array-buffer-utils';
 export {padToNBytes, copyToArray, copyArrayBuffer} from './lib/binary-utils/memory-copy-utils';
 export {
-  padStringToByteAlignment,
-  copyStringToDataView,
-  copyBinaryToDataView,
   copyPaddedArrayBufferToDataView,
   copyPaddedStringToDataView
-} from './lib/binary-utils/dataview-copy-utils';
+} from './lib/binary-utils/binary-copy-utils';
+export {
+  padStringToByteAlignment,
+  copyStringToDataView,
+  copyBinaryToDataView
+} from './lib/binary-utils/encode-utils';
 export {getFirstCharacters, getMagicString} from './lib/binary-utils/get-first-characters';
 
 // ITERATOR UTILS
@@ -73,31 +76,24 @@ export {JSONLoader} from './json-loader';
 
 // Node.js emulation (can be used in browser)
 
+// `path` replacement (avoids bundling big path polyfill)
+import * as path from './lib/path-utils/path';
+export {path};
+
 // Avoid direct use of `Buffer` which pulls in 50KB polyfill
-export {isBuffer, toBuffer, toArrayBuffer} from './lib/binary-utils/memory-conversion-utils';
+export {isBuffer, toBuffer, bufferToArrayBuffer} from './lib/binary-utils/buffer-utils';
 
 // Note.js wrappers (can be safely imported, but not used in browser)
 
-// Use instead of importing 'util' to avoid node dependencies
-export {promisify1, promisify2} from './lib/node/util';
-
-// `path` replacement (avoids bundling big path polyfill)
-import * as path from './lib/path-utils/path';
-export {path};
+// Use instead of importing 'util'
+import * as util from './lib/node/util';
+export {util};
+// TODO - remove
+export {promisify} from './lib/node/util';
 
-// Use instead of importing 'fs' to avoid node dependencies`
+// Use instead of importing 'fs';`
 import * as fs from './lib/node/fs';
 export {fs};
 
-// Use instead of importing 'stream' to avoid node dependencies`
-import * as stream from './lib/node/stream';
-export {stream};
-
 // EXPERIMENTAL
-export type {ReadableFile} from './lib/filesystems/readable-file';
-export {makeReadableFile} from './lib/filesystems/readable-file';
-
-export type {WritableFile} from './lib/filesystems/writable-file';
-export {makeWritableFile} from './lib/filesystems/writable-file';
-
 export {default as _NodeFileSystem} from './lib/filesystems/node-filesystem';

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

@@ -1,10 +1,46 @@
 import {TypedArray} from '../../types';
+import {isBuffer, bufferToArrayBuffer} from './buffer-utils';
+
+/**
+ * Convert an object to an array buffer
+ */
+export function toArrayBuffer(data: any): ArrayBuffer {
+  // Note: Should be called first, Buffers can trigger other detections below
+  if (isBuffer(data)) {
+    return bufferToArrayBuffer(data);
+  }
+
+  if (data instanceof ArrayBuffer) {
+    return data;
+  }
+
+  // Careful - Node Buffers look like Uint8Arrays (keep after isBuffer)
+  if (ArrayBuffer.isView(data)) {
+    if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
+      return data.buffer;
+    }
+    return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+  }
+
+  if (typeof data === 'string') {
+    const text = data;
+    const uint8Array = new TextEncoder().encode(text);
+    return uint8Array.buffer;
+  }
+
+  // HACK to support Blob polyfill
+  if (data && typeof data === 'object' && data._toArrayBuffer) {
+    return data._toArrayBuffer();
+  }
+
+  throw new Error('toArrayBuffer');
+}
 
 /**
  * compare two binary arrays for equality
- * @param a
- * @param b
- * @param byteLength
+ * @param {ArrayBuffer} a
+ * @param {ArrayBuffer} b
+ * @param {number} byteLength
  */
 export function compareArrayBuffers(
   arrayBuffer1: ArrayBuffer,
@@ -55,7 +91,7 @@ export function concatenateArrayBuffers(...sources: (ArrayBuffer | Uint8Array)[]
 /**
  * Concatenate arbitrary count of typed arrays
  * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays
- * @param - list of arrays. All arrays should be the same type
+ * @param {...*} arrays - list of arrays. All arrays should be the same type
  * @return A concatenated TypedArray
  */
 export function concatenateTypedArrays<T>(...typedArrays: T[]): T {

package/src/lib/binary-utils/{dataview-copy-utils.ts → binary-copy-utils.ts}

@@ -1,65 +1,13 @@
-// loaders./gl, MIT license
-
 import {TypedArray} from '../../types';
 import {padToNBytes} from './memory-copy-utils';
 
-/**
- * Helper function that pads a string with spaces to fit a certain byte alignment
- * @param string
- * @param byteAlignment
- * @returns
- *
- * @todo PERFORMANCE IDEA: No need to copy string twice...
- */
-export function padStringToByteAlignment(string: string, byteAlignment: number): string {
-  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;
-}
-
-/**
- *
- * @param dataView
- * @param byteOffset
- * @param string
- * @param byteLength
- * @returns
- */
-export function copyStringToDataView(
-  dataView: DataView,
-  byteOffset: number,
-  string: string,
-  byteLength: number
-): number {
-  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;
-}
-
 /**
  * Copy sourceBuffer to dataView with some padding
  *
- * @param dataView - destination data container. If null - only new offset is calculated
- * @param byteOffset - destination byte offset to copy to
- * @param sourceBuffer - source data buffer
- * @param padding - pad the resulting array to multiple of "padding" bytes. Additional bytes are filled with 0x20 (ASCII space)
+ * @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
  */
@@ -68,7 +16,7 @@ export function copyPaddedArrayBufferToDataView(
   byteOffset: number,
   sourceBuffer: TypedArray,
   padding: number
-): number {
+) {
   const paddedLength = padToNBytes(sourceBuffer.byteLength, padding);
   const padLength = paddedLength - sourceBuffer.byteLength;
 

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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,32 @@
+// 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;
+}

package/src/lib/binary-utils/get-first-characters.ts

@@ -1,12 +1,4 @@
-// loaders.gl, MIT license
-
-/**
- * Get the first characters from a binary file (interpret the first bytes as an ASCII string)
- * @param data
- * @param length
- * @returns
- */
-export function getFirstCharacters(data: string | ArrayBuffer, length: number = 5): string {
+export function getFirstCharacters(data, length = 5): string {
   if (typeof data === 'string') {
     return data.slice(0, length);
   } else if (ArrayBuffer.isView(data)) {
@@ -19,14 +11,6 @@ export function getFirstCharacters(data: string | ArrayBuffer, length: number =
   return '';
 }
 
-/**
- * Gets a magic string from a "file"
- * Typically used to check or detect file format
- * @param arrayBuffer
- * @param byteOffset
- * @param length
- * @returns
- */
 export function getMagicString(
   arrayBuffer: ArrayBuffer,
   byteOffset: number,

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,18 +18,19 @@ export function toArrayBuffer(buffer) {
 /**
  * Convert (copy) ArrayBuffer to Buffer
  */
-export function toBuffer(binaryData: ArrayBuffer | ArrayBuffer | Buffer): Buffer {
-  if (Buffer.isBuffer(binaryData)) {
-    return binaryData;
-  }
-
+export function toBuffer(binaryData) {
   if (ArrayBuffer.isView(binaryData)) {
     binaryData = binaryData.buffer;
   }
 
   if (typeof Buffer !== 'undefined' && binaryData instanceof ArrayBuffer) {
-    return Buffer.from(binaryData);
+    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;
   }
 
-  throw new Error('toBuffer');
+  return assert(false);
 }

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 {promisify2, promisify3} from './util';
+import {promisify} from './util';
 
-export type {Stats, WriteStream} from 'fs';
+export type {Stats} from 'fs';
 
 export let readdir;
 /** Wrapper for Node.js fs method */
@@ -23,46 +23,41 @@ export let writeFileSync;
 /** Wrapper for Node.js fs method */
 export let open;
 /** Wrapper for Node.js fs method */
-export let close: (fd: number) => Promise<void>;
+export let close;
 /** 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 = promisify2(fs.readdir);
+  readdir = promisify(fs.readdir);
   /** Wrapper for Node.js fs method */
-  stat = promisify2(fs.stat);
+  stat = promisify(fs.stat);
 
   /** Wrapper for Node.js fs method */
-  readFile = fs.readFile;
+  readFile = promisify(fs.readFile);
   /** Wrapper for Node.js fs method */
   readFileSync = fs.readFileSync;
   /** Wrapper for Node.js fs method */
-  writeFile = promisify3(fs.writeFile);
+  writeFile = promisify(fs.writeFile);
   /** Wrapper for Node.js fs method */
   writeFileSync = fs.writeFileSync;
 
   // file descriptors
 
   /** Wrapper for Node.js fs method */
-  open = fs.open;
+  open = promisify(fs.open);
   /** Wrapper for Node.js fs method */
-  close = (fd: number) =>
-    new Promise((resolve, reject) => fs.close(fd, (err) => (err ? reject(err) : resolve())));
+  close = promisify(fs.close);
   /** Wrapper for Node.js fs method */
-  read = fs.read;
+  read = promisify(fs.read);
   /** Wrapper for Node.js fs method */
-  fstat = fs.fstat;
-
-  createWriteStream = fs.createWriteStream;
+  fstat = promisify(fs.fstat);
 
   isSupported = Boolean(fs);
 } catch {

package/src/lib/node/util.ts

@@ -1,70 +1,4 @@
-// @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>>;
+import * as util from 'util';
 
 /** Wrapper for Node.js promisify */
-type Callback<A> = (error: unknown, args: A) => void;
-
-/**
- * Typesafe promisify implementation
- * @link https://dev.to/_gdelgado/implement-a-type-safe-version-of-node-s-promisify-in-7-lines-of-code-in-typescript-2j34
- * @param fn
- * @returns
- */
-export function promisify1<T, A>(fn: (args: T, cb: Callback<A>) => void): (args: T) => Promise<A> {
-  return (args: T) =>
-    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, 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)))
-    );
-}
+export const promisify = util.promisify;

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

@@ -1 +0,0 @@
-{"version":3,"file":"dataview-copy-utils.js","names":["padStringToByteAlignment","string","byteAlignment","length","paddedLength","Math","ceil","padding","whitespace","i","copyStringToDataView","dataView","byteOffset","byteLength","setUint8","charCodeAt","copyBinaryToDataView","binary","copyPaddedArrayBufferToDataView","sourceBuffer","padToNBytes","padLength","targetArray","Uint8Array","buffer","sourceArray","set","copyPaddedStringToDataView","textEncoder","TextEncoder","stringBuffer","encode"],"sources":["../../../../src/lib/binary-utils/dataview-copy-utils.ts"],"sourcesContent":["// loaders./gl, MIT license\n\nimport {TypedArray} from '../../types';\nimport {padToNBytes} from './memory-copy-utils';\n\n/**\n * Helper function that pads a string with spaces to fit a certain byte alignment\n * @param string\n * @param byteAlignment\n * @returns\n *\n * @todo PERFORMANCE IDEA: No need to copy string twice...\n */\nexport function padStringToByteAlignment(string: string, byteAlignment: number): string {\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\n/**\n *\n * @param dataView\n * @param byteOffset\n * @param string\n * @param byteLength\n * @returns\n */\nexport function copyStringToDataView(\n  dataView: DataView,\n  byteOffset: number,\n  string: string,\n  byteLength: number\n): number {\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\n/**\n * Copy sourceBuffer to dataView with some padding\n *\n * @param dataView - destination data container. If null - only new offset is calculated\n * @param byteOffset - destination byte offset to copy to\n * @param sourceBuffer - source data buffer\n * @param 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): number {\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":";;;;;;;;;;AAGA;;AAUO,SAASA,wBAAwB,CAACC,MAAc,EAAEC,aAAqB,EAAU;EACtF,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;;AAUO,SAASE,oBAAoB,CAClCC,QAAkB,EAClBC,UAAkB,EAClBX,MAAc,EACdY,UAAkB,EACV;EACR,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;;AAYO,SAASK,+BAA+B,CAC7CP,QAAyB,EACzBC,UAAkB,EAClBO,YAAwB,EACxBZ,OAAe,EACP;EACR,IAAMH,YAAY,GAAG,IAAAgB,4BAAW,EAACD,YAAY,CAACN,UAAU,EAAEN,OAAO,CAAC;EAClE,IAAMc,SAAS,GAAGjB,YAAY,GAAGe,YAAY,CAACN,UAAU;EAExD,IAAIF,QAAQ,EAAE;IAEZ,IAAMW,WAAW,GAAG,IAAIC,UAAU,CAChCZ,QAAQ,CAACa,MAAM,EACfb,QAAQ,CAACC,UAAU,GAAGA,UAAU,EAChCO,YAAY,CAACN,UAAU,CACxB;IACD,IAAMY,WAAW,GAAG,IAAIF,UAAU,CAACJ,YAAY,CAAC;IAChDG,WAAW,CAACI,GAAG,CAACD,WAAW,CAAC;;IAG5B,KAAK,IAAIhB,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGY,SAAS,EAAE,EAAEZ,CAAC,EAAE;MAElCE,QAAQ,CAACG,QAAQ,CAACF,UAAU,GAAGO,YAAY,CAACN,UAAU,GAAGJ,CAAC,EAAE,IAAI,CAAC;IACnE;EACF;EACAG,UAAU,IAAIR,YAAY;EAC1B,OAAOQ,UAAU;AACnB;;AAYO,SAASe,0BAA0B,CACxChB,QAAyB,EACzBC,UAAkB,EAClBX,MAAc,EACdM,OAAe,EACP;EACR,IAAMqB,WAAW,GAAG,IAAIC,WAAW,EAAE;EAGrC,IAAMC,YAAY,GAAGF,WAAW,CAACG,MAAM,CAAC9B,MAAM,CAAC;EAE/CW,UAAU,GAAGM,+BAA+B,CAACP,QAAQ,EAAEC,UAAU,EAAEkB,YAAY,EAAEvB,OAAO,CAAC;EAEzF,OAAOK,UAAU;AACnB"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"memory-conversion-utils.js","names":["isBuffer","value","toBuffer","data","node","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;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;;AAKO,SAASE,aAAa,CAACF,IAAa,EAAe;EAExD,IAAIH,QAAQ,CAACG,IAAI,CAAC,EAAE;IAClB,OAAOC,IAAI,CAACC,aAAa,CAACF,IAAI,CAAC;EACjC;EAEA,IAAIA,IAAI,YAAYG,WAAW,EAAE;IAC/B,OAAOH,IAAI;EACb;;EAGA,IAAIG,WAAW,CAACC,MAAM,CAACJ,IAAI,CAAC,EAAE;IAC5B,IAAIA,IAAI,CAACK,UAAU,KAAK,CAAC,IAAIL,IAAI,CAACM,UAAU,KAAKN,IAAI,CAACO,MAAM,CAACD,UAAU,EAAE;MACvE,OAAON,IAAI,CAACO,MAAM;IACpB;IACA,OAAOP,IAAI,CAACO,MAAM,CAACC,KAAK,CAACR,IAAI,CAACK,UAAU,EAAEL,IAAI,CAACK,UAAU,GAAGL,IAAI,CAACM,UAAU,CAAC;EAC9E;EAEA,IAAI,OAAON,IAAI,KAAK,QAAQ,EAAE;IAC5B,IAAMS,IAAI,GAAGT,IAAI;IACjB,IAAMU,UAAU,GAAG,IAAIC,WAAW,EAAE,CAACC,MAAM,CAACH,IAAI,CAAC;IACjD,OAAOC,UAAU,CAACH,MAAM;EAC1B;;EAGA,IAAIP,IAAI,IAAI,sBAAOA,IAAI,MAAK,QAAQ,IAAKA,IAAI,CAASa,cAAc,EAAE;IACpE,OAAQb,IAAI,CAASa,cAAc,EAAE;EACvC;EAEA,MAAM,IAAIC,KAAK,CAAC,eAAe,CAAC;AAClC"}