@loaders.gl/polyfills 3.1.3 → 4.0.0-alpha.5

package/dist/node/fetch/response.node.js

@@ -1,77 +1,88 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const assert_1 = require("../../utils/assert");
-const stream_utils_node_1 = require("./utils/stream-utils.node");
-const headers_node_1 = __importDefault(require("./headers.node"));
-const isBoolean = (x) => typeof x === 'boolean';
-const isFunction = (x) => typeof x === 'function';
-const isObject = (x) => x !== null && typeof x === 'object';
-const isReadableNodeStream = (x) => isObject(x) && isFunction(x.read) && isFunction(x.pipe) && isBoolean(x.readable);
-/**
- * Polyfill for Browser Response
- *
- * Under Node.js we return a mock "fetch response object"
- * so that apps can use the same API as in the browser.
- *
- * Note: This is intended to be a "lightweight" implementation and will have limitations.
- *
- * See https://developer.mozilla.org/en-US/docs/Web/API/Response
- */
-const stream_1 = require("stream");
-class Response {
-    // TODO - handle ArrayBuffer, ArrayBufferView, Buffer
-    constructor(body, options) {
-        this.bodyUsed = false;
-        const { headers, status = 200, statusText = 'OK', url } = options || {};
-        this.url = url;
-        this.ok = status === 200;
-        this.status = status; // TODO - handle errors and set status
-        this.statusText = statusText;
-        this.headers = new headers_node_1.default(options?.headers || {});
-        // Check for content-encoding and create a decompression stream
-        if (isReadableNodeStream(body)) {
-            this._body = (0, stream_utils_node_1.decompressReadStream)(body, headers);
-        }
-        else if (typeof body === 'string') {
-            this._body = stream_1.Readable.from([new TextEncoder().encode(body)]);
-        }
-        else {
-            this._body = stream_1.Readable.from([body || new ArrayBuffer(0)]);
-        }
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { assert } from '../../utils/assert';
+import { decompressReadStream, concatenateReadStream } from './utils/stream-utils.node';
+import Headers from './headers.node';
+
+const isBoolean = x => typeof x === 'boolean';
+
+const isFunction = x => typeof x === 'function';
+
+const isObject = x => x !== null && typeof x === 'object';
+
+const isReadableNodeStream = x => isObject(x) && isFunction(x.read) && isFunction(x.pipe) && isBoolean(x.readable);
+
+import { Readable } from 'stream';
+export default class Response {
+  constructor(body, options) {
+    _defineProperty(this, "ok", void 0);
+
+    _defineProperty(this, "status", void 0);
+
+    _defineProperty(this, "statusText", void 0);
+
+    _defineProperty(this, "headers", void 0);
+
+    _defineProperty(this, "url", void 0);
+
+    _defineProperty(this, "bodyUsed", false);
+
+    _defineProperty(this, "_body", void 0);
+
+    const {
+      headers,
+      status = 200,
+      statusText = 'OK',
+      url
+    } = options || {};
+    this.url = url;
+    this.ok = status === 200;
+    this.status = status;
+    this.statusText = statusText;
+    this.headers = new Headers((options === null || options === void 0 ? void 0 : options.headers) || {});
+
+    if (isReadableNodeStream(body)) {
+      this._body = decompressReadStream(body, headers);
+    } else if (typeof body === 'string') {
+      this._body = Readable.from([new TextEncoder().encode(body)]);
+    } else {
+      this._body = Readable.from([body || new ArrayBuffer(0)]);
     }
-    // Subset of Properties
-    // Returns a readable stream to the "body" of the response (or file)
-    get body() {
-        (0, assert_1.assert)(!this.bodyUsed);
-        (0, assert_1.assert)(isReadableNodeStream(this._body)); // Not implemented: conversion of ArrayBuffer etc to stream
-        this.bodyUsed = true;
-        return this._body;
+  }
+
+  get body() {
+    assert(!this.bodyUsed);
+    assert(isReadableNodeStream(this._body));
+    this.bodyUsed = true;
+    return this._body;
+  }
+
+  async arrayBuffer() {
+    if (!isReadableNodeStream(this._body)) {
+      return this._body || new ArrayBuffer(0);
     }
-    // Subset of Methods
-    async arrayBuffer() {
-        if (!isReadableNodeStream(this._body)) {
-            return this._body || new ArrayBuffer(0);
-        }
-        const data = await (0, stream_utils_node_1.concatenateReadStream)(this._body);
-        return data;
-    }
-    async text() {
-        const arrayBuffer = await this.arrayBuffer();
-        const textDecoder = new TextDecoder();
-        return textDecoder.decode(arrayBuffer);
-    }
-    async json() {
-        const text = await this.text();
-        return JSON.parse(text);
-    }
-    async blob() {
-        if (typeof Blob === 'undefined') {
-            throw new Error('Blob polyfill not installed');
-        }
-        return new Blob([await this.arrayBuffer()]);
+
+    const data = await concatenateReadStream(this._body);
+    return data;
+  }
+
+  async text() {
+    const arrayBuffer = await this.arrayBuffer();
+    const textDecoder = new TextDecoder();
+    return textDecoder.decode(arrayBuffer);
+  }
+
+  async json() {
+    const text = await this.text();
+    return JSON.parse(text);
+  }
+
+  async blob() {
+    if (typeof Blob === 'undefined') {
+      throw new Error('Blob polyfill not installed');
     }
+
+    return new Blob([await this.arrayBuffer()]);
+  }
+
 }
-exports.default = Response;
+//# sourceMappingURL=response.node.js.map

package/dist/node/fetch/response.node.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/node/fetch/response.node.ts"],"names":["assert","decompressReadStream","concatenateReadStream","Headers","isBoolean","x","isFunction","isObject","isReadableNodeStream","read","pipe","readable","Readable","Response","constructor","body","options","headers","status","statusText","url","ok","_body","from","TextEncoder","encode","ArrayBuffer","bodyUsed","arrayBuffer","data","text","textDecoder","TextDecoder","decode","json","JSON","parse","blob","Blob","Error"],"mappings":"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","sourcesContent":["import {assert} from '../../utils/assert';\nimport {decompressReadStream, concatenateReadStream} from './utils/stream-utils.node';\nimport Headers from './headers.node';\n\nconst isBoolean = (x) => typeof x === 'boolean';\nconst isFunction = (x) => typeof x === 'function';\nconst isObject = (x) => x !== null && typeof x === 'object';\nconst isReadableNodeStream = (x) =>\n  isObject(x) && isFunction(x.read) && isFunction(x.pipe) && isBoolean(x.readable);\n\n/**\n * Polyfill for Browser Response\n *\n * Under Node.js we return a mock \"fetch response object\"\n * so that apps can use the same API as in the browser.\n *\n * Note: This is intended to be a \"lightweight\" implementation and will have limitations.\n *\n * See https://developer.mozilla.org/en-US/docs/Web/API/Response\n */\nimport {Readable} from 'stream';\n\nexport default class Response {\n  readonly ok: boolean;\n  readonly status: number;\n  readonly statusText: string;\n  readonly headers: Headers;\n  readonly url: string;\n  bodyUsed: boolean = false;\n  private readonly _body;\n\n  // TODO - handle ArrayBuffer, ArrayBufferView, Buffer\n  constructor(\n    body,\n    options: {\n      headers?;\n      status?: number;\n      statusText?: string;\n      url: string;\n    }\n  ) {\n    const {headers, status = 200, statusText = 'OK', url} = options || {};\n\n    this.url = url;\n    this.ok = status === 200;\n    this.status = status; // TODO - handle errors and set status\n    this.statusText = statusText;\n    this.headers = new Headers(options?.headers || {});\n\n    // Check for content-encoding and create a decompression stream\n    if (isReadableNodeStream(body)) {\n      this._body = decompressReadStream(body, headers);\n    } else if (typeof body === 'string') {\n      this._body = Readable.from([new TextEncoder().encode(body)]);\n    } else {\n      this._body = Readable.from([body || new ArrayBuffer(0)]);\n    }\n  }\n\n  // Subset of Properties\n\n  // Returns a readable stream to the \"body\" of the response (or file)\n  get body() {\n    assert(!this.bodyUsed);\n    assert(isReadableNodeStream(this._body)); // Not implemented: conversion of ArrayBuffer etc to stream\n    this.bodyUsed = true;\n    return this._body;\n  }\n\n  // Subset of Methods\n\n  async arrayBuffer() {\n    if (!isReadableNodeStream(this._body)) {\n      return this._body || new ArrayBuffer(0);\n    }\n    const data = await concatenateReadStream(this._body);\n    return data;\n  }\n\n  async text() {\n    const arrayBuffer = await this.arrayBuffer();\n    const textDecoder = new TextDecoder();\n    return textDecoder.decode(arrayBuffer);\n  }\n\n  async json() {\n    const text = await this.text();\n    return JSON.parse(text);\n  }\n\n  async blob() {\n    if (typeof Blob === 'undefined') {\n      throw new Error('Blob polyfill not installed');\n    }\n    return new Blob([await this.arrayBuffer()]);\n  }\n}\n"],"file":"response.node.js"}

package/dist/node/fetch/utils/decode-data-uri.node.js

@@ -1,65 +1,55 @@
-"use strict";
-// Based on binary-gltf-utils under MIT license: Copyright (c) 2016-17 Karl Cheng
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toArrayBuffer = exports.decodeDataUri = void 0;
-const isArrayBuffer = (x) => x && x instanceof ArrayBuffer;
-const isBuffer = (x) => x && x instanceof Buffer;
-/**
- * Parses a data URI into a buffer, as well as retrieving its declared MIME type.
- *
- * @param {string} uri - a data URI (assumed to be valid)
- * @returns {Object} { buffer, mimeType }
- */
-function decodeDataUri(uri) {
-    const dataIndex = uri.indexOf(',');
-    let buffer;
-    let mimeType;
-    if (uri.slice(dataIndex - 7, dataIndex) === ';base64') {
-        buffer = Buffer.from(uri.slice(dataIndex + 1), 'base64');
-        mimeType = uri.slice(5, dataIndex - 7).trim();
-    }
-    else {
-        buffer = Buffer.from(decodeURIComponent(uri.slice(dataIndex + 1)));
-        mimeType = uri.slice(5, dataIndex).trim();
-    }
-    if (!mimeType) {
-        mimeType = 'text/plain;charset=US-ASCII';
-    }
-    else if (mimeType.startsWith(';')) {
-        mimeType = `text/plain${mimeType}`;
-    }
-    return { arrayBuffer: toArrayBuffer(buffer), mimeType };
+const isArrayBuffer = x => x && x instanceof ArrayBuffer;
+
+const isBuffer = x => x && x instanceof Buffer;
+
+export function decodeDataUri(uri) {
+  const dataIndex = uri.indexOf(',');
+  let buffer;
+  let mimeType;
+
+  if (uri.slice(dataIndex - 7, dataIndex) === ';base64') {
+    buffer = Buffer.from(uri.slice(dataIndex + 1), 'base64');
+    mimeType = uri.slice(5, dataIndex - 7).trim();
+  } else {
+    buffer = Buffer.from(decodeURIComponent(uri.slice(dataIndex + 1)));
+    mimeType = uri.slice(5, dataIndex).trim();
+  }
+
+  if (!mimeType) {
+    mimeType = 'text/plain;charset=US-ASCII';
+  } else if (mimeType.startsWith(';')) {
+    mimeType = "text/plain".concat(mimeType);
+  }
+
+  return {
+    arrayBuffer: toArrayBuffer(buffer),
+    mimeType
+  };
 }
-exports.decodeDataUri = decodeDataUri;
-/**
- * @param data
- * @todo Duplicate of core
- */
-function toArrayBuffer(data) {
-    if (isArrayBuffer(data)) {
-        return data;
-    }
-    // TODO - per docs we should just be able to call buffer.buffer, but there are issues
-    if (isBuffer(data)) {
-        // @ts-expect-error
-        const typedArray = new Uint8Array(data);
-        return typedArray.buffer;
-    }
-    // Careful - Node Buffers will look like ArrayBuffers (keep after isBuffer)
-    if (ArrayBuffer.isView(data)) {
-        return data.buffer;
-    }
-    if (typeof data === 'string') {
-        const text = data;
-        const uint8Array = new TextEncoder().encode(text);
-        return uint8Array.buffer;
-    }
-    // HACK to support Blob polyfill
-    // @ts-expect-error
-    if (data && typeof data === 'object' && data._toArrayBuffer) {
-        // @ts-expect-error
-        return data._toArrayBuffer();
-    }
-    throw new Error(`toArrayBuffer(${JSON.stringify(data, null, 2).slice(10)})`);
+export function toArrayBuffer(data) {
+  if (isArrayBuffer(data)) {
+    return data;
+  }
+
+  if (isBuffer(data)) {
+    const typedArray = new Uint8Array(data);
+    return typedArray.buffer;
+  }
+
+  if (ArrayBuffer.isView(data)) {
+    return data.buffer;
+  }
+
+  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(".concat(JSON.stringify(data, null, 2).slice(10), ")"));
 }
-exports.toArrayBuffer = toArrayBuffer;
+//# sourceMappingURL=decode-data-uri.node.js.map

package/dist/node/fetch/utils/decode-data-uri.node.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/node/fetch/utils/decode-data-uri.node.ts"],"names":["isArrayBuffer","x","ArrayBuffer","isBuffer","Buffer","decodeDataUri","uri","dataIndex","indexOf","buffer","mimeType","slice","from","trim","decodeURIComponent","startsWith","arrayBuffer","toArrayBuffer","data","typedArray","Uint8Array","isView","text","uint8Array","TextEncoder","encode","_toArrayBuffer","Error","JSON","stringify"],"mappings":"AAEA,MAAMA,aAAa,GAAIC,CAAD,IAAOA,CAAC,IAAIA,CAAC,YAAYC,WAA/C;;AACA,MAAMC,QAAQ,GAAIF,CAAD,IAAOA,CAAC,IAAIA,CAAC,YAAYG,MAA1C;;AAQA,OAAO,SAASC,aAAT,CAAuBC,GAAvB,EAAkF;AACvF,QAAMC,SAAS,GAAGD,GAAG,CAACE,OAAJ,CAAY,GAAZ,CAAlB;AAEA,MAAIC,MAAJ;AACA,MAAIC,QAAJ;;AACA,MAAIJ,GAAG,CAACK,KAAJ,CAAUJ,SAAS,GAAG,CAAtB,EAAyBA,SAAzB,MAAwC,SAA5C,EAAuD;AACrDE,IAAAA,MAAM,GAAGL,MAAM,CAACQ,IAAP,CAAYN,GAAG,CAACK,KAAJ,CAAUJ,SAAS,GAAG,CAAtB,CAAZ,EAAsC,QAAtC,CAAT;AACAG,IAAAA,QAAQ,GAAGJ,GAAG,CAACK,KAAJ,CAAU,CAAV,EAAaJ,SAAS,GAAG,CAAzB,EAA4BM,IAA5B,EAAX;AACD,GAHD,MAGO;AACLJ,IAAAA,MAAM,GAAGL,MAAM,CAACQ,IAAP,CAAYE,kBAAkB,CAACR,GAAG,CAACK,KAAJ,CAAUJ,SAAS,GAAG,CAAtB,CAAD,CAA9B,CAAT;AACAG,IAAAA,QAAQ,GAAGJ,GAAG,CAACK,KAAJ,CAAU,CAAV,EAAaJ,SAAb,EAAwBM,IAAxB,EAAX;AACD;;AAED,MAAI,CAACH,QAAL,EAAe;AACbA,IAAAA,QAAQ,GAAG,6BAAX;AACD,GAFD,MAEO,IAAIA,QAAQ,CAACK,UAAT,CAAoB,GAApB,CAAJ,EAA8B;AACnCL,IAAAA,QAAQ,uBAAgBA,QAAhB,CAAR;AACD;;AAED,SAAO;AAACM,IAAAA,WAAW,EAAEC,aAAa,CAACR,MAAD,CAA3B;AAAqCC,IAAAA;AAArC,GAAP;AACD;AAMD,OAAO,SAASO,aAAT,CAAuBC,IAAvB,EAAmD;AACxD,MAAIlB,aAAa,CAACkB,IAAD,CAAjB,EAAyB;AACvB,WAAOA,IAAP;AACD;;AAGD,MAAIf,QAAQ,CAACe,IAAD,CAAZ,EAAoB;AAElB,UAAMC,UAAU,GAAG,IAAIC,UAAJ,CAAeF,IAAf,CAAnB;AACA,WAAOC,UAAU,CAACV,MAAlB;AACD;;AAGD,MAAIP,WAAW,CAACmB,MAAZ,CAAmBH,IAAnB,CAAJ,EAA8B;AAC5B,WAAOA,IAAI,CAACT,MAAZ;AACD;;AAED,MAAI,OAAOS,IAAP,KAAgB,QAApB,EAA8B;AAC5B,UAAMI,IAAI,GAAGJ,IAAb;AACA,UAAMK,UAAU,GAAG,IAAIC,WAAJ,GAAkBC,MAAlB,CAAyBH,IAAzB,CAAnB;AACA,WAAOC,UAAU,CAACd,MAAlB;AACD;;AAID,MAAIS,IAAI,IAAI,OAAOA,IAAP,KAAgB,QAAxB,IAAoCA,IAAI,CAACQ,cAA7C,EAA6D;AAE3D,WAAOR,IAAI,CAACQ,cAAL,EAAP;AACD;;AAED,QAAM,IAAIC,KAAJ,yBAA2BC,IAAI,CAACC,SAAL,CAAeX,IAAf,EAAqB,IAArB,EAA2B,CAA3B,EAA8BP,KAA9B,CAAoC,EAApC,CAA3B,OAAN;AACD","sourcesContent":["// Based on binary-gltf-utils under MIT license: Copyright (c) 2016-17 Karl Cheng\n\nconst isArrayBuffer = (x) => x && x instanceof ArrayBuffer;\nconst isBuffer = (x) => x && x instanceof Buffer;\n\n/**\n * Parses a data URI into a buffer, as well as retrieving its declared MIME type.\n *\n * @param {string} uri - a data URI (assumed to be valid)\n * @returns {Object} { buffer, mimeType }\n */\nexport function decodeDataUri(uri: string): {arrayBuffer: ArrayBuffer; mimeType: string} {\n  const dataIndex = uri.indexOf(',');\n\n  let buffer;\n  let mimeType;\n  if (uri.slice(dataIndex - 7, dataIndex) === ';base64') {\n    buffer = Buffer.from(uri.slice(dataIndex + 1), 'base64');\n    mimeType = uri.slice(5, dataIndex - 7).trim();\n  } else {\n    buffer = Buffer.from(decodeURIComponent(uri.slice(dataIndex + 1)));\n    mimeType = uri.slice(5, dataIndex).trim();\n  }\n\n  if (!mimeType) {\n    mimeType = 'text/plain;charset=US-ASCII';\n  } else if (mimeType.startsWith(';')) {\n    mimeType = `text/plain${mimeType}`;\n  }\n\n  return {arrayBuffer: toArrayBuffer(buffer), mimeType};\n}\n\n/**\n * @param data\n * @todo Duplicate of core\n */\nexport function toArrayBuffer(data: unknown): ArrayBuffer {\n  if (isArrayBuffer(data)) {\n    return data as ArrayBuffer;\n  }\n\n  // TODO - per docs we should just be able to call buffer.buffer, but there are issues\n  if (isBuffer(data)) {\n    // @ts-expect-error\n    const typedArray = new Uint8Array(data);\n    return typedArray.buffer;\n  }\n\n  // Careful - Node Buffers will look like ArrayBuffers (keep after isBuffer)\n  if (ArrayBuffer.isView(data)) {\n    return data.buffer;\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  // @ts-expect-error\n  if (data && typeof data === 'object' && data._toArrayBuffer) {\n    // @ts-expect-error\n    return data._toArrayBuffer();\n  }\n\n  throw new Error(`toArrayBuffer(${JSON.stringify(data, null, 2).slice(10)})`);\n}\n"],"file":"decode-data-uri.node.js"}

package/dist/node/fetch/utils/stream-utils.node.js

@@ -1,116 +1,98 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.concatenateArrayBuffers = exports.concatenateReadStream = exports.decompressReadStream = exports.createReadStream = void 0;
-const fs_1 = __importDefault(require("fs")); // `fs` will be empty object in browsers (see package.json "browser" field).
-const http_1 = __importDefault(require("http"));
-const https_1 = __importDefault(require("https"));
-const zlib_1 = __importDefault(require("zlib"));
-const decode_data_uri_node_1 = require("./decode-data-uri.node");
+import fs from 'fs';
+import http from 'http';
+import https from 'https';
+import zlib from 'zlib';
+import { toArrayBuffer } from './decode-data-uri.node';
+
 function isRequestURL(url) {
-    return url.startsWith('http:') || url.startsWith('https:');
+  return url.startsWith('http:') || url.startsWith('https:');
 }
-// Returns a promise that resolves to a readable stream
-async function createReadStream(url, options) {
-    // Handle file streams in node
-    if (!isRequestURL(url)) {
-        const noqueryUrl = url.split('?')[0];
-        // Now open the stream
-        return await new Promise((resolve, reject) => {
-            // @ts-ignore
-            const stream = fs_1.default.createReadStream(noqueryUrl, { encoding: null });
-            stream.once('readable', () => resolve(stream));
-            stream.on('error', (error) => reject(error));
-        });
-    }
-    // HANDLE HTTP/HTTPS REQUESTS IN NODE
-    // TODO: THIS IS BAD SINCE WE RETURN A PROMISE INSTEAD OF A STREAM
+
+export async function createReadStream(url, options) {
+  if (!isRequestURL(url)) {
+    const noqueryUrl = url.split('?')[0];
     return await new Promise((resolve, reject) => {
-        const requestFunction = url.startsWith('https:') ? https_1.default.request : http_1.default.request;
-        const requestOptions = getRequestOptions(url, options);
-        const req = requestFunction(requestOptions, (res) => resolve(res));
-        req.on('error', (error) => reject(error));
-        req.end();
+      const stream = fs.createReadStream(noqueryUrl, {
+        encoding: null
+      });
+      stream.once('readable', () => resolve(stream));
+      stream.on('error', error => reject(error));
     });
+  }
+
+  return await new Promise((resolve, reject) => {
+    const requestFunction = url.startsWith('https:') ? https.request : http.request;
+    const requestOptions = getRequestOptions(url, options);
+    const req = requestFunction(requestOptions, res => resolve(res));
+    req.on('error', error => reject(error));
+    req.end();
+  });
 }
-exports.createReadStream = createReadStream;
-function decompressReadStream(readStream, headers) {
-    switch (headers.get('content-encoding')) {
-        case 'br':
-            return readStream.pipe(zlib_1.default.createBrotliDecompress());
-        case 'gzip':
-            return readStream.pipe(zlib_1.default.createGunzip());
-        case 'deflate':
-            return readStream.pipe(zlib_1.default.createDeflate());
-        default:
-            // No compression or an unknown one, just return it as is
-            return readStream;
-    }
+export function decompressReadStream(readStream, headers) {
+  switch (headers.get('content-encoding')) {
+    case 'br':
+      return readStream.pipe(zlib.createBrotliDecompress());
+
+    case 'gzip':
+      return readStream.pipe(zlib.createGunzip());
+
+    case 'deflate':
+      return readStream.pipe(zlib.createDeflate());
+
+    default:
+      return readStream;
+  }
 }
-exports.decompressReadStream = decompressReadStream;
-async function concatenateReadStream(readStream) {
-    const arrayBufferChunks = [];
-    return await new Promise((resolve, reject) => {
-        readStream.on('error', (error) => reject(error));
-        // Once the readable callback has been added, stream switches to "flowing mode"
-        // In Node 10 (but not 12 and 14) this causes `data` and `end` to never be called unless we read data here
-        readStream.on('readable', () => readStream.read());
-        readStream.on('data', (chunk) => {
-            if (typeof chunk === 'string') {
-                reject(new Error('Read stream not binary'));
-            }
-            arrayBufferChunks.push((0, decode_data_uri_node_1.toArrayBuffer)(chunk));
-        });
-        readStream.on('end', () => {
-            const arrayBuffer = concatenateArrayBuffers(arrayBufferChunks);
-            resolve(arrayBuffer);
-        });
+export async function concatenateReadStream(readStream) {
+  const arrayBufferChunks = [];
+  return await new Promise((resolve, reject) => {
+    readStream.on('error', error => reject(error));
+    readStream.on('readable', () => readStream.read());
+    readStream.on('data', chunk => {
+      if (typeof chunk === 'string') {
+        reject(new Error('Read stream not binary'));
+      }
+
+      arrayBufferChunks.push(toArrayBuffer(chunk));
+    });
+    readStream.on('end', () => {
+      const arrayBuffer = concatenateArrayBuffers(arrayBufferChunks);
+      resolve(arrayBuffer);
     });
+  });
 }
-exports.concatenateReadStream = concatenateReadStream;
-// HELPERS
+
 function getRequestOptions(url, options) {
-    // Ensure header keys are lower case so that we can merge without duplicates
-    const originalHeaders = options?.headers || {};
-    const headers = {};
-    for (const key of Object.keys(originalHeaders)) {
-        headers[key.toLowerCase()] = originalHeaders[key];
-    }
-    // Add default accept-encoding to headers
-    headers['accept-encoding'] = headers['accept-encoding'] || 'gzip,br,deflate';
-    const urlObject = new URL(url);
-    return {
-        hostname: urlObject.hostname,
-        path: urlObject.pathname,
-        method: 'GET',
-        // Add options and user provided 'options.fetch' overrides if available
-        ...options,
-        ...options?.fetch,
-        // Override with updated headers with accepted encodings:
-        headers
-    };
+  const originalHeaders = (options === null || options === void 0 ? void 0 : options.headers) || {};
+  const headers = {};
+
+  for (const key of Object.keys(originalHeaders)) {
+    headers[key.toLowerCase()] = originalHeaders[key];
+  }
+
+  headers['accept-encoding'] = headers['accept-encoding'] || 'gzip,br,deflate';
+  const urlObject = new URL(url);
+  return {
+    hostname: urlObject.hostname,
+    path: urlObject.pathname,
+    method: 'GET',
+    ...options,
+    ...(options === null || options === void 0 ? void 0 : options.fetch),
+    headers
+  };
 }
-/**
- * Concatenate a sequence of ArrayBuffers
- * @return A concatenated ArrayBuffer
- * @note duplicates loader-utils since polyfills should be independent
- */
-function concatenateArrayBuffers(sources) {
-    // Make sure all inputs are wrapped in typed arrays
-    const sourceArrays = sources.map((source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2);
-    // Get length of all inputs
-    const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);
-    // Allocate array with space for all inputs
-    const result = new Uint8Array(byteLength);
-    // Copy the subarrays
-    let offset = 0;
-    for (const sourceArray of sourceArrays) {
-        result.set(sourceArray, offset);
-        offset += sourceArray.byteLength;
-    }
-    // We work with ArrayBuffers, discard the typed array wrapper
-    return result.buffer;
+
+export function concatenateArrayBuffers(sources) {
+  const sourceArrays = sources.map(source2 => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2);
+  const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);
+  const result = new Uint8Array(byteLength);
+  let offset = 0;
+
+  for (const sourceArray of sourceArrays) {
+    result.set(sourceArray, offset);
+    offset += sourceArray.byteLength;
+  }
+
+  return result.buffer;
 }
-exports.concatenateArrayBuffers = concatenateArrayBuffers;
+//# sourceMappingURL=stream-utils.node.js.map

package/dist/node/fetch/utils/stream-utils.node.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/node/fetch/utils/stream-utils.node.ts"],"names":["fs","http","https","zlib","toArrayBuffer","isRequestURL","url","startsWith","createReadStream","options","noqueryUrl","split","Promise","resolve","reject","stream","encoding","once","on","error","requestFunction","request","requestOptions","getRequestOptions","req","res","end","decompressReadStream","readStream","headers","get","pipe","createBrotliDecompress","createGunzip","createDeflate","concatenateReadStream","arrayBufferChunks","read","chunk","Error","push","arrayBuffer","concatenateArrayBuffers","originalHeaders","key","Object","keys","toLowerCase","urlObject","URL","hostname","path","pathname","method","fetch","sources","sourceArrays","map","source2","ArrayBuffer","Uint8Array","byteLength","reduce","length","typedArray","result","offset","sourceArray","set","buffer"],"mappings":"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","sourcesContent":["import fs from 'fs'; // `fs` will be empty object in browsers (see package.json \"browser\" field).\nimport http from 'http';\nimport https from 'https';\nimport zlib from 'zlib';\n\nimport {toArrayBuffer} from './decode-data-uri.node';\n\nfunction isRequestURL(url: string): boolean {\n  return url.startsWith('http:') || url.startsWith('https:');\n}\n\n// Returns a promise that resolves to a readable stream\nexport async function createReadStream(url, options): Promise<any> {\n  // Handle file streams in node\n  if (!isRequestURL(url)) {\n    const noqueryUrl = url.split('?')[0];\n    // Now open the stream\n    return await new Promise((resolve, reject) => {\n      // @ts-ignore\n      const stream = fs.createReadStream(noqueryUrl, {encoding: null});\n      stream.once('readable', () => resolve(stream));\n      stream.on('error', (error) => reject(error));\n    });\n  }\n\n  // HANDLE HTTP/HTTPS REQUESTS IN NODE\n  // TODO: THIS IS BAD SINCE WE RETURN A PROMISE INSTEAD OF A STREAM\n  return await new Promise((resolve, reject) => {\n    const requestFunction = url.startsWith('https:') ? https.request : http.request;\n    const requestOptions = getRequestOptions(url, options);\n    const req = requestFunction(requestOptions, (res) => resolve(res));\n    req.on('error', (error) => reject(error));\n    req.end();\n  });\n}\n\nexport function decompressReadStream(readStream, headers) {\n  switch (headers.get('content-encoding')) {\n    case 'br':\n      return readStream.pipe(zlib.createBrotliDecompress());\n    case 'gzip':\n      return readStream.pipe(zlib.createGunzip());\n    case 'deflate':\n      return readStream.pipe(zlib.createDeflate());\n    default:\n      // No compression or an unknown one, just return it as is\n      return readStream;\n  }\n}\n\nexport async function concatenateReadStream(readStream): Promise<ArrayBuffer> {\n  const arrayBufferChunks: ArrayBuffer[] = [];\n\n  return await new Promise((resolve, reject) => {\n    readStream.on('error', (error) => reject(error));\n\n    // Once the readable callback has been added, stream switches to \"flowing mode\"\n    // In Node 10 (but not 12 and 14) this causes `data` and `end` to never be called unless we read data here\n    readStream.on('readable', () => readStream.read());\n\n    readStream.on('data', (chunk) => {\n      if (typeof chunk === 'string') {\n        reject(new Error('Read stream not binary'));\n      }\n      arrayBufferChunks.push(toArrayBuffer(chunk));\n    });\n\n    readStream.on('end', () => {\n      const arrayBuffer = concatenateArrayBuffers(arrayBufferChunks);\n      resolve(arrayBuffer);\n    });\n  });\n}\n\n// HELPERS\n\nfunction getRequestOptions(url: string, options?: {fetch?: typeof fetch; headers?}) {\n  // Ensure header keys are lower case so that we can merge without duplicates\n  const originalHeaders = options?.headers || {};\n  const headers = {};\n  for (const key of Object.keys(originalHeaders)) {\n    headers[key.toLowerCase()] = originalHeaders[key];\n  }\n\n  // Add default accept-encoding to headers\n  headers['accept-encoding'] = headers['accept-encoding'] || 'gzip,br,deflate';\n\n  const urlObject = new URL(url);\n  return {\n    hostname: urlObject.hostname,\n    path: urlObject.pathname,\n    method: 'GET',\n    // Add options and user provided 'options.fetch' overrides if available\n    ...options,\n    ...options?.fetch,\n    // Override with updated headers with accepted encodings:\n    headers\n  };\n}\n\n/**\n * Concatenate a sequence of ArrayBuffers\n * @return A concatenated ArrayBuffer\n * @note duplicates loader-utils since polyfills should be independent\n */\nexport function concatenateArrayBuffers(sources: (ArrayBuffer | Uint8Array)[]): ArrayBuffer {\n  // Make sure all inputs are wrapped in typed arrays\n  const sourceArrays = sources.map((source2) =>\n    source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2\n  );\n\n  // Get length of all inputs\n  const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);\n\n  // Allocate array with space for all inputs\n  const result = new Uint8Array(byteLength);\n\n  // Copy the subarrays\n  let offset = 0;\n  for (const sourceArray of sourceArrays) {\n    result.set(sourceArray, offset);\n    offset += sourceArray.byteLength;\n  }\n\n  // We work with ArrayBuffers, discard the typed array wrapper\n  return result.buffer;\n}\n"],"file":"stream-utils.node.js"}