kiriya 0.1.0

package/dist/src/modules/archive/application/extract-zip.use-case.js

@@ -0,0 +1,181 @@
+import path from "node:path";
+import { isInside } from "../../../core/application/paths.js";
+import { requireTypedConfirmation } from "../../../core/application/safety.js";
+import { done } from "../../../core/domain/command.js";
+import { ConflictError, KiriyaError, NotFoundError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { message } from "../../../core/domain/message.js";
+import { invalidNameReason } from "../../../core/domain/names.js";
+import { safeEntrySegments } from "../domain/zip-format.js";
+import { ZipReader } from "./zip-reader.js";
+/** Names listed per kind of problem before the rest are counted. */
+const REPORT_LIMIT = 20;
+export const unzipSpec = {
+    id: "archive.unzip",
+    summary: "archive.unzip.summary",
+    examples: [
+        "kiriya archive unzip release.zip",
+        "kiriya archive unzip release.zip --list",
+        "kiriya archive unzip release.zip --to vendor/tool --overwrite",
+    ],
+    safety: "destroy",
+    idempotent: false,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [
+            { name: "archive", description: "archive.unzip.arg.archive", required: true, variadic: false, path: true },
+        ],
+        options: {
+            to: { type: "string", description: "archive.unzip.option.to", valueName: "<folder>", path: true },
+            list: { type: "boolean", description: "archive.unzip.option.list" },
+            overwrite: { type: "boolean", description: "archive.unzip.option.overwrite" },
+            confirm: {
+                type: "string",
+                description: "archive.unzip.option.confirm",
+                valueName: "<count>",
+                terminalOnly: true,
+            },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return {
+                archive: reader.positional(0) ?? "",
+                to: reader.string("to"),
+                list: reader.flag("list"),
+                overwrite: reader.flag("overwrite"),
+                confirm: reader.string("confirm"),
+            };
+        },
+    },
+};
+export class ExtractZip {
+    fileSystem;
+    content;
+    compression;
+    spec = unzipSpec;
+    constructor(fileSystem, content, compression) {
+        this.fileSystem = fileSystem;
+        this.content = content;
+        this.compression = compression;
+    }
+    async execute(input, context) {
+        const archive = path.resolve(context.cwd, input.archive);
+        if ((await this.fileSystem.lstat(archive)) === null)
+            throw new NotFoundError("core.fs.not-found", { path: archive });
+        const reader = await ZipReader.open(this.content, this.compression, archive);
+        try {
+            if (input.list) {
+                const entries = reader.entries.map((entry) => ({
+                    name: entry.name,
+                    isDirectory: entry.isDirectory,
+                    size: entry.size,
+                    compressedSize: entry.compressedSize,
+                    modifiedMs: entry.modifiedMs,
+                }));
+                return done({ mode: "list", archive, entries, bytes: entries.reduce((sum, entry) => sum + entry.size, 0) });
+            }
+            return await this.extract(reader, archive, input, context);
+        }
+        finally {
+            await reader.close();
+        }
+    }
+    async extract(reader, archive, input, context) {
+        const defaultTarget = path.join(path.dirname(archive), path.basename(archive, path.extname(archive)));
+        const target = path.resolve(context.cwd, input.to ?? defaultTarget);
+        const plan = [];
+        const unsafe = [];
+        const skipped = [];
+        const failures = [];
+        for (const entry of reader.entries) {
+            const segments = safeEntrySegments(entry.name);
+            if (segments === null) {
+                unsafe.push(entry.name);
+                continue;
+            }
+            if (segments.length === 0)
+                continue;
+            // A tool that could not encode a name may have stored "?" in it, which no Windows folder accepts.
+            const invalid = segments
+                .map((segment) => ({ segment, reason: invalidNameReason(segment) }))
+                .find((item) => item.reason !== null);
+            if (invalid !== undefined && invalid.reason !== null) {
+                skipped.push(entry.name);
+                const reason = message(invalid.reason, { name: invalid.segment });
+                failures.push(message("archive.unzip.invalid-name", { name: entry.name, reason }));
+                continue;
+            }
+            const destination = path.join(target, ...segments);
+            if (isInside(destination, target))
+                plan.push({ entry, destination });
+            else
+                unsafe.push(entry.name);
+        }
+        const result = {
+            mode: "extract",
+            archive,
+            target,
+            extracted: false,
+            files: 0,
+            bytes: 0,
+            unsafe,
+            skipped,
+            conflicts: [],
+        };
+        if (unsafe.length > 0) {
+            const names = unsafe.slice(0, REPORT_LIMIT).map((name) => message("archive.unzip.unsafe-name", { name }));
+            return done(result, { failures: [...names, message("archive.unzip.unsafe-archive")] });
+        }
+        const conflicts = [];
+        for (const item of plan) {
+            if (!item.entry.isDirectory && (await this.fileSystem.lstat(item.destination)) !== null) {
+                conflicts.push(item.destination);
+            }
+        }
+        if (conflicts.length > 0) {
+            if (!input.overwrite) {
+                const existing = conflicts
+                    .slice(0, REPORT_LIMIT)
+                    .map((conflict) => message("core.fs.exists", { path: conflict }));
+                const warnings = conflicts.length > REPORT_LIMIT
+                    ? [
+                        message("core.list.more", { count: conflicts.length - REPORT_LIMIT }),
+                        message("archive.unzip.nothing-extracted"),
+                    ]
+                    : [message("archive.unzip.nothing-extracted")];
+                return done({ ...result, conflicts }, { failures: [...failures, ...existing], warnings });
+            }
+            const warning = message("archive.unzip.warn-overwrite", { count: conflicts.length, target });
+            await requireTypedConfirmation(context, warning, String(conflicts.length), input.confirm);
+        }
+        let files = 0;
+        let bytes = 0;
+        for (const { entry, destination } of plan) {
+            if (context.signal.aborted)
+                break;
+            try {
+                if (entry.isDirectory) {
+                    await this.fileSystem.createDirectory(destination);
+                    continue;
+                }
+                if ((await this.fileSystem.stat(destination))?.kind === "directory") {
+                    throw new ConflictError("archive.unzip.folder-in-the-way", { name: entry.name });
+                }
+                await this.fileSystem.createDirectory(path.dirname(destination));
+                const data = await reader.read(entry);
+                await this.content.write(destination, data);
+                await this.fileSystem.setTimes(destination, entry.modifiedMs, entry.modifiedMs);
+                files += 1;
+                bytes += data.length;
+            }
+            catch (error) {
+                if (!(error instanceof KiriyaError))
+                    throw error;
+                failures.push(message("archive.unzip.entry-failed", { name: entry.name, reason: error.detail }));
+            }
+        }
+        return done({ ...result, conflicts, extracted: true, files, bytes }, { failures });
+    }
+}
+//# sourceMappingURL=extract-zip.use-case.js.map

