@patrickdk77/archive-defuse 0.0.0-stage → 0.1.1

package/dist/lzma-writers.js

@@ -0,0 +1,276 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WRITABLE_CHECKS = exports.passesRatio = void 0;
+exports.writeXz = writeXz;
+exports.writeAlone = writeAlone;
+exports.writeSevenZip = writeSevenZip;
+const checks_1 = require("./checks");
+const crc32_1 = require("./crc32");
+const encoder_1 = require("./encoder");
+const io_1 = require("./io");
+const lzma_sniff_1 = require("./lzma-sniff");
+const sevenzip_1 = require("./sevenzip");
+/** Bytes at the start of a file other readers search for their signatures, such as PDF's header. */
+const SIGNATURE_WINDOW = 1024;
+/** A stream's ratio counts once it passes this many decoded bytes, as the readers count it. */
+const RATIO_FLOOR = 1024 * 1024;
+/** True when data compressed this far would pass the ratio limit, so the writer stores it instead. */
+const passesRatio = (size, packed, ratioLimit) => size > RATIO_FLOOR && size > packed * ratioLimit;
+exports.passesRatio = passesRatio;
+async function* chunksOf(source, size, step, time) {
+    for (let pos = 0; pos < size; pos += step) {
+        time();
+        const b = await source.read(pos, Math.min(step, size - pos));
+        if (b.length !== Math.min(step, size - pos))
+            throw Object.assign(new Error('A temporary file returned fewer bytes than it holds'), { code: 'EIO' });
+        yield b;
+    }
+}
+/** The bytes of `content` in pieces of at most `step`, checked to add up to its size. */
+async function* piecesOf(content, step, time) {
+    let n = 0;
+    for await (const c of content.chunks()) {
+        for (let at = 0; at < c.length; at += step) {
+            time();
+            const piece = c.subarray(at, Math.min(c.length, at + step));
+            n += piece.length;
+            if (n > content.size)
+                throw new Error('An entry holds more bytes than its size');
+            yield piece;
+        }
+    }
+    if (n !== content.size)
+        throw new Error('An entry holds fewer bytes than its size');
+}
+const le32 = (v) => {
+    const b = Buffer.alloc(4);
+    b.writeUInt32LE(v >>> 0, 0);
+    return b;
+};
+const le64 = (v) => {
+    const b = Buffer.alloc(8);
+    b.writeUInt32LE(v % 2 ** 32, 0);
+    b.writeUInt32LE(Math.floor(v / 2 ** 32), 4);
+    return b;
+};
+/** An xz variable-length integer. */
+function vli(v) {
+    const out = [];
+    let n = v;
+    while (n >= 0x80) {
+        out.push((n % 0x80) | 0x80);
+        n = Math.floor(n / 0x80);
+    }
+    out.push(n);
+    return Uint8Array.from(out);
+}
+/** The check IDs this package writes, the ones it can compute. */
+exports.WRITABLE_CHECKS = new Set([checks_1.CHECK_NONE, checks_1.CHECK_CRC32, checks_1.CHECK_CRC64, checks_1.CHECK_SHA256]);
+/**
+ * Writes `content` as a single-stream xz file with one LZMA2 block, or no block when it is empty. The block's chunks
+ * come from Lzma2ChunkWriter. Chunks that would start within the first 1024 bytes of the file stay compressed.
+ */
+async function writeXz(content, checkId, sink, time, store = false) {
+    const flags = Uint8Array.of(0, checkId);
+    let out = 0;
+    const put = async (b) => {
+        out += b.length;
+        await sink.write(b);
+    };
+    await put(Buffer.concat([Uint8Array.from(lzma_sniff_1.XZ_MAGIC), flags, le32((0, crc32_1.crc32)(flags))]));
+    const size = content ? await content.size() : 0;
+    const records = [];
+    if (content && size > 0) {
+        // One filter, no sizes: size byte, flags, LZMA2's ID, props size, props, padding, CRC32.
+        const blockHeader = Buffer.alloc(12);
+        blockHeader.set([2, 0x00, 0x21, 0x01, encoder_1.LZMA2_DICT_PROP]);
+        blockHeader.writeUInt32LE((0, crc32_1.crc32)(blockHeader.subarray(0, 8)), 8);
+        await put(blockHeader);
+        const writer = new encoder_1.Lzma2ChunkWriter();
+        const check = (0, checks_1.makeCheck)(checkId);
+        let compressed = 0;
+        let pos = 0;
+        while (pos < size) {
+            time();
+            const force = out < SIGNATURE_WINDOW;
+            const piece = await content.read(pos, Math.min(force ? 1 << 15 : 1 << 16, size - pos));
+            if (piece.length === 0)
+                throw Object.assign(new Error('A temporary file returned fewer bytes than it holds'), { code: 'EIO' });
+            check?.update(piece);
+            const chunk = writer.chunk(piece, force, store);
+            compressed += chunk.length;
+            await put(chunk);
+            pos += piece.length;
+        }
+        await put(Uint8Array.of(0x00));
+        compressed += 1;
+        const padding = (4 - ((12 + compressed) % 4)) % 4;
+        await put(Buffer.alloc(padding));
+        await put(check ? check.digest() : new Uint8Array(0));
+        records.push({ unpadded: 12 + compressed + (0, checks_1.checkSize)(checkId), uncompressed: size });
+    }
+    const indexBody = Buffer.concat([Uint8Array.of(0x00), vli(records.length), ...records.flatMap(r => [vli(r.unpadded), vli(r.uncompressed)])]);
+    const index = Buffer.concat([indexBody, Buffer.alloc((4 - (indexBody.length % 4)) % 4)]);
+    await put(Buffer.concat([index, le32((0, crc32_1.crc32)(index))]));
+    const footerBody = Buffer.concat([le32((index.length + 4) / 4 - 1), flags]);
+    await put(Buffer.concat([le32((0, crc32_1.crc32)(footerBody)), footerBody, Uint8Array.of(0x59, 0x5a)]));
+}
+/** Writes `content` as an .lzma file with its size in the header and no end marker. */
+async function writeAlone(content, sink, time) {
+    const size = content ? await content.size() : 0;
+    const encoder = new encoder_1.RawLzmaEncoder(size);
+    const header = Buffer.alloc(13);
+    header[0] = encoder_1.PROPS_BYTE;
+    header.writeUInt32LE(encoder.dictSize, 1);
+    le64(size).copy(header, 5);
+    await sink.write(header);
+    if (content)
+        for await (const b of chunksOf(content, size, 1 << 16, time))
+            await sink.write(encoder.write(b));
+    await sink.write(encoder.finish());
+}
+/** A 7z number. */
+function num(v) {
+    if (v < 0x80)
+        return Uint8Array.of(v);
+    const bytes = [];
+    let n = v;
+    for (let i = 0; i < 8; i++) {
+        bytes.push(n % 256);
+        n = Math.floor(n / 256);
+    }
+    // Fewest extra bytes such that what is left fits in the first byte's free bits.
+    for (let extra = 1; extra <= 8; extra++) {
+        const high = Math.floor(v / 2 ** (8 * extra));
+        if (extra === 8 || high < 2 ** (7 - extra)) {
+            const mask = (0xff << (8 - extra)) & 0xff;
+            return Uint8Array.from([mask | (extra === 8 ? 0 : high), ...bytes.slice(0, extra)]);
+        }
+    }
+    throw new RangeError('A 7z number too large to write');
+}
+function bitVector(bits) {
+    const out = new Uint8Array(Math.ceil(bits.length / 8));
+    bits.forEach((b, i) => {
+        if (b)
+            out[i >> 3] |= 0x80 >> (i & 7);
+    });
+    return out;
+}
+/** A property of the files info: its ID, size and body. */
+const property = (id, body) => Buffer.concat([Uint8Array.of(id), num(body.length), body]);
+/** Times or attributes that may be missing for some entries: the all-defined byte or the vector, then external 0. */
+function definedValues(values) {
+    if (!values.some(v => v !== undefined))
+        return undefined;
+    const all = values.every(v => v !== undefined);
+    const head = all ? Uint8Array.of(1) : Buffer.concat([Uint8Array.of(0), bitVector(values.map(v => v !== undefined))]);
+    return Buffer.concat([head, Uint8Array.of(0), ...values.filter((v) => v !== undefined)]);
+}
+/**
+ * Writes a 7z archive: one LZMA folder per file with content, compressed by lzma1's encoder at its preset 1, a plain
+ * header with the names, empty files and directories, attributes and the times given, and CRCs of every file.
+ */
+async function writeSevenZip(entries, sink, temp, memoryThreshold, time, ratioLimit = Number.POSITIVE_INFINITY) {
+    if (entries.length === 0) {
+        const start = Buffer.alloc(20);
+        await sink.write(Buffer.concat([Uint8Array.from(lzma_sniff_1.SEVENZIP_MAGIC), Uint8Array.of(0, 4), le32((0, crc32_1.crc32)(start)), start]));
+        return;
+    }
+    const packed = new io_1.SpillSink(temp, memoryThreshold);
+    try {
+        const folders = [];
+        try {
+            for (const e of entries) {
+                const size = e.content ? e.content.size : 0;
+                if (e.dir || !e.content || size === 0)
+                    continue;
+                const encoder = new encoder_1.RawLzmaEncoder(size);
+                let crc = 0;
+                const one = new io_1.SpillSink(temp, memoryThreshold);
+                try {
+                    for await (const b of piecesOf(e.content, 1 << 16, time)) {
+                        crc = (0, crc32_1.crc32)(b, crc);
+                        await one.write(encoder.write(b));
+                    }
+                    await one.write(encoder.finish());
+                    await one.close();
+                    // A file LZMA would compress past the ratio limit is stored, so the output reads under the same limit.
+                    const stored = (0, exports.passesRatio)(size, one.length, ratioLimit);
+                    if (stored)
+                        for await (const b of piecesOf(e.content, 1 << 16, time))
+                            await packed.write(b);
+                    else
+                        for await (const b of one.read())
+                            await packed.write(b);
+                    folders.push({ packSize: stored ? size : one.length, unpackSize: size, crc, dict: encoder.dictSize, stored });
+                }
+                finally {
+                    await one.dispose();
+                }
+            }
+        }
+        finally {
+            await packed.close();
+        }
+        const parts = [Uint8Array.of(sevenzip_1.Nid.Header)];
+        if (folders.length) {
+            parts.push(Uint8Array.of(sevenzip_1.Nid.MainStreamsInfo, sevenzip_1.Nid.PackInfo), num(0), num(folders.length), Uint8Array.of(sevenzip_1.Nid.Size));
+            for (const f of folders)
+                parts.push(num(f.packSize));
+            parts.push(Uint8Array.of(sevenzip_1.Nid.End, sevenzip_1.Nid.UnpackInfo, sevenzip_1.Nid.Folder), num(folders.length), Uint8Array.of(0));
+            for (const f of folders) {
+                if (f.stored) {
+                    // One coder: ID size 1 and no properties, Copy.
+                    parts.push(num(1), Uint8Array.of(0x01, 0x00));
+                    continue;
+                }
+                // One coder: ID size 3 with properties, LZMA, five bytes of properties.
+                const props = Buffer.concat([Uint8Array.of((encoder_1.PB * 5 + encoder_1.LP) * 9 + encoder_1.LC), le32(f.dict)]);
+                parts.push(num(1), Uint8Array.of(0x23, 0x03, 0x01, 0x01), num(props.length), props);
+            }
+            parts.push(Uint8Array.of(sevenzip_1.Nid.CodersUnpackSize));
+            for (const f of folders)
+                parts.push(num(f.unpackSize));
+            parts.push(Uint8Array.of(sevenzip_1.Nid.End, sevenzip_1.Nid.SubStreamsInfo, sevenzip_1.Nid.Crc, 1));
+            for (const f of folders)
+                parts.push(le32(f.crc));
+            parts.push(Uint8Array.of(sevenzip_1.Nid.End, sevenzip_1.Nid.End));
+        }
+        const sizes = entries.map(e => (e.dir || !e.content ? 0 : e.content.size));
+        const empty = entries.map((e, i) => e.dir || sizes[i] === 0);
+        const props = [];
+        if (empty.some(Boolean)) {
+            props.push(property(sevenzip_1.Nid.EmptyStream, bitVector(empty)));
+            const emptyFiles = entries.filter((_, i) => empty[i]).map(e => !e.dir);
+            if (emptyFiles.some(Boolean))
+                props.push(property(sevenzip_1.Nid.EmptyFile, bitVector(emptyFiles)));
+        }
+        if (entries.some(e => e.name !== undefined)) {
+            const names = Buffer.concat([Uint8Array.of(0), ...entries.map(e => Buffer.from(`${e.name ?? ''}\0`, 'utf16le'))]);
+            props.push(property(sevenzip_1.Nid.Name, names));
+        }
+        for (const [id, key] of [
+            [sevenzip_1.Nid.CTime, 'ctime'],
+            [sevenzip_1.Nid.ATime, 'atime'],
+            [sevenzip_1.Nid.MTime, 'mtime'],
+        ]) {
+            const body = definedValues(entries.map(e => e[key]));
+            if (body)
+                props.push(property(id, body));
+        }
+        const attribs = definedValues(entries.map(e => (e.attrib === undefined ? undefined : le32(e.attrib))));
+        if (attribs)
+            props.push(property(sevenzip_1.Nid.WinAttributes, attribs));
+        parts.push(Uint8Array.of(sevenzip_1.Nid.FilesInfo), num(entries.length), ...props, Uint8Array.of(sevenzip_1.Nid.End, sevenzip_1.Nid.End));
+        const header = Buffer.concat(parts);
+        const start = Buffer.concat([le64(packed.length), le64(header.length), le32((0, crc32_1.crc32)(header))]);
+        await sink.write(Buffer.concat([Uint8Array.from(lzma_sniff_1.SEVENZIP_MAGIC), Uint8Array.of(0, 4), le32((0, crc32_1.crc32)(start)), start]));
+        for await (const b of packed.read())
+            await sink.write(b);
+        await sink.write(header);
+    }
+    finally {
+        await packed.dispose();
+    }
+}

