@loaders.gl/polyfills 3.1.0-alpha.4 → 3.1.0-beta.3

package/dist/node/buffer/btoa.node.d.ts

@@ -0,0 +1,3 @@
+export declare function atob(string: any): string;
+export declare function btoa(base64: any): string;
+//# sourceMappingURL=btoa.node.d.ts.map

package/dist/node/buffer/btoa.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"btoa.node.d.ts","sourceRoot":"","sources":["../../../src/node/buffer/btoa.node.ts"],"names":[],"mappings":"AAIA,wBAAgB,IAAI,CAAC,MAAM,KAAA,UAE1B;AAED,wBAAgB,IAAI,CAAC,MAAM,KAAA,UAE1B"}

package/dist/node/buffer/btoa.node.js

@@ -0,0 +1,14 @@
+"use strict";
+// btoa, atob polyfills for Node.js
+// Note: The atob and btoa functions (not just the polyfills!) are not unicode safe
+// But still useful for unit testing
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.btoa = exports.atob = void 0;
+function atob(string) {
+    return Buffer.from(string).toString('base64');
+}
+exports.atob = atob;
+function btoa(base64) {
+    return Buffer.from(base64, 'base64').toString('ascii');
+}
+exports.btoa = btoa;

package/dist/node/buffer/to-array-buffer.node.d.ts

@@ -0,0 +1,2 @@
+export declare function bufferToArrayBuffer(buffer: any): any;
+//# sourceMappingURL=to-array-buffer.node.d.ts.map

package/dist/node/buffer/to-array-buffer.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-array-buffer.node.d.ts","sourceRoot":"","sources":["../../../src/node/buffer/to-array-buffer.node.ts"],"names":[],"mappings":"AAAA,wBAAgB,mBAAmB,CAAC,MAAM,KAAA,OAOzC"}

package/dist/node/buffer/to-array-buffer.node.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bufferToArrayBuffer = void 0;
+function bufferToArrayBuffer(buffer) {
+    // 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);
+        return typedArray.buffer;
+    }
+    return buffer;
+}
+exports.bufferToArrayBuffer = bufferToArrayBuffer;

package/dist/node/fetch/fetch.node.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Emulation of Browser fetch for Node.js
+ * @param url
+ * @param options
+ */
+export default function fetchNode(url: any, options: any): any;
+//# sourceMappingURL=fetch.node.d.ts.map

