@patrickdk77/archive-defuse 0.0.0-stage → 0.1.0

package/dist/findings.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindingFactory = void 0;
+exports.findingSpec = findingSpec;
+exports.allFindingSpecs = allFindingSpecs;
+// The finding table and the factory, as pdf-defuse src/findings.ts has them, with archive-defuse's own kinds.
+const types_1 = require("./types");
+const specs = new Map();
+function def(c, d, action, weight, description) {
+    specs.set(`${c}/${d}`, { action, weight, description });
+}
+// CORRUPTED
+def(types_1.ArchiveCategory.Corrupted, types_1.ArchiveDetail.Unparseable, 'reject', 0, 'Archive cannot be parsed<: {reason}|>');
+def(types_1.ArchiveCategory.Corrupted, types_1.ArchiveDetail.Truncated, 'reject', 0, 'Archive ends before its last <{what}|entry>');
+def(types_1.ArchiveCategory.Corrupted, types_1.ArchiveDetail.DataError, 'reject', 0, 'The compressed data does not decode<: {reason}|>');
+def(types_1.ArchiveCategory.Corrupted, types_1.ArchiveDetail.EntryData, 'strip', 30, 'Entry removed because its data does not decode or does not match its size or checksum<: {reason}|>');
+def(types_1.ArchiveCategory.Corrupted, types_1.ArchiveDetail.CheckFailed, 'reject', 0, 'An integrity check does not match<: {check}|>');
+// STRUCTURE
+def(types_1.ArchiveCategory.Structure, types_1.ArchiveDetail.LeadingBytes, 'strip', 10, 'Data before the start of the archive');
+def(types_1.ArchiveCategory.Structure, types_1.ArchiveDetail.TrailingBytes, 'strip', 10, 'Data after the end of the archive');
+def(types_1.ArchiveCategory.Structure, types_1.ArchiveDetail.HiddenData, 'strip', 20, 'Data inside the archive that belongs to no entry');
+def(types_1.ArchiveCategory.Structure, types_1.ArchiveDetail.Polyglot, 'strip', 40, 'The file also reads as <{type}|another format>');
+def(types_1.ArchiveCategory.Structure, types_1.ArchiveDetail.SeveralEndRecords, 'strip', 30, 'More than one end of central directory record, which readers can pick differently');
+def(types_1.ArchiveCategory.Structure, types_1.ArchiveDetail.HeaderMismatch, 'strip', 40, 'Two headers of the archive disagree<: {what}|>');
+def(types_1.ArchiveCategory.Structure, types_1.ArchiveDetail.OffsetShift, 'strip', 20, 'The offsets in the central directory are shifted, which some readers correct and others do not');
+def(types_1.ArchiveCategory.Structure, types_1.ArchiveDetail.Overlap, 'strip', 50, 'Entries share bytes of the archive');
+def(types_1.ArchiveCategory.Structure, types_1.ArchiveDetail.ExtraField, 'strip', 0, 'An entry carries <{field}|header data> that the rewrite does not keep');
+def(types_1.ArchiveCategory.Structure, types_1.ArchiveDetail.NonFileData, 'strip', 10, 'An entry that is not a file carries data');
+def(types_1.ArchiveCategory.Structure, types_1.ArchiveDetail.MultipleStreams, 'strip', 10, 'The file holds <count> compressed streams one after another, and some readers stop after the first');
+def(types_1.ArchiveCategory.Structure, types_1.ArchiveDetail.MalformedHeader, 'strip', 10, 'A header is malformed<: {reason}|>');
+def(types_1.ArchiveCategory.Structure, types_1.ArchiveDetail.MultiVolume, 'reject', 0, 'The archive is one part of a set split across several files');
+def(types_1.ArchiveCategory.Structure, types_1.ArchiveDetail.StreamPadding, 'info', 0, 'Stream padding between or after xz streams');
+def(types_1.ArchiveCategory.Structure, types_1.ArchiveDetail.BadPadding, 'strip', 20, 'Padding of a length or content the xz format does not allow');
+def(types_1.ArchiveCategory.Structure, types_1.ArchiveDetail.IndexMismatch, 'strip', 30, 'The xz index disagrees with the blocks it lists<: {reason}|>');
+def(types_1.ArchiveCategory.Structure, types_1.ArchiveDetail.SizeMismatch, 'strip', 20, 'A declared size disagrees with the data<: {reason}|>');
+def(types_1.ArchiveCategory.Structure, types_1.ArchiveDetail.NoCheck, 'info', 0, 'The xz stream carries no integrity check, so the decoded data was not verified');
+def(types_1.ArchiveCategory.Structure, types_1.ArchiveDetail.UnknownCheck, 'strip', 10, 'An xz integrity check of a type this package does not know, so the decoded data was not verified');
+def(types_1.ArchiveCategory.Structure, types_1.ArchiveDetail.UnknownProperty, 'strip', 5, 'A 7z header property this package does not use<: {property}|>');
+def(types_1.ArchiveCategory.Structure, types_1.ArchiveDetail.EmptyStartHeader, 'strip', 10, 'The 7z start header is empty, as an archive whose writing did not finish leaves it. The header was found at the end of the file, where 7-Zip looks for it');
+// NAME
+def(types_1.ArchiveCategory.Name, types_1.ArchiveDetail.Traversal, 'strip', 70, 'An entry name climbs out of the folder it is extracted to');
+def(types_1.ArchiveCategory.Name, types_1.ArchiveDetail.Absolute, 'strip', 60, 'An entry name is an absolute path');
+def(types_1.ArchiveCategory.Name, types_1.ArchiveDetail.DriveLetter, 'strip', 60, 'An entry name starts with a drive letter');
+def(types_1.ArchiveCategory.Name, types_1.ArchiveDetail.Backslash, 'strip', 20, 'An entry name holds a backslash, which Windows reads as a folder separator');
+def(types_1.ArchiveCategory.Name, types_1.ArchiveDetail.EmptySegment, 'strip', 5, 'An entry name has empty or "." parts');
+def(types_1.ArchiveCategory.Name, types_1.ArchiveDetail.ControlCharacter, 'strip', 40, 'An entry name holds control characters or characters that reorder text');
+def(types_1.ArchiveCategory.Name, types_1.ArchiveDetail.WindowsReserved, 'strip', 20, 'An entry name is one Windows cannot create as written');
+def(types_1.ArchiveCategory.Name, types_1.ArchiveDetail.Encoding, 'strip', 5, 'An entry name has no single reading in the encodings readers use');
+def(types_1.ArchiveCategory.Name, types_1.ArchiveDetail.UnicodePath, 'strip', 30, 'The Unicode path field of an entry names a different file than its header');
+def(types_1.ArchiveCategory.Name, types_1.ArchiveDetail.Empty, 'strip', 10, 'An entry has an empty name');
+def(types_1.ArchiveCategory.Name, types_1.ArchiveDetail.TooLong, 'info', 10, 'An entry name is longer than file systems allow');
+def(types_1.ArchiveCategory.Name, types_1.ArchiveDetail.Duplicate, 'strip', 40, 'Several entries have the same name, and readers keep different ones');
+def(types_1.ArchiveCategory.Name, types_1.ArchiveDetail.CaseCollision, 'strip', 20, 'Entry names differ only in case, so they collide on file systems that ignore case');
+def(types_1.ArchiveCategory.Name, types_1.ArchiveDetail.NormalizationCollision, 'strip', 30, 'Entry names differ only in Unicode normalization, so they collide on file systems that normalize names');
+def(types_1.ArchiveCategory.Name, types_1.ArchiveDetail.FileDirectoryClash, 'strip', 30, 'An entry is a file or a link where other entries need a folder');
+def(types_1.ArchiveCategory.Name, types_1.ArchiveDetail.ShortNameCollision, 'strip', 30, 'An entry name has the form of a Windows 8.3 short name that another name in its folder could get');
+// LINK
+def(types_1.ArchiveCategory.Link, types_1.ArchiveDetail.Symlink, 'info', 10, 'A symbolic link');
+def(types_1.ArchiveCategory.Link, types_1.ArchiveDetail.Hardlink, 'info', 10, 'A hard link');
+def(types_1.ArchiveCategory.Link, types_1.ArchiveDetail.Outside, 'strip', 70, 'A link points outside the folder the archive is extracted to');
+def(types_1.ArchiveCategory.Link, types_1.ArchiveDetail.Dangling, 'strip', 40, 'A hard link names no entry before it, so extraction links to whatever file has that name');
+def(types_1.ArchiveCategory.Link, types_1.ArchiveDetail.ThroughLink, 'strip', 70, 'An entry is written through a symbolic link of the archive');
+// SPECIAL
+def(types_1.ArchiveCategory.Special, types_1.ArchiveDetail.Device, 'strip', 60, 'A device file');
+def(types_1.ArchiveCategory.Special, types_1.ArchiveDetail.Fifo, 'strip', 30, 'A named pipe');
+def(types_1.ArchiveCategory.Special, types_1.ArchiveDetail.Socket, 'strip', 30, 'A socket');
+def(types_1.ArchiveCategory.Special, types_1.ArchiveDetail.UnknownType, 'strip', 20, 'An entry of a type this package does not recognize');
+def(types_1.ArchiveCategory.Special, types_1.ArchiveDetail.AntiItem, 'strip', 20, 'An entry is a 7z anti-item, which tells an updater to delete a file');
+// PERMISSIONS
+def(types_1.ArchiveCategory.Permissions, types_1.ArchiveDetail.Setuid, 'strip', 50, 'An entry has the setuid bit, which runs it as its owner');
+def(types_1.ArchiveCategory.Permissions, types_1.ArchiveDetail.Setgid, 'strip', 40, "An entry has the setgid bit, which runs it as its group or gives a folder's group to new files");
+def(types_1.ArchiveCategory.Permissions, types_1.ArchiveDetail.Sticky, 'strip', 10, 'An entry has the sticky bit');
+def(types_1.ArchiveCategory.Permissions, types_1.ArchiveDetail.Capability, 'strip', 60, 'An entry carries file capabilities, which grant privileges when it runs');
+// ENCRYPTED
+def(types_1.ArchiveCategory.Encrypted, types_1.ArchiveDetail.ZipCrypto, 'info', 0, "Entry encrypted with PKWARE's traditional encryption");
+def(types_1.ArchiveCategory.Encrypted, types_1.ArchiveDetail.Aes128, 'info', 0, 'Entry encrypted with AES and a 128-bit key');
+def(types_1.ArchiveCategory.Encrypted, types_1.ArchiveDetail.Aes192, 'info', 0, 'Entry encrypted with AES and a 192-bit key');
+def(types_1.ArchiveCategory.Encrypted, types_1.ArchiveDetail.Aes256, 'info', 0, 'Entry encrypted with AES and a 256-bit key');
+def(types_1.ArchiveCategory.Encrypted, types_1.ArchiveDetail.Decrypted, 'strip', 0, 'Entry decrypted with a supplied password');
+def(types_1.ArchiveCategory.Encrypted, types_1.ArchiveDetail.EmptyPassword, 'strip', 10, 'Entry encrypted with an empty password');
+def(types_1.ArchiveCategory.Encrypted, types_1.ArchiveDetail.PasswordRequired, 'reject', 0, 'An entry requires a password, and none supplied opened it');
+def(types_1.ArchiveCategory.Encrypted, types_1.ArchiveDetail.Unsupported, 'reject', 0, 'An entry uses encryption this package cannot open<: {reason}|>');
+def(types_1.ArchiveCategory.Encrypted, types_1.ArchiveDetail.Header, 'strip', 0, 'The 7z header, which holds the names, was decrypted with a supplied password. The output does not encrypt it');
+// COMPRESSION
+def(types_1.ArchiveCategory.Compression, types_1.ArchiveDetail.UnsupportedMethod, 'reject', 0, 'An entry uses a compression method this package cannot decode<: {method}|>');
+def(types_1.ArchiveCategory.Compression, types_1.ArchiveDetail.UnusualMethod, 'info', 10, 'An entry uses a compression method few readers handle<: {method}|>');
+def(types_1.ArchiveCategory.Compression, types_1.ArchiveDetail.Unavailable, 'reject', 0, 'The data uses <{method}|a compression method> that this Node does not provide');
+def(types_1.ArchiveCategory.Compression, types_1.ArchiveDetail.UnsupportedFeature, 'reject', 0, 'The file uses a feature this package cannot read<: {reason}|>');
+// ENTRY
+def(types_1.ArchiveCategory.Entry, types_1.ArchiveDetail.NoPlugin, 'strip', 30, '<Entry "{name}"|An entry> (<{sniffed}|unknown type>) removed. No plugin accepts this type');
+def(types_1.ArchiveCategory.Entry, types_1.ArchiveDetail.TypeMismatch, 'info', 40, 'The types of <entry "{name}"|an unnamed entry> disagree: <its name says {nameType}|its name has no known extension>, and <its content looks like {sniffed}|its content is not recognized>');
+def(types_1.ArchiveCategory.Entry, types_1.ArchiveDetail.PluginPassed, 'info', 20, 'Entry kept by plugin <plugin> with nothing removed');
+def(types_1.ArchiveCategory.Entry, types_1.ArchiveDetail.PluginScrubbed, 'info', 10, 'Entry cleaned and kept by plugin <plugin>');
+def(types_1.ArchiveCategory.Entry, types_1.ArchiveDetail.PluginFailed, 'strip', 0, 'Plugin <plugin> failed, so the entry was removed');
+def(types_1.ArchiveCategory.Entry, types_1.ArchiveDetail.PluginRemoved, 'strip', 0, 'Entry removed by plugin <plugin>');
+// METADATA
+def(types_1.ArchiveCategory.Metadata, types_1.ArchiveDetail.Comment, 'info', 0, 'The archive or an entry carries a comment');
+def(types_1.ArchiveCategory.Metadata, types_1.ArchiveDetail.Stripped, 'info', 0, 'Metadata removed because the caller turned on metadata stripping');
+// LIMIT
+def(types_1.ArchiveCategory.Limit, types_1.ArchiveDetail.FileSize, 'reject', 0, 'Archive exceeds the file size limit');
+def(types_1.ArchiveCategory.Limit, types_1.ArchiveDetail.EntryCount, 'reject', 0, 'Archive exceeds the entry count limit');
+def(types_1.ArchiveCategory.Limit, types_1.ArchiveDetail.DecompressedSize, 'reject', 0, 'An entry exceeds the decompressed size limit');
+def(types_1.ArchiveCategory.Limit, types_1.ArchiveDetail.TotalDecompressedSize, 'reject', 0, 'The entries together exceed the total decompressed size limit');
+def(types_1.ArchiveCategory.Limit, types_1.ArchiveDetail.Ratio, 'reject', 0, 'An entry exceeds the compression ratio limit');
+def(types_1.ArchiveCategory.Limit, types_1.ArchiveDetail.DictionarySize, 'reject', 0, 'Decoding needs more dictionary memory than the dictionary size limit allows');
+def(types_1.ArchiveCategory.Limit, types_1.ArchiveDetail.NestingDepth, 'reject', 0, 'Archive exceeds the nesting depth limit');
+def(types_1.ArchiveCategory.Limit, types_1.ArchiveDetail.Time, 'reject', 0, 'Archive exceeds the time limit');
+// PROCESSING
+def(types_1.ArchiveCategory.Processing, types_1.ArchiveDetail.MemoryFallback, 'info', 0, '<part> was too large for memory and went through a temporary file');
+def(types_1.ArchiveCategory.Processing, types_1.ArchiveDetail.VerificationFailed, 'reject', 0, 'The defused output did not pass its own inspection, so nothing was written');
+def(types_1.ArchiveCategory.Processing, types_1.ArchiveDetail.ContentRemoved, 'strip', 20, 'Content was removed that no other finding names');
+/** The built-in spec for a kind of finding, or undefined for a kind archive-defuse does not make, such as one from another package. */
+function findingSpec(category, detail) {
+    return specs.get(`${category}/${detail}`);
+}
+/** The spec of a kind archive-defuse makes itself, which always has one. */
+function ownSpec(category, detail) {
+    const s = findingSpec(category, detail);
+    if (!s)
+        throw new Error(`No finding spec for ${category}/${detail}`);
+    return s;
+}
+function allFindingSpecs() {
+    return [...specs.entries()].map(([k, s]) => {
+        const [category, detail] = k.split('/');
+        return { category, detail, ...s };
+    });
+}
+class FindingFactory {
+    overrides;
+    constructor(overrides = []) {
+        this.overrides = overrides;
+    }
+    actionFor(category, detail) {
+        const exact = this.overrides.find(o => o.category === category && o.detail === detail);
+        if (exact)
+            return exact.action;
+        const byCategory = this.overrides.find(o => o.category === category && o.detail === undefined);
+        if (byCategory)
+            return byCategory.action;
+        return ownSpec(category, detail).action;
+    }
+    /** True when findings of this kind remove what they report. */
+    strips(category, detail) {
+        return this.actionFor(category, detail) === 'strip';
+    }
+    make(category, detail, location, data) {
+        const spec = ownSpec(category, detail);
+        // Values can come from the archive, so the description shows no control or direction characters from them.
+        const shown = (v) => String(v).replace(/[\p{Cc}\p{Cf}]/gu, '?');
+        const description = spec.description.replace(/<([^<>]*)>/g, (m, body) => {
+            if (/^[a-z]+$/.test(body))
+                return data?.[body] !== undefined ? shown(data[body]) : m;
+            for (const alt of body.split('|')) {
+                let missing = false;
+                const filled = alt.replace(/\{([a-zA-Z]+)\}/g, (_, key) => {
+                    const v = data?.[key];
+                    if (v === undefined || v === '')
+                        missing = true;
+                    const s = shown(v ?? '');
+                    return s.length > 60 ? `${s.slice(0, 57)}...` : s;
+                });
+                if (!missing)
+                    return filled;
+            }
+            return m;
+        });
+        const f = { category, detail, description, action: this.actionFor(category, detail) };
+        if (location !== undefined)
+            f.location = location;
+        if (data !== undefined && Object.keys(data).length)
+            f.data = data;
+        return f;
+    }
+}
+exports.FindingFactory = FindingFactory;

package/dist/formats.d.ts

@@ -0,0 +1,14 @@
+import type { TempDir } from './io';
+import type { Archive, Entry } from './model';
+import type { Limits } from './stream-meter';
+import { type ArchiveFormat, type ByteSource } from './types';
+/**
+ * The format the content has, from its first bytes. A file that starts with no signature of ours can still be a ZIP
+ * archive with data in front, which its end record shows, or Brotli, which has no signature and is tried last.
+ */
+export declare function detect(source: ByteSource): Promise<ArchiveFormat | undefined>;
+/** Opens the archive in the format `detect` found. A file in no format of ours throws the UNPARSEABLE refusal. */
+export declare function openArchive(source: ByteSource, limits: Limits, deadline: number | undefined, passwords: string[], temp?: {
+    dir: TempDir;
+    threshold: number;
+}): Promise<Archive<Entry>>;

package/dist/formats.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detect = detect;
+exports.openArchive = openArchive;
+const cab_1 = require("./cab");
+const errors_1 = require("./errors");
+const lzma_formats_1 = require("./lzma-formats");
+const lzma_sniff_1 = require("./lzma-sniff");
+const single_1 = require("./single");
+const tar_1 = require("./tar");
+const types_1 = require("./types");
+const zip_1 = require("./zip");
+const zstd_1 = require("./zstd");
+const isZipStart = (b) => b.length >= 4 && b[0] === 0x50 && b[1] === 0x4b && ((b[2] === 3 && b[3] === 4) || (b[2] === 5 && b[3] === 6) || (b[2] === 7 && b[3] === 8));
+const startsWith = (b, bytes) => b.length >= bytes.length && bytes.every((x, i) => b[i] === x);
+/** Formats with a signature that no package of the family reads. */
+function otherFormat(b) {
+    const s = Buffer.from(b.subarray(0, 8)).toString('latin1');
+    if (s.startsWith('Rar!\x1a\x07'))
+        return 'RAR';
+    return undefined;
+}
+/**
+ * The format the content has, from its first bytes. A file that starts with no signature of ours can still be a ZIP
+ * archive with data in front, which its end record shows, or Brotli, which has no signature and is tried last.
+ */
+async function detect(source) {
+    const size = await source.size();
+    const head = await source.read(0, Math.min(1024, size));
+    if (isZipStart(head))
+        return 'zip';
+    if (startsWith(head, lzma_sniff_1.XZ_MAGIC))
+        return 'xz';
+    if (startsWith(head, lzma_sniff_1.SEVENZIP_MAGIC))
+        return '7z';
+    if ((0, single_1.isGzip)(head))
+        return 'gzip';
+    if ((0, single_1.isBzip2)(head))
+        return 'bzip2';
+    if ((0, zstd_1.isZstdMagic)(head))
+        return 'zstd';
+    if ((0, cab_1.isCab)(head))
+        return 'cab';
+    if ((0, tar_1.isTar)(head))
+        return 'tar';
+    // An archive with no entries is its two end blocks, and a tar writer pads it with more zeros.
+    if (size >= 1024 && size % 512 === 0 && head.every(b => b === 0))
+        return 'tar';
+    if (otherFormat(head) !== undefined)
+        return undefined;
+    // An .lzma header has no magic, and 14 zero bytes pass liblzma's own test, so a ZIP found from its end comes first.
+    if (await (0, zip_1.hasZipEnd)(source))
+        return 'zip';
+    if ((0, lzma_sniff_1.looksLikeLzma)(head))
+        return 'lzma';
+    // A 7z archive after other data, such as the program of a self-extracting archive.
+    if ((0, lzma_sniff_1.detectLzmaFormat)(await source.read(0, Math.min(size, lzma_sniff_1.SEVENZIP_SEARCH)))?.format === '7z')
+        return '7z';
+    if (await (0, single_1.looksLikeBrotli)(source))
+        return 'brotli';
+    return undefined;
+}
+/** Opens the archive in the format `detect` found. A file in no format of ours throws the UNPARSEABLE refusal. */
+async function openArchive(source, limits, deadline, passwords, temp) {
+    const format = await detect(source);
+    switch (format) {
+        case 'zip': {
+            const zip = await zip_1.ZipArchive.open(source, limits, deadline);
+            if (temp)
+                zip.decoders = { temp: temp.dir, threshold: temp.threshold, limits };
+            return zip;
+        }
+        case 'tar':
+            return tar_1.TarArchive.open(source, limits, deadline);
+        case 'gzip':
+            return single_1.GzipArchive.open(source);
+        case 'bzip2':
+            return single_1.Bzip2Archive.open(source);
+        case 'zstd':
+            return single_1.ZstdArchive.open(source, deadline);
+        case 'brotli':
+            return single_1.BrotliArchive.open(source);
+        case 'cab':
+            return cab_1.CabArchive.open(source, limits, deadline);
+        case '7z':
+            return lzma_formats_1.SevenZipArchive.open(source, limits, deadline, passwords);
+        case 'xz':
+            return lzma_formats_1.XzArchive.open(source, limits);
+        case 'lzma':
+            return lzma_formats_1.LzmaArchive.open(source, limits);
+        default: {
+            const other = otherFormat(await source.read(0, 8));
+            const reason = other ? `a ${other} file, which this package does not read` : 'not an archive this package reads';
+            throw new errors_1.StopError(types_1.ArchiveCategory.Corrupted, types_1.ArchiveDetail.Unparseable, reason, { reason });
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { disarmArchive, disarmArchiveSource, inspectArchive, inspectArchiveSource } from './engine';
+export { allFindingSpecs } from './findings';
+export { bufferSink, bufferSource, fileSink, fileSource, writableSink } from './io';
+export { type CompressFormat, compress, compressStream, compressTo, createArchive, createArchiveBytes, createArchiveStream, type PackData, type PackEntry, PackError, type PackFormat, type PackOptions, } from './pack';
+export { archivePlugin, passThrough } from './plugins';
+export { COMBINATIONS, DEFAULT_BANDS, scoreFindings } from './score';
+export * from './types';
+export { ArchiveReadError, type ArchiveReader, type ArchiveReaderEntry, decompress, type OpenArchiveOptions, openArchive } from './unpack';

package/dist/index.js

@@ -0,0 +1,50 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openArchive = exports.decompress = exports.ArchiveReadError = exports.scoreFindings = exports.DEFAULT_BANDS = exports.COMBINATIONS = exports.passThrough = exports.archivePlugin = exports.PackError = exports.createArchiveStream = exports.createArchiveBytes = exports.createArchive = exports.compressTo = exports.compressStream = exports.compress = exports.writableSink = exports.fileSource = exports.fileSink = exports.bufferSource = exports.bufferSink = exports.allFindingSpecs = exports.inspectArchiveSource = exports.inspectArchive = exports.disarmArchiveSource = exports.disarmArchive = void 0;
+var engine_1 = require("./engine");
+Object.defineProperty(exports, "disarmArchive", { enumerable: true, get: function () { return engine_1.disarmArchive; } });
+Object.defineProperty(exports, "disarmArchiveSource", { enumerable: true, get: function () { return engine_1.disarmArchiveSource; } });
+Object.defineProperty(exports, "inspectArchive", { enumerable: true, get: function () { return engine_1.inspectArchive; } });
+Object.defineProperty(exports, "inspectArchiveSource", { enumerable: true, get: function () { return engine_1.inspectArchiveSource; } });
+var findings_1 = require("./findings");
+Object.defineProperty(exports, "allFindingSpecs", { enumerable: true, get: function () { return findings_1.allFindingSpecs; } });
+var io_1 = require("./io");
+Object.defineProperty(exports, "bufferSink", { enumerable: true, get: function () { return io_1.bufferSink; } });
+Object.defineProperty(exports, "bufferSource", { enumerable: true, get: function () { return io_1.bufferSource; } });
+Object.defineProperty(exports, "fileSink", { enumerable: true, get: function () { return io_1.fileSink; } });
+Object.defineProperty(exports, "fileSource", { enumerable: true, get: function () { return io_1.fileSource; } });
+Object.defineProperty(exports, "writableSink", { enumerable: true, get: function () { return io_1.writableSink; } });
+var pack_1 = require("./pack");
+Object.defineProperty(exports, "compress", { enumerable: true, get: function () { return pack_1.compress; } });
+Object.defineProperty(exports, "compressStream", { enumerable: true, get: function () { return pack_1.compressStream; } });
+Object.defineProperty(exports, "compressTo", { enumerable: true, get: function () { return pack_1.compressTo; } });
+Object.defineProperty(exports, "createArchive", { enumerable: true, get: function () { return pack_1.createArchive; } });
+Object.defineProperty(exports, "createArchiveBytes", { enumerable: true, get: function () { return pack_1.createArchiveBytes; } });
+Object.defineProperty(exports, "createArchiveStream", { enumerable: true, get: function () { return pack_1.createArchiveStream; } });
+Object.defineProperty(exports, "PackError", { enumerable: true, get: function () { return pack_1.PackError; } });
+var plugins_1 = require("./plugins");
+Object.defineProperty(exports, "archivePlugin", { enumerable: true, get: function () { return plugins_1.archivePlugin; } });
+Object.defineProperty(exports, "passThrough", { enumerable: true, get: function () { return plugins_1.passThrough; } });
+var score_1 = require("./score");
+Object.defineProperty(exports, "COMBINATIONS", { enumerable: true, get: function () { return score_1.COMBINATIONS; } });
+Object.defineProperty(exports, "DEFAULT_BANDS", { enumerable: true, get: function () { return score_1.DEFAULT_BANDS; } });
+Object.defineProperty(exports, "scoreFindings", { enumerable: true, get: function () { return score_1.scoreFindings; } });
+__exportStar(require("./types"), exports);
+var unpack_1 = require("./unpack");
+Object.defineProperty(exports, "ArchiveReadError", { enumerable: true, get: function () { return unpack_1.ArchiveReadError; } });
+Object.defineProperty(exports, "decompress", { enumerable: true, get: function () { return unpack_1.decompress; } });
+Object.defineProperty(exports, "openArchive", { enumerable: true, get: function () { return unpack_1.openArchive; } });

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import cjs from './index.js';
+export const { disarmArchive, disarmArchiveSource, inspectArchive, inspectArchiveSource, allFindingSpecs, bufferSink, bufferSource, fileSink, fileSource, writableSink, compress, compressStream, compressTo, createArchive, createArchiveBytes, createArchiveStream, PackError, archivePlugin, passThrough, COMBINATIONS, DEFAULT_BANDS, scoreFindings, ArchiveReadError, decompress, openArchive, ArchiveCategory, ArchiveDetail, ArchiveRisk } = cjs;
+export default cjs;

package/dist/inflate64.d.ts

@@ -0,0 +1,6 @@
+import type { Consumed } from './codecs';
+/**
+ * Decodes a raw Deflate64 stream. Stops after the final block; consumed.bytes then counts the input bytes the stream
+ * used, so bytes after it are the caller's. Output comes in chunks of at most 64 KiB.
+ */
+export declare function inflate64(chunks: AsyncIterable<Uint8Array>, consumed?: Consumed, deadline?: number): AsyncGenerator<Uint8Array>;