@loaders.gl/compression 3.4.10 → 3.4.12

package/dist/bundle.js

@@ -1,5 +0,0 @@
-"use strict";
-// @ts-nocheck
-const moduleExports = require('./index');
-globalThis.loaders = globalThis.loaders || {};
-module.exports = Object.assign(globalThis.loaders, moduleExports);

package/dist/index.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compressOnWorker = exports.CompressionWorker = exports.LZOCompression = exports.BrotliCompression = exports.SnappyCompression = exports.ZstdCompression = exports.LZ4Compression = exports.GZipCompression = exports.DeflateCompression = exports.NoCompression = exports.Compression = void 0;
-var compression_1 = require("./lib/compression");
-Object.defineProperty(exports, "Compression", { enumerable: true, get: function () { return compression_1.Compression; } });
-var no_compression_1 = require("./lib/no-compression");
-Object.defineProperty(exports, "NoCompression", { enumerable: true, get: function () { return no_compression_1.NoCompression; } });
-var deflate_compression_1 = require("./lib/deflate-compression");
-Object.defineProperty(exports, "DeflateCompression", { enumerable: true, get: function () { return deflate_compression_1.DeflateCompression; } });
-var gzip_compression_1 = require("./lib/gzip-compression");
-Object.defineProperty(exports, "GZipCompression", { enumerable: true, get: function () { return gzip_compression_1.GZipCompression; } });
-var lz4_compression_1 = require("./lib/lz4-compression");
-Object.defineProperty(exports, "LZ4Compression", { enumerable: true, get: function () { return lz4_compression_1.LZ4Compression; } });
-var zstd_compression_1 = require("./lib/zstd-compression");
-Object.defineProperty(exports, "ZstdCompression", { enumerable: true, get: function () { return zstd_compression_1.ZstdCompression; } });
-var snappy_compression_1 = require("./lib/snappy-compression");
-Object.defineProperty(exports, "SnappyCompression", { enumerable: true, get: function () { return snappy_compression_1.SnappyCompression; } });
-var brotli_compression_1 = require("./lib/brotli-compression");
-Object.defineProperty(exports, "BrotliCompression", { enumerable: true, get: function () { return brotli_compression_1.BrotliCompression; } });
-var lzo_compression_1 = require("./lib/lzo-compression");
-Object.defineProperty(exports, "LZOCompression", { enumerable: true, get: function () { return lzo_compression_1.LZOCompression; } });
-var compression_worker_1 = require("./compression-worker");
-Object.defineProperty(exports, "CompressionWorker", { enumerable: true, get: function () { return compression_worker_1.CompressionWorker; } });
-Object.defineProperty(exports, "compressOnWorker", { enumerable: true, get: function () { return compression_worker_1.compressOnWorker; } });

package/dist/lib/brotli-compression.js