package/dist/node/fetch/fetch.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.node.d.ts","sourceRoot":"","sources":["../../../src/node/fetch/fetch.node.ts"],"names":[],"mappings":"AAUA;;;;GAIG;AACH,wBAA8B,SAAS,CAAC,GAAG,KAAA,EAAE,OAAO,KAAA,OAwCnD"}

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

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs")); // `fs` will be empty object in browsers (see package.json "browser" field).
+const response_node_1 = __importDefault(require("./response.node"));
+const headers_node_1 = __importDefault(require("./headers.node"));
+const decode_data_uri_node_1 = require("./utils/decode-data-uri.node");
+const stream_utils_node_1 = require("./utils/stream-utils.node");
+const isDataURL = (url) => url.startsWith('data:');
+const isRequestURL = (url) => url.startsWith('http:') || url.startsWith('https:');
+/**
+ * Emulation of Browser fetch for Node.js
+ * @param url
+ * @param options
+ */
+async function fetchNode(url, options) {
+    try {
+        // Handle data urls in node, to match `fetch``
+        // Note - this loses the MIME type, data URIs are handled directly in fetch
+        if (isDataURL(url)) {
+            const { arrayBuffer, mimeType } = (0, decode_data_uri_node_1.decodeDataUri)(url);
+            const response = new response_node_1.default(arrayBuffer, {
+                headers: { 'content-type': mimeType },
+                url
+            });
+            return response;
+        }
+        // Automatically decompress gzipped files with .gz extension
+        const syntheticResponseHeaders = {};
+        const originalUrl = url;
+        if (url.endsWith('.gz')) {
+            url = url.slice(0, -3);
+            syntheticResponseHeaders['content-encoding'] = 'gzip';
+        }
+        // Need to create the stream in advance since Response constructor needs to be sync
+        const body = await (0, stream_utils_node_1.createReadStream)(originalUrl, options);
+        const headers = getHeaders(url, body, syntheticResponseHeaders);
+        const { status, statusText } = getStatus(body);
+        const followRedirect = !options || options.followRedirect || options.followRedirect === undefined;
+        if (status >= 300 && status < 400 && headers.has('location') && followRedirect) {
+            const redirectUrl = generateRedirectUrl(url, headers.get('location'));
+            // Redirect
+            return await fetchNode(redirectUrl, options);
+        }
+        return new response_node_1.default(body, { headers, status, statusText, url });
+    }
+    catch (error) {
+        // TODO - what error code to use here?
+        return new response_node_1.default(null, { status: 400, statusText: String(error), url });
+    }
+}
+exports.default = fetchNode;
+/**
+ * Generate redirect url from location without origin and protocol.
+ * @param originalUrl
+ * @param redirectUrl
+ */
+function generateRedirectUrl(originalUrl, location) {
+    if (location.startsWith('http')) {
+        return location;
+    }
+    // If url doesn't have origin and protocol just extend current url origin with location.
+    const url = new URL(originalUrl);
+    url.pathname = location;
+    return url.href;
+}
+// HELPER FUNCTIONS
+// PRIVATE
+function getStatus(httpResponse) {
+    if (httpResponse.statusCode) {
+        return { status: httpResponse.statusCode, statusText: httpResponse.statusMessage || 'NA' };
+    }
+    return { status: 200, statusText: 'OK' };
+}
+function getHeaders(url, httpResponse, additionalHeaders = {}) {
+    const headers = {};
+    if (httpResponse && httpResponse.headers) {
+        const httpHeaders = httpResponse.headers;
+        for (const key in httpHeaders) {
+            const header = httpHeaders[key];
+            headers[key.toLowerCase()] = String(header);
+        }
+    }
+    // Fix up content length if we can for best progress experience
+    if (!headers['content-length']) {
+        const contentLength = getContentLength(url);
+        if (Number.isFinite(contentLength)) {
+            headers['content-length'] = contentLength;
+        }
+    }
+    Object.assign(headers, additionalHeaders);
+    return new headers_node_1.default(headers);
+}
+function getContentLength(url) {
+    if (isRequestURL(url)) {
+        // Needs to be read from actual headers
+        return null;
+    }
+    else if (isDataURL(url)) {
+        // TODO - remove media type etc
+        return url.length - 'data:'.length;
+    }
+    // File URL
+    // TODO - how to handle non-existing file, this presumably just throws
+    try {
+        // strip query params from URL
+        const noqueryUrl = url.split('?')[0];
+        const stats = fs_1.default.statSync(noqueryUrl);
+        return stats.size;
+    }
+    catch (error) {
+        // ignore for now
+    }
+    return null;
+}

package/dist/node/fetch/headers.node.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Polyfill for Browser Headers
+ * Based on https://github.com/github/fetch under MIT license
+ */
+export default class Headers {
+    map: {};
+    constructor(headers: any);
+    append(name: any, value: any): void;
+    delete(name: any): void;
+    get(name: any): any;
+    has(name: any): boolean;
+    set(name: any, value: any): void;
+    forEach(visitor: any, thisArg?: null): void;
+    keys(): {
+        next(): {
+            done: boolean;
+            value: any;
+        };
+    };
+    values(): {
+        next(): {
+            done: boolean;
+            value: any;
+        };
+    };
+    entries(): {
+        next(): {
+            done: boolean;
+            value: any;
+        };
+    };
+    [Symbol.iterator](): Generator<any, void, unknown>;
+}
+//# sourceMappingURL=headers.node.d.ts.map

package/dist/node/fetch/headers.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headers.node.d.ts","sourceRoot":"","sources":["../../../src/node/fetch/headers.node.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,OAAO;IAC1B,GAAG,EAAE,EAAE,CAAC;gBAEI,OAAO,KAAA;IAYnB,MAAM,CAAC,IAAI,KAAA,EAAE,KAAK,KAAA;IAOlB,MAAM,CAAC,IAAI,KAAA;IAIX,GAAG,CAAC,IAAI,KAAA;IAKR,GAAG,CAAC,IAAI,KAAA;IAIR,GAAG,CAAC,IAAI,KAAA,EAAE,KAAK,KAAA;IAIf,OAAO,CAAC,OAAO,KAAA,EAAE,OAAO,OAAO;IAY/B,IAAI;;;;;;IAQJ,MAAM;;;;;;IAQN,OAAO;;;;;;IAQN,CAAC,MAAM,CAAC,QAAQ,CAAC;CAInB"}

