@poe-platform/safe-bash 0.1.798 → 0.1.800

package/dist/safe-bash/commands/diff-patch/patch-formats.js

@@ -1,265 +1,2 @@
-import { byteLength } from "../../byte-encoding.js";
-import { Budget, ToolError, integer } from "./shared.js";
-import { parseUnified, parseUnifiedSection } from "./unified.js";
-import { decodeHeaderPath } from "./patch-path.js";
-class Reader {
-    budget;
-    lines;
-    index = 0;
-    constructor(text, budget) {
-        this.budget = budget;
-        this.lines = budget.split(text).map(line => line.slice(0, -1));
-    }
-    peek() { return this.lines[this.index]; }
-    async take() {
-        this.budget.step();
-        {
-            const c = this.budget.checkpoint();
-            if (c)
-                await c;
-        }
-        const line = this.lines[this.index++];
-        if (line === undefined)
-            throw new ToolError("truncated patch");
-        return line;
-    }
-    number(value) {
-        const result = integer(value, "patch range");
-        if (result > this.budget.limits.maxLines)
-            throw new ToolError("hunk coordinate exceeds line limit");
-        return result;
-    }
-    async content(prefix) {
-        const line = await this.take();
-        if (line !== prefix && !(prefix === " " && line === "")
-            && !line.startsWith(`${prefix} `) && !line.startsWith(`${prefix}\t`))
-            throw new ToolError("malformed patch body prefix");
-        let text = `${line.slice(2)}\n`;
-        if (this.peek() === "\") {
-            await this.take();
-            if (text === "\n")
-                throw new ToolError("empty incomplete line is not a valid text line");
-            text = text.slice(0, -1);
-        }
-        return text;
-    }
-}
-function encoded(line) {
-    return `${line.kind}${line.text}${line.text.endsWith("\n") ? "" : "\n\\n"}`;
-}
-async function normal(reader, target) {
-    const quoted = JSON.stringify(target ?? "/dev/null");
-    const output = [`--- ${quoted}\n+++ ${quoted}\n`];
-    while (reader.peek() !== undefined) {
-        if (reader.peek() === "") {
-            await reader.take();
-            continue;
-        }
-        if (!/^\d/u.test(reader.peek()))
-            break;
-        const command = /^(\d+)(?:,(\d+))?([acd])(\d+)(?:,(\d+))?$/u.exec(await reader.take());
-        if (!command)
-            throw new ToolError("malformed normal patch command");
-        const oldStart = reader.number(command[1]);
-        const oldLast = reader.number(command[2] ?? command[1]);
-        const newStart = reader.number(command[4]);
-        const newLast = reader.number(command[5] ?? command[4]);
-        const operation = command[3];
-        if (oldLast < oldStart || newLast < newStart || (operation === "a" && command[2] !== undefined)
-            || (operation === "d" && command[5] !== undefined))
-            throw new ToolError("invalid normal patch range");
-        const oldCount = operation === "a" ? 0 : oldLast - oldStart + 1;
-        const newCount = operation === "d" ? 0 : newLast - newStart + 1;
-        output.push(`@@ -${oldStart},${oldCount} +${newStart},${newCount} @@\n`);
-        for (let index = 0; index < oldCount; index++)
-            output.push(encoded({ kind: "-", text: await reader.content("<") }));
-        if (operation === "c" && await reader.take() !== "---")
-            throw new ToolError("missing normal change separator");
-        for (let index = 0; index < newCount; index++)
-            output.push(encoded({ kind: "+", text: await reader.content(">") }));
-    }
-    return output.join("");
-}
-async function contextRange(reader, old) {
-    const line = await reader.take();
-    const match = (old ? /^\*\*\* (\d+)(?:,(\d+))? \*\*\*\*$/u : /^--- (\d+)(?:,(\d+))? ----$/u).exec(line);
-    if (!match)
-        throw new ToolError("malformed context range");
-    const start = reader.number(match[1]);
-    const last = reader.number(match[2] ?? match[1]);
-    if (last < start || (match[2] !== undefined && start === 0))
-        throw new ToolError("invalid context range");
-    return { start, last, multiple: match[2] !== undefined };
-}
-async function contextSide(reader, old, range) {
-    const lines = [];
-    const count = range.start === 0 ? 0 : range.last - range.start + 1;
-    while (reader.peek() !== undefined && lines.length < count) {
-        const kind = reader.peek() === "" ? " " : reader.peek()[0];
-        if (kind !== " " && kind !== "!" && kind !== (old ? "-" : "+"))
-            break;
-        if (old && /^--- \d+(?:,\d+)? ----$/u.test(reader.peek()))
-            break;
-        lines.push({ kind, text: await reader.content(kind) });
-        if (lines.length > reader.budget.limits.maxLines)
-            throw new ToolError("context body line limit exceeded");
-    }
-    if (!old && lines.length === count && lines.at(-1)?.text.endsWith("\n") === false) {
-        // GNU accepts surplus markers after the complete new side, preserving its EOF.
-        while (reader.peek() === "\")
-            await reader.take();
-    }
-    return lines;
-}
-function contextCount(range, lines) {
-    if (!lines.length) {
-        if (range.multiple)
-            throw new ToolError("empty context side has a nonempty range");
-        return 0;
-    }
-    if (range.start === 0 || lines.length !== range.last - range.start + 1)
-        throw new ToolError("context body count does not match range");
-    return lines.length;
-}
-async function context(reader) {
-    const output = [];
-    while (reader.peek() !== undefined) {
-        const header = await reader.take();
-        if (header === "")
-            continue;
-        if (/^diff -[^ ]+ /u.test(header)) {
-            output.push(`${header}\n`);
-            continue;
-        }
-        if (!header.startsWith("*** "))
-            throw new ToolError("expected context file header");
-        const next = await reader.take();
-        if (!next.startsWith("--- "))
-            throw new ToolError("expected new context file header");
-        output.push(`--- ${header.slice(4)}\n+++ ${next.slice(4)}\n`);
-        let hunks = 0;
-        while (reader.peek()?.startsWith("***************")) {
-            const delimiter = await reader.take();
-            if (!/^\*{15}(?: .*)?$/u.test(delimiter))
-                throw new ToolError("malformed context hunk separator");
-            if (++hunks > reader.budget.limits.maxHunks)
-                throw new ToolError("hunk limit exceeded");
-            const oldRange = await contextRange(reader, true);
-            let oldLines = await contextSide(reader, true, oldRange);
-            const newRange = await contextRange(reader, false);
-            let newLines = await contextSide(reader, false, newRange);
-            if (!oldLines.length) {
-                if (newLines.some(line => line.kind === "!"))
-                    throw new ToolError("missing old changed context body");
-                oldLines = newLines.filter(line => line.kind === " ");
-            }
-            if (!newLines.length) {
-                if (oldLines.some(line => line.kind === "!"))
-                    throw new ToolError("missing new changed context body");
-                newLines = oldLines.filter(line => line.kind === " ");
-            }
-            const oldCount = contextCount(oldRange, oldLines);
-            const newCount = contextCount(newRange, newLines);
-            output.push(`@@ -${oldRange.start},${oldCount} +${newRange.start},${newCount} @@${delimiter.slice(15)}\n`);
-            let oldIndex = 0;
-            let newIndex = 0;
-            while (oldIndex < oldLines.length || newIndex < newLines.length) {
-                let oldChanged = false;
-                let newChanged = false;
-                while (oldIndex < oldLines.length && oldLines[oldIndex].kind !== " ") {
-                    const line = oldLines[oldIndex++];
-                    oldChanged ||= line.kind === "!";
-                    output.push(encoded({ kind: "-", text: line.text }));
-                    reader.budget.step();
-                    {
-                        const c = reader.budget.checkpoint();
-                        if (c)
-                            await c;
-                    }
-                }
-                while (newIndex < newLines.length && newLines[newIndex].kind !== " ") {
-                    const line = newLines[newIndex++];
-                    newChanged ||= line.kind === "!";
-                    output.push(encoded({ kind: "+", text: line.text }));
-                    reader.budget.step();
-                    {
-                        const c = reader.budget.checkpoint();
-                        if (c)
-                            await c;
-                    }
-                }
-                if (oldChanged !== newChanged)
-                    throw new ToolError("unpaired changed context group");
-                if (oldIndex < oldLines.length || newIndex < newLines.length) {
-                    const oldLine = oldLines[oldIndex++];
-                    const newLine = newLines[newIndex++];
-                    if (!oldLine || !newLine || !reader.budget.equal(oldLine.text, newLine.text))
-                        throw new ToolError("context halves disagree");
-                    output.push(encoded({ kind: " ", text: oldLine.text }));
-                }
-            }
-        }
-        if (!hunks)
-            throw new ToolError("context file patch has no hunks");
-        break;
-    }
-    return output.join("");
-}
-export async function parsePatch(text, budget, format, target, progress) {
-    if (text && !text.endsWith("\n"))
-        throw new ToolError("patch is truncated: missing final LF");
-    const reader = new Reader(text, budget);
-    const patches = [];
-    let convertedBytes = 0;
-    while (reader.peek() !== undefined) {
-        try {
-            if (reader.peek() === "") {
-                await reader.take();
-                continue;
-            }
-            if (!progress && patches.length && reader.peek().startsWith("-") && !reader.peek().startsWith("---")) {
-                throw new ToolError("unexpected deletion outside a patch hunk");
-            }
-            if (patches.length && !/^(?:Index: |diff |index |---|\*\*\*|@@|[+\\<>]|\d)/u.test(reader.peek())) {
-                await reader.take();
-                continue;
-            }
-            let indexPath;
-            if (reader.peek()?.startsWith("Index: ")) {
-                indexPath = decodeHeaderPath((await reader.take()).slice(7));
-                if (/^=+$/u.test(reader.peek() ?? ""))
-                    await reader.take();
-            }
-            const start = reader.index;
-            while (/^diff /u.test(reader.peek() ?? ""))
-                await reader.take();
-            const first = reader.peek() ?? "";
-            const detected = first.startsWith("*** ") ? "context" : /^\d/u.test(first) ? "normal" : "unified";
-            if (format && detected !== format)
-                throw new ToolError(`patch format is ${detected}, not requested ${format}`);
-            if (detected === "unified") {
-                reader.index = start;
-                patches.push(...(await parseUnifiedSection(reader, budget)).map(patch => ({ ...patch, ...(indexPath === undefined ? {} : { indexPath }) })));
-            }
-            else {
-                if (detected === "context")
-                    reader.index = start;
-                const converted = detected === "normal" ? await normal(reader, target ?? indexPath) : await context(reader);
-                convertedBytes += byteLength(converted);
-                if (convertedBytes > budget.limits.maxInputBytes * 2 + 16_384)
-                    throw new ToolError("converted patch byte limit exceeded");
-                patches.push(...(await parseUnified(converted, budget)).map(patch => ({ ...patch, format: detected,
-                    ...(indexPath === undefined ? {} : { indexPath }),
-                    ...(detected === "normal" && target === undefined && indexPath === undefined ? { unlocated: true } : {}) })));
-            }
-        }
-        catch (error) {
-            if (!progress || !(error instanceof ToolError) || /limit|budget|filename|path|escape/u.test(error.message))
-                throw error;
-            progress.error = error;
-            break;
-        }
-    }
-    return patches;
-}
+export * from "../../../safe-bash-command-patch/patch-formats.js";
 //# sourceMappingURL=patch-formats.js.map

package/dist/safe-bash/commands/diff-patch/patch-gnu-paths.d.ts

@@ -1,42 +1,2 @@
-import { type FileStat } from "../../contracts/index.js";
-import { Budget } from "./shared.js";
-import type { FilePatch } from "./unified.js";
-export interface PathOptions {
-    readonly posix?: boolean | undefined;
-    readonly strip: number | undefined;
-    readonly explicit: string | undefined;
-    readonly reject: string | undefined;
-    readonly input: string | undefined;
-}
-export interface AuthorizedPatch {
-    readonly patch: FilePatch;
-    readonly oldName: string | undefined;
-    readonly newName: string | undefined;
-    readonly indexName: string | undefined;
-    readonly candidates: readonly string[];
-    readonly selected?: string;
-    readonly posix?: boolean;
-}
-interface SelectionState {
-    readonly reverse: boolean;
-    readonly exists: (path: string) => Promise<boolean>;
-    readonly advance: (patch: AuthorizedPatch) => Promise<void>;
-}
-export declare function regular(stat: FileStat | undefined, path: string): void;
-export declare function rejectName(target: string, options: PathOptions): string | undefined;
-export declare function pruneParents(target: string, cwd: string): string[];
-export declare function authorizePaths(patches: readonly FilePatch[], options: PathOptions, budget: Budget, state?: SelectionState): Promise<AuthorizedPatch[]>;
-export interface BackupOptions {
-    suffix?: string;
-    prefix?: string;
-    basenamePrefix?: string;
-    versionControl?: "existing" | "simple" | "numbered";
-}
-export declare function backupName(path: string, budget: Budget, options?: BackupOptions): Promise<string>;
-export declare function authorizeOutputs(paths: readonly (string | undefined)[], targets: ReadonlySet<string>, input: string | undefined, budget: Budget): Promise<void>;
-export declare function candidateStat(path: string, budget: Budget): Promise<FileStat | undefined>;
-export declare function selectTarget(authorized: AuthorizedPatch, exists: (path: string) => Promise<boolean>, budget: Budget): Promise<string>;
-export declare function ensureParents(path: string, budget: Budget): Promise<void>;
-export declare function pruneDirectories(parents: ReadonlySet<string>, budget: Budget): Promise<void>;
-export {};
+export * from "../../../safe-bash-command-patch/patch-gnu-paths.js";
 //# sourceMappingURL=patch-gnu-paths.d.ts.map

package/dist/safe-bash/commands/diff-patch/patch-gnu-paths.js

@@ -1,264 +1,2 @@
-import { byteLength } from "../../byte-encoding.js";
-import { publicDiagnosticMessage } from "../../diagnostics.js";
-import { FsError, basename, dirname, isFsError, resolvePath } from "../../contracts/index.js";
-import { safeTarget } from "./patch-path.js";
-import { Budget, ToolError, host, inspect } from "./shared.js";
-export function regular(stat, path) {
-    if (stat && stat.type !== "file")
-        throw new ToolError(`patch target is not a regular file: ${path}`);
-    if (stat && (stat.nlink ?? 1) > 1)
-        throw new ToolError(`hard-linked patch targets are unsupported: ${path}`);
-}
-function headerName(path, options) {
-    const safe = safeTarget(path, 0, options.explicit !== undefined);
-    if (safe === undefined)
-        return undefined;
-    if (options.explicit !== undefined)
-        return safe;
-    if (options.strip === undefined)
-        return safe.split("/").at(-1);
-    if (path.split(/\/+/u).filter(Boolean).length <= options.strip)
-        return undefined;
-    return safeTarget(path, options.strip);
-}
-export function rejectName(target, options) {
-    return options.reject === "-" ? undefined : options.reject ?? `${target}.rej`;
-}
-export function pruneParents(target, cwd) {
-    const stop = target.startsWith("/") ? "/" : resolvePath(cwd, ".");
-    const parents = [];
-    for (let path = dirname(resolvePath(cwd, target)); path !== stop && path !== "/"; path = dirname(path))
-        parents.push(path);
-    return parents;
-}
-export async function authorizePaths(patches, options, budget, state) {
-    const result = [];
-    for (const patch of patches) {
-        budget.step();
-        {
-            const c = budget.checkpoint();
-            if (c)
-                await c;
-        }
-        if (patch.unlocated) {
-            result.push({ patch, oldName: undefined, newName: undefined, indexName: undefined, candidates: [] });
-            continue;
-        }
-        if (patch.oldPath === "/dev/null" && patch.newPath === "/dev/null")
-            throw new ToolError("both patch filenames are /dev/null");
-        const oldName = headerName(patch.oldPath, options);
-        const newName = headerName(patch.newPath, options);
-        const indexHeader = patch.indexPath === undefined ? undefined : headerName(patch.indexPath, options);
-        const indexName = options.posix || patch.format === "normal" || (oldName === undefined && newName === undefined) ? indexHeader : undefined;
-        const candidates = options.explicit === undefined ? [...new Set([oldName, newName, indexName].filter((name) => name !== undefined))] : [options.explicit];
-        if (!candidates.length)
-            throw new ToolError("strip count removes every patch filename");
-        result.push({ patch, oldName, newName, indexName, candidates, ...(options.posix ? { posix: true } : {}) });
-    }
-    const order = result.map((_patch, index) => index);
-    if (state?.reverse)
-        order.reverse();
-    budget.step(order.length);
-    const lastChoice = order.findLastIndex(index => result[index].candidates.length > 1);
-    for (const [position, index] of order.entries()) {
-        const authorized = result[index];
-        if (authorized.patch.unlocated)
-            continue;
-        const selected = await selectTarget(authorized, state?.exists ?? (async (path) => await candidateStat(path, budget) !== undefined), budget);
-        const path = resolvePath(budget.context.cwd, selected);
-        if (path === options.input)
-            throw new ToolError(`patch target aliases patch input: ${path}`);
-        regular(await inspect(budget, path), path);
-        result[index] = { ...authorized, selected };
-        if (position < lastChoice)
-            await state?.advance(result[index]);
-    }
-    return result;
-}
-export async function backupName(path, budget, options = {}) {
-    const simple = safeTarget(`${path}${options.suffix ?? ".orig"}`, 0, true);
-    if (simple === undefined)
-        throw new ToolError("invalid backup path");
-    if (options.prefix !== undefined || options.basenamePrefix !== undefined) {
-        // GNU prefixes are applied to the operand, before resolving against cwd.
-        const relative = path.startsWith(`${budget.context.cwd}/`) ? path.slice(budget.context.cwd.length + 1) : path;
-        const prefixed = options.prefix !== undefined ? `${options.prefix}${relative}` : `${dirname(path)}/${options.basenamePrefix ?? ""}${basename(path)}`;
-        const safe = safeTarget(`${prefixed}${options.suffix ?? ".orig"}`, 0, true);
-        if (safe === undefined)
-            throw new ToolError("invalid backup path");
-        return resolvePath(budget.context.cwd, safe);
-    }
-    if (options.versionControl === "simple")
-        return simple;
-    const parent = dirname(path);
-    if (!await inspect(budget, parent))
-        return options.versionControl === "numbered" ? `${path}.~1~` : simple;
-    const prefix = `${basename(path)}.~`;
-    const entries = await host(budget.context, () => budget.context.fs.readdir(parent, { signal: budget.context.signal }));
-    let maximum = "0";
-    for (const entry of entries) {
-        budget.file();
-        {
-            const c = budget.checkpoint();
-            if (c)
-                await c;
-        }
-        if (!entry.name || /[/\0]/u.test(entry.name) || entry.name === "." || entry.name === "..")
-            throw new ToolError("unsafe directory entry in backup directory");
-        if (!entry.name.startsWith(prefix) || !entry.name.endsWith("~"))
-            continue;
-        const version = entry.name.slice(prefix.length, -1);
-        budget.step(version.length);
-        {
-            const c = budget.checkpoint();
-            if (c)
-                await c;
-        }
-        if (!/^[1-9]\d*$/u.test(version))
-            continue;
-        if (version.length > maximum.length || version.length === maximum.length && version > maximum)
-            maximum = version;
-    }
-    if (maximum === "0" && options.versionControl !== "numbered")
-        return simple;
-    // Decimal increment avoids converting arbitrarily long versions to BigInt.
-    let position = maximum.length - 1;
-    while (position >= 0 && maximum[position] === "9")
-        position--;
-    const next = position < 0 ? `1${"0".repeat(maximum.length)}`
-        : `${maximum.slice(0, position)}${Number(maximum[position]) + 1}${"0".repeat(maximum.length - position - 1)}`;
-    return `${path}.~${next}~`;
-}
-export async function authorizeOutputs(paths, targets, input, budget) {
-    const outputs = new Set();
-    for (const path of paths) {
-        if (path === undefined)
-            continue;
-        budget.step();
-        if (targets.has(path) || outputs.has(path) || path === input)
-            throw new ToolError(`patch output aliases a target, input, or another output: ${path}`);
-        outputs.add(path);
-        regular(await inspect(budget, path), path);
-    }
-}
-function rank(name) {
-    return [name.split("/").length, byteLength(name.split("/").at(-1)), byteLength(name)];
-}
-export async function candidateStat(path, budget) {
-    budget.step();
-    {
-        const c = budget.checkpoint();
-        if (c)
-            await c;
-    }
-    try {
-        return await host(budget.context, () => budget.context.fs.stat(path, { signal: budget.context.signal }));
-    }
-    catch (error) {
-        if (isFsError(error, "ENOENT") || isFsError(error, "ENOTDIR") || isFsError(error, "ELOOP"))
-            return undefined;
-        throw error;
-    }
-}
-export async function selectTarget(authorized, exists, budget) {
-    const present = [];
-    for (const candidate of authorized.candidates) {
-        budget.step();
-        if (await exists(resolvePath(budget.context.cwd, candidate)))
-            present.push(candidate);
-    }
-    if (authorized.posix)
-        return present[0] ?? authorized.candidates[0];
-    const candidates = present.length ? present : [...authorized.candidates];
-    const missingParents = new Map();
-    if (!present.length)
-        for (const candidate of candidates) {
-            let missing = 0;
-            for (let parent = dirname(resolvePath(budget.context.cwd, candidate)); parent !== "/"; parent = dirname(parent)) {
-                if (await exists(parent))
-                    break;
-                missing++;
-            }
-            missingParents.set(candidate, missing);
-        }
-    candidates.sort((left, right) => {
-        const missing = (missingParents.get(left) ?? 0) - (missingParents.get(right) ?? 0);
-        if (missing)
-            return missing;
-        const leftRank = rank(left);
-        const rightRank = rank(right);
-        for (let index = 0; index < leftRank.length; index++) {
-            const order = leftRank[index] - rightRank[index];
-            if (order)
-                return order;
-        }
-        return 0;
-    });
-    return candidates[0];
-}
-export async function ensureParents(path, budget) {
-    const missing = [];
-    for (let parent = dirname(path);; parent = dirname(parent)) {
-        const stat = await inspect(budget, parent);
-        if (stat) {
-            if (stat.type !== "directory")
-                throw new ToolError(`not a directory: ${parent}`);
-            break;
-        }
-        if (parent === "/")
-            throw new ToolError("filesystem root does not exist");
-        missing.push(parent);
-    }
-    for (const parent of missing.reverse()) {
-        budget.step();
-        {
-            const c = budget.checkpoint();
-            if (c)
-                await c;
-        }
-        await inspect(budget, parent);
-        await host(budget.context, () => budget.context.fs.mkdir(parent, { signal: budget.context.signal }));
-    }
-}
-export async function pruneDirectories(parents, budget) {
-    for (const parent of [...parents].sort((left, right) => right.split("/").length - left.split("/").length)) {
-        budget.step();
-        {
-            const c = budget.checkpoint();
-            if (c)
-                await c;
-        }
-        const stat = await inspect(budget, parent);
-        budget.context.signal.throwIfAborted();
-        if (!stat)
-            continue;
-        if (stat.type !== "directory")
-            throw new ToolError(`pruning path changed type: ${parent}`);
-        try {
-            const entries = await host(budget.context, () => budget.context.fs.readdir(parent, { signal: budget.context.signal }));
-            budget.step(entries.length);
-            if (entries.length)
-                continue;
-            const rmdir = budget.context.fs.rmdir;
-            if (!rmdir)
-                throw new FsError("ENOTSUP", { syscall: "rmdir", path: parent });
-            try {
-                await host(budget.context, () => rmdir.call(budget.context.fs, parent, { signal: budget.context.signal }));
-            }
-            catch (error) {
-                budget.context.signal.throwIfAborted();
-                if (!isFsError(error, "ENOTEMPTY"))
-                    throw error;
-            }
-        }
-        catch (error) {
-            budget.context.signal.throwIfAborted();
-            if (isFsError(error, "ENOENT"))
-                continue;
-            if (isFsError(error) || error instanceof ToolError)
-                throw error;
-            throw new ToolError(`cannot prune directory ${parent}: ${publicDiagnosticMessage(error, budget.context.onInternalError)}`);
-        }
-    }
-}
+export * from "../../../safe-bash-command-patch/patch-gnu-paths.js";
 //# sourceMappingURL=patch-gnu-paths.js.map

package/dist/safe-bash/commands/diff-patch/patch-gnu-reject.d.ts

@@ -1,4 +1,2 @@
-import type { Budget } from "./shared.js";
-import type { FilePatch, HunkOutcome } from "./unified.js";
-export declare function rejectText(patch: FilePatch, outcomes: readonly HunkOutcome[], oldName: string | undefined, newName: string | undefined, indexName: string | undefined, reverse: boolean, budget: Budget, format?: "unified" | "context"): Promise<string>;
+export * from "../../../safe-bash-command-patch/patch-gnu-reject.js";
 //# sourceMappingURL=patch-gnu-reject.d.ts.map