package/dist/lzma1/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2023 Filip Seman
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/dist/lzma1/NOTICE

@@ -0,0 +1,36 @@
+The files in this directory come from lzma1 by Filip Seman, https://github.com/xseman/lzma1, under the Apache
+License 2.0 in LICENSE here. They come from the fork on branch feat/lzma2-decoder at commit
+19f319c68ed898619393a579d126ce06e3d5d704, which is lzma1 0.4.0 plus raw LZMA1 and LZMA2 decoding. lzma1 ports them
+from XZ for Java (0BSD) by Lasse Collin and Igor Pavlov.
+
+Copied: crc32.ts, hash234.ts, hc4.ts, header.ts, lz-decoder.ts, lz-encoder.ts, lzma-coder.ts, lzma-decoder.ts,
+lzma-encoder.ts, lzma-encoder-fast.ts, lzma2-decoder.ts, range-coder.ts, range-decoder.ts and range-encoder.ts.
+
+lzma-defuse changed them as follows, and the files then moved into archive-defuse unchanged.
+
+In every file:
+- Biome reformatted it to this package's style, with spaces for tabs and single quotes for double.
+- Imports drop the ".js" suffix, since this package compiles to CommonJS.
+- A first line names lzma1, its license and this NOTICE.
+
+In lzma-decoder.ts and lzma-encoder.ts, the box-drawing characters around section comments are now "--", since this
+package keeps its files ASCII.
+
+In hc4.ts, lz-decoder.ts, lz-encoder.ts, lzma-encoder.ts, lzma2-decoder.ts and range-encoder.ts, each function that
+assigned to its own parameter now copies the parameter into a local variable first. This package's lint rules forbid
+the assignment. The arithmetic is the same.
+
+In lzma-encoder-fast.ts:
+- getNextSymbol() throws if no matches were read, where it used a non-null assertion.
+- A chained assignment is now two assignments.
+
+In lzma-encoder.ts, the empty body of the loop in encode() holds a comment.
+
+In lzma2-decoder.ts:
+- The file defines INPUT_MARGIN itself instead of importing it from alone-decoder.ts, which this package does not
+  copy. The value is still 64.
+- A private method, currentLzma(), returns the LZMA decoder or throws "LZMA2 chunk without properties". It replaces
+  two non-null assertions.
+
+crc32.ts, hash234.ts, header.ts, lzma-coder.ts, lzma-decoder.ts, range-coder.ts and range-decoder.ts have no changes
+beyond formatting and imports.

