@poe-platform/safe-bash 0.1.710 → 0.1.712

package/dist/safe-bash-command-exiftool/shifts.js

@@ -1,29 +0,0 @@
-/** Numeric shift grammar differs from conservative JSON token admission. */
-export function isNumericShift(value) {
-    const end = value.endsWith("\n") ? value.length - 1 : value.length;
-    let index = value[0] === "+" || value[0] === "-" ? 1 : 0;
-    const digit = () => index < end && value.charCodeAt(index) >= 48 && value.charCodeAt(index) <= 57;
-    const start = index;
-    while (digit())
-        index++;
-    let digits = index - start;
-    if (value[index] === "." || value[index] === ",") {
-        const start = ++index;
-        while (digit())
-            index++;
-        digits += index - start;
-    }
-    if (!digits)
-        return false;
-    if (value[index] === "e" || value[index] === "E") {
-        index++;
-        if (value[index] === "+" || value[index] === "-")
-            index++;
-        const start = index;
-        while (digit())
-            index++;
-        if (index === start)
-            return false;
-    }
-    return index === end;
-}

package/dist/safe-bash-command-wkhtmltopdf/command.js

@@ -1,373 +0,0 @@
-import { commandRuntimeIdentity, getCommandArguments } from "../safe-bash-contracts/command.js";
-import { readBytes, writeBytes } from "../safe-bash-contracts/io.js";
-import { shellValueByteLength } from "../safe-bash-contracts/value.js";
-import { FsError } from "../safe-bash-contracts/errors.js";
-import { createOutputOperation } from "../safe-bash-contracts/output.js";
-import { basename, compareEntries, dirname, resolvePath } from "@poe-platform/safe-fs/core";
-import { WkhtmltopdfError } from "./errors.js";
-import { requireRendererFeatures } from "./engine.js";
-import { ParseBudget } from "./limits.js";
-import { conversionOutcome } from "./outcome.js";
-import { parseInvocation, tokenizeBatchLine } from "./parser.js";
-import { withResources } from "./resources.js";
-export const wkhtmltopdfLimits = Object.freeze({
-    parse: Object.freeze({ maxArguments: 1024, maxTextBytes: 65536, maxObjects: 64, maxWork: 1048576 }),
-    resources: Object.freeze({ maxInputBytes: 16777216, maxDecodedBytes: 16777216, maxRetainedBytes: 33554432, maxWork: 67108864, maxResources: 128 }),
-    maxOutputBytes: 16777216, maxOutputChunks: 65536, maxBatchJobs: 128,
-});
-const encoder = new TextEncoder();
-const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
-const typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
-const byteType = Object.getOwnPropertyDescriptor(typedArrayPrototype, Symbol.toStringTag).get;
-const byteLength = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteLength").get;
-/** The SDK uses exactly the CLI's literal argument model, signals and destinations. */
-export async function runWkhtmltopdf(context, options) {
-    context.signal.throwIfAborted();
-    const controller = new AbortController();
-    const signal = controller.signal;
-    let opening;
-    let closing;
-    let cleanupPromise;
-    let resourceRun;
-    let stdout;
-    let stderr;
-    const retire = () => {
-        if (!opening)
-            return Promise.resolve();
-        closing ??= opening.then(document => document.close(), () => { });
-        return closing;
-    };
-    const onAbort = () => controller.abort(context.signal.reason);
-    const cleanup = () => {
-        cleanupPromise ??= (async () => {
-            controller.abort(new WkhtmltopdfError("INVALID_VALUE", "Invocation has ended"));
-            context.signal.removeEventListener("abort", onAbort);
-            const drained = await Promise.allSettled([
-                retire(), resourceRun?.then(() => { }, () => { }), stdout?.close(), stderr?.close(),
-            ]);
-            const failures = drained.filter(value => value.status === "rejected").map(value => value.reason);
-            if (failures.length)
-                throw new AggregateError(failures, "Invocation cleanup failed");
-        })();
-        return cleanupPromise;
-    };
-    // Registration precedes argv copies, input opens, renderer acquisition and output.
-    context.registerCleanup?.(cleanup);
-    let primary = false;
-    let failure;
-    let result;
-    try {
-        context.signal.addEventListener("abort", onAbort, { once: true });
-        if (context.signal.aborted)
-            onAbort();
-        signal.throwIfAborted();
-        stdout = createOutputOperation({ signal, registerCleanup: callback => context.registerCleanup?.(callback) }, context.stdout);
-        stderr = createOutputOperation({ signal, registerCleanup: callback => context.registerCleanup?.(callback) }, context.stderr);
-        const limits = Object.freeze({
-            ...options.limits, parse: Object.freeze({ ...options.limits.parse }), resources: Object.freeze({ ...options.limits.resources }),
-        });
-        for (const value of [limits.maxOutputBytes, limits.maxOutputChunks, limits.maxBatchJobs]) {
-            if (!Number.isSafeInteger(value) || value < 1)
-                throw new WkhtmltopdfError("INVALID_VALUE", "Command limits must be positive safe integers");
-        }
-        for (const key of ["maxInputBytes", "maxDecodedBytes", "maxRetainedBytes", "maxWork", "maxResources"]) {
-            if (!Number.isSafeInteger(limits.resources[key]) || limits.resources[key] < 1) {
-                throw new WkhtmltopdfError("INVALID_VALUE", "Resource limits must be positive safe integers");
-            }
-        }
-        // Admit text/argument bounds before materializing carrier byte copies.
-        const admission = new ParseBudget({ limits: limits.parse, signal });
-        admission.admitArguments(context.args.length);
-        for (const arg of context.args)
-            admission.admitText(arg);
-        const carrier = context.argumentValues === undefined ? undefined : getCommandArguments(context);
-        const argv = [];
-        let argumentBytes = 0;
-        for (let index = 0; index < context.args.length; index++) {
-            signal.throwIfAborted();
-            if (carrier === undefined || typeof carrier.values[index] === "string") {
-                argv.push(context.args[index]);
-                continue;
-            }
-            const bytes = carrier.bytes(index);
-            if (bytes.byteLength > limits.parse.maxTextBytes - argumentBytes)
-                throw new WkhtmltopdfError("LIMIT_EXCEEDED", "CLI argument byte limit exceeded");
-            argumentBytes += bytes.byteLength;
-            try {
-                argv.push(decoder.decode(bytes));
-            }
-            catch {
-                throw new WkhtmltopdfError("INVALID_VALUE", "CLI arguments must be valid UTF-8");
-            }
-        }
-        const parse = (args, batchJob = false) => parseInvocation(args, { limits: limits.parse, signal, endOfOptions: true, batchJob });
-        const initial = parse(argv);
-        if (initial.mode === "information") {
-            let text;
-            if (initial.global.action === "help" || initial.global.action === "extended-help") {
-                text = "Usage: wkhtmltopdf [options] [page|cover input|toc]... output\nStatic first-party renderer requires an explicit binding. Input/output '-' use stdin/stdout.\n";
-            }
-            else if (initial.global.action === "version") {
-                text = "wkhtmltopdf safe static adapter (source 024b2b2bb459dd904d15b911d04c6df4ff2c9031; Qt compatibility unqualified)\n";
-            }
-            else
-                throw new WkhtmltopdfError("UNSUPPORTED_CAPABILITY", "Information action is unavailable in the static profile", initial.global.action);
-            if (shellValueByteLength(text) > limits.maxOutputBytes) {
-                throw new WkhtmltopdfError("LIMIT_EXCEEDED", "Information output byte limit exceeded");
-            }
-            await writeBytes(stdout.output, encoder.encode(text), signal);
-            result = { kind: "information", exitCode: 0 };
-        }
-        else {
-            const renderer = options.renderer;
-            if (!renderer)
-                throw new WkhtmltopdfError("UNSUPPORTED_CAPABILITY", "A qualified first-party static renderer binding is required");
-            requireRendererFeatures(renderer.profile, []);
-            let outputBytes = 0;
-            let outputChunks = 0;
-            let jobs = 0;
-            let inputBytes = 0;
-            let currentInputs = [];
-            let produced;
-            // Capture the drain promise before synchronous host opens can call cleanup.
-            resourceRun = Promise.resolve().then(() => withResources({
-                limits: limits.resources, signal,
-                vfs: async (reference, readSignal) => {
-                    if (reference === "vfs:output") {
-                        if (!produced)
-                            throw new WkhtmltopdfError("INVALID_VALUE", "No renderer output is active");
-                        const document = produced;
-                        return {
-                            chunks: (async function* () {
-                                for await (const chunk of document.chunks) {
-                                    readSignal.throwIfAborted();
-                                    if (byteType.call(chunk) !== "Uint8Array")
-                                        throw new WkhtmltopdfError("INVALID_VALUE", "Renderer must produce byte chunks");
-                                    const length = byteLength.call(chunk);
-                                    if (++outputChunks > limits.maxOutputChunks || length > limits.maxOutputBytes - outputBytes) {
-                                        throw new WkhtmltopdfError("LIMIT_EXCEEDED", "PDF output stage limit exceeded");
-                                    }
-                                    outputBytes += length;
-                                    yield chunk;
-                                }
-                            })(),
-                            close: retire,
-                        };
-                    }
-                    const index = Number(reference.slice("vfs:input/".length));
-                    const input = currentInputs[index];
-                    if (input === undefined)
-                        throw new WkhtmltopdfError("INVALID_VALUE", "Unknown invocation input identity");
-                    if (input === "-")
-                        return {
-                            chunks: (async function* () {
-                                for await (const chunk of readBytes(context.stdin, readSignal)) {
-                                    inputBytes += byteLength.call(chunk);
-                                    context.inputBudget?.check(inputBytes);
-                                    yield chunk;
-                                }
-                            })(),
-                            async close() { },
-                        };
-                    if (!context.fs.openReadFile)
-                        throw new WkhtmltopdfError("UNSUPPORTED_CAPABILITY", "VFS requires bounded read handles");
-                    const handle = await context.fs.openReadFile(resolvePath(context.cwd, input), { signal: readSignal });
-                    let position = 0;
-                    return {
-                        chunks: (async function* () {
-                            for (;;) {
-                                readSignal.throwIfAborted();
-                                const chunk = await handle.read(position, Math.min(65536, limits.resources.maxInputBytes, limits.resources.maxDecodedBytes, limits.resources.maxRetainedBytes, Math.max(1, context.inputBudget?.maxBytes ?? limits.resources.maxInputBytes)), { signal: readSignal });
-                                if (byteType.call(chunk) !== "Uint8Array")
-                                    throw new WkhtmltopdfError("INVALID_VALUE", "VFS must produce byte chunks");
-                                const length = byteLength.call(chunk);
-                                if (!length)
-                                    return;
-                                inputBytes += length;
-                                context.inputBudget?.check(inputBytes);
-                                position += length;
-                                yield chunk;
-                            }
-                        })(),
-                        close: () => handle.close(),
-                    };
-                },
-            }, async (resources) => {
-                const convert = async (job, batch) => {
-                    if (++jobs > limits.maxBatchJobs)
-                        throw new WkhtmltopdfError("LIMIT_EXCEEDED", "Batch job limit exceeded");
-                    currentInputs = job.objects.map(object => {
-                        if (object.input === null)
-                            throw new WkhtmltopdfError("UNSUPPORTED_CAPABILITY", "TOC requires a qualified outline/XSLT engine");
-                        if (batch && object.input === "-")
-                            throw new WkhtmltopdfError("UNSUPPORTED_CAPABILITY", "Batch conversion cannot share stdin with HTML input");
-                        return object.input;
-                    });
-                    let destination;
-                    if (job.output !== "-") {
-                        if (!context.fs.writeFileConditional) {
-                            throw new WkhtmltopdfError("UNSUPPORTED_CAPABILITY", "VFS requires conditional file publication");
-                        }
-                        const requested = resolvePath(context.cwd, job.output);
-                        const parentPath = await context.fs.realpath(dirname(requested), { signal });
-                        const path = resolvePath(parentPath, basename(requested));
-                        const parent = await context.fs.stat(parentPath, { signal });
-                        let expected = null;
-                        try {
-                            expected = await context.fs.lstat(path, { signal });
-                        }
-                        catch (error) {
-                            if (!(error instanceof FsError && error.code === "ENOENT"))
-                                throw error;
-                        }
-                        // Refuse final symlinks rather than granting authority over their target.
-                        if (expected !== null && expected.type !== "file") {
-                            throw new WkhtmltopdfError("INVALID_VALUE", "Output must be a regular VFS file or absent");
-                        }
-                        for (let index = 0; index < currentInputs.length; index++) {
-                            const input = currentInputs[index];
-                            if (input === "-")
-                                continue;
-                            const source = await context.fs.realpath(resolvePath(context.cwd, input), { signal });
-                            currentInputs[index] = source;
-                            if (source === path || (expected !== null &&
-                                await compareEntries(context.fs, source, context.fs, path, { signal }) !== "distinct")) {
-                                throw new WkhtmltopdfError("INVALID_VALUE", "Input and output VFS identities must be distinct");
-                            }
-                        }
-                        destination = { path, condition: { parent, expected, signal } };
-                    }
-                    const inputs = [];
-                    for (let index = 0; index < currentInputs.length; index++)
-                        inputs.push(await resources.load("vfs:input/" + index));
-                    signal.throwIfAborted();
-                    opening = Promise.resolve().then(() => {
-                        signal.throwIfAborted();
-                        return renderer.open({ job, inputs, signal, limits });
-                    });
-                    closing = undefined;
-                    const document = await opening;
-                    produced = document;
-                    signal.throwIfAborted();
-                    const outcome = conversionOutcome({
-                        mode: batch ? "batch" : "single", success: document.success, errorCode: document.errorCode,
-                        ...(document.networkErrorName === undefined ? {} : { networkErrorName: document.networkErrorName }),
-                    });
-                    let pdf;
-                    if (outcome.exitCode === 0) {
-                        // The same ledger covers retained HTML, copied PDF chunks, assembly and work.
-                        pdf = await resources.load("vfs:output");
-                    }
-                    await retire();
-                    opening = undefined;
-                    closing = undefined;
-                    produced = undefined;
-                    signal.throwIfAborted();
-                    if (outcome.exitCode === 0) {
-                        if (job.output === "-")
-                            await writeBytes(stdout.output, pdf, signal);
-                        else
-                            await context.fs.writeFileConditional(destination.path, pdf, destination.condition);
-                    }
-                    else
-                        await diagnostic({ ...context, stderr: stderr.output }, outcome, signal);
-                    return outcome;
-                };
-                let outcome = { exitCode: 0, diagnostic: null };
-                if (initial.mode === "batch") {
-                    // Shared resource accounting bounds batch text as well as every job input.
-                    currentInputs = ["-"];
-                    const bytes = await resources.load("vfs:input/0");
-                    let text;
-                    try {
-                        text = decoder.decode(bytes);
-                    }
-                    catch {
-                        throw new WkhtmltopdfError("INVALID_VALUE", "Batch input must be valid UTF-8");
-                    }
-                    let start = 0;
-                    for (let end = 0; end <= text.length; end++) {
-                        signal.throwIfAborted();
-                        if (end !== text.length && text[end] !== "\n")
-                            continue;
-                        if (end === text.length && start === end)
-                            break;
-                        const args = tokenizeBatchLine(text.slice(start, end), { limits: limits.parse, signal });
-                        const job = parse([...argv, ...args], true);
-                        if (job.mode !== "conversion")
-                            throw new WkhtmltopdfError("UNSUPPORTED_CAPABILITY", "Batch lines must describe conversion jobs");
-                        outcome = await convert(job, true);
-                        if (outcome.exitCode !== 0)
-                            break;
-                        start = end + 1;
-                    }
-                }
-                else
-                    outcome = await convert(initial, false);
-                return { kind: "conversion", exitCode: outcome.exitCode, jobs, outcome, usage: resources.usage };
-            }));
-            result = await resourceRun;
-        }
-    }
-    catch (error) {
-        if (context.signal.aborted) {
-            primary = true;
-            failure = context.signal.reason;
-        }
-        else if (signal.aborted) {
-            primary = true;
-            failure = signal.reason;
-        }
-        else if (error instanceof WkhtmltopdfError || error instanceof FsError) {
-            try {
-                const option = error instanceof WkhtmltopdfError ? error.option : undefined;
-                await writeBytes(stderr.output, encoder.encode(`wkhtmltopdf: ${error.code}${option ? ` (${option})` : ""}: ${error.message}\n`), signal);
-                result = { kind: "rejected", exitCode: 1, code: error.code };
-            }
-            catch (writeError) {
-                primary = true;
-                failure = writeError;
-            }
-        }
-        else {
-            primary = true;
-            failure = error;
-        }
-    }
-    finally {
-        try {
-            await cleanup();
-        }
-        catch (error) {
-            if (primary)
-                failure = new AggregateError([failure, error], "Invocation and cleanup failed");
-            else {
-                primary = true;
-                failure = error;
-            }
-        }
-    }
-    if (primary)
-        throw failure;
-    return result;
-}
-async function diagnostic(context, outcome, signal) {
-    const value = outcome.diagnostic;
-    if (!value)
-        return;
-    const message = value.kind === "http" ? `Exit with code ${outcome.exitCode} due to http error: ${value.code} ${value.description}` :
-        value.kind === "network" ? `Exit with code 1 due to network error: ${value.name ?? "UnqualifiedNetworkError"}` : "Exit with code 1, due to unknown error.";
-    await writeBytes(context.stderr, encoder.encode(message + "\n"), signal);
-}
-export function createWkhtmltopdfCommand(options = { limits: wkhtmltopdfLimits }) {
-    return Object.freeze({
-        name: "wkhtmltopdf", runtimeIdentity: commandRuntimeIdentity,
-        description: "Bounded static HTML-to-PDF adapter with an explicit first-party renderer",
-        execute: (context) => runWkhtmltopdf(context, options),
-    });
-}
-export const wkhtmltopdfCommand = createWkhtmltopdfCommand();
-export function wkhtmltopdfCommands(options = { limits: wkhtmltopdfLimits }) {
-    const command = createWkhtmltopdfCommand(options);
-    return { name: "wkhtmltopdf-commands", setup(host) { host.commands.register(command); } };
-}