@@ -1,92 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BrotliCompression = void 0;
-const compression_1 = require("./compression");
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-// import brotli from 'brotli';  // https://bundlephobia.com/package/brotli
-const decode_1 = require("../brotli/decode");
-const zlib_1 = __importDefault(require("zlib"));
-const loader_utils_2 = require("@loaders.gl/loader-utils");
-const DEFAULT_BROTLI_OPTIONS = {
-    brotli: {
-        mode: 0,
-        quality: 8,
-        lgwin: 22
-    }
-};
-let brotli;
-/**
- * brotli compression / decompression
- */
-class BrotliCompression extends compression_1.Compression {
-    constructor(options) {
-        super(options);
-        this.name = 'brotli';
-        this.extensions = ['br'];
-        this.contentEncodings = ['br'];
-        this.isSupported = true;
-        this.options = options;
-    }
-    /**
-     * brotli is an injectable dependency due to big size
-     * @param options
-     */
-    async preload() {
-        brotli = brotli || this.options?.modules?.brotli;
-        if (!brotli) {
-            // eslint-disable-next-line no-console
-            console.warn(`${this.name} library not installed`);
-        }
-    }
-    async compress(input) {
-        // On Node.js we can use built-in zlib
-        if (!loader_utils_1.isBrowser && this.options.brotli?.useZlib) {
-            const buffer = await (0, loader_utils_2.promisify1)(zlib_1.default.brotliCompress)(input);
-            return (0, loader_utils_1.toArrayBuffer)(buffer);
-        }
-        return this.compressSync(input);
-    }
-    compressSync(input) {
-        // On Node.js we can use built-in zlib
-        if (!loader_utils_1.isBrowser && this.options.brotli?.useZlib) {
-            const buffer = zlib_1.default.brotliCompressSync(input);
-            return (0, loader_utils_1.toArrayBuffer)(buffer);
-        }
-        const brotliOptions = { ...DEFAULT_BROTLI_OPTIONS.brotli, ...this.options?.brotli };
-        const inputArray = new Uint8Array(input);
-        if (!brotli) {
-            throw new Error('brotli compression: brotli module not installed');
-        }
-        // @ts-ignore brotli types state that only Buffers are accepted...
-        const outputArray = brotli.compress(inputArray, brotliOptions);
-        return outputArray.buffer;
-    }
-    async decompress(input) {
-        // On Node.js we can use built-in zlib
-        if (!loader_utils_1.isBrowser && this.options.brotli?.useZlib) {
-            const buffer = await (0, loader_utils_2.promisify1)(zlib_1.default.brotliDecompress)(input);
-            return (0, loader_utils_1.toArrayBuffer)(buffer);
-        }
-        return this.decompressSync(input);
-    }
-    decompressSync(input) {
-        // On Node.js we can use built-in zlib
-        if (!loader_utils_1.isBrowser && this.options.brotli?.useZlib) {
-            const buffer = zlib_1.default.brotliDecompressSync(input);
-            return (0, loader_utils_1.toArrayBuffer)(buffer);
-        }
-        const brotliOptions = { ...DEFAULT_BROTLI_OPTIONS.brotli, ...this.options?.brotli };
-        const inputArray = new Uint8Array(input);
-        if (brotli) {
-            // @ts-ignore brotli types state that only Buffers are accepted...
-            const outputArray = brotli.decompress(inputArray, brotliOptions);
-            return outputArray.buffer;
-        }
-        const outputArray = (0, decode_1.BrotliDecode)(inputArray, undefined);
-        return outputArray.buffer;
-    }
-}
-exports.BrotliCompression = BrotliCompression;

package/dist/lib/compression.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Compression = void 0;
-// Compression interface
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-/** Compression */
-class Compression {
-    constructor(options) {
-        this.compressBatches = this.compressBatches.bind(this);
-        this.decompressBatches = this.decompressBatches.bind(this);
-    }
-    /** Preloads any dynamic libraries. May enable sync functions */
-    async preload() {
-        return;
-    }
-    /** Asynchronously compress data */
-    async compress(input) {
-        await this.preload();
-        return this.compressSync(input);
-    }
-    /** Asynchronously decompress data */
-    async decompress(input, size) {
-        await this.preload();
-        return this.decompressSync(input, size);
-    }
-    /** Synchronously compress data */
-    compressSync(input) {
-        throw new Error(`${this.name}: sync compression not supported`);
-    }
-    /** Synchronously compress data */
-    decompressSync(input, size) {
-        throw new Error(`${this.name}: sync decompression not supported`);
-    }
-    /** Compress batches */
-    async *compressBatches(asyncIterator) {
-        // TODO - implement incremental compression
-        const input = await this.concatenate(asyncIterator);
-        yield this.compress(input);
-    }
-    /** Decompress batches */
-    async *decompressBatches(asyncIterator) {
-        // TODO - implement incremental compression
-        const input = await this.concatenate(asyncIterator);
-        yield this.decompress(input);
-    }
-    // HELPERS
-    concatenate(asyncIterator) {
-        return (0, loader_utils_1.concatenateArrayBuffersAsync)(asyncIterator);
-    }
-    improveError(error) {
-        if (!error.message.includes(this.name)) {
-            error.message = `${this.name} ${error.message}`;
-        }
-        return error;
-    }
-}
-exports.Compression = Compression;

