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

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 '../env-utils/globals';
+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/node/buffer.browser.ts

@@ -0,0 +1,20 @@
+// loaders.gl, MIT license
+
+// Isolates Buffer references to ensure they are only bundled under Node.js (avoids big webpack polyfill)
+// this file is selected by the package.json "browser" field).
+
+/**
+ * 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) {
+  return buffer;
+}
+
+/**
+ * Convert (copy) ArrayBuffer to Buffer
+ */
+export function toBuffer(binaryData: ArrayBuffer | ArrayBuffer | Buffer): Buffer {
+  throw new Error('Buffer not supported in browser');
+}

package/src/lib/node/buffer.ts

@@ -1,10 +1,12 @@
-// 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).
+// loaders.gl, MIT license
 
-import {assert} from '../env-utils/assert';
+// Isolates Buffer references to ensure they are only bundled under Node.js (avoids big webpack polyfill)
+// this file is selected by the package.json "browser" field).
 
 /**
  * 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 +20,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 {promisify} from './util';
+import {promisify2, promisify3} from './promisify';
 
-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 = promisify(fs.readdir);
+  readdir = promisify2(fs.readdir);
   /** Wrapper for Node.js fs method */
-  stat = promisify(fs.stat);
+  stat = promisify2(fs.stat);
 
   /** Wrapper for Node.js fs method */
-  readFile = promisify(fs.readFile);
+  readFile = fs.readFile;
   /** Wrapper for Node.js fs method */
   readFileSync = fs.readFileSync;
   /** Wrapper for Node.js fs method */
-  writeFile = promisify(fs.writeFile);
+  writeFile = promisify3(fs.writeFile);
   /** Wrapper for Node.js fs method */
   writeFileSync = fs.writeFileSync;
 
   // file descriptors
 
   /** Wrapper for Node.js fs method */
-  open = promisify(fs.open);
+  open = fs.open;
   /** Wrapper for Node.js fs method */
-  close = promisify(fs.close);
+  close = (fd: number) =>
+    new Promise((resolve, reject) => fs.close(fd, (err) => (err ? reject(err) : resolve())));
   /** Wrapper for Node.js fs method */
-  read = promisify(fs.read);
+  read = fs.read;
   /** Wrapper for Node.js fs method */
-  fstat = promisify(fs.fstat);
+  fstat = fs.fstat;
+
+  createWriteStream = fs.createWriteStream;
 
   isSupported = Boolean(fs);
 } catch {

package/src/lib/node/promisify.ts

@@ -0,0 +1,70 @@
+// @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> = (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)))
+    );
+}

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/option-utils/merge-loader-options.ts

@@ -0,0 +1,25 @@
+// loaders.gl, MIT license
+
+import {LoaderOptions} from '../../types';
+
+/**
+ *
+ * @param baseOptions Can be undefined, in which case a fresh options object will be minted
+ * @param newOptions
+ * @returns
+ */
+export function mergeLoaderOptions<Options extends LoaderOptions>(
+  baseOptions: Options | undefined,
+  newOptions: Options
+): Options {
+  const options = {...baseOptions};
+  for (const [key, newValue] of Object.entries(newOptions)) {
+    if (newValue && typeof newValue === 'object') {
+      options[key] = options[key] || {};
+      Object.assign(options[key] as object, newOptions[key]);
+    } else {
+      options[key] = newOptions[key];
+    }
+  }
+  return options as Options;
+}

package/src/lib/path-utils/get-cwd.ts

@@ -0,0 +1,9 @@
+// loaders.gl MIT license
+
+export function getCWD() {
+  if (typeof process !== 'undefined' && typeof process.cwd !== 'undefined') {
+    return process.cwd();
+  }
+  const pathname = window.location?.pathname;
+  return pathname?.slice(0, pathname.lastIndexOf('/') + 1) || '';
+}

package/src/lib/path-utils/path.ts

@@ -1,12 +1,14 @@
 // Beginning of a minimal implementation of the Node.js path API, that doesn't pull in big polyfills.
 