package/dist/safe-bash-command-wkhtmltopdf/engine.js

@@ -1,99 +0,0 @@
-import { WkhtmltopdfError } from "./errors.js";
-const rendererFeatures = [
-    "html5", "computed-css", "selectors", "css-units", "block-inline", "font-shaping",
-    "lists", "images", "table-spans", "pagination", "break-rules", "widows-orphans",
-    "positioning", "page-furniture", "flex", "grid",
-];
-/** Admission only. Never substitutes another layout mode for an absent feature. */
-export function requireRendererFeatures(profile, required) {
-    if (typeof profile.id !== "string" || !profile.id || profile.id.length > 128 ||
-        profile.features.length > rendererFeatures.length || required.length > rendererFeatures.length) {
-        throw new WkhtmltopdfError("INVALID_VALUE", "Expected a bounded renderer profile and feature requirements");
-    }
-    for (const feature of [...profile.features, ...required]) {
-        if (!rendererFeatures.includes(feature)) {
-            throw new WkhtmltopdfError("INVALID_VALUE", "Unknown renderer feature");
-        }
-    }
-    for (const feature of required) {
-        if (!profile.features.includes(feature)) {
-            throw new WkhtmltopdfError("UNSUPPORTED_CAPABILITY", `Renderer profile ${profile.id} does not support ${feature}`);
-        }
-    }
-}
-/**
- * Pure final-layout accounting, not HTML layout or PDF emission. Admission completes
- * before retaining output records. No resources are acquired or cleanup hooks needed.
- */
-export function planPageSequence(objects, options) {
-    const checkCancellation = () => { if (options.signal?.aborted)
-        throw options.signal.reason; };
-    checkCancellation();
-    const { maxObjects, maxPhysicalPages, maxWork } = options.limits;
-    for (const value of [maxObjects, maxPhysicalPages, maxWork, options.copies]) {
-        if (!Number.isSafeInteger(value) || value < 1) {
-            throw new WkhtmltopdfError("INVALID_VALUE", "Page sequence limits and copies must be positive safe integers");
-        }
-    }
-    if (typeof options.collate !== "boolean" || !Number.isInteger(options.pageOffset) ||
-        options.pageOffset < -2147483648 || options.pageOffset > 2147483647) {
-        throw new WkhtmltopdfError("INVALID_VALUE", "Expected boolean collate and int32 page offset");
-    }
-    if (objects.length > maxObjects || objects.length > maxWork) {
-        throw new WkhtmltopdfError("LIMIT_EXCEEDED", "Page sequence object/work limit exceeded");
-    }
-    let outlineTotal = 0;
-    let logicalTotal = 0;
-    // Division prevents multiplication overflow during copies admission.
-    const sourcePageLimit = Math.floor(Math.min(maxPhysicalPages, maxWork - objects.length) / options.copies);
-    for (const object of objects) {
-        checkCancellation();
-        if (!Number.isSafeInteger(object.physicalPages) || object.physicalPages < 0 || typeof object.pagesCount !== "boolean") {
-            throw new WkhtmltopdfError("INVALID_VALUE", "Expected a nonnegative safe page count and boolean pagesCount");
-        }
-        if (object.physicalPages > sourcePageLimit - outlineTotal) {
-            throw new WkhtmltopdfError("LIMIT_EXCEEDED", "Page sequence physical-page/work limit exceeded");
-        }
-        outlineTotal += object.physicalPages;
-        if (object.pagesCount)
-            logicalTotal += object.physicalPages;
-    }
-    if (!Number.isSafeInteger(logicalTotal + Math.abs(options.pageOffset) + 1)) {
-        throw new WkhtmltopdfError("LIMIT_EXCEEDED", "Logical page number exceeds checked precision");
-    }
-    const passes = options.collate ? options.copies : 1;
-    if (outlineTotal > 0) {
-        const remainingWork = maxWork - objects.length - outlineTotal * options.copies;
-        if (objects.length > Math.floor(remainingWork / passes)) {
-            throw new WkhtmltopdfError("LIMIT_EXCEEDED", "Page sequence repeated traversal work limit exceeded");
-        }
-    }
-    const pages = [];
-    const emit = (objectIndex, pageIndex, copyIndex, logicalPage, outlinePage) => {
-        checkCancellation();
-        pages.push({ objectIndex, pageIndex, copyIndex, outputPage: pages.length + 1, logicalPage, outlinePage });
-    };
-    // Empty documents must not loop copies times without charging output work.
-    if (outlineTotal === 0)
-        return { pages, logicalTotal, outlineTotal };
-    for (let pass = 0; pass < passes; pass++) {
-        let logicalPage = 1 + options.pageOffset;
-        let outlinePage = 1;
-        for (let objectIndex = 0; objectIndex < objects.length; objectIndex++) {
-            checkCancellation();
-            const object = objects[objectIndex];
-            for (let pageIndex = 0; pageIndex < object.physicalPages; pageIndex++) {
-                if (options.collate)
-                    emit(objectIndex, pageIndex, pass, logicalPage, outlinePage);
-                else
-                    for (let copyIndex = 0; copyIndex < options.copies; copyIndex++) {
-                        emit(objectIndex, pageIndex, copyIndex, logicalPage, outlinePage);
-                    }
-                if (object.pagesCount)
-                    logicalPage++;
-                outlinePage++;
-            }
-        }
-    }
-    return { pages, logicalTotal, outlineTotal };
-}