package/dist/lzma1/crc32.d.ts

@@ -0,0 +1,4 @@
+/**
+ * CRC-32 (IEEE 802.3) lookup table. The match finders use it for hashing.
+ */
+export declare const CRC32_TABLE: number[];

package/dist/lzma1/crc32.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CRC32_TABLE = void 0;
+// Copied from lzma1 (Apache-2.0, Copyright Filip Seman) and changed for lzma-defuse. NOTICE in this folder lists the changes.
+/**
+ * CRC-32 (IEEE 802.3) lookup table. The match finders use it for hashing.
+ */
+exports.CRC32_TABLE = createCrc32Table();
+function createCrc32Table() {
+    const table = [];
+    for (let i = 0; i < 256; ++i) {
+        let r = i;
+        for (let j = 0; j < 8; ++j) {
+            r = (r & 1) !== 0 ? (r >>> 1) ^ 0xedb88320 : r >>> 1;
+        }
+        table.push(r >>> 0);
+    }
+    return table;
+}

package/dist/lzma1/hash234.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Hash tables of the last positions of 2-, 3- and 4-byte sequences.
+ *
+ * Ported from XZ for Java (0BSD) by Lasse Collin and Igor Pavlov.
+ */
+export declare class Hash234 {
+    private readonly hash4Mask;
+    private readonly hash2Table;
+    private readonly hash3Table;
+    private readonly hash4Table;
+    private hash2Value;
+    private hash3Value;
+    private hash4Value;
+    constructor(dictSize: number);
+    calcHashes(buf: Uint8Array, off: number): void;
+    getHash2Pos(): number;
+    getHash3Pos(): number;
+    getHash4Pos(): number;
+    updateTables(pos: number): void;
+    clear(): void;
+    normalize(offset: number): void;
+}

