@loaders.gl/compression 4.0.0-alpha.1 → 4.0.0-alpha.11

package/dist/lib/deflate-compression.js

@@ -1,157 +1,135 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { Compression } from './compression';
-import { isBrowser, toArrayBuffer } from '@loaders.gl/loader-utils';
-import pako from 'pako';
-import zlib from 'zlib';
-import { promisify } from '@loaders.gl/loader-utils';
-export class DeflateCompression extends Compression {
-  constructor(options = {}) {
-    super(options);
-
-    _defineProperty(this, "name", 'deflate');
-
-    _defineProperty(this, "extensions", []);
-
-    _defineProperty(this, "contentEncodings", ['deflate']);
-
-    _defineProperty(this, "isSupported", true);
-
-    _defineProperty(this, "options", void 0);
-
-    _defineProperty(this, "_chunks", []);
-
-    this.options = options;
-  }
-
-  async compress(input) {
-    var _this$options$deflate;
-
-    if (!isBrowser && (_this$options$deflate = this.options.deflate) !== null && _this$options$deflate !== void 0 && _this$options$deflate.useZlib) {
-      var _this$options$deflate2;
-
-      const buffer = (_this$options$deflate2 = this.options.deflate) !== null && _this$options$deflate2 !== void 0 && _this$options$deflate2.gzip ? await promisify(zlib.gzip)(input) : await promisify(zlib.deflate)(input);
-      return toArrayBuffer(buffer);
+"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;
     }
-
-    return this.compressSync(input);
-  }
-
-  async decompress(input) {
-    var _this$options$deflate3;
-
-    if (!isBrowser && (_this$options$deflate3 = this.options.deflate) !== null && _this$options$deflate3 !== void 0 && _this$options$deflate3.useZlib) {
-      var _this$options$deflate4;
-
-      const buffer = (_this$options$deflate4 = this.options.deflate) !== null && _this$options$deflate4 !== void 0 && _this$options$deflate4.gzip ? await promisify(zlib.gunzip)(input) : await promisify(zlib.inflate)(input);
-      return toArrayBuffer(buffer);
+    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);
     }
-
-    return this.decompressSync(input);
-  }
-
-  compressSync(input) {
-    var _this$options$deflate5, _this$options;
-
-    if (!isBrowser && (_this$options$deflate5 = this.options.deflate) !== null && _this$options$deflate5 !== void 0 && _this$options$deflate5.useZlib) {
-      var _this$options$deflate6;
-
-      const buffer = (_this$options$deflate6 = this.options.deflate) !== null && _this$options$deflate6 !== void 0 && _this$options$deflate6.gzip ? zlib.gzipSync(input) : zlib.deflateSync(input);
-      return toArrayBuffer(buffer);
+    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);
     }
-
-    const pakoOptions = ((_this$options = this.options) === null || _this$options === void 0 ? void 0 : _this$options.deflate) || {};
-    const inputArray = new Uint8Array(input);
-    return pako.deflate(inputArray, pakoOptions).buffer;
-  }
-
-  decompressSync(input) {
-    var _this$options$deflate7, _this$options2;
-
-    if (!isBrowser && (_this$options$deflate7 = this.options.deflate) !== null && _this$options$deflate7 !== void 0 && _this$options$deflate7.useZlib) {
-      var _this$options$deflate8;
-
-      const buffer = (_this$options$deflate8 = this.options.deflate) !== null && _this$options$deflate8 !== void 0 && _this$options$deflate8.gzip ? zlib.gunzipSync(input) : zlib.inflateSync(input);
-      return toArrayBuffer(buffer);
+    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;
     }
-
-    const pakoOptions = ((_this$options2 = this.options) === null || _this$options2 === void 0 ? void 0 : _this$options2.deflate) || {};
-    const inputArray = new Uint8Array(input);
-    return pako.inflate(inputArray, pakoOptions).buffer;
-  }
-
-  async *compressBatches(asyncIterator) {
-    var _this$options3;
-
-    const pakoOptions = ((_this$options3 = this.options) === null || _this$options3 === void 0 ? void 0 : _this$options3.deflate) || {};
-    const pakoProcessor = new pako.Deflate(pakoOptions);
-    yield* this.transformBatches(pakoProcessor, asyncIterator);
-  }
-
-  async *decompressBatches(asyncIterator) {
-    var _this$options4;
-
-    const pakoOptions = ((_this$options4 = this.options) === null || _this$options4 === void 0 ? void 0 : _this$options4.deflate) || {};
-    const pakoProcessor = new pako.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);
-
-      if (!ok) {
-        throw new Error("".concat(this._getError(), "write"));
-      }
-
-      const chunks = this._getChunks();
-
-      yield* chunks;
+    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;
     }