package/dist/safe-bash-command-wkhtmltopdf/errors.js

@@ -1,11 +0,0 @@
-export class WkhtmltopdfError extends Error {
-    code;
-    option;
-    exitCode = 1;
-    constructor(code, message, option) {
-        super(message);
-        this.code = code;
-        this.option = option;
-        this.name = "WkhtmltopdfError";
-    }
-}

package/dist/safe-bash-command-wkhtmltopdf/limits.js

@@ -1,69 +0,0 @@
-import { WkhtmltopdfError } from "./errors.js";
-// Admission counts input UTF-8 bytes without allocating an encoded copy.
-// maxWork covers scans, option dispatch and cloned retained settings/entries.
-export class ParseBudget {
-    options;
-    work = 0;
-    bytes = 0;
-    objects = 0;
-    limits;
-    constructor(options) {
-        this.options = options;
-        this.checkCancellation();
-        this.limits = {
-            maxArguments: options.limits?.maxArguments,
-            maxTextBytes: options.limits?.maxTextBytes,
-            maxObjects: options.limits?.maxObjects,
-            maxWork: options.limits?.maxWork,
-        };
-        for (const value of Object.values(this.limits)) {
-            if (!Number.isSafeInteger(value) || value < 1) {
-                throw new WkhtmltopdfError("INVALID_VALUE", "Parser limits must be positive safe integers");
-            }
-        }
-    }
-    checkCancellation() {
-        if (this.options.signal?.aborted)
-            throw this.options.signal.reason;
-    }
-    step(amount = 1) {
-        this.checkCancellation();
-        if (amount > this.limits.maxWork - this.work) {
-            throw new WkhtmltopdfError("LIMIT_EXCEEDED", "Parser work limit exceeded");
-        }
-        this.work += amount;
-    }
-    admitArguments(count) {
-        this.step();
-        if (count > this.limits.maxArguments) {
-            throw new WkhtmltopdfError("LIMIT_EXCEEDED", "Parser argument limit exceeded");
-        }
-    }
-    admitText(text) {
-        for (let i = 0; i < text.length; i++) {
-            this.step();
-            const code = text.charCodeAt(i);
-            let size = code < 128 ? 1 : code < 2048 ? 2 : 3;
-            if (code >= 0xd800 && code <= 0xdbff) {
-                const next = text.charCodeAt(i + 1);
-                if (next >= 0xdc00 && next <= 0xdfff) {
-                    size = 4;
-                    i++;
-                    this.step();
-                }
-            }
-            if (size > this.limits.maxTextBytes - this.bytes) {
-                throw new WkhtmltopdfError("LIMIT_EXCEEDED", "Parser text byte limit exceeded");
-            }
-            this.bytes += size;
-            if (code === 0)
-                throw new WkhtmltopdfError("INVALID_VALUE", "NUL is not admitted in CLI text");
-        }
-    }
-    admitObject(replacementCount) {
-        this.step(64 + replacementCount * 2);
-        if (++this.objects > this.limits.maxObjects) {
-            throw new WkhtmltopdfError("LIMIT_EXCEEDED", "Parser object limit exceeded");
-        }
-    }
-}