package/dist/src/modules/archive/application/tar-reader.js

@@ -0,0 +1,45 @@
+import { InterruptedError, OperationFailedError } from "../../../core/domain/errors.js";
+import { TarFormatError, TarParser } from "../domain/tar-stream.js";
+/** The archive is read in pieces this size, so it never has to fit in memory. */
+const CHUNK_BYTES = 1024 * 1024;
+/**
+ * Streams a .tar, .tar.gz or .tgz, whichever its first bytes show it to be, and hands
+ * each event to `handle` in order. Damaged gzip or tar data becomes one error naming the archive.
+ */
+export async function readTar(content, compression, archive, signal, handle) {
+    const reader = await content.openForReading(archive);
+    try {
+        const head = await reader.readAt(0, Math.min(2, reader.size));
+        const gunzip = head[0] === 0x1f && head[1] === 0x8b ? compression.gunzip() : null;
+        const parser = new TarParser();
+        const feed = async (bytes) => {
+            for (const event of parser.push(bytes))
+                await handle(event);
+        };
+        try {
+            for (let position = 0; position < reader.size && !parser.ended; position += CHUNK_BYTES) {
+                if (signal.aborted)
+                    throw new InterruptedError("core.error.interrupted");
+                const raw = await reader.readAt(position, Math.min(CHUNK_BYTES, reader.size - position));
+                await feed(gunzip === null ? raw : await gunzip.push(raw));
+            }
+            if (gunzip !== null && !parser.ended)
+                await feed(await gunzip.end());
+            // What follows the end blocks does not matter, even when it is not valid gzip.
+            if (gunzip !== null && parser.ended)
+                await gunzip.end().catch(() => undefined);
+            parser.finish();
+        }
+        catch (error) {
+            const damaged = error instanceof TarFormatError ||
+                (error instanceof OperationFailedError && error.detail.key === "core.compression.failed");
+            if (!damaged)
+                throw error;
+            throw new OperationFailedError("archive.untar.damaged", { path: archive, reason: error.detail }, { cause: error });
+        }
+    }
+    finally {
+        await reader.close();
+    }
+}
+//# sourceMappingURL=tar-reader.js.map