package/dist/lib/deflate-compression.js

@@ -1,135 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeflateCompression = void 0;
-const compression_1 = require("./compression");
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const pako_1 = __importDefault(require("pako")); // https://bundlephobia.com/package/pako
-const zlib_1 = __importDefault(require("zlib"));
-const loader_utils_2 = require("@loaders.gl/loader-utils");
-/**
- * DEFLATE compression / decompression
- */
-class DeflateCompression extends compression_1.Compression {
-    constructor(options = {}) {
-        super(options);
-        this.name = 'deflate';
-        this.extensions = [];
-        this.contentEncodings = ['deflate'];
-        this.isSupported = true;
-        this._chunks = [];
-        this.options = options;
-    }
-    async compress(input) {
-        // On Node.js we can use built-in zlib
-        if (!loader_utils_1.isBrowser && this.options.deflate?.useZlib) {
-            const buffer = this.options.deflate?.gzip
-                ? await (0, loader_utils_2.promisify1)(zlib_1.default.gzip)(input)
-                : await (0, loader_utils_2.promisify1)(zlib_1.default.deflate)(input);
-            return (0, loader_utils_1.toArrayBuffer)(buffer);
-        }
-        return this.compressSync(input);
-    }
-    async decompress(input) {
-        // On Node.js we can use built-in zlib
-        if (!loader_utils_1.isBrowser && this.options.deflate?.useZlib) {
-            const buffer = this.options.deflate?.gzip
-                ? await (0, loader_utils_2.promisify1)(zlib_1.default.gunzip)(input)
-                : await (0, loader_utils_2.promisify1)(zlib_1.default.inflate)(input);
-            return (0, loader_utils_1.toArrayBuffer)(buffer);
-        }
-        return this.decompressSync(input);
-    }
-    compressSync(input) {
-        // On Node.js we can use built-in zlib
-        if (!loader_utils_1.isBrowser && this.options.deflate?.useZlib) {
-            const buffer = this.options.deflate?.gzip ? zlib_1.default.gzipSync(input) : zlib_1.default.deflateSync(input);
-            return (0, loader_utils_1.toArrayBuffer)(buffer);
-        }
-        const pakoOptions = this.options?.deflate || {};
-        const inputArray = new Uint8Array(input);
-        return pako_1.default.deflate(inputArray, pakoOptions).buffer;
-    }
-    decompressSync(input) {
-        // On Node.js we can use built-in zlib
-        if (!loader_utils_1.isBrowser && this.options.deflate?.useZlib) {
-            const buffer = this.options.deflate?.gzip ? zlib_1.default.gunzipSync(input) : zlib_1.default.inflateSync(input);
-            return (0, loader_utils_1.toArrayBuffer)(buffer);
-        }
-        const pakoOptions = this.options?.deflate || {};
-        const inputArray = new Uint8Array(input);
-        return pako_1.default.inflate(inputArray, pakoOptions).buffer;
-    }
-    async *compressBatches(asyncIterator) {
-        const pakoOptions = this.options?.deflate || {};
-        const pakoProcessor = new pako_1.default.Deflate(pakoOptions);
-        yield* this.transformBatches(pakoProcessor, asyncIterator);
-    }
-    async *decompressBatches(asyncIterator) {
-        const pakoOptions = this.options?.deflate || {};
-        const pakoProcessor = new pako_1.default.Inflate(pakoOptions);
-        yield* this.transformBatches(pakoProcessor, asyncIterator);
-    }
-    async *transformBatches(pakoProcessor, asyncIterator) {
-        pakoProcessor.onData = this._onData.bind(this);
-        pakoProcessor.onEnd = this._onEnd.bind(this);
-        for await (const chunk of asyncIterator) {
-            const uint8Array = new Uint8Array(chunk);
-            const ok = pakoProcessor.push(uint8Array, false); // false -> not last chunk
-            if (!ok) {
-                throw new Error(`${this._getError()}write`);
-            }
-            const chunks = this._getChunks();
-            yield* chunks;
-        }
-        // End
-        const emptyChunk = new Uint8Array(0);
-        const ok = pakoProcessor.push(emptyChunk, true); // true -> last chunk
-        if (!ok) {
-            // For some reason we get error but it still works???
-            // throw new Error(this._getError() + 'end');
-        }
-        const chunks = this._getChunks();
-        yield* chunks;
-    }
-    _onData(chunk) {
-        this._chunks.push(chunk);
-    }
-    _onEnd(status) {
-        if (status !== 0) {
-            throw new Error(this._getError(status) + this._chunks.length);
-        }
-    }
-    _getChunks() {
-        const chunks = this._chunks;
-        this._chunks = [];
-        return chunks;
-    }
-    // TODO - For some reason we don't get the error message from pako in _onEnd?
-    _getError(code = 0) {
-        const MESSAGES = {
-            /* Z_NEED_DICT       2  */
-            2: 'need dictionary',
-            /* Z_STREAM_END      1  */
-            1: 'stream end',
-            /* Z_OK              0  */
-            0: '',
-            /* Z_ERRNO         (-1) */
-            '-1': 'file error',
-            /* Z_STREAM_ERROR  (-2) */
-            '-2': 'stream error',
-            /* Z_DATA_ERROR    (-3) */
-            '-3': 'data error',
-            /* Z_MEM_ERROR     (-4) */
-            '-4': 'insufficient memory',
-            /* Z_BUF_ERROR     (-5) */
-            '-5': 'buffer error',
-            /* Z_VERSION_ERROR (-6) */
-            '-6': 'incompatible version'
-        };
-        return `${this.name}: ${MESSAGES[code]}`;
-    }
-}
-exports.DeflateCompression = DeflateCompression;