+import {getCWD} from './get-cwd';
+
 /**
  * Replacement for Node.js path.filename
  * @param url
  */
 export function filename(url: string): string {
-  const slashIndex = url && url.lastIndexOf('/');
-  return slashIndex >= 0 ? url.substr((slashIndex as number) + 1) : '';
+  const slashIndex = url ? url.lastIndexOf('/') : -1;
+  return slashIndex >= 0 ? url.substr(slashIndex + 1) : '';
 }
 
 /**
@@ -14,8 +16,8 @@ export function filename(url: string): string {
  * @param url
  */
 export function dirname(url: string): string {
-  const slashIndex = url && url.lastIndexOf('/');
-  return slashIndex >= 0 ? url.substr(0, slashIndex as number) : '';
+  const slashIndex = url ? url.lastIndexOf('/') : -1;
+  return slashIndex >= 0 ? url.substr(0, slashIndex) : '';
 }
 
 /**
@@ -35,3 +37,135 @@ export function join(...parts: string[]): string {
   });
   return parts.join(separator);
 }
+
+/* eslint-disable no-continue */
+
+/**
+ * https://nodejs.org/api/path.html#path_path_resolve_paths
+ * @param paths A sequence of paths or path segments.
+ * @return resolved path
+ * Forked from BTOdell/path-resolve under MIT license
+ * @see https://github.com/BTOdell/path-resolve/blob/master/LICENSE
+ */
+export function resolve(...components: string[]): string {
+  const paths: string[] = [];
+  for (let _i = 0; _i < components.length; _i++) {
+    paths[_i] = components[_i];
+  }
+  let resolvedPath = '';
+  let resolvedAbsolute = false;
+  let cwd: string | undefined;
+  for (let i = paths.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+    let path: string | undefined;
+    if (i >= 0) {
+      path = paths[i];
+    } else {
+      if (cwd === undefined) {
+        cwd = getCWD();
+      }
+      path = cwd;
+    }
+    // Skip empty entries
+    if (path.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path}/${resolvedPath}`;
+    resolvedAbsolute = path.charCodeAt(0) === SLASH;
+  }
+  // At this point the path should be resolved to a full absolute path, but
+  // handle relative paths to be safe (might happen when process.cwd() fails)
+  // Normalize the path (removes leading slash)
+  resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute) {
+    return `/${resolvedPath}`;
+  } else if (resolvedPath.length > 0) {
+    return resolvedPath;
+  }
+  return '.';
+}
+
+const SLASH = 47;
+const DOT = 46;
+
+/**
+ * Resolves . and .. elements in a path with directory names
+ * Forked from BTOdell/path-resolve under MIT license
+ * @see https://github.com/BTOdell/path-resolve/blob/master/LICENSE
+ */
+/* eslint-disable max-depth */
+// eslint-disable-next-line complexity, max-statements
+function normalizeStringPosix(path: string, allowAboveRoot: boolean): string {
+  let res = '';
+  let lastSlash = -1;
+  let dots = 0;
+  let code: number | undefined;
+  let isAboveRoot = false;
+
+  for (let i = 0; i <= path.length; ++i) {
+    if (i < path.length) {
+      code = path.charCodeAt(i);
+    } else if (code === SLASH) {
+      break;
+    } else {
+      code = SLASH;
+    }
+    if (code === SLASH) {
+      if (lastSlash === i - 1 || dots === 1) {
+        // NOOP
+      } else if (lastSlash !== i - 1 && dots === 2) {
+        if (
+          res.length < 2 ||
+          !isAboveRoot ||
+          res.charCodeAt(res.length - 1) !== DOT ||
+          res.charCodeAt(res.length - 2) !== DOT
+        ) {
+          if (res.length > 2) {
+            const start = res.length - 1;
+            let j = start;
+            for (; j >= 0; --j) {
+              if (res.charCodeAt(j) === SLASH) {
+                break;
+              }
+            }
+            if (j !== start) {
+              res = j === -1 ? '' : res.slice(0, j);
+              lastSlash = i;
+              dots = 0;
+              isAboveRoot = false;
+              continue;
+            }
+          } else if (res.length === 2 || res.length === 1) {
+            res = '';
+            lastSlash = i;
+            dots = 0;
+            isAboveRoot = false;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0) {
+            res += '/..';
+          } else {
+            res = '..';
+          }
+          isAboveRoot = true;
+        }
+      } else {
+        const slice = path.slice(lastSlash + 1, i);
+        if (res.length > 0) {
+          res += `/${slice}`;
+        } else {
+          res = slice;
+        }
+        isAboveRoot = false;
+      }
+      lastSlash = i;
+      dots = 0;
+    } else if (code === DOT && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}

package/src/types.ts

@@ -57,7 +57,7 @@ export type LoaderOptions = {
   // workers
 
   /** CDN load workers from */
-  CDN?: string;
+  CDN?: string | null;
   /** Set to `false` to disable workers */
   worker?: boolean;
   /** Number of concurrent workers (per loader) on desktop browser */
@@ -76,40 +76,40 @@ export type LoaderOptions = {
   /** @deprecated `options.throw removed`, Use `options.nothrow` instead */
   throws?: boolean;
   /** @deprecated `options.dataType` no longer used */
-  dataType?: any;
+  dataType?: never;
   /** @deprecated `options.uri` no longer used */
-  uri?: any;
+  uri?: never;
   /** @deprecated `options.method` removed. Use `options.fetch.method` */
-  method?: any;
+  method?: never;
   /** @deprecated `options.headers` removed. Use `options.fetch.headers` */
-  headers?: any;
+  headers?: never;
   /** @deprecated `options.body` removed. Use `options.fetch.body` */
-  body?: any;
+  body?: never;
   /** @deprecated `options.mode` removed. Use `options.fetch.mode` */
-  mode?: any;
+  mode?: never;
   /** @deprecated `options.credentials` removed. Use `options.fetch.credentials` */
-  credentials?: any;
+  credentials?: never;
   /** @deprecated `options.cache` removed. Use `options.fetch.cache` */
-  cache?: any;
+  cache?: never;
   /** @deprecated `options.redirect` removed. Use `options.fetch.redirect` */
-  redirect?: any;
+  redirect?: never;
   /** @deprecated `options.referrer` removed. Use `options.fetch.referrer` */
-  referrer?: any;
+  referrer?: never;
   /** @deprecated `options.referrerPolicy` removed. Use `options.fetch.referrerPolicy` */
-  referrerPolicy?: any;
+  referrerPolicy?: never;
   /** @deprecated `options.integrity` removed. Use `options.fetch.integrity` */
-  integrity?: any;
+  integrity?: never;
   /** @deprecated `options.keepalive` removed. Use `options.fetch.keepalive` */
-  keepalive?: any;
+  keepalive?: never;
   /** @deprecated `options.signal` removed. Use `options.fetch.signal` */
-  signal?: any;
+  signal?: never;
 
   // Accept other keys (loader options objects, e.g. `options.csv`, `options.json` ...)
-  [loaderId: string]: any;
+  [loaderId: string]: unknown;
 };
 
 type PreloadOptions = {
-  [key: string]: any;
+  [key: string]: unknown;
 };
 
 /**
@@ -122,7 +122,7 @@ export type Loader = {
   module: string;
   version: string;
   worker?: string | boolean;
-  options: object;
+  options: LoaderOptions;
   deprecatedOptions?: object;
   // end Worker
 
@@ -133,11 +133,11 @@ export type Loader = {
   binary?: boolean;
   text?: boolean;
 
-  tests?: (((ArrayBuffer) => boolean) | ArrayBuffer | string)[];
+  tests?: (((ArrayBuffer: ArrayBuffer) => boolean) | ArrayBuffer | string)[];
 
   // TODO - deprecated
   supported?: boolean;
-  testText?: (string) => boolean;
+  testText?: (string: string) => boolean;
 };
 
 /**
@@ -146,7 +146,7 @@ export type Loader = {
  */
 export type LoaderWithParser = Loader & {
   // TODO - deprecated
-  testText?: (string) => boolean;
+  testText?: (string: string) => boolean;
 
   parse: Parse;
   preload?: Preload;
@@ -196,23 +196,23 @@ export type LoaderContext = {
   loaders?: Loader[] | null;
   url?: string;
 
-  fetch: typeof fetch;
+  fetch: typeof fetch | FetchLike;
   response?: Response;
   parse: (
     arrayBuffer: ArrayBuffer,
-    loaders?,
+    loaders?: Loader | Loader[] | LoaderOptions,
     options?: LoaderOptions,
     context?: LoaderContext
   ) => Promise<any>;
   parseSync?: (
     arrayBuffer: ArrayBuffer,
-    loaders?,
+    loaders?: Loader | Loader[] | LoaderOptions,
     options?: LoaderOptions,
     context?: LoaderContext
   ) => any;
   parseInBatches?: (
     iterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,
-    loaders?,
+    loaders?: Loader | Loader[] | LoaderOptions,
     options?: LoaderOptions,
     context?: LoaderContext
   ) => AsyncIterable<any> | Promise<AsyncIterable<any>>;
@@ -306,7 +306,7 @@ export interface IFileSystem {
 
 type ReadOptions = {buffer?: ArrayBuffer; offset?: number; length?: number; position?: number};
 export interface IRandomAccessReadFileSystem extends IFileSystem {
-  open(path: string, flags, mode?): Promise<any>;
+  open(path: string, flags: string | number, mode?: any): Promise<any>;
   close(fd: any): Promise<void>;
   fstat(fd: any): Promise<object>;
   read(fd: any, options?: ReadOptions): Promise<{bytesRead: number; buffer: Buffer}>;

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"}