package/dist/src/modules/archive/application/zip-reader.js

@@ -0,0 +1,57 @@
+import { OperationFailedError } from "../../../core/domain/errors.js";
+import { crc32 } from "../domain/crc32.js";
+import { dataOffset, DEFLATED, END_SEARCH_LENGTH, findDirectory, LOCAL_HEADER_LENGTH, parseDirectory, STORED, usesZip64, } from "../domain/zip-format.js";
+/** An open archive: its entries from the central directory, and each entry's bytes on request. */
+export class ZipReader {
+    file;
+    compression;
+    entries;
+    constructor(file, compression, entries) {
+        this.file = file;
+        this.compression = compression;
+        this.entries = entries;
+    }
+    static async open(content, compression, archive) {
+        const file = await content.openForReading(archive);
+        try {
+            const tailLength = Math.min(file.size, END_SEARCH_LENGTH);
+            const location = findDirectory(await file.readAt(file.size - tailLength, tailLength));
+            if (location === null)
+                throw new OperationFailedError("archive.read.not-a-zip", { path: archive });
+            if (usesZip64(location))
+                throw new OperationFailedError("archive.read.zip64", { path: archive });
+            if (location.offset + location.size > file.size) {
+                throw new OperationFailedError("archive.read.damaged", { path: archive });
+            }
+            const entries = parseDirectory(await file.readAt(location.offset, location.size), location.count);
+            if (entries === null)
+                throw new OperationFailedError("archive.read.damaged", { path: archive });
+            return new ZipReader(file, compression, entries);
+        }
+        catch (error) {
+            await file.close();
+            throw error;
+        }
+    }
+    /** One entry's bytes, checked against its CRC-32. */
+    async read(entry) {
+        if (entry.encrypted)
+            throw new OperationFailedError("archive.unzip.encrypted", { name: entry.name });
+        if (entry.method !== STORED && entry.method !== DEFLATED) {
+            throw new OperationFailedError("archive.unzip.method", { name: entry.name, method: entry.method });
+        }
+        const header = await this.file.readAt(entry.localOffset, LOCAL_HEADER_LENGTH);
+        const start = dataOffset(entry.localOffset, header);
+        if (start === null)
+            throw new OperationFailedError("archive.unzip.damaged-entry", { name: entry.name });
+        const raw = await this.file.readAt(start, entry.compressedSize);
+        const data = entry.method === DEFLATED ? await this.compression.inflateRaw(raw) : raw;
+        if (crc32(data) !== entry.crc)
+            throw new OperationFailedError("archive.unzip.checksum", { name: entry.name });
+        return data;
+    }
+    close() {
+        return this.file.close();
+    }
+}
+//# sourceMappingURL=zip-reader.js.map

package/dist/src/modules/archive/archive.module.js