package/dist/lib/gzip-compression.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GZipCompression = void 0;
-const deflate_compression_1 = require("./deflate-compression");
-/**
- * GZIP compression / decompression
- */
-class GZipCompression extends deflate_compression_1.DeflateCompression {
-    constructor(options) {
-        super({ ...options, deflate: { ...options?.gzip, gzip: true } });
-        this.name = 'gzip';
-        this.extensions = ['gz', 'gzip'];
-        this.contentEncodings = ['gzip', 'x-gzip'];
-        this.isSupported = true;
-    }
-}
-exports.GZipCompression = GZipCompression;

package/dist/lib/lz4-compression.js

@@ -1,141 +0,0 @@
-"use strict";
-// Copyright (c) 2012 Pierre Curto
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LZ4Compression = void 0;
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-/* eslint-disable complexity */
-/* eslint-disable max-statements */
-// LZ4
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const compression_1 = require("./compression");
-// import lz4js from 'lz4js'; // https://bundlephobia.com/package/lz4
-const LZ4_MAGIC_NUMBER = 0x184d2204;
-let lz4js;
-/**
- * LZ4 compression / decompression
- */
-class LZ4Compression extends compression_1.Compression {
-    constructor(options) {
-        super(options);
-        this.name = 'lz4';
-        this.extensions = ['lz4'];
-        this.contentEncodings = ['x-lz4'];
-        this.isSupported = true;
-        this.options = options;
-        lz4js = lz4js || this.options?.modules?.lz4js;
-        if (!lz4js) {
-            throw new Error(this.name);
-        }
-    }
-    compressSync(input) {
-        const inputArray = new Uint8Array(input);
-        return lz4js.compress(inputArray).buffer;
-    }
-    /**
-     * Decompresses an ArrayBuffer containing an Lz4 frame. maxSize is optional; if not
-     * provided, a maximum size will be determined by examining the data. The
-     * returned ArrayBuffer will always be perfectly sized.
-     * If data provided without magic number we will parse it as block
-     */
-    decompressSync(data, maxSize) {
-        try {
-            const isMagicNumberExists = this.checkMagicNumber(data);
-            const inputArray = new Uint8Array(data);
-            if (isMagicNumberExists) {
-                return lz4js.decompress(inputArray, maxSize).buffer;
-            }
-            if (!maxSize) {
-                const error = new Error('Need to provide maxSize');
-                throw this.improveError(error);
-            }
-            let uncompressed = new Uint8Array(maxSize);
-            const uncompressedSize = this.decodeBlock(inputArray, uncompressed);
-            uncompressed = uncompressed.slice(0, uncompressedSize);
-            return (0, loader_utils_1.toArrayBuffer)(uncompressed);
-        }
-        catch (error) {
-            throw this.improveError(error);
-        }
-    }
-    /**
-     * Decode lz4 file as block
-     * Solution taken from here
-     * https://github.com/pierrec/node-lz4/blob/0dac687262403fd34f905b963da7220692f2a4a1/lib/binding.js#L25
-     * @param input
-     * @param output
-     * @param startIndex
-     * @param endIndex
-     */
-    decodeBlock(data, output, startIndex, endIndex) {
-        startIndex = startIndex || 0;
-        endIndex = endIndex || data.length - startIndex;
-        let uncompressedSize = 0;
-        // Process each sequence in the incoming data
-        for (let index = startIndex; index < endIndex;) {
-            const token = data[index++];
-            // Literals
-            let literalsLength = token >> 4;
-            if (literalsLength > 0) {
-                // length of literals
-                let length = literalsLength + 240;
-                while (length === 255) {
-                    length = data[index++];
-                    literalsLength += length;
-                }
-                // Copy the literals
-                const end = index + literalsLength;
-                while (index < end) {
-                    output[uncompressedSize++] = data[index++];
-                }
-                // End of buffer?
-                if (index === endIndex) {
-                    return uncompressedSize;
-                }
-            }
-            // Match copy
-            // 2 bytes offset (little endian)
-            const offset = data[index++] | (data[index++] << 8);
-            // 0 is an invalid offset value
-            if (offset === 0 || offset > uncompressedSize) {
-                return -(index - 2);
-            }
-            // length of match copy
-            let matchLength = token & 0xf;
-            let length = matchLength + 240;
-            while (length === 255) {
-                length = data[index++];
-                matchLength += length;
-            }
-            // Copy the match
-            let pos = uncompressedSize - offset; // position of the match copy in the current output
-            const end = uncompressedSize + matchLength + 4; // minmatch = 4
-            while (uncompressedSize < end) {
-                output[uncompressedSize++] = output[pos++];
-            }
-        }
-        return uncompressedSize;
-    }
-    /**
-     * Compare file magic with lz4 magic number
-     * @param input
-     */
-    checkMagicNumber(data) {
-        const magic = new Uint32Array(data.slice(0, 4));
-        return magic[0] === LZ4_MAGIC_NUMBER;
-    }
-}
-exports.LZ4Compression = LZ4Compression;