-
-    const emptyChunk = new Uint8Array(0);
-    const ok = pakoProcessor.push(emptyChunk, true);
-
-    if (!ok) {}
-
-    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);
+    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]}`;
     }
-  }
-
-  _getChunks() {
-    const chunks = this._chunks;
-    this._chunks = [];
-    return chunks;
-  }
-
-  _getError(code = 0) {
-    const MESSAGES = {
-      2: 'need dictionary',
-      1: 'stream end',
-      0: '',
-      '-1': 'file error',
-      '-2': 'stream error',
-      '-3': 'data error',
-      '-4': 'insufficient memory',
-      '-5': 'buffer error',
-      '-6': 'incompatible version'
-    };
-    return "".concat(this.name, ": ").concat(MESSAGES[code]);
-  }
-
 }
-//# sourceMappingURL=deflate-compression.js.map
+exports.DeflateCompression = DeflateCompression;

package/dist/lib/gzip-compression.d.ts

@@ -0,0 +1,17 @@
+import type { CompressionOptions } from './compression';
+import { DeflateCompression } from './deflate-compression';
+import pako from 'pako';
+export type GZipCompressionOptions = CompressionOptions & {
+    gzip?: pako.InflateOptions & pako.DeflateOptions;
+};
+/**
+ * GZIP compression / decompression
+ */
+export declare class GZipCompression extends DeflateCompression {
+    readonly name: string;
+    readonly extensions: string[];
+    readonly contentEncodings: string[];
+    readonly isSupported = true;
+    constructor(options?: GZipCompressionOptions);
+}
+//# sourceMappingURL=gzip-compression.d.ts.map

package/dist/lib/gzip-compression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gzip-compression.d.ts","sourceRoot":"","sources":["../../src/lib/gzip-compression.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,eAAe,CAAC;AACtD,OAAO,EAAC,kBAAkB,EAAC,MAAM,uBAAuB,CAAC;AACzD,OAAO,IAAI,MAAM,MAAM,CAAC;AAExB,MAAM,MAAM,sBAAsB,GAAG,kBAAkB,GAAG;IACxD,IAAI,CAAC,EAAE,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC;CAClD,CAAC;AAEF;;GAEG;AACH,qBAAa,eAAgB,SAAQ,kBAAkB;IACrD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAU;IAC/B,QAAQ,CAAC,UAAU,WAAkB;IACrC,QAAQ,CAAC,gBAAgB,WAAsB;IAC/C,QAAQ,CAAC,WAAW,QAAQ;gBAEhB,OAAO,CAAC,EAAE,sBAAsB;CAG7C"}

package/dist/lib/gzip-compression.js

@@ -1,21 +1,17 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { DeflateCompression } from './deflate-compression';
-export class GZipCompression extends DeflateCompression {
-  constructor(options) {
-    super({ ...options,
-      deflate: { ...(options === null || options === void 0 ? void 0 : options.gzip),
-        gzip: true
-      }
-    });
-
-    _defineProperty(this, "name", 'gzip');
-
-    _defineProperty(this, "extensions", ['gz', 'gzip']);
-
-    _defineProperty(this, "contentEncodings", ['gzip', 'x-gzip']);
-
-    _defineProperty(this, "isSupported", true);
-  }
-
+"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;
+    }
 }
-//# sourceMappingURL=gzip-compression.js.map
+exports.GZipCompression = GZipCompression;

package/dist/lib/lz4-compression.d.ts

@@ -0,0 +1,37 @@
+import type { CompressionOptions } from './compression';
+import { Compression } from './compression';
+/**
+ * LZ4 compression / decompression
+ */
+export declare class LZ4Compression extends Compression {
+    readonly name: string;
+    readonly extensions: string[];
+    readonly contentEncodings: string[];
+    readonly isSupported = true;
+    readonly options: CompressionOptions;
+    constructor(options: CompressionOptions);
+    compressSync(input: ArrayBuffer): ArrayBuffer;
+    /**
+     * 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: ArrayBuffer, maxSize?: number): ArrayBuffer;
+    /**
+     * 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: Uint8Array, output: Uint8Array, startIndex?: number, endIndex?: number): number;
+    /**
+     * Compare file magic with lz4 magic number
+     * @param input
+     */
+    checkMagicNumber(data: ArrayBuffer): boolean;
+}
+//# sourceMappingURL=lz4-compression.d.ts.map

package/dist/lib/lz4-compression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lz4-compression.d.ts","sourceRoot":"","sources":["../../src/lib/lz4-compression.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,eAAe,CAAC;AACtD,OAAO,EAAC,WAAW,EAAC,MAAM,eAAe,CAAC;AAM1C;;GAEG;AACH,qBAAa,cAAe,SAAQ,WAAW;IAC7C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAS;IAC9B,QAAQ,CAAC,UAAU,WAAW;IAC9B,QAAQ,CAAC,gBAAgB,WAAa;IACtC,QAAQ,CAAC,WAAW,QAAQ;IAC5B,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;gBAEzB,OAAO,EAAE,kBAAkB;IAUvC,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,WAAW;IAK7C;;;;;OAKG;IACH,cAAc,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,WAAW;IAwBhE;;;;;;;;OAQG;IACH,WAAW,CACT,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,UAAU,EAClB,UAAU,CAAC,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,MAAM,GAChB,MAAM;IAgET;;;OAGG;IACH,gBAAgB,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO;CAI7C"}

package/dist/lib/lz4-compression.js

@@ -1,117 +1,141 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { toArrayBuffer } from '@loaders.gl/loader-utils';
-import { Compression } from './compression';
+"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;
-export class LZ4Compression extends Compression {
-  constructor(options) {
-    var _this$options, _this$options$modules;
-
-    super(options);
-
-    _defineProperty(this, "name", 'lz4');
-
-    _defineProperty(this, "extensions", ['lz4']);
-
-    _defineProperty(this, "contentEncodings", ['x-lz4']);
-
-    _defineProperty(this, "isSupported", true);
-
-    _defineProperty(this, "options", void 0);
-
-    this.options = options;
-    lz4js = lz4js || ((_this$options = this.options) === null || _this$options === void 0 ? void 0 : (_this$options$modules = _this$options.modules) === null || _this$options$modules === void 0 ? void 0 : _this$options$modules.lz4js);
-
-    if (!lz4js) {
-      throw new Error(this.name);
+/**
+ * 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;
-  }
-
-  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 toArrayBuffer(uncompressed);
-    } catch (error) {
-      throw this.improveError(error);
+    compressSync(input) {
+        const inputArray = new Uint8Array(input);
+        return lz4js.compress(inputArray).buffer;
     }
-  }
-
-  decodeBlock(data, output, startIndex, endIndex) {
-    startIndex = startIndex || 0;
-    endIndex = endIndex || data.length - startIndex;
-    let uncompressedSize = 0;
-
-    for (let index = startIndex; index < endIndex;) {
-      const token = data[index++];
-      let literalsLength = token >> 4;
-
-      if (literalsLength > 0) {
-        let length = literalsLength + 240;
-
-        while (length === 255) {
-          length = data[index++];
-          literalsLength += length;
+    /**
+     * 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);
         }
-
-        const end = index + literalsLength;
-
-        while (index < end) {
-          output[uncompressedSize++] = data[index++];
+        catch (error) {
+            throw this.improveError(error);
         }
-
-        if (index === endIndex) {
-          return uncompressedSize;
+    }
+    /**
+     * 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++];
+            }
         }
-      }
-
-      const offset = data[index++] | data[index++] << 8;
-
-      if (offset === 0 || offset > uncompressedSize) {
-        return -(index - 2);
-      }
-
-      let matchLength = token & 0xf;
-      let length = matchLength + 240;
-
-      while (length === 255) {
-        length = data[index++];
-        matchLength += length;
-      }
-
-      let pos = uncompressedSize - offset;
-      const end = uncompressedSize + matchLength + 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;
     }
-
-    return uncompressedSize;
-  }
-
-  checkMagicNumber(data) {
-    const magic = new Uint32Array(data.slice(0, 4));
-    return magic[0] === LZ4_MAGIC_NUMBER;
-  }
-
 }
-//# sourceMappingURL=lz4-compression.js.map
+exports.LZ4Compression = LZ4Compression;