package/dist/safe-bash-command-wkhtmltopdf/outcome.js

@@ -1,38 +0,0 @@
-import { WkhtmltopdfError } from "./errors.js";
-const httpDescriptions = {
-    400: "Bad Request", 401: "Unauthorized", 402: "Payment Required",
-    403: "Forbidden", 404: "Page not found", 405: "Method Not Allowed",
-    500: "Internal Server Error", 501: "Not Implemented",
-    503: "Service Unavailable", 505: "HTTP Version Not Supported",
-};
-/** Pure source-defined status mapping; no renderer or native profile qualification. */
-export function conversionOutcome(completion) {
-    const { mode, success, errorCode, networkErrorName } = completion;
-    if ((mode !== "single" && mode !== "batch") || typeof success !== "boolean" ||
-        !Number.isInteger(errorCode) || errorCode < 0 || errorCode > 2147483647) {
-        throw new WkhtmltopdfError("INVALID_VALUE", "Expected a conversion mode, boolean success and nonnegative int32 loader code");
-    }
-    if (networkErrorName !== undefined) {
-        if (typeof networkErrorName !== "string" || !networkErrorName.length || networkErrorName.length > 128) {
-            throw new WkhtmltopdfError("INVALID_VALUE", "Network enum name must contain 1–128 ASCII identifier characters");
-        }
-        for (const character of networkErrorName) {
-            if (!(character >= "a" && character <= "z") && !(character >= "A" && character <= "Z") &&
-                !(character >= "0" && character <= "9") && character !== "_") {
-                throw new WkhtmltopdfError("INVALID_VALUE", "Network enum name must contain ASCII identifier characters");
-            }
-        }
-    }
-    if (mode === "batch")
-        return { exitCode: success ? 0 : 1, diagnostic: null };
-    if (errorCode >= 1000) {
-        return { exitCode: 1, diagnostic: { kind: "network", code: errorCode - 1000, name: networkErrorName ?? null } };
-    }
-    if (errorCode !== 0) {
-        return {
-            exitCode: errorCode === 404 ? 2 : errorCode === 401 ? 3 : 1,
-            diagnostic: { kind: "http", code: errorCode, description: httpDescriptions[errorCode] ?? "" },
-        };
-    }
-    return { exitCode: success ? 0 : 1, diagnostic: success ? null : { kind: "unknown" } };
-}