package/dist/node/fetch/headers.node.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Polyfill for Browser Headers
+ * Based on https://github.com/github/fetch under MIT license
+ */
+class Headers {
+    constructor(headers) {
+        this.map = {};
+        if (headers instanceof Headers) {
+            headers.forEach((value, name) => this.append(name, value));
+        }
+        else if (Array.isArray(headers)) {
+            headers.forEach((header) => this.append(header[0], header[1]));
+        }
+        else if (headers) {
+            Object.getOwnPropertyNames(headers).forEach((name) => this.append(name, headers[name]));
+        }
+    }
+    append(name, value) {
+        name = normalizeName(name);
+        value = normalizeValue(value);
+        const oldValue = this.map[name];
+        this.map[name] = oldValue ? `${oldValue}, ${value}` : value;
+    }
+    delete(name) {
+        delete this.map[normalizeName(name)];
+    }
+    get(name) {
+        name = normalizeName(name);
+        return this.has(name) ? this.map[name] : null;
+    }
+    has(name) {
+        return this.map.hasOwnProperty(normalizeName(name));
+    }
+    set(name, value) {
+        this.map[normalizeName(name)] = normalizeValue(value);
+    }
+    forEach(visitor, thisArg = null) {
+        for (const name in this.map) {
+            if (this.map.hasOwnProperty(name)) {
+                if (thisArg) {
+                    visitor.call(thisArg, this.map[name], name, this);
+                }
+                else {
+                    visitor(this.map[name], name, this);
+                }
+            }
+        }
+    }
+    keys() {
+        const items = [];
+        this.forEach(function (value, name) {
+            items.push(name);
+        });
+        return iteratorFor(items);
+    }
+    values() {
+        const items = [];
+        this.forEach(function (value) {
+            items.push(value);
+        });
+        return iteratorFor(items);
+    }
+    entries() {
+        const items = [];
+        this.forEach(function (value, name) {
+            items.push([name, value]);
+        });
+        return iteratorFor(items);
+    }
+    *[Symbol.iterator]() {
+        // @ts-ignore must have a '[Symbol.iterator]()' method that returns an iterator.
+        yield* this.entries();
+    }
+}
+exports.default = Headers;
+function normalizeName(name) {
+    if (typeof name !== 'string') {
+        name = String(name);
+    }
+    if (/[^a-z0-9\-#$%&'*+.^_`|~]/i.test(name) || name === '') {
+        throw new TypeError('Invalid character in header field name');
+    }
+    return name.toLowerCase();
+}
+function normalizeValue(value) {
+    if (typeof value !== 'string') {
+        value = String(value);
+    }
+    return value;
+}
+// Build a destructive iterator for the value list
+function iteratorFor(items) {
+    const iterator = {
+        next() {
+            const value = items.shift();
+            return { done: value === undefined, value };
+        }
+    };
+    iterator[Symbol.iterator] = function () {
+        return iterator;
+    };
+    return iterator;
+}

package/dist/node/fetch/response.node.d.ts

@@ -0,0 +1,22 @@
+import Headers from './headers.node';
+export default class Response {
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly headers: Headers;
+    readonly url: string;
+    bodyUsed: boolean;
+    private readonly _body;
+    constructor(body: any, options: {
+        headers?: any;
+        status?: number;
+        statusText?: string;
+        url: string;
+    });
+    get body(): any;
+    arrayBuffer(): Promise<any>;
+    text(): Promise<string>;
+    json(): Promise<any>;
+    blob(): Promise<Blob>;
+}
+//# sourceMappingURL=response.node.d.ts.map

package/dist/node/fetch/response.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.node.d.ts","sourceRoot":"","sources":["../../../src/node/fetch/response.node.ts"],"names":[],"mappings":"AAEA,OAAO,OAAO,MAAM,gBAAgB,CAAC;AAoBrC,MAAM,CAAC,OAAO,OAAO,QAAQ;IAC3B,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,OAAO,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC;gBAIrB,IAAI,KAAA,EACJ,OAAO,EAAE;QACP,OAAO,CAAC,MAAC;QACT,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,GAAG,EAAE,MAAM,CAAC;KACb;IAuBH,IAAI,IAAI,QAKP;IAIK,WAAW;IAQX,IAAI;IAMJ,IAAI;IAKJ,IAAI;CAMX"}

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

@@ -0,0 +1,77 @@
+"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)]);
+        }
+    }
+    // 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;
+    }
+    // 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()]);
+    }
+}
+exports.default = Response;

package/dist/node/fetch/utils/decode-data-uri.node.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 }
+ */
+export declare function decodeDataUri(uri: any): {
+    arrayBuffer: any;
+    mimeType: any;
+};
+/**
+ * @param data
+ * @todo Duplicate of core
+ */
+export declare function toArrayBuffer(data: any): any;
+//# sourceMappingURL=decode-data-uri.node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"decode-data-uri.node.d.ts","sourceRoot":"","sources":["../../../../src/node/fetch/utils/decode-data-uri.node.ts"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,GAAG,KAAA;;;EAoBhC;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,KAAA,OA4BjC"}

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

@@ -0,0 +1,63 @@
+"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 assert_1 = require("../../../utils/assert");
+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 };
+}
+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)) {
+        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
+    if (data && typeof data === 'object' && data._toArrayBuffer) {
+        return data._toArrayBuffer();
+    }
+    return (0, assert_1.assert)(false, `toArrayBuffer(${JSON.stringify(data, null, 2).slice(10)})`);
+}
+exports.toArrayBuffer = toArrayBuffer;

package/dist/node/fetch/utils/stream-utils.node.d.ts

@@ -0,0 +1,4 @@
+export declare function createReadStream(url: any, options: any): Promise<unknown>;
+export declare function decompressReadStream(readStream: any, headers: any): any;
+export declare function concatenateReadStream(readStream: any): Promise<unknown>;
+//# sourceMappingURL=stream-utils.node.d.ts.map

package/dist/node/fetch/utils/stream-utils.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-utils.node.d.ts","sourceRoot":"","sources":["../../../../src/node/fetch/utils/stream-utils.node.ts"],"names":[],"mappings":"AAUA,wBAAsB,gBAAgB,CAAC,GAAG,KAAA,EAAE,OAAO,KAAA,oBAsBlD;AAED,wBAAgB,oBAAoB,CAAC,UAAU,KAAA,EAAE,OAAO,KAAA,OAYvD;AAED,wBAAsB,qBAAqB,CAAC,UAAU,KAAA,oBAoBrD"}

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

@@ -0,0 +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.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");
+const isRequestURL = (url) => 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
+    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();
+    });
+}
+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;
+    }
+}
+exports.decompressReadStream = decompressReadStream;
+async function concatenateReadStream(readStream) {
+    let arrayBuffer = new ArrayBuffer(0);
+    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'));
+            }
+            const chunkAsArrayBuffer = (0, decode_data_uri_node_1.toArrayBuffer)(chunk);
+            arrayBuffer = concatenateArrayBuffers(arrayBuffer, chunkAsArrayBuffer);
+        });
+        readStream.on('end', () => 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
+    };
+}
+function concatenateArrayBuffers(source1, source2) {
+    const sourceArray1 = source1 instanceof ArrayBuffer ? new Uint8Array(source1) : source1;
+    const sourceArray2 = source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2;
+    const temp = new Uint8Array(sourceArray1.byteLength + sourceArray2.byteLength);
+    temp.set(sourceArray1, 0);
+    temp.set(sourceArray2, sourceArray1.byteLength);
+    return temp.buffer;
+}

package/dist/node/file/blob-stream-controller.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Forked from @gozala's web-blob under MIT license
+ * @see https://github.com/Gozala/web-blob
+ */
+export declare class BlobStreamController {
+    private chunks;
+    private isWorking;
+    private isCancelled;
+    /**
+     * @param chunks
+     */
+    constructor(chunks: Iterator<Uint8Array>);
+    /**
+     * @param controller
+     */
+    start(controller: ReadableStreamDefaultController): void;
+    /**
+     *
+     * @param controller
+     */
+    work(controller: ReadableStreamDefaultController): Promise<void>;
+    /**
+     *
+     * @param {ReadableStreamDefaultController} controller
+     */
+    pull(controller: any): void;
+    cancel(): void;
+}
+//# sourceMappingURL=blob-stream-controller.d.ts.map

package/dist/node/file/blob-stream-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blob-stream-controller.d.ts","sourceRoot":"","sources":["../../../src/node/file/blob-stream-controller.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,WAAW,CAAkB;IAErC;;OAEG;gBACS,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC;IAIxC;;OAEG;IACH,KAAK,CAAC,UAAU,EAAE,+BAA+B;IAIjD;;;OAGG;IACG,IAAI,CAAC,UAAU,EAAE,+BAA+B;IAyBtD;;;OAGG;IACH,IAAI,CAAC,UAAU,KAAA;IAKf,MAAM;CAGP"}