package/dist/lib/lzo-compression.js

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LZOCompression = void 0;
-// LZO
-// import {loadLibrary} from '@loaders.gl/worker-utils';
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const compression_1 = require("./compression");
-// import {isBrowser} from '@loaders.gl/loader-utils';
-// import lzo from 'lzo'; // https://bundlephobia.com/package/lzo
-// import {decompress} from 'lzo-wasm';
-// const LZO_WASM_JS_URL = './node_modules/lzo-wasm/lzo-wasm.js';
-// const LZO_WASM_WASM_URL = './node_modules/lzo-wasm/lzo-wasm.wasm';
-let lzo;
-/**
- * Lempel-Ziv-Oberheimer compression / decompression
- */
-class LZOCompression extends compression_1.Compression {
-    /**
-     * lzo is an injectable dependency due to big size
-     * @param options
-     */
-    constructor(options) {
-        super(options);
-        this.name = 'lzo';
-        this.extensions = [];
-        this.contentEncodings = [];
-        this.isSupported = false; // !isBrowser;
-        this.options = options;
-        lzo = lzo || this.options?.modules?.lzo;
-        if (!lzo) {
-            throw new Error(this.name);
-        }
-    }
-    async preload() {
-        // await loadLibrary(LZO_WASM_JS_URL);
-        // await loadLibrary(LZO_WASM_WASM_URL);
-    }
-    async compress(input) {
-        await this.preload();
-        // const inputArray = new Uint8Array(input);
-        const inputBuffer = (0, loader_utils_1.toBuffer)(input);
-        return lzo.compress(inputBuffer).buffer;
-    }
-    async decompress(input) {
-        try {
-            await this.preload();
-            // const inputArray = new Uint8Array(input);
-            const inputBuffer = (0, loader_utils_1.toBuffer)(input);
-            return lzo.decompress(inputBuffer).buffer;
-        }
-        catch (error) {
-            // TODO - solve SharedArrayBuffer issues
-            // return decompress(input);
-            throw error;
-        }
-    }
-}
-exports.LZOCompression = LZOCompression;

