@openclaw/fs-safe 0.4.7 → 0.5.1

package/dist/archive-tar-meta.js

@@ -0,0 +1,143 @@
+import fs from "node:fs";
+import { Transform, Writable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { createGunzip } from "node:zlib";
+import { ArchiveFormatError } from "./archive-errors.js";
+import { ARCHIVE_LIMIT_ERROR_CODE, ArchiveLimitError } from "./archive-limits.js";
+class TarMetadataMeter extends Transform {
+    maxMetaEntryBytes;
+    block = Buffer.alloc(512);
+    blockLength = 0;
+    state = { kind: "header" };
+    constructor(maxMetaEntryBytes) {
+        super();
+        this.maxMetaEntryBytes = maxMetaEntryBytes;
+    }
+    invalid(message) {
+        return new ArchiveFormatError(`invalid TAR header: ${message}`);
+    }
+    parseSize() {
+        const field = this.block.subarray(124, 136);
+        if ((field[0] ?? 0) & 0x80) {
+            const value = field.readBigUInt64BE(4);
+            if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+                throw this.invalid("base-256 size exceeds the safe integer range");
+            }
+            return Number(value);
+        }
+        const zero = field.indexOf(0);
+        const text = field.subarray(0, zero < 0 ? field.length : zero).toString("ascii").trim();
+        if (!text || !/^[0-7]+$/.test(text))
+            throw this.invalid("size is not valid octal");
+        const value = Number.parseInt(text, 8);
+        if (!Number.isSafeInteger(value))
+            throw this.invalid("octal size exceeds the safe integer range");
+        return value;
+    }
+    finishHeader() {
+        if (this.block.every((byte) => byte === 0)) {
+            this.blockLength = 0;
+            this.state = { kind: "header" };
+            return;
+        }
+        const size = this.parseSize();
+        const type = this.block[156];
+        if ([0x78, 0x67, 0x4c, 0x4b, 0x58].includes(type ?? -1) && size > this.maxMetaEntryBytes) {
+            throw new ArchiveLimitError(ARCHIVE_LIMIT_ERROR_CODE.META_ENTRY_SIZE_EXCEEDS_LIMIT);
+        }
+        if (type === 0x78 || type === 0x67 || type === 0x58) {
+            throw this.invalid("PAX metadata is unmeterable without interpreting content");
+        }
+        const padded = Math.ceil(size / 512) * 512;
+        if (!Number.isSafeInteger(padded))
+            throw this.invalid("entry padding exceeds the safe integer range");
+        if (type === 0x53) {
+            if (this.block[482] !== 0 && this.block[482] !== 1) {
+                throw this.invalid("GNU sparse extension flag is not 0 or 1");
+            }
+            if (this.block[482] === 0) {
+                throw this.invalid("GNU sparse entries are not supported");
+            }
+            this.state = { kind: "sparse", dataRemaining: padded, metaBytes: 0 };
+        }
+        else {
+            this.state = padded === 0 ? { kind: "header" } : { kind: "data", remaining: padded };
+        }
+        this.blockLength = 0;
+    }
+    finishSparseHeader(state) {
+        const metaBytes = state.metaBytes + 512;
+        if (metaBytes > this.maxMetaEntryBytes) {
+            throw new ArchiveLimitError(ARCHIVE_LIMIT_ERROR_CODE.META_ENTRY_SIZE_EXCEEDS_LIMIT);
+        }
+        if (this.block[504] !== 0 && this.block[504] !== 1) {
+            throw this.invalid("GNU sparse extension flag is not 0 or 1");
+        }
+        if (this.block[504] === 1) {
+            this.state = { ...state, metaBytes };
+        }
+        else {
+            throw this.invalid("GNU sparse entries are not supported");
+        }
+        this.blockLength = 0;
+    }
+    meter(chunk) {
+        let offset = 0;
+        while (offset < chunk.length) {
+            if (this.state.kind === "data") {
+                const take = Math.min(this.state.remaining, chunk.length - offset);
+                offset += take;
+                const remaining = this.state.remaining - take;
+                this.state = remaining === 0 ? { kind: "header" } : { kind: "data", remaining };
+                continue;
+            }
+            const take = Math.min(512 - this.blockLength, chunk.length - offset);
+            chunk.copy(this.block, this.blockLength, offset, offset + take);
+            this.blockLength += take;
+            offset += take;
+            if (this.blockLength === 512) {
+                if (this.state.kind === "sparse")
+                    this.finishSparseHeader(this.state);
+                else
+                    this.finishHeader();
+            }
+        }
+    }
+    _transform(chunk, _encoding, callback) {
+        try {
+            this.meter(chunk);
+            callback(null, chunk);
+        }
+        catch (error) {
+            callback(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    _flush(callback) {
+        if (this.state.kind === "header" && this.blockLength === 0)
+            callback();
+        else
+            callback(this.invalid(this.state.kind === "header" ? "truncated TAR header" : "truncated TAR entry"));
+    }
+}
+async function isGzip(filePath) {
+    const handle = await fs.promises.open(filePath, "r");
+    try {
+        const magic = Buffer.alloc(2);
+        const { bytesRead } = await handle.read(magic, 0, 2, 0);
+        return bytesRead === 2 && magic[0] === 0x1f && magic[1] === 0x8b;
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function preflightTarMetadata(params) {
+    const input = fs.createReadStream(params.archivePath);
+    const meter = new TarMetadataMeter(params.maxMetaEntryBytes);
+    const sink = new Writable({ write(_chunk, _encoding, callback) { callback(); } });
+    if (await isGzip(params.archivePath)) {
+        await pipeline(input, createGunzip(), meter, sink, { signal: params.signal });
+    }
+    else {
+        await pipeline(input, meter, sink, { signal: params.signal });
+    }
+}

package/dist/archive-tar-runtime.d.ts

@@ -0,0 +1,43 @@
+export type TarParserEntry = {
+    meta?: boolean;
+    size: number;
+    type?: string;
+    resume(): void;
+};
+export type TarParser = NodeJS.WritableStream & {
+    abort(error: Error): void;
+    on(event: "ignoredEntry", listener: (entry: TarParserEntry) => void): TarParser;
+    on(event: "entry", listener: (entry: TarParserEntry) => void): TarParser;
+    on(event: "meta", listener: (metadata: string) => void): TarParser;
+    on(event: "error", listener: (error: Error) => void): TarParser;
+    on(event: "end", listener: () => void): TarParser;
+};
+export type TarModule = {
+    Parser: new (options: {
+        strict: true;
+        maxMetaEntrySize: number;
+    }) => TarParser;
+    x(options: {
+        cwd: string;
+        strip: number;
+        gzip?: boolean;
+        signal?: AbortSignal;
+        preservePaths: false;
+        noChmod: true;
+        preserveOwner: false;
+        strict: true;
+        maxMetaEntrySize: number;
+        filter?(this: TarParser, entryPath: string, entry: unknown): boolean;
+        onReadEntry(this: unknown, entry: unknown): void;
+    }): TarParser;
+    t(options: {
+        file: string;
+        strict: true;
+        maxMetaEntrySize: number;
+        onReadEntry(entry: AsyncIterable<unknown> & {
+            resume(): void;
+        }): void;
+    }): Promise<unknown>;
+};
+export declare function importOptionalTar(): Promise<TarModule>;
+//# sourceMappingURL=archive-tar-runtime.d.ts.map

package/dist/archive-tar-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive-tar-runtime.d.ts","sourceRoot":"","sources":["../src/archive-tar-runtime.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,IAAI,IAAI,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,cAAc,GAAG;IAC9C,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAC1B,EAAE,CAAC,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,GAAG,SAAS,CAAC;IAChF,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,GAAG,SAAS,CAAC;IACzE,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,GAAG,SAAS,CAAC;IACnE,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,SAAS,CAAC;IAChE,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,SAAS,CAAC;CACnD,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,MAAM,EAAE,KAAK,OAAO,EAAE;QAAE,MAAM,EAAE,IAAI,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAA;KAAE,KAAK,SAAS,CAAC;IAC/E,CAAC,CAAC,OAAO,EAAE;QACT,GAAG,EAAE,MAAM,CAAC;QACZ,KAAK,EAAE,MAAM,CAAC;QACd,IAAI,CAAC,EAAE,OAAO,CAAC;QACf,MAAM,CAAC,EAAE,WAAW,CAAC;QACrB,aAAa,EAAE,KAAK,CAAC;QACrB,OAAO,EAAE,IAAI,CAAC;QACd,aAAa,EAAE,KAAK,CAAC;QACrB,MAAM,EAAE,IAAI,CAAC;QACb,gBAAgB,EAAE,MAAM,CAAC;QACzB,MAAM,CAAC,CAAC,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;QACrE,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;KAClD,GAAG,SAAS,CAAC;IACd,CAAC,CAAC,OAAO,EAAE;QACT,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,IAAI,CAAC;QACb,gBAAgB,EAAE,MAAM,CAAC;QACzB,WAAW,CAAC,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,GAAG;YAAE,MAAM,IAAI,IAAI,CAAA;SAAE,GAAG,IAAI,CAAC;KACvE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACtB,CAAC;AAEF,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,SAAS,CAAC,CAS5D"}

package/dist/archive-tar-runtime.js

@@ -0,0 +1,8 @@
+export async function importOptionalTar() {
+    try {
+        return await import("tar");
+    }
+    catch (cause) {
+        throw new Error('Optional archive dependency "tar" is not installed. Install it to use TAR archive helpers from @openclaw/fs-safe/archive.', { cause });
+    }
+}

package/dist/archive-tar.d.ts

@@ -1,8 +1,10 @@
 import { type ArchiveExtractLimits } from "./archive-limits.js";
+import { type ArchiveEntryFilter, type ArchiveFilteredEntryPolicy } from "./archive-policy.js";
 export type TarEntryInfo = {
     path: string;
     type: string;
     size: number;
+    mode?: number;
 };
 export declare function readTarEntryInfo(entry: unknown): TarEntryInfo;
 export declare function createTarEntryPreflightChecker(params: {
@@ -10,5 +12,7 @@ export declare function createTarEntryPreflightChecker(params: {
     stripComponents?: number;
     limits?: ArchiveExtractLimits;
     escapeLabel?: string;
-}): (entry: TarEntryInfo) => void;
+    entryFilter?: ArchiveEntryFilter;
+    onFiltered?: ArchiveFilteredEntryPolicy;
+}): (entry: TarEntryInfo) => boolean;
 //# sourceMappingURL=archive-tar.d.ts.map

package/dist/archive-tar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"archive-tar.d.ts","sourceRoot":"","sources":["../src/archive-tar.ts"],"names":[],"mappings":"AAKA,OAAO,EAIL,KAAK,oBAAoB,EAC1B,MAAM,qBAAqB,CAAC;AAE7B,MAAM,MAAM,YAAY,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAWxE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY,CAkB7D;AAED,wBAAgB,8BAA8B,CAAC,MAAM,EAAE;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,MAAM,CAAC,EAAE,oBAAoB,CAAC;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,GAAG,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CA6BhC"}
+{"version":3,"file":"archive-tar.d.ts","sourceRoot":"","sources":["../src/archive-tar.ts"],"names":[],"mappings":"AAKA,OAAO,EAKL,KAAK,oBAAoB,EAC1B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAGL,KAAK,kBAAkB,EACvB,KAAK,0BAA0B,EAChC,MAAM,qBAAqB,CAAC;AAG7B,MAAM,MAAM,YAAY,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAWvF,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY,CAyB7D;AAED,wBAAgB,8BAA8B,CAAC,MAAM,EAAE;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,MAAM,CAAC,EAAE,oBAAoB,CAAC;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,UAAU,CAAC,EAAE,0BAA0B,CAAC;CACzC,GAAG,CAAC,KAAK,EAAE,YAAY,KAAK,OAAO,CA2CnC"}

package/dist/archive-tar.js

@@ -1,5 +1,7 @@
 import { resolveArchiveOutputPath, stripArchivePath, validateArchiveEntryPath, } from "./archive-entry.js";
-import { assertArchiveEntryCountWithinLimit, createByteBudgetTracker, resolveExtractLimits, } from "./archive-limits.js";
+import { assertArchiveEntryCountWithinLimit, assertArchiveEntryPathComponentsWithinLimit, createByteBudgetTracker, resolveExtractLimits, } from "./archive-limits.js";
+import { archiveEntryKindFromTarType, shouldExtractArchiveEntry, } from "./archive-policy.js";
+import { ArchiveSecurityError } from "./archive-errors.js";
 const BLOCKED_TAR_ENTRY_TYPES = new Set([
     "SymbolicLink",
     "Link",
@@ -22,7 +24,13 @@ export function readTarEntryInfo(entry) {
         Number.isFinite(entry.size)
         ? Math.max(0, Math.floor(entry.size))
         : 0;
-    return { path: p, type: t, size: s };
+    const mode = typeof entry === "object" &&
+        entry !== null &&
+        "mode" in entry &&
+        typeof entry.mode === "number"
+        ? entry.mode
+        : undefined;
+    return { path: p, type: t, size: s, mode };
 }
 export function createTarEntryPreflightChecker(params) {
     const strip = Math.max(0, Math.floor(params.stripComponents ?? 0));
@@ -33,20 +41,30 @@ export function createTarEntryPreflightChecker(params) {
         validateArchiveEntryPath(entry.path, { escapeLabel: params.escapeLabel });
         const relPath = stripArchivePath(entry.path, strip);
         if (!relPath) {
-            return;
+            return false;
         }
         validateArchiveEntryPath(relPath, { escapeLabel: params.escapeLabel });
+        assertArchiveEntryPathComponentsWithinLimit(relPath, limits);
         resolveArchiveOutputPath({
             rootDir: params.rootDir,
             relPath,
             originalPath: entry.path,
             escapeLabel: params.escapeLabel,
         });
-        if (BLOCKED_TAR_ENTRY_TYPES.has(entry.type)) {
-            throw new Error(`tar entry is a link: ${entry.path}`);
-        }
         entryCount += 1;
         assertArchiveEntryCountWithinLimit(entryCount, limits);
+        const kind = archiveEntryKindFromTarType(entry.type);
+        if (!shouldExtractArchiveEntry({
+            filter: params.entryFilter,
+            onFiltered: params.onFiltered,
+            entry: { path: entry.path, kind, size: entry.size },
+        })) {
+            return false;
+        }
+        if (BLOCKED_TAR_ENTRY_TYPES.has(entry.type)) {
+            throw new ArchiveSecurityError("entry-link", `tar entry is a link: ${entry.path}`);
+        }
         budget.addEntrySize(entry.size);
+        return true;
     };
 }

package/dist/archive-zip-entry.d.ts

@@ -0,0 +1,15 @@
+import { type ArchiveEntryModePolicy } from "./archive-policy.js";
+export type ZipEntry = {
+    name: string;
+    dir: boolean;
+    unixPermissions?: number;
+    _data?: {
+        uncompressedSize?: number;
+    };
+    nodeStream?: () => NodeJS.ReadableStream;
+    async: (type: "nodebuffer") => Promise<Buffer>;
+};
+export declare function isZipSymlinkEntry(entry: ZipEntry): boolean;
+export declare function zipEntryMode(entry: ZipEntry, policy: ArchiveEntryModePolicy | undefined): number;
+export declare function zipEntryDeclaredSize(entry: ZipEntry): number;
+//# sourceMappingURL=archive-zip-entry.d.ts.map

package/dist/archive-zip-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive-zip-entry.d.ts","sourceRoot":"","sources":["../src/archive-zip-entry.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,sBAAsB,EAC5B,MAAM,qBAAqB,CAAC;AAE7B,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,OAAO,CAAC;IACb,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,KAAK,CAAC,EAAE;QAAE,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACtC,UAAU,CAAC,EAAE,MAAM,MAAM,CAAC,cAAc,CAAC;IACzC,KAAK,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CAChD,CAAC;AAKF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAK1D;AAED,wBAAgB,YAAY,CAC1B,KAAK,EAAE,QAAQ,EACf,MAAM,EAAE,sBAAsB,GAAG,SAAS,GACzC,MAAM,CAMR;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAE5D"}

package/dist/archive-zip-entry.js

@@ -0,0 +1,17 @@
+import { resolveArchiveEntryMode, } from "./archive-policy.js";
+const ZIP_UNIX_FILE_TYPE_MASK = 0o170000;
+const ZIP_UNIX_SYMLINK_TYPE = 0o120000;
+export function isZipSymlinkEntry(entry) {
+    return (typeof entry.unixPermissions === "number" &&
+        (entry.unixPermissions & ZIP_UNIX_FILE_TYPE_MASK) === ZIP_UNIX_SYMLINK_TYPE);
+}
+export function zipEntryMode(entry, policy) {
+    return resolveArchiveEntryMode({
+        kind: entry.dir ? "directory" : "file",
+        archivedMode: entry.unixPermissions,
+        policy,
+    });
+}
+export function zipEntryDeclaredSize(entry) {
+    return Math.max(0, Math.floor(entry._data?.uncompressedSize ?? 0));
+}

package/dist/archive.d.ts

@@ -1,24 +1,14 @@
-import { type ArchiveExtractLimits } from "./archive-limits.js";
-import { type ArchiveKind } from "./archive-kind.js";
-export type ArchiveLogger = {
-    info?: (message: string) => void;
-    warn?: (message: string) => void;
-};
+import type { ExtractArchiveOptions } from "./archive-options.js";
+export type { ArchiveLogger, ExtractArchiveOptions } from "./archive-options.js";
+export type { ArchiveEntryFilter, ArchiveEntryKind, ArchiveEntryModePolicy, ArchiveFilteredEntryPolicy, } from "./archive-policy.js";
 export { isWindowsDrivePath, normalizeArchiveEntryPath, resolveArchiveOutputPath, stripArchivePath, validateArchiveEntryPath, } from "./archive-entry.js";
 export { resolveArchiveKind, resolvePackedRootDir, type ArchiveKind } from "./archive-kind.js";
-export { ARCHIVE_LIMIT_ERROR_CODE, ArchiveLimitError, DEFAULT_MAX_ARCHIVE_BYTES_ZIP, DEFAULT_MAX_ENTRIES, DEFAULT_MAX_EXTRACTED_BYTES, DEFAULT_MAX_ENTRY_BYTES, type ArchiveExtractLimits, type ArchiveLimitErrorCode, } from "./archive-limits.js";
+export { readArchiveEntry } from "./archive-read.js";
+export { ARCHIVE_LIMIT_ERROR_CODE, ArchiveLimitError, DEFAULT_MAX_ARCHIVE_BYTES_ZIP, DEFAULT_MAX_ENTRIES, DEFAULT_MAX_EXTRACTED_BYTES, DEFAULT_MAX_ENTRY_BYTES, DEFAULT_MAX_META_ENTRY_BYTES, DEFAULT_MAX_ENTRY_PATH_COMPONENTS, type ArchiveExtractLimits, type ArchiveLimitErrorCode, } from "./archive-limits.js";
+export { ArchiveFormatError, type ArchiveFormatErrorCode } from "./archive-errors.js";
 export { ArchiveSecurityError, type ArchiveSecurityErrorCode } from "./archive-staging.js";
 export { createArchiveSymlinkTraversalError, mergeExtractedTreeIntoDestination, prepareArchiveDestinationDir, prepareArchiveOutputPath, withStagedArchiveDestination, } from "./archive-staging.js";
 export { createTarEntryPreflightChecker, type TarEntryInfo } from "./archive-tar.js";
 export { loadZipArchiveWithPreflight, readZipCentralDirectoryEntryCount, type ZipArchiveWithFiles, } from "./archive-zip-preflight.js";
-export declare function extractArchive(params: {
-    archivePath: string;
-    destDir: string;
-    timeoutMs: number;
-    kind?: ArchiveKind;
-    stripComponents?: number;
-    tarGzip?: boolean;
-    limits?: ArchiveExtractLimits;
-    logger?: ArchiveLogger;
-}): Promise<void>;
+export declare function extractArchive(params: ExtractArchiveOptions): Promise<void>;
 //# sourceMappingURL=archive.d.ts.map

package/dist/archive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"archive.d.ts","sourceRoot":"","sources":["../src/archive.ts"],"names":[],"mappings":"AAkBA,OAAO,EAOL,KAAK,oBAAoB,EAC1B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAsB,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAiBzE,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAClC,CAAC;AAEF,OAAO,EACL,kBAAkB,EAClB,yBAAyB,EACzB,wBAAwB,EACxB,gBAAgB,EAChB,wBAAwB,GACzB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC/F,OAAO,EACL,wBAAwB,EACxB,iBAAiB,EACjB,6BAA6B,EAC7B,mBAAmB,EACnB,2BAA2B,EAC3B,uBAAuB,EACvB,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,GAC3B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,oBAAoB,EAAE,KAAK,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAC3F,OAAO,EACL,kCAAkC,EAClC,iCAAiC,EACjC,4BAA4B,EAC5B,wBAAwB,EACxB,4BAA4B,GAC7B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,8BAA8B,EAAE,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrF,OAAO,EACL,2BAA2B,EAC3B,iCAAiC,EACjC,KAAK,mBAAmB,GACzB,MAAM,4BAA4B,CAAC;AAuTpC,wBAAsB,cAAc,CAAC,MAAM,EAAE;IAC3C,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,oBAAoB,CAAC;IAC9B,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB,GAAG,OAAO,CAAC,IAAI,CAAC,CA6EhB"}
+{"version":3,"file":"archive.d.ts","sourceRoot":"","sources":["../src/archive.ts"],"names":[],"mappings":"AAuDA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAElE,YAAY,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AACjF,YAAY,EACV,kBAAkB,EAClB,gBAAgB,EAChB,sBAAsB,EACtB,0BAA0B,GAC3B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,kBAAkB,EAClB,yBAAyB,EACzB,wBAAwB,EACxB,gBAAgB,EAChB,wBAAwB,GACzB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC/F,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EACL,wBAAwB,EACxB,iBAAiB,EACjB,6BAA6B,EAC7B,mBAAmB,EACnB,2BAA2B,EAC3B,uBAAuB,EACvB,4BAA4B,EAC5B,iCAAiC,EACjC,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,GAC3B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,kBAAkB,EAAE,KAAK,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AACtF,OAAO,EAAE,oBAAoB,EAAE,KAAK,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAC3F,OAAO,EACL,kCAAkC,EAClC,iCAAiC,EACjC,4BAA4B,EAC5B,wBAAwB,EACxB,4BAA4B,GAC7B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,8BAA8B,EAAE,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrF,OAAO,EACL,2BAA2B,EAC3B,iCAAiC,EACjC,KAAK,mBAAmB,GACzB,MAAM,4BAA4B,CAAC;AAiNpC,wBAAsB,cAAc,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAiKjF"}