@@ -0,0 +1,27 @@
+import { CreateTar } from "./application/create-tar.use-case.js";
+import { CreateZip } from "./application/create-zip.use-case.js";
+import { ExtractTar } from "./application/extract-tar.use-case.js";
+import { ExtractZip } from "./application/extract-zip.use-case.js";
+import { tarView } from "./presentation/tar.view.js";
+import { untarView } from "./presentation/untar.view.js";
+import { unzipView } from "./presentation/unzip.view.js";
+import { zipView } from "./presentation/zip.view.js";
+export const archiveModule = {
+    id: "archive",
+    summary: "archive.summary",
+    about: "archive.about",
+    examples: [
+        "kiriya archive zip my-project --to my-project.zip --lean",
+        "kiriya archive unzip release.zip --list",
+        "kiriya archive untar node.tar.gz --to vendor/node",
+    ],
+    guide: "https://github.com/SatPaingOo/kiriya/blob/main/docs/modules/archive.md",
+    register(registrar, ports) {
+        const { fileSystem, fileContent, compression } = ports;
+        registrar.add(new CreateZip(fileSystem, fileContent, compression), zipView);
+        registrar.add(new ExtractZip(fileSystem, fileContent, compression), unzipView);
+        registrar.add(new CreateTar(fileSystem, fileContent, compression), tarView);
+        registrar.add(new ExtractTar(fileSystem, fileContent, compression), untarView);
+    },
+};
+//# sourceMappingURL=archive.module.js.map

package/dist/src/modules/archive/domain/crc32.js

@@ -0,0 +1,18 @@
+const TABLE = (() => {
+    const table = new Uint32Array(256);
+    for (let n = 0; n < 256; n += 1) {
+        let c = n;
+        for (let k = 0; k < 8; k += 1)
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        table[n] = c >>> 0;
+    }
+    return table;
+})();
+/** The CRC-32 that ZIP stores for every entry. */
+export function crc32(data) {
+    let crc = 0xffffffff;
+    for (const byte of data)
+        crc = (TABLE[(crc ^ byte) & 0xff] ?? 0) ^ (crc >>> 8);
+    return (crc ^ 0xffffffff) >>> 0;
+}
+//# sourceMappingURL=crc32.js.map

package/dist/src/modules/archive/domain/tar-format.js

@@ -0,0 +1,97 @@
+import { utf8Bytes } from "../../../core/domain/encodings.js";
+export const TAR_BLOCK = 512;
+/** Two empty blocks end an archive. */
+export const TAR_END = new Uint8Array(TAR_BLOCK * 2);
+/** The largest number eleven octal digits hold, just under 8 GB; a larger size goes in a pax record. */
+const OCTAL_SIZE_LIMIT = 8 ** 11 - 1;
+const NAME_BYTES = 100;
+/** gzip for .tar.gz and .tgz, none for .tar, and null for any other name. */
+export function tarCompression(archive) {
+    const lower = archive.toLowerCase();
+    if (lower.endsWith(".tar.gz") || lower.endsWith(".tgz"))
+        return true;
+    return lower.endsWith(".tar") ? false : null;
+}
+/** Zero bytes that bring `size` up to a whole block. */
+export function tarPadding(size) {
+    return (TAR_BLOCK - (size % TAR_BLOCK)) % TAR_BLOCK;
+}
+function isPlainAscii(text) {
+    return [...text].every((char) => char >= " " && char <= "~");
+}
+function writeAscii(block, offset, length, text) {
+    for (let index = 0; index < Math.min(length, text.length); index += 1) {
+        block[offset + index] = text.charCodeAt(index);
+    }
+}
+/** Zero-padded octal digits, with the field's last byte left as NUL. */
+function writeOctal(block, offset, length, value) {
+    writeAscii(block, offset, length - 1, Math.floor(value)
+        .toString(8)
+        .padStart(length - 1, "0"));
+}
+function concat(parts) {
+    const bytes = new Uint8Array(parts.reduce((total, part) => total + part.length, 0));
+    let offset = 0;
+    for (const part of parts) {
+        bytes.set(part, offset);
+        offset += part.length;
+    }
+    return bytes;
+}
+/** One ustar header block. No user or group names are written, so an archive says nothing about who made it. */
+function header(name, typeflag, size, mode, mtimeSeconds) {
+    const block = new Uint8Array(TAR_BLOCK);
+    writeAscii(block, 0, NAME_BYTES, name);
+    writeOctal(block, 100, 8, mode & 0o7777);
+    writeOctal(block, 108, 8, 0);
+    writeOctal(block, 116, 8, 0);
+    writeOctal(block, 124, 12, size);
+    writeOctal(block, 136, 12, mtimeSeconds);
+    block[156] = typeflag.charCodeAt(0);
+    writeAscii(block, 257, 5, "ustar");
+    writeAscii(block, 263, 2, "00");
+    // The checksum counts its own field as spaces, then takes six octal digits, a NUL and a space.
+    block.fill(0x20, 148, 156);
+    const sum = block.reduce((total, byte) => total + byte, 0);
+    writeAscii(block, 148, 6, sum.toString(8).padStart(6, "0"));
+    block[154] = 0;
+    return block;
+}
+/** "LENGTH key=value" and a newline, where LENGTH counts the whole record, its own digits included. */
+function paxRecord(key, value) {
+    const body = utf8Bytes(` ${key}=${value}\n`).length;
+    let length = body + 1;
+    while (String(length).length + body !== length)
+        length = String(length).length + body;
+    return utf8Bytes(`${length} ${key}=${value}\n`);
+}
+/** A plain ASCII stand-in for tools that ignore pax records, keeping the end, where the file name is. */
+function asciiName(name) {
+    const ascii = [...name].map((char) => (char >= " " && char <= "~" ? char : "_")).join("");
+    return ascii.length <= NAME_BYTES ? ascii : ascii.slice(-NAME_BYTES);
+}
+/**
+ * The header blocks for one entry, in POSIX ustar form. A name longer than 100 bytes
+ * or not plain ASCII, and a size of 8 GB or more, go in a pax extended header before
+ * it, which GNU tar, bsdtar and 7-Zip all read.
+ */
+export function tarHeader(entry) {
+    const name = entry.isDirectory && !entry.name.endsWith("/") ? `${entry.name}/` : entry.name;
+    const mtime = Math.max(0, Math.floor(entry.modifiedMs / 1000));
+    const plainName = isPlainAscii(name) && name.length <= NAME_BYTES;
+    const largeSize = entry.size > OCTAL_SIZE_LIMIT;
+    const records = [];
+    if (!plainName)
+        records.push(paxRecord("path", name));
+    if (largeSize)
+        records.push(paxRecord("size", String(entry.size)));
+    const typeflag = entry.isDirectory ? "5" : "0";
+    const main = header(plainName ? name : asciiName(name), typeflag, largeSize ? 0 : entry.size, entry.mode, mtime);
+    if (records.length === 0)
+        return main;
+    const pax = concat(records);
+    const paxHeader = header(asciiName(`PaxHeader/${name}`), "x", pax.length, 0o644, mtime);
+    return concat([paxHeader, pax, new Uint8Array(tarPadding(pax.length)), main]);
+}
+//# sourceMappingURL=tar-format.js.map

package/dist/src/modules/archive/domain/tar-stream.js

@@ -0,0 +1,223 @@
+import { utf8Text } from "../../../core/domain/encodings.js";
+import { OperationFailedError } from "../../../core/domain/errors.js";
+const BLOCK = 512;
+/** Extended headers hold a name and a few numbers; anything larger is no real archive. */
+const META_LIMIT = 1024 * 1024;
+/** Tar data that cannot be read; its detail is the reason, such as a checksum that does not match. */
+export class TarFormatError extends OperationFailedError {
+}
+function ascii(bytes, offset, length) {
+    let text = "";
+    for (let index = offset; index < offset + length; index += 1)
+        text += String.fromCharCode(bytes[index] ?? 0);
+    return text;
+}
+/** Text up to the first NUL: UTF-8, or Latin-1 from tools that wrote names in another encoding. */
+function nameText(bytes) {
+    const end = bytes.indexOf(0);
+    const raw = end < 0 ? bytes : bytes.subarray(0, end);
+    return utf8Text(raw) ?? ascii(raw, 0, raw.length);
+}
+function trimmedField(bytes, offset, length) {
+    return ascii(bytes, offset, length).replace(/^[ \0]+|[ \0]+$/g, "");
+}
+/** An octal field, or GNU's base-256 form, which sets the top bit of the first byte. */
+function readNumber(block, offset, length) {
+    const first = block[offset] ?? 0;
+    if ((first & 0x80) !== 0) {
+        let value = first & 0x7f;
+        for (let index = 1; index < length; index += 1)
+            value = value * 256 + (block[offset + index] ?? 0);
+        return value;
+    }
+    const text = trimmedField(block, offset, length);
+    if (text === "")
+        return 0;
+    if (!/^[0-7]+$/.test(text))
+        throw new TarFormatError("archive.tar.bad-header");
+    return parseInt(text, 8);
+}
+/** Old tools summed header bytes as signed numbers, so either sum is accepted. */
+function checksumMatches(block) {
+    const text = trimmedField(block, 148, 8);
+    if (!/^[0-7]+$/.test(text))
+        return false;
+    let unsigned = 0;
+    let signed = 0;
+    for (let index = 0; index < BLOCK; index += 1) {
+        const byte = index >= 148 && index < 156 ? 0x20 : (block[index] ?? 0);
+        unsigned += byte;
+        signed += byte > 127 ? byte - 256 : byte;
+    }
+    const stored = parseInt(text, 8);
+    return stored === unsigned || stored === signed;
+}
+/** Records of "LENGTH key=value" and a newline. */
+function parsePax(bytes) {
+    const records = new Map();
+    let position = 0;
+    while (position < bytes.length) {
+        const space = bytes.indexOf(0x20, position);
+        const length = space < 0 ? Number.NaN : Number(ascii(bytes, position, space - position));
+        if (!Number.isInteger(length) || length <= space - position || position + length > bytes.length) {
+            throw new TarFormatError("archive.tar.bad-header");
+        }
+        const record = utf8Text(bytes.subarray(space + 1, position + length - 1)) ?? "";
+        const equals = record.indexOf("=");
+        if (equals > 0)
+            records.set(record.slice(0, equals), record.slice(equals + 1));
+        position += length;
+    }
+    return records;
+}
+function entryType(typeflag, name) {
+    if (typeflag === "5")
+        return "directory";
+    if (typeflag === "0" || typeflag === "7" || typeflag === String.fromCharCode(0)) {
+        return name.endsWith("/") ? "directory" : "file";
+    }
+    return typeflag === "1" || typeflag === "2" ? "link" : "other";
+}
+function concat(first, second) {
+    const bytes = new Uint8Array(first.length + second.length);
+    bytes.set(first);
+    bytes.set(second, first.length);
+    return bytes;
+}
+/**
+ * Reads a tar stream from pieces of any size: POSIX ustar, pax extended headers and GNU
+ * long names, as GNU tar, bsdtar and most other tools write them. It never touches a file:
+ * each entry, its data and its end arrive as events for the caller to act on.
+ */
+export class TarParser {
+    buffer = new Uint8Array(0);
+    state = "header";
+    remaining = 0;
+    padding = 0;
+    metaType = "";
+    meta = [];
+    pax = new Map();
+    longName = null;
+    headers = 0;
+    emptyBlocks = 0;
+    /** The two empty blocks that end an archive have been read. */
+    get ended() {
+        return this.state === "done";
+    }
+    push(chunk) {
+        const events = [];
+        const data = this.buffer.length === 0 ? chunk : concat(this.buffer, chunk);
+        let offset = 0;
+        while (this.state !== "done") {
+            const available = data.length - offset;
+            if (this.state === "data" || this.state === "meta") {
+                if (this.remaining === 0) {
+                    if (this.state === "data")
+                        events.push({ kind: "entry-end" });
+                    else
+                        this.applyMeta();
+                    this.state = this.padding > 0 ? "padding" : "header";
+                    continue;
+                }
+                const take = Math.min(this.remaining, available);
+                if (take === 0)
+                    break;
+                const bytes = data.slice(offset, offset + take);
+                if (this.state === "data")
+                    events.push({ kind: "data", bytes });
+                else
+                    this.meta.push(bytes);
+                offset += take;
+                this.remaining -= take;
+                continue;
+            }
+            if (this.state === "padding") {
+                const take = Math.min(this.padding, available);
+                if (take === 0)
+                    break;
+                offset += take;
+                this.padding -= take;
+                if (this.padding === 0)
+                    this.state = "header";
+                continue;
+            }
+            if (available < BLOCK)
+                break;
+            const event = this.readHeader(data.subarray(offset, offset + BLOCK));
+            offset += BLOCK;
+            if (event !== null)
+                events.push(event);
+        }
+        this.buffer = data.slice(offset);
+        return events;
+    }
+    /** Called when the input is over. An archive that stops cleanly after an entry, without its end blocks, still counts. */
+    finish() {
+        if (this.state === "done")
+            return;
+        if (this.state === "header" && this.buffer.length === 0 && this.headers > 0) {
+            this.state = "done";
+            return;
+        }
+        throw new TarFormatError(this.headers === 0 ? "archive.tar.not-tar" : "archive.tar.truncated");
+    }
+    readHeader(block) {
+        if (block.every((byte) => byte === 0)) {
+            this.emptyBlocks += 1;
+            if (this.emptyBlocks === 2)
+                this.state = "done";
+            return null;
+        }
+        this.emptyBlocks = 0;
+        if (!checksumMatches(block)) {
+            throw new TarFormatError(this.headers === 0 ? "archive.tar.not-tar" : "archive.tar.bad-checksum");
+        }
+        this.headers += 1;
+        const typeflag = String.fromCharCode(block[156] ?? 0);
+        const isMeta = "xgLK".includes(typeflag);
+        const paxSize = this.pax.get("size");
+        const size = !isMeta && paxSize !== undefined ? Number(paxSize) : readNumber(block, 124, 12);
+        if (!Number.isSafeInteger(size) || size < 0)
+            throw new TarFormatError("archive.tar.bad-header");
+        this.remaining = size;
+        this.padding = (BLOCK - (size % BLOCK)) % BLOCK;
+        if (isMeta) {
+            if (size > META_LIMIT)
+                throw new TarFormatError("archive.tar.meta-too-large");
+            this.state = "meta";
+            this.metaType = typeflag;
+            this.meta = [];
+            return null;
+        }
+        let name = nameText(block.subarray(0, 100));
+        // Only POSIX ustar keeps a name prefix here; GNU's older format stores times in the same place.
+        if (ascii(block, 257, 5) === "ustar" && block[262] === 0) {
+            const prefix = nameText(block.subarray(345, 500));
+            if (prefix !== "")
+                name = `${prefix}/${name}`;
+        }
+        name = this.pax.get("path") ?? this.longName ?? name;
+        const mtime = Number(this.pax.get("mtime") ?? readNumber(block, 136, 12));
+        const entry = {
+            name,
+            type: entryType(typeflag, name),
+            size,
+            mode: readNumber(block, 100, 8),
+            modifiedMs: Number.isFinite(mtime) ? Math.round(mtime * 1000) : 0,
+        };
+        this.pax = new Map();
+        this.longName = null;
+        this.state = "data";
+        return { kind: "entry", entry };
+    }
+    applyMeta() {
+        const bytes = this.meta.reduce((joined, part) => concat(joined, part), new Uint8Array(0));
+        this.meta = [];
+        if (this.metaType === "x")
+            this.pax = parsePax(bytes);
+        if (this.metaType === "L")
+            this.longName = nameText(bytes);
+        // Global pax headers (g) and GNU long link names (K) change nothing kiriya extracts.
+    }
+}
+//# sourceMappingURL=tar-stream.js.map