package/dist/lib/no-compression.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NoCompression = void 0;
-const compression_1 = require("./compression");
-/**
- * Applies no compression.
- */
-class NoCompression extends compression_1.Compression {
-    constructor(options) {
-        super(options);
-        this.name = 'uncompressed';
-        this.extensions = [];
-        this.contentEncodings = [];
-        this.isSupported = true;
-        this.options = options || {};
-    }
-    compressSync(input) {
-        return input;
-    }
-    decompressSync(input) {
-        return input;
-    }
-    async *compressBatches(asyncIterator) {
-        return yield* asyncIterator;
-    }
-    async *decompressBatches(asyncIterator) {
-        return yield* asyncIterator;
-    }
-}
-exports.NoCompression = NoCompression;

package/dist/lib/snappy-compression.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SnappyCompression = void 0;
-const compression_1 = require("./compression");
-const snappyjs_1 = require("snappyjs"); // https://bundlephobia.com/package/snappy
-/**
- * Snappy/zippy compression / decompression
- */
-class SnappyCompression extends compression_1.Compression {
-    constructor(options) {
-        super(options);
-        this.name = 'snappy';
-        this.extensions = [];
-        this.contentEncodings = [];
-        this.isSupported = true;
-        this.options = options || {};
-    }
-    compressSync(input) {
-        // Accepts arrayBuffer - https://github.com/zhipeng-jia/snappyjs#usage
-        return (0, snappyjs_1.compress)(input);
-    }
-    decompressSync(input) {
-        // Accepts arrayBuffer - https://github.com/zhipeng-jia/snappyjs#usage
-        return (0, snappyjs_1.uncompress)(input);
-    }
-}
-exports.SnappyCompression = SnappyCompression;

package/dist/lib/zstd-compression.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZstdCompression = void 0;
-const compression_1 = require("./compression");
-// import {ZstdCodec} from 'zstd-codec'; // https://bundlephobia.com/package/zstd-codec
-let ZstdCodec;
-let zstd;
-/**
- * Zstandard compression / decompression
- */
-class ZstdCompression extends compression_1.Compression {
-    /**
-     * zstd-codec is an injectable dependency due to big size
-     * @param options
-     */
-    constructor(options) {
-        super(options);
-        this.name = 'zstd';
-        this.extensions = [];
-        this.contentEncodings = [];
-        this.isSupported = true;
-        this.options = options;
-        ZstdCodec = this.options?.modules?.['zstd-codec'];
-        if (!ZstdCodec) {
-            // eslint-disable-next-line no-console
-            console.warn(`${this.name} library not installed`);
-        }
-    }
-    async preload() {
-        if (!zstd && ZstdCodec) {
-            zstd = await new Promise((resolve) => ZstdCodec.run((zstd) => resolve(zstd)));
-        }
-    }
-    compressSync(input) {
-        const simpleZstd = new zstd.Simple();
-        const inputArray = new Uint8Array(input);
-        return simpleZstd.compress(inputArray).buffer;
-    }
-    decompressSync(input) {
-        const simpleZstd = new zstd.Simple();
-        // var ddict = new zstd.Dict.Decompression(dictData);
-        // var jsonBytes = simpleZstd.decompressUsingDict(jsonZstData, ddict);
-        const inputArray = new Uint8Array(input);
-        return simpleZstd.decompress(inputArray).buffer;
-    }
-}
-exports.ZstdCompression = ZstdCompression;

package/dist/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });