@sema-agent/core 7.45.0 → 7.46.0

package/dist/tools/fs/shell-read-bindings.js

@@ -0,0 +1,746 @@
+import { argvOf, lexShell, literalTildeSpelling, substitutionsInHeredocBody } from "../../shell/lex.js";
+import { readProgramPosition } from "./bash-program-position.js";
+import { declaredAttributes, programRow, readArgRoles } from "./program-read-model.js";
+import { codeBodies } from "./shell-reentry-text.js";
+export const SHELL_INTEGER_VARIABLES = new Set([
+    "RANDOM", "SECONDS", "LINENO", "OPTIND", "MAILCHECK", "HISTCMD", "SRANDOM", "EPOCHSECONDS", "EPOCHREALTIME", "BASHPID", "BASH_MONOSECONDS",
+    "BASH_TRAPSIG", "COLUMNS", "LINES", "SHLVL", "ERRNO", "TMOUT", "HISTSIZE", "SAVEHIST", "TRY_BLOCK_ERROR", "TRY_BLOCK_INTERRUPT", "KEYTIMEOUT",
+    "LISTMAX", "LOGCHECK", "PERIOD", "FUNCNEST", "UID", "EUID", "GID", "EGID", "REPORTTIME", "REPORTMEMORY", "DIRSTACKSIZE", "BAUD",
+    "ZLE_RPROMPT_INDENT", "MBEGIN", "MEND", "PPID", "ARGC", "ZSH_SUBSHELL", "TTYIDLE", "status",
+]);
+const SHELL_SET_VARIABLES = new Set(["PWD", "OLDPWD", "REPLY", "OPTARG", "MAPFILE", "BASH_REMATCH", "PIPESTATUS", "FUNCNAME", "BASH_COMMAND", "BASH_SUBSHELL", "COPROC", "GROUPS", "SHELLOPTS", "BASHOPTS", "BASH_VERSINFO"]);
+export function shellKeepsName(name) {
+    return SHELL_INTEGER_VARIABLES.has(name) || SHELL_SET_VARIABLES.has(name);
+}
+const OPENING_WORDS = new Set(["if", "case", "for", "while", "until", "select", "{"]);
+const CLOSING_WORDS = new Set(["fi", "esac", "done", "}"]);
+const SWITCHING_WORDS = new Set(["else", "elif"]);
+const SPECIAL_BUILTINS = new Set([":", ".", "break", "continue", "eval", "exec", "exit", "export", "readonly", "return", "set", "shift", "source", "times", "trap", "unset"]);
+const IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const ATTRIBUTE_KINDS = { integer: "integer", transformed: "transformed", frozen: "frozen" };
+const EVERY_ATTRIBUTE = Object.values(ATTRIBUTE_KINDS).map((kind) => ({ kind }));
+export function projectSegment(segment) {
+    const tokens = [...segment.tokens];
+    let grouped = tokens.some((t) => t.kind === "group");
+    const definesFunction = dropDefinitionHeads(tokens).some((n) => n > 0);
+    dropCasePattern(tokens);
+    const words = tokens.filter((t) => {
+        if (t.kind !== "word")
+            return false;
+        if (t.raw === t.folded && (t.folded === "{" || t.folded === "}")) {
+            grouped = true;
+            return false;
+        }
+        return true;
+    });
+    return { argv: words, redirects: tokens.filter((t) => t.kind === "redirect"), grouped, definesFunction };
+}
+function isDefinitionName(word) {
+    return IDENTIFIER.test(word.folded) || (word.atCommandPosition && word.expansions.length === 0 && !/[?*+@!]$/.test(word.raw));
+}
+export function dropDefinitionHeads(tokens) {
+    const heads = new Array(tokens.length + 1).fill(0);
+    const drop = (k, count) => {
+        tokens.splice(k, count);
+        heads.splice(k, count);
+        heads[k]++;
+    };
+    for (let k = 0; k + 1 < tokens.length; k++) {
+        const [a, b, c, d] = [tokens[k], tokens[k + 1], tokens[k + 2], tokens[k + 3]];
+        if (a.kind === "word" && a.raw === "function" && a.atCommandPosition && b.kind === "word") {
+            drop(k--, c?.kind === "group" && c.op === "(" && d?.kind === "group" && d.op === ")" ? 4 : 2);
+        }
+    }
+    for (let k = 0; k + 2 < tokens.length; k++) {
+        const [a, b, c] = [tokens[k], tokens[k + 1], tokens[k + 2]];
+        if (a.kind === "word" && b.kind === "group" && b.op === "(" && c.kind === "group" && c.op === ")" && isDefinitionName(a))
+            drop(k, 3);
+    }
+    return heads;
+}
+function dropCasePattern(tokens) {
+    const end = casePatternEnd(tokens);
+    if (end >= 0)
+        tokens.splice(0, end + 1);
+}
+function casePatternEnd(tokens) {
+    const open = [];
+    let end = -1;
+    for (let k = 0; k < tokens.length; k++) {
+        const t = tokens[k];
+        if (t.kind === "word" && t.raw === "[[")
+            return -1;
+        if (t.kind !== "group")
+            continue;
+        if (t.op === "(") {
+            open.push(k);
+            continue;
+        }
+        const from = open.pop();
+        if (from !== undefined && extglobParen(tokens, from))
+            continue;
+        if (tokens[k + 1]?.kind === "word")
+            end = k;
+    }
+    return end;
+}
+function extglobParen(tokens, at) {
+    const before = tokens[at - 1];
+    return before?.kind === "word" && /[?*+@!]$/.test(before.raw);
+}
+function blockStructure(segments) {
+    let depth = 0;
+    let bodies = 0;
+    const frames = [];
+    const deeper = () => {
+        depth++;
+        for (const f of frames)
+            if (!f.opened && depth > f.body.base)
+                f.opened = true;
+    };
+    const shallower = () => {
+        depth--;
+        while (frames.length > 0 && frames[frames.length - 1].opened && depth <= frames[frames.length - 1].body.base)
+            frames.pop();
+    };
+    return segments.map((segment) => {
+        const tokens = [...segment.tokens];
+        const heads = dropDefinitionHeads(tokens);
+        const startBodies = (k) => {
+            for (let n = heads[k]; n > 0; n--)
+                frames.push({ body: { id: bodies++, base: depth }, opened: false });
+        };
+        const arithmetic = isArithmeticCommand(segment);
+        const patternEnd = casePatternEnd(tokens);
+        const skipped = new Set();
+        const open = [];
+        let lowest = depth;
+        let words;
+        let body;
+        const switches = [];
+        const innermost = () => [...frames].reverse().find((f) => f.opened)?.body;
+        const visit = (t, k) => {
+            if (t.kind === "group") {
+                if (arithmetic || skipped.has(k))
+                    return;
+                if (t.op === "(") {
+                    if (extglobParen(tokens, k)) {
+                        skipped.add(k);
+                        open.push(-1);
+                        return;
+                    }
+                    open.push(k);
+                    if (k <= patternEnd)
+                        return;
+                    deeper();
+                    return;
+                }
+                const from = open.pop();
+                if (from === -1)
+                    return;
+                if (k <= patternEnd) {
+                    if (k === patternEnd)
+                        switches.push(depth);
+                    return;
+                }
+                shallower();
+                lowest = Math.min(lowest, depth);
+                return;
+            }
+            if (t.kind !== "word")
+                return;
+            const keyword = t.atCommandPosition && t.raw === t.folded ? t.folded : undefined;
+            if (keyword !== undefined && OPENING_WORDS.has(keyword))
+                deeper();
+            else if (keyword !== undefined && CLOSING_WORDS.has(keyword)) {
+                shallower();
+                lowest = Math.min(lowest, depth);
+            }
+            else if (keyword !== undefined && SWITCHING_WORDS.has(keyword))
+                switches.push(depth);
+            else if (k > patternEnd) {
+                words ??= depth;
+                body = innermost();
+            }
+        };
+        tokens.forEach((t, k) => {
+            startBodies(k);
+            visit(t, k);
+            let settled = false;
+            for (let i = frames.length - 1; i >= 0 && !frames[i].opened; i--) {
+                const f = frames[i];
+                f.opened = true;
+                settled = true;
+                if (t.kind === "word" && t.raw === "[[" && t.atCommandPosition)
+                    f.conditional = true;
+                else if (t.kind === "group" && t.op === "(" && arithmetic)
+                    f.parens = 0;
+                else
+                    f.flat = true;
+            }
+            if (settled && t.kind === "word")
+                body = innermost();
+            const top = frames[frames.length - 1];
+            if (top?.parens !== undefined && t.kind === "group") {
+                top.parens += t.op === "(" ? 1 : -1;
+                if (top.parens <= 0)
+                    frames.pop();
+            }
+            if (t.kind === "word" && t.raw === "]]")
+                while (frames.length > 0 && frames[frames.length - 1].conditional === true)
+                    frames.pop();
+        });
+        while (frames.length > 0 && frames[frames.length - 1].flat === true)
+            frames.pop();
+        startBodies(tokens.length);
+        return { words: words ?? depth, after: depth, lowest, switches, ...(body !== undefined ? { body } : {}) };
+    });
+}
+const ONE_WORD = /^[A-Za-z0-9_./+@:%=,-]+$/;
+const WORD_VALUES_MAX = 64;
+export function wordValues(word, table, quoted, overlay = new Map()) {
+    const pieces = word.pieces;
+    if (!pieces.some((p) => p.expansion?.kind === "parameter" || p.expansion?.kind === "tilde"))
+        return undefined;
+    if (table === undefined)
+        return "unknown";
+    const start = pieces[0]?.span[0] ?? 0;
+    const raw = word.raw;
+    let combos = [{ text: "", glob: false }];
+    const stateOf = (name) => overlay.get(name) ?? table.stateOf(name);
+    for (const p of pieces) {
+        const e = p.expansion;
+        let options;
+        if (e === undefined) {
+            if (p.literal === undefined)
+                return "unknown";
+            options = [{ spelled: p.literal }];
+        }
+        else if (e.kind === "glob") {
+            const written = raw === undefined ? undefined : raw.slice(p.span[0] - start, p.span[1] - start);
+            if (written === undefined)
+                return "unknown";
+            options = [{ spelled: written, glob: true }];
+        }
+        else if (e.kind === "tilde") {
+            if (e.body !== "~")
+                return "unknown";
+            const home = stateOf("HOME");
+            if (home === "unknown")
+                return "unknown";
+            options = home;
+        }
+        else if (e.kind === "parameter" && e.name !== undefined && (e.body === undefined || e.body === e.name)) {
+            const state = stateOf(e.name);
+            if (state === "unknown")
+                return "unknown";
+            if (p.quotedBy === undefined && !quoted && (table.ifsTouched || state.some((v) => v.glob === true || !ONE_WORD.test(v.spelled))))
+                return "unknown";
+            options = state;
+        }
+        else
+            return "unknown";
+        const next = [];
+        for (const c of combos)
+            for (const o of options)
+                next.push({ text: c.text + o.spelled, glob: c.glob || o.glob === true });
+        if (next.length > WORD_VALUES_MAX)
+            return "unknown";
+        combos = next;
+    }
+    const out = [];
+    for (const c of combos)
+        if (!out.some((v) => v.spelled === c.text && (v.glob === true) === c.glob))
+            out.push(c.glob ? { spelled: c.text, glob: true } : { spelled: c.text });
+    return out;
+}
+export function wordFloorValues(word, table) {
+    if (table === undefined)
+        return [];
+    let combos = [{ spelled: "" }];
+    for (const p of word.pieces) {
+        const e = p.expansion;
+        let options;
+        if (e === undefined) {
+            if (p.literal === undefined)
+                return [];
+            options = [{ spelled: p.literal }];
+        }
+        else if (e.kind === "parameter" && e.name !== undefined) {
+            const state = table.stateOf(e.name);
+            options = state !== "unknown" && (e.body === undefined || e.body === e.name) ? state : table.floorOf(e.name);
+        }
+        else
+            return [];
+        if (options.length === 0)
+            return [];
+        const next = [];
+        for (const c of combos)
+            for (const o of options)
+                next.push(c.glob === true || o.glob === true ? { spelled: c.spelled + o.spelled, glob: true } : { spelled: c.spelled + o.spelled });
+        if (next.length > WORD_VALUES_MAX)
+            return [];
+        combos = next;
+    }
+    return combos;
+}
+export function valueOf(word, table, quoted, overlay = new Map()) {
+    const values = wordValues(word, table, quoted, overlay);
+    if (values !== undefined)
+        return values;
+    if (word.pieces.every((p) => p.expansion === undefined && p.literal !== undefined))
+        return [{ spelled: word.pieces.map((p) => p.literal).join("") }];
+    const folded = word.folded;
+    if (folded !== undefined && word.pieces.every((p) => p.expansion === undefined ? p.literal !== undefined : p.expansion.kind === "glob"))
+        return [{ spelled: folded, glob: true }];
+    return "unknown";
+}
+export function bindingEffectOf(segment, argv, shape, readValue) {
+    const bindings = [];
+    let all = shape.definesFunction ? "reset" : undefined;
+    const unknownAll = () => void (all = "unknown");
+    const overlay = new Map();
+    let scope;
+    const bind = (b) => {
+        bindings.push(scope !== undefined ? { ...b, scope } : b);
+        if (b.prefix !== true)
+            overlay.set(b.name, b.state);
+    };
+    const kill = (name) => bind({ name, state: "unknown" });
+    const nameOf = (w) => {
+        if (w.pieces.some((p) => p.expansion !== undefined || p.literal === undefined))
+            return "computed";
+        return nameIn(w.pieces.map((p) => p.literal).join(""));
+    };
+    const killNamed = (name) => {
+        if (name === "computed")
+            unknownAll();
+        else if (name !== undefined)
+            kill(name);
+    };
+    const wordsOfSegment = segment.tokens.flatMap((t) => (t.kind === "word" ? [t] : t.kind === "redirect" && t.target !== undefined ? [t.target] : []));
+    for (const w of wordsOfSegment)
+        for (const name of assignedByPieces(w.pieces))
+            kill(name);
+    for (const t of segment.tokens) {
+        if (t.kind !== "heredoc" || t.quoted)
+            continue;
+        if (t.body.includes("${"))
+            unknownAll();
+        for (const s of substitutionsInHeredocBody(t.body) ?? [])
+            if (s.kind === "arithmetic")
+                for (const name of arithmeticAssignedNames(s.body))
+                    kill(name);
+    }
+    segment.tokens.forEach((t, i) => {
+        const next = segment.tokens[i + 1];
+        const m = t.kind === "word" && next?.kind === "redirect" ? /^\{([A-Za-z_][A-Za-z0-9_]*)\}$/.exec(t.raw) : null;
+        if (m !== null)
+            kill(m[1]);
+    });
+    const tokens = segment.tokens;
+    if (isArithmeticCommand(segment)) {
+        for (const name of arithmeticAssignedNames(argv.map((w) => w.raw).join(" ")))
+            kill(name);
+        return { bindings, all };
+    }
+    const head = argv[0];
+    const headWord = head !== undefined && head.raw === head.folded ? head.folded : undefined;
+    if (headWord === "for" || headWord === "select") {
+        if (tokens.some((t) => t.kind === "group"))
+            unknownAll();
+        const name = argv[1] !== undefined ? nameOf(argv[1]) : undefined;
+        if (name === undefined || name === "computed") {
+            unknownAll();
+            return { bindings, all };
+        }
+        const inAt = argv.findIndex((w, i) => i >= 2 && w.raw === "in");
+        let state = "unknown";
+        if (headWord === "for" && inAt === 2 && argv.length > 3) {
+            const values = [];
+            for (const w of argv.slice(3)) {
+                const v = readValue(w, false, overlay);
+                if (v === "unknown") {
+                    values.length = 0;
+                    break;
+                }
+                values.push(...v);
+            }
+            if (values.length > 0)
+                state = values;
+        }
+        bind({ name, state, loopVar: true });
+        return { bindings, all };
+    }
+    if (headWord === "coproc" && argv[1] !== undefined)
+        killNamed(nameOf(argv[1]));
+    const pos = readProgramPosition(argv);
+    const program = pos.program;
+    const row = program === undefined ? undefined : programRow(program.basename);
+    const statement = program === undefined && pos.launchers.length === 0 && pos.refusal === undefined;
+    for (const k of pos.assignments) {
+        const a = argv[k].assignment;
+        if (a === undefined)
+            continue;
+        if (statement)
+            bind({ name: a.name, state: assignedState(a, readValue, overlay), ...(a.form === "compound" ? { floor: compoundFloor(a.value.raw, readValue, overlay) } : {}) });
+        else if (program !== undefined && SPECIAL_BUILTINS.has(program.basename))
+            bind({ name: a.name, state: assignedState(a, readValue, overlay), prefix: true });
+    }
+    const programWord = program === undefined ? undefined : argv[program.index];
+    if (programWord !== undefined && nameOf(programWord) === "computed" && !programWord.pieces.some((p) => p.literal?.includes("/") === true)) {
+        unknownAll();
+        return { bindings, all, attributes: EVERY_ATTRIBUTE, references: true };
+    }
+    if (program === undefined || row === undefined)
+        return { bindings, all };
+    const args = argv.slice(program.index + 1);
+    const folded = args.map((w) => w.folded);
+    if (row.reentry?.kind === "shell" && (row.reentry.text === "words" || row.reentry.text === "file-operand"))
+        unknownAll();
+    for (const body of codeBodies(program.basename, folded)) {
+        const inner = namesBoundIn(body);
+        if (inner === "all")
+            unknownAll();
+        else
+            for (const name of inner)
+                kill(name);
+    }
+    if (row.builtin === "declaration") {
+        scope = args.some((w) => w.folded.startsWith("-") || w.folded.startsWith("+")) ? "unread" : program.basename === "local" ? "local" : undefined;
+        const assigns = declaredAttributes(row, folded);
+        const kinds = [...assigns].filter((k) => k !== "reference" && k !== "unsettled");
+        const storesText = [...assigns].every((k) => k === "frozen");
+        let references = assigns.has("reference");
+        const attributes = [];
+        const expanded = new Map(overlay);
+        for (const w of args) {
+            const a = w.assignment;
+            const name = a?.name ?? nameOf(w);
+            if (name === "computed") {
+                unknownAll();
+                attributes.push(...EVERY_ATTRIBUTE);
+                references = true;
+                continue;
+            }
+            if (name === undefined)
+                continue;
+            const refused = attributes.some((x) => x.name === undefined || x.name === name);
+            if (a?.form === "compound")
+                bind({ name, state: "unknown", floor: compoundFloor(a.value.raw, readValue, expanded) });
+            else if (a === undefined || !storesText || refused)
+                kill(name);
+            else
+                bind({ name, state: assignedState(a, readValue, expanded) });
+            attributes.push(...kinds.map((kind) => ({ name, kind })));
+        }
+        const inFunction = program.basename === "local" ? { inFunction: true } : {};
+        if (references) {
+            unknownAll();
+            return { bindings, all, attributes, references: true, ...inFunction };
+        }
+        return { bindings, all, attributes, ...inFunction };
+    }
+    for (const e of readArgRoles(row, folded)) {
+        const role = e.kind === "value" || e.kind === "operand" ? e.role : e.kind === "option" && typeof e.reading === "object" ? e.reading.role : undefined;
+        if (role?.kind === "program-text" && role.language === "arithmetic" && e.kind !== "end-of-options" && e.kind !== "dash-word-operand") {
+            for (const name of arithmeticAssignedNames(e.kind === "option" && typeof e.reading === "object" ? e.reading.attached : folded[e.at]))
+                kill(name);
+            continue;
+        }
+        if (role?.kind !== "binds-name")
+            continue;
+        if (e.kind === "option" && typeof e.reading === "object") {
+            killNamed(nameOf(args[e.at]) === "computed" ? "computed" : nameIn(e.reading.attached));
+            continue;
+        }
+        killNamed(nameOf(args[e.at]));
+    }
+    const nameLetters = new Set(row.grammars.flatMap((g) => Object.entries(g.short).flatMap(([letter, s]) => (s.value?.kind === "binds-name" ? [letter] : []))));
+    if (nameLetters.size > 0 && readArgRoles(row, folded).some((e) => e.kind === "option" && e.reading === "speculative" && [...folded[e.at].slice(1)].some((ch) => nameLetters.has(ch))))
+        unknownAll();
+    return { bindings, all };
+}
+function nameIn(text) {
+    return /^([A-Za-z_][A-Za-z0-9_]*)(?:\[.*\])?$/s.exec(text)?.[1];
+}
+function compoundElementWords(raw) {
+    const inner = /^\(([\s\S]*)\)$/.exec(raw)?.[1];
+    const l = inner === undefined ? undefined : lexShell(inner);
+    if (l === undefined || "parseFailure" in l)
+        return [];
+    return l.segments.flatMap((sg) => argvOf(sg)).flatMap((element) => {
+        const prefix = /^\[[^\]]*\]\+?=/.exec(element.raw)?.[0];
+        const assigned = prefix === undefined ? undefined : lexShell(`V=${element.raw.slice(prefix.length)}`);
+        const value = assigned === undefined || "parseFailure" in assigned ? undefined : argvOf(assigned.segments[0])[0]?.assignment?.value;
+        const folded = /^\[[^\]]*\]\+?=/.exec(element.folded)?.[0];
+        return [prefix === undefined ? element : value, ...(folded !== undefined ? [{ pieces: element.pieces, folded: element.folded.slice(folded.length), tail: true }] : [])].filter((w) => w !== undefined);
+    });
+}
+function compoundFloor(raw, readValue, overlay) {
+    return compoundElementWords(raw).flatMap((w) => {
+        const v = w.tail === true ? "unknown" : readValue(w, true, overlay);
+        if (v !== "unknown")
+            return [...v];
+        const text = w.pieces.some((q) => q.expansion?.kind === "tilde") ? w.folded : literalTildeSpelling(w.folded);
+        return [w.pieces.some((q) => q.expansion?.kind === "glob") ? { spelled: text, glob: true } : { spelled: text }];
+    });
+}
+function assignedState(a, readValue, overlay) {
+    if (a.op !== "=" || a.subscript !== undefined || a.form !== "scalar" || a.value.unresolved !== undefined)
+        return "unknown";
+    return readValue({ pieces: a.value.pieces }, true, overlay);
+}
+function assignedByPieces(pieces) {
+    const out = [];
+    for (const p of pieces) {
+        const e = p.expansion;
+        if (e?.kind === "parameter" && e.name !== undefined && e.body !== undefined && new RegExp(`^${e.name}:?=`).test(e.body))
+            out.push(e.name);
+        if (e?.kind === "arithmetic" && e.body !== undefined)
+            out.push(...arithmeticAssignedNames(e.body));
+    }
+    return out;
+}
+export function arithmeticAssignedNames(text) {
+    const assigns = /(?:^|[^=!<>])=(?!=)|\+\+|--/.test(text);
+    return assigns ? [...new Set(text.match(/[A-Za-z_][A-Za-z0-9_]*/g) ?? [])] : [];
+}
+export function namesBoundIn(text, depth = 0) {
+    if (depth > 4)
+        return "all";
+    const lexed = lexShell(text);
+    if ("parseFailure" in lexed)
+        return "all";
+    const names = new Set();
+    const nothing = () => "unknown";
+    for (const segment of lexed.segments) {
+        const p = projectSegment(segment);
+        const effect = bindingEffectOf(segment, p.argv, p, nothing);
+        if (effect.all === "unknown")
+            return "all";
+        for (const b of effect.bindings)
+            names.add(b.name);
+    }
+    return names;
+}
+export function textBindsHome(text) {
+    const names = namesBoundIn(text);
+    return names === "all" || names.has("HOME");
+}
+const NOTHING_INHERITED = { attributes: [], references: false };
+export class BindingThread {
+    segments;
+    named;
+    initial;
+    boundAnywhere;
+    loops;
+    homeStartsTouched;
+    entries = [];
+    attributesAt;
+    unreadable;
+    blocks;
+    detached;
+    constructor(segments, named, initial, boundAnywhere, loops, homeStartsTouched = false, inherited = NOTHING_INHERITED) {
+        this.segments = segments;
+        this.named = named;
+        this.initial = initial;
+        this.boundAnywhere = boundAnywhere;
+        this.loops = loops;
+        this.homeStartsTouched = homeStartsTouched;
+        this.blocks = blockStructure(segments);
+        this.detached = segments.map((s, i) => s.connector === "|" || segments[i + 1]?.connector === "|" || segments[i + 1]?.connector === "&");
+        this.unreadable = [...(inherited.references ? [{ at: -1 }] : []), ...named.flatMap((effect, at) => this.unreadableBy(effect, at))];
+        this.attributesAt = [...inherited.attributes.map((a) => ({ ...a, at: -1 })), ...named.flatMap((effect, at) => (effect.attributes ?? []).map((a) => ({ ...a, at })))];
+    }
+    inheritedAt(j) {
+        const holds = (at) => j === undefined || this.mayRunBefore(at, j);
+        return {
+            attributes: this.attributesAt.filter((x) => holds(x.at)).map(({ name, kind }) => (name !== undefined ? { name, kind } : { kind })),
+            references: this.unreadable.some((u) => u.name === undefined && u.body === undefined && holds(u.at)),
+        };
+    }
+    unreadableBy(effect, at) {
+        const body = this.blocks[at].body;
+        const out = [];
+        if (body !== undefined) {
+            for (const b of effect.bindings)
+                if (b.scope !== "local" && (b.scope === "unread" || !this.declaredLocal(b.name, at, body)))
+                    out.push({ at, name: b.name, body });
+            if (effect.all === "unknown")
+                out.push({ at, body });
+        }
+        if (effect.references === true)
+            out.push({ at });
+        return out;
+    }
+    mayRunBefore(x, e) {
+        if (x < e)
+            return true;
+        return this.blocks[e].body !== undefined || [...this.loops].some(([head, end]) => head <= e && x < end);
+    }
+    declaredLocal(name, at, body) {
+        for (let k = 0; k < at; k++) {
+            const connector = this.segments[k].connector;
+            if (this.blocks[k].body?.id !== body.id || this.detached[k] === true || connector === "&&" || connector === "||")
+                continue;
+            if (this.named[k].bindings.some((b) => b.scope === "local" && b.name === name) && this.heldThrough(k, at))
+                return true;
+        }
+        return false;
+    }
+    heldThrough(at, j) {
+        const depth = this.blocks[at].words;
+        if (this.blocks[at].after < depth)
+            return false;
+        for (let k = at + 1; k <= j; k++)
+            if (this.blocks[k].lowest < depth || this.blocks[k].switches.includes(depth))
+                return false;
+        return true;
+    }
+    apply(at, effect, andRun, loopEnd) {
+        const detached = this.detached[at] === true;
+        const refused = effect.inFunction === true && this.blocks[at].body === undefined;
+        if (effect.all !== undefined)
+            this.entries.push({ at, state: effect.all === "reset" ? "reset" : "unknown", detached: false, andRun: false });
+        for (const b of effect.bindings) {
+            this.entries.push({
+                at, name: b.name, state: refused ? "unknown" : b.state, detached: detached || b.prefix === true, andRun,
+                ...(b.loopVar === true && loopEnd !== undefined ? { certainUntil: loopEnd } : {}),
+                ...(b.floor !== undefined && b.floor.length > 0 ? { floor: b.floor } : {}),
+            });
+        }
+    }
+    leftBody(at, body, j) {
+        if (this.blocks[at].after <= body.base)
+            return true;
+        for (let k = at + 1; k <= j; k++)
+            if (this.blocks[k].lowest <= body.base)
+                return true;
+        return false;
+    }
+    kill(at, names) {
+        if (names === "all") {
+            this.entries.push({ at, state: "unknown", detached: false, andRun: false });
+            return;
+        }
+        for (const name of names)
+            this.entries.push({ at, name, state: "unknown", detached: false, andRun: false });
+    }
+    tableAt(j, andRunStart) {
+        const certain = (e) => {
+            if (e.certainUntil !== undefined && j < e.certainUntil)
+                return true;
+            if (e.detached || !this.heldThrough(e.at, j))
+                return false;
+            return !e.andRun || e.at >= andRunStart;
+        };
+        const readerBody = this.blocks[j].body;
+        const lost = (u) => {
+            if (u.body === undefined)
+                return this.mayRunBefore(u.at, j);
+            if (readerBody !== undefined && readerBody.id !== u.body.id)
+                return true;
+            return u.at < j && this.leftBody(u.at, u.body, j);
+        };
+        const before = (e) => e.at < j || (e.at === j && e.state === "reset");
+        const given = (name, at, integer) => this.attributesAt.some((x) => (x.name === undefined || x.name === name) && (integer !== true || x.kind === "integer") && x.at !== at && this.mayRunBefore(x.at, at));
+        const stateOf = (name) => {
+            if (shellKeepsName(name))
+                return "unknown";
+            if (this.unreadable.some((u) => (u.name === undefined || u.name === name) && lost(u)))
+                return "unknown";
+            const values = [];
+            const add = (vs) => { for (const v of vs)
+                if (!values.some((x) => x.spelled === v.spelled && x.glob === v.glob))
+                    values.push(v); };
+            for (let i = this.entries.length - 1; i >= 0; i--) {
+                const e = this.entries[i];
+                if (!before(e) || (e.name !== undefined && e.name !== name))
+                    continue;
+                const state = e.state === "reset" ? (name === "HOME" && this.boundAnywhere("HOME") ? "unknown" : this.initial(name)) : e.state;
+                if (state === "unknown")
+                    return "unknown";
+                if (e.name !== undefined && given(e.name, e.at))
+                    return "unknown";
+                add(state);
+                if (certain(e))
+                    return values;
+            }
+            const start = this.initial(name);
+            if (start === "unknown")
+                return "unknown";
+            add(start);
+            return values;
+        };
+        const touched = (name) => this.entries.some((e) => before(e) && (e.name === undefined || e.name === name));
+        return {
+            stateOf,
+            isInteger: (name) => SHELL_INTEGER_VARIABLES.has(name) || given(name, j, true),
+            ifsTouched: touched("IFS"),
+            homeTouched: this.homeStartsTouched || touched("HOME"),
+            floorOf: (name) => this.entries.filter((e) => e.at < j && e.name === name).flatMap((e) => e.floor ?? []),
+            inherited: this.inheritedAt(j),
+        };
+    }
+}
+export function isArithmeticCommand(segment) {
+    const [a, b] = segment.tokens;
+    return a?.kind === "group" && a.op === "(" && b?.kind === "group" && b.op === "(";
+}
+export const ARITHMETIC_TEST_OPERATORS = new Set(["-eq", "-ne", "-lt", "-le", "-gt", "-ge"]);
+export function parameterBodySubstitutions(name, body, table) {
+    const rest = body.slice(name.length);
+    const out = arithmeticSubstitutions(rest.startsWith("[") ? rest.slice(0, rest.indexOf("]") + 1 || undefined) : "", table);
+    const offset = /^(?:\[[^\]]*\])?:(?![-=+?])(.*)$/s.exec(rest)?.[1];
+    if (offset !== undefined)
+        out.push(...substitutionBodies(`${offset}`, true), ...arithmeticSubstitutions(offset, table));
+    return [...new Set(out)];
+}
+export function arithmeticSubstitutions(text, table, chain = new Set(), budget = { left: ARITHMETIC_VALUES_MAX }) {
+    if (--budget.left < 0)
+        return [text];
+    const out = [];
+    for (const subscript of subscriptsOf(text))
+        out.push(...substitutionBodies(subscript));
+    if (table !== undefined) {
+        for (const name of new Set(text.match(/[A-Za-z_][A-Za-z0-9_]*/g) ?? [])) {
+            if (chain.has(name))
+                continue;
+            const state = table.stateOf(name);
+            const values = state === "unknown" ? table.floorOf(name) : state;
+            for (const v of values)
+                out.push(...arithmeticSubstitutions(v.spelled, table, new Set([...chain, name]), budget));
+        }
+    }
+    return [...new Set(out)];
+}
+const ARITHMETIC_VALUES_MAX = 256;
+export function subscriptsOf(text) {
+    const out = [];
+    for (let i = 0; i < text.length; i++) {
+        if (text[i] !== "[")
+            continue;
+        let depth = 0;
+        let j = i;
+        for (; j < text.length; j++) {
+            if (text[j] === "[")
+                depth++;
+            else if (text[j] === "]" && --depth === 0)
+                break;
+        }
+        out.push(text.slice(i + 1, j));
+        i = j;
+    }
+    return out;
+}
+function substitutionBodies(subscript, keepQuotes = false) {
+    if (!/\$\(|`|[<>]\(/.test(subscript))
+        return [];
+    const unquoted = keepQuotes ? subscript : subscript.replace(/["']/g, "");
+    const lexed = lexShell(unquoted);
+    if ("parseFailure" in lexed)
+        return [unquoted];
+    const bodies = lexed.segments.flatMap((s) => s.substitutions);
+    return bodies.length > 0 ? bodies : [unquoted];
+}