package/dist/lzma1/hash234.js

@@ -0,0 +1,75 @@
+"use strict";
+// Copied from lzma1 (Apache-2.0, Copyright Filip Seman) and changed for lzma-defuse. NOTICE in this folder lists the changes.
+/**
+ * Hash tables of the last positions of 2-, 3- and 4-byte sequences.
+ *
+ * Ported from XZ for Java (0BSD) by Lasse Collin and Igor Pavlov.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hash234 = void 0;
+const crc32_1 = require("./crc32");
+const lz_encoder_1 = require("./lz-encoder");
+const HASH_2_SIZE = 1 << 10;
+const HASH_2_MASK = HASH_2_SIZE - 1;
+const HASH_3_SIZE = 1 << 16;
+const HASH_3_MASK = HASH_3_SIZE - 1;
+function getHash4Size(dictSize) {
+    let h = dictSize - 1;
+    h |= h >>> 1;
+    h |= h >>> 2;
+    h |= h >>> 4;
+    h |= h >>> 8;
+    h >>>= 1;
+    h |= 0xffff;
+    if (h > 1 << 24) {
+        h >>>= 1;
+    }
+    return h + 1;
+}
+class Hash234 {
+    hash4Mask;
+    hash2Table = new Int32Array(HASH_2_SIZE);
+    hash3Table = new Int32Array(HASH_3_SIZE);
+    hash4Table;
+    hash2Value = 0;
+    hash3Value = 0;
+    hash4Value = 0;
+    constructor(dictSize) {
+        const hash4Size = getHash4Size(dictSize);
+        this.hash4Table = new Int32Array(hash4Size);
+        this.hash4Mask = hash4Size - 1;
+    }
+    calcHashes(buf, off) {
+        let temp = crc32_1.CRC32_TABLE[buf[off]] ^ buf[off + 1];
+        this.hash2Value = temp & HASH_2_MASK;
+        temp ^= buf[off + 2] << 8;
+        this.hash3Value = temp & HASH_3_MASK;
+        temp ^= crc32_1.CRC32_TABLE[buf[off + 3]] << 5;
+        this.hash4Value = temp & this.hash4Mask;
+    }
+    getHash2Pos() {
+        return this.hash2Table[this.hash2Value];
+    }
+    getHash3Pos() {
+        return this.hash3Table[this.hash3Value];
+    }
+    getHash4Pos() {
+        return this.hash4Table[this.hash4Value];
+    }
+    updateTables(pos) {
+        this.hash2Table[this.hash2Value] = pos;
+        this.hash3Table[this.hash3Value] = pos;
+        this.hash4Table[this.hash4Value] = pos;
+    }
+    clear() {
+        this.hash2Table.fill(0);
+        this.hash3Table.fill(0);
+        this.hash4Table.fill(0);
+    }
+    normalize(offset) {
+        (0, lz_encoder_1.normalizePositions)(this.hash2Table, offset);
+        (0, lz_encoder_1.normalizePositions)(this.hash3Table, offset);
+        (0, lz_encoder_1.normalizePositions)(this.hash4Table, offset);
+    }
+}
+exports.Hash234 = Hash234;

package/dist/lzma1/hc4.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Hash chain match finder with 2-, 3- and 4-byte hashing.
+ *
+ * Every position links to the previous position with the same 4-byte hash.
+ * Faster than the binary tree finder but finds fewer long matches.
+ *
+ * Ported from XZ for Java (0BSD) by Lasse Collin and Igor Pavlov.
+ */
+import { LzEncoder, type LzEncoderConfig, Matches } from './lz-encoder';
+export declare class HC4 extends LzEncoder {
+    private readonly hash;
+    /** Previous position with the same hash, per position in the cyclic buffer. */
+    private readonly chain;
+    private readonly matches;
+    private readonly depthLimit;
+    private readonly cyclicSize;
+    private cyclicPos;
+    /** Position counter stored in the hash tables and chain. */
+    private lzPos;
+    constructor(config: LzEncoderConfig);
+    /**
+     * Prepares for a new input without clearing the tables: positions
+     * continue after the previous input, so its entries are too far back
+     * (`delta >= cyclicSize`) and get ignored like empty ones.
+     */
+    reset(): void;
+    getMatches(): Matches;
+    skip(len: number): void;
+    private movePosition;
+}