@poe-platform/safe-bash 0.1.630 → 0.1.631

package/dist/safe-bash/shell/parser.js

@@ -5,10 +5,72 @@ import { arithmeticEnd, prepareArithmetic } from "./arithmetic.js";
 import { arraySelector, compoundEntry, compoundHead, elementAssignment, getArrayAssignment, getArraySelector, isQuoteMarker, prefixNameQuoteGroups, scalarAssignmentName, setArrayAssignment, setArraySelector, setQuoteMarker } from "./arrays/syntax.js";
 import { conditionalBinary, conditionalUnary } from "./conditional.js";
 import { concatShellValues, shellValueBytes, shellValueFromBytes, shellValueText } from "../contracts/value.js";
+const capturedSyntax = new WeakSet();
+function indexedDeclarations(input) {
+    if (input === undefined)
+        return Object.freeze([]);
+    if (!Array.isArray(input) || input.length > 1 || Reflect.ownKeys(input).some(name => name !== "length" && name !== "0")) {
+        throw new TypeError("Invalid or duplicate indexed declarations");
+    }
+    if (!input.length)
+        return Object.freeze([]);
+    const slot = Object.getOwnPropertyDescriptor(input, "0");
+    if (!slot || !("value" in slot) || slot.value !== "readonly")
+        throw new TypeError("Invalid indexed declaration");
+    return Object.freeze(["readonly"]);
+}
+function syntaxEntries(input, key, allowed) {
+    if (input === undefined)
+        return Object.freeze([]);
+    if (!Array.isArray(input) || input.length > 1 || Reflect.ownKeys(input).some(name => name !== "length" && name !== "0")) {
+        throw new TypeError("Invalid or duplicate shell syntax declarations");
+    }
+    const entries = [];
+    for (let index = 0; index < input.length; index++) {
+        const slot = Object.getOwnPropertyDescriptor(input, String(index));
+        const entry = slot && "value" in slot ? slot.value : undefined;
+        if (!entry || typeof entry !== "object" || Reflect.ownKeys(entry).length !== 1)
+            throw new TypeError("Invalid shell syntax declaration");
+        const property = Object.getOwnPropertyDescriptor(entry, key);
+        if (!property || !("value" in property) || property.value !== allowed)
+            throw new TypeError("Invalid or reserved shell syntax declaration");
+        entries.push(Object.freeze({ [key]: allowed }));
+    }
+    return Object.freeze(entries);
+}
+export function captureShellSyntax(declarations = defaultSyntax) {
+    if (!declarations || typeof declarations !== "object" || Array.isArray(declarations))
+        throw new TypeError("Invalid shell syntax declarations");
+    if (capturedSyntax.has(declarations))
+        return declarations;
+    const prototype = Object.getPrototypeOf(declarations);
+    if (prototype !== null && prototype !== Object.prototype)
+        throw new TypeError("Invalid shell syntax declarations");
+    const properties = Object.getOwnPropertyDescriptors(declarations);
+    if (Reflect.ownKeys(properties).some(key => key !== "listTerminators" && key !== "specialParameters" && key !== "arrayKeys" && key !== "indexedDeclarations" && key !== "indexedElementOperators")
+        || Object.values(properties).some(property => !("value" in property)))
+        throw new TypeError("Invalid shell syntax declarations");
+    if (properties.arrayKeys && properties.arrayKeys.value !== true)
+        throw new TypeError("Invalid shell syntax capability");
+    if (properties.indexedElementOperators && properties.indexedElementOperators.value !== true)
+        throw new TypeError("Invalid shell syntax capability");
+    const indexed = indexedDeclarations(properties.indexedDeclarations?.value);
+    const syntax = Object.freeze({
+        listTerminators: syntaxEntries(properties.listTerminators?.value, "operator", "&"),
+        specialParameters: syntaxEntries(properties.specialParameters?.value, "name", "!"),
+        ...(properties.arrayKeys ? { arrayKeys: true } : {}),
+        ...(properties.indexedElementOperators ? { indexedElementOperators: true } : {}),
+        ...(indexed.length ? { indexedDeclarations: indexed } : {}),
+    });
+    capturedSyntax.add(syntax);
+    return syntax;
+}
+const defaultSyntax = captureShellSyntax({});
 export const compoundEntryWords = new WeakMap();
 export const expansionSpellings = new WeakMap();
 const documentValues = new WeakMap();
 const documentDelimiters = new WeakMap();
+const hereDocumentSyntax = new WeakMap();
 export class HereDocumentSyntaxError extends Error {
     diagnostic;
     constructor(diagnostic) {
@@ -16,6 +78,172 @@ export class HereDocumentSyntaxError extends Error {
         this.diagnostic = diagnostic;
     }
 }
+const scriptSeparators = new WeakMap();
+const functionLayouts = new WeakMap();
+export function functionReprintedLines(script) {
+    if (functionLayouts.has(script))
+        return functionLayouts.get(script);
+    const lines = new Map();
+    let line = 1;
+    let found = false;
+    let endedWithDocument = false;
+    function words(values) {
+        for (const word of values) {
+            if (word.printedNewlines === undefined)
+                return false;
+            line += word.printedNewlines;
+        }
+        return true;
+    }
+    function redirects(values) {
+        if (!values.length)
+            return true;
+        endedWithDocument = false;
+        if (!words(values.map(redirect => redirect.target)))
+            return false;
+        const documents = values.flatMap(redirect => redirect.document ? [redirect.document] : []);
+        if (documents.length) {
+            line++;
+            for (const document of documents) {
+                line += document.body.split("\n").length - 1 + document.delimiter.split("\n").length;
+            }
+            endedWithDocument = true;
+        }
+        return true;
+    }
+    function commands(body, inFunction) {
+        const separators = scriptSeparators.get(body.lists);
+        if (!separators)
+            return false;
+        for (let index = 0; index < body.lists.length; index++) {
+            for (const pipeline of body.lists[index].pipelines) {
+                for (const command of pipeline.commands)
+                    if (!visit(command, inFunction))
+                        return false;
+            }
+            if (index < body.lists.length - 1) {
+                line += endedWithDocument ? Number(inFunction || separators[index]) : Number(separators[index]) + Number(inFunction);
+                endedWithDocument = false;
+            }
+        }
+        return true;
+    }
+    function conditional(expression) {
+        switch (expression.kind) {
+            case "nonempty":
+            case "unary": return words([expression.operand]);
+            case "binary": return words([expression.left, expression.right]);
+            case "not": return conditional(expression.operand);
+            case "and":
+            case "or": return conditional(expression.left) && conditional(expression.right);
+        }
+    }
+    function visit(command, inFunction) {
+        lines.set(command, line);
+        if (command.kind === "simple") {
+            if (command.words.length) {
+                const firstNewlines = command.words[0].printedNewlines;
+                if (firstNewlines === undefined)
+                    return false;
+                lines.set(command, line + firstNewlines);
+            }
+            if (!words(command.words))
+                return false;
+        }
+        else if (command.kind === "function") {
+            found = true;
+            line += 2;
+            if (command.body.kind === "group") {
+                lines.set(command.body, line - 1);
+                if (!commands(command.body.body, true))
+                    return false;
+                line++;
+                endedWithDocument = false;
+                if (!redirects(command.body.redirects))
+                    return false;
+            }
+            else {
+                if (!visit(command.body, true))
+                    return false;
+                line++;
+                endedWithDocument = false;
+            }
+        }
+        else if (command.kind === "group" || command.kind === "subshell") {
+            const expanded = inFunction && command.kind === "group";
+            line += Number(expanded);
+            if (!commands(command.body, inFunction))
+                return false;
+            line += Number(expanded);
+            endedWithDocument = false;
+        }
+        else if (command.kind === "if") {
+            for (let index = 0; index < command.branches.length; index++) {
+                if (index)
+                    line += 2;
+                const branch = command.branches[index];
+                if (!commands(branch.condition, inFunction))
+                    return false;
+                line++;
+                endedWithDocument = false;
+                if (!commands(branch.body, inFunction))
+                    return false;
+            }
+            if (command.otherwise) {
+                line += 2;
+                if (!commands(command.otherwise, inFunction))
+                    return false;
+            }
+            line += command.branches.length;
+        }
+        else if (command.kind === "for") {
+            if (command.words && !words(command.words))
+                return false;
+            line += 2;
+            if (!commands(command.body, inFunction))
+                return false;
+            line++;
+        }
+        else if (command.kind === "while" || command.kind === "until") {
+            if (!commands(command.condition, inFunction))
+                return false;
+            line++;
+            endedWithDocument = false;
+            if (!commands(command.body, inFunction))
+                return false;
+            line++;
+        }
+        else if (command.kind === "arithmetic") {
+            line += command.source.split("\n").length - 1;
+        }
+        else if (command.kind === "conditional") {
+            if (!conditional(command.expression))
+                return false;
+        }
+        else if (command.kind === "case") {
+            if (!words([command.subject]))
+                return false;
+            for (let index = 0; index < command.clauses.length; index++) {
+                if (index)
+                    line++;
+                const clause = command.clauses[index];
+                if (!words(clause.patterns))
+                    return false;
+                line++;
+                if (!commands(clause.body, inFunction))
+                    return false;
+                line++;
+            }
+            line++;
+        }
+        else
+            return false;
+        return redirects(command.redirects);
+    }
+    const result = commands(script, false) && found ? lines : undefined;
+    functionLayouts.set(script, result);
+    return result;
+}
 function printedSimpleLines(lists, separators, budget) {
     budget.admit();
     const printedLines = new Map();
@@ -54,6 +282,8 @@ class Lexer {
     sourceOffset;
     ordinaryBacktick;
     sourceValues;
+    byteSource;
+    syntax;
     position = 0;
     operandDepth = 0;
     printedNewlineReduction = 0;
@@ -63,7 +293,7 @@ class Lexer {
     conditionalPattern;
     braceReplay;
     documents = [];
-    constructor(budget, source, depth, warnings = [], lineOffset = 0, byteLocale = false, documentLine, partial = false, lineIndex = new SourceLineIndex(source, budget), sourceOffset = 0, ordinaryBacktick = false, sourceValues) {
+    constructor(budget, source, depth, warnings = [], lineOffset = 0, byteLocale = false, documentLine, partial = false, lineIndex = new SourceLineIndex(source, budget), sourceOffset = 0, ordinaryBacktick = false, sourceValues, byteSource = false, syntax = defaultSyntax) {
         this.budget = budget;
         this.source = source;
         this.depth = depth;
@@ -76,6 +306,8 @@ class Lexer {
         this.sourceOffset = sourceOffset;
         this.ordinaryBacktick = ordinaryBacktick;
         this.sourceValues = sourceValues;
+        this.byteSource = byteSource;
+        this.syntax = syntax;
         if (depth > 64)
             throw new ShellSyntaxError("Syntax nesting exceeds 64", 0);
     }
@@ -122,7 +354,7 @@ class Lexer {
         }
         const operator = this.conditionalPattern ? undefined : /^(?:;;&|<<<|<<-|&>>|;&|&&|\|\||\|&|>>|>&|<&|>\||<<|;;|&>|[;\n|&()<>])/u.exec(logical)?.[0];
         if (operator) {
-            if (operator === "&>>")
+            if (operator === "&>>" || operator === "&" && !this.syntax.listTerminators.length)
                 this.error(`Unsupported operator ${operator}`);
             this.position = ends[operator.length - 1];
             if (operator === "<<" || operator === "<<-")
@@ -142,13 +374,14 @@ class Lexer {
             document = {
                 delimiter: word.parts.map((part) => part.kind === "text" ? part.value : "").join(""),
                 quoted: word.parts.some((part) => part.quoted), stripTabs: delimiterOperator === "<<-", offset,
-                body: "", endLine: this.lineAt(offset), depth: this.depth,
+                body: "", endLine: this.lineAt(offset), depth: this.depth, ...(this.byteSource ? { byteSource: true } : {}),
             };
             if (this.sourceValues?.size) {
                 this.budget.admit(word.parts.length + 1);
                 documentDelimiters.set(document, shellValueBytes(concatShellValues(word.parts.map(part => part.kind === "text" ? part.byteValue ?? part.value : ""))));
             }
             this.documents.push(document);
+            hereDocumentSyntax.set(document, this.syntax);
         }
         this.budget.admit();
         return { kind: "word", value: word.plain ?? "", offset, end: this.position, word: { ...word, spelling: this.source.slice(offset, this.position) }, ...(document ? { document } : {}) };
@@ -235,7 +468,7 @@ class Lexer {
             if (opaque !== undefined) {
                 if (text) {
                     this.budget.admit(2);
-                    yield { offset: 0, parts: [{ kind: "text", value: text, quoted: true }] };
+                    yield { offset: 0, parts: [{ kind: "text", value: text, quoted: true, ...(this.byteSource ? { byteValue: shellValueFromBytes(Buffer.from(text, "latin1")) } : {}) }] };
                     text = "";
                 }
                 this.budget.admit(2);
@@ -244,7 +477,7 @@ class Lexer {
             else if (current === "$" || current === "`") {
                 if (text) {
                     this.budget.admit(2);
-                    yield { offset: 0, parts: [{ kind: "text", value: text, quoted: true }] };
+                    yield { offset: 0, parts: [{ kind: "text", value: text, quoted: true, ...(this.byteSource ? { byteValue: shellValueFromBytes(Buffer.from(text, "latin1")) } : {}) }] };
                     text = "";
                 }
                 const offset = this.position;
@@ -276,13 +509,13 @@ class Lexer {
             }
             if (text.length >= 1024) {
                 this.budget.admit(2);
-                yield { offset: 0, parts: [{ kind: "text", value: text, quoted: true }] };
+                yield { offset: 0, parts: [{ kind: "text", value: text, quoted: true, ...(this.byteSource ? { byteValue: shellValueFromBytes(Buffer.from(text, "latin1")) } : {}) }] };
                 text = "";
             }
         }
         if (text) {
             this.budget.admit(2);
-            yield { offset: 0, parts: [{ kind: "text", value: text, quoted: true }] };
+            yield { offset: 0, parts: [{ kind: "text", value: text, quoted: true, ...(this.byteSource ? { byteValue: shellValueFromBytes(Buffer.from(text, "latin1")) } : {}) }] };
         }
     }
     documentSubstitutionError(source, error, backtick = false) {
@@ -374,6 +607,8 @@ class Lexer {
         const conditionalPattern = terminator === undefined ? this.conditionalPattern : undefined;
         let plain = true;
         const text = (value, quoted, synthetic = false, start = this.position, end = start + shellValueText(value).length, ansi = false) => {
+            if (this.byteSource && typeof value === "string" && [...value].some(character => character.charCodeAt(0) > 127))
+                value = shellValueFromBytes(Buffer.from(value, "latin1"));
             const projection = shellValueText(value);
             if (conditionalPattern === "regex" && regexBracket && quoted && projection.length) {
                 regexBracketFirst = false;
@@ -598,6 +833,10 @@ class Lexer {
             if (character === "'") {
                 const nul = bytes.indexOf(0);
                 const raw = Uint8Array.from(nul < 0 ? bytes : bytes.slice(0, nul));
+                if (this.byteSource) {
+                    this.budget.admit(2);
+                    return shellValueFromBytes(raw);
+                }
                 const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
                 try {
                     return decoder.decode(raw);
@@ -611,7 +850,7 @@ class Lexer {
                 }
             }
             if (character !== "\\") {
-                bytes.push(...encoder.encode(character));
+                bytes.push(...(this.byteSource ? Buffer.from(character, "latin1") : encoder.encode(character)));
                 continue;
             }
             const escape = this.source[this.position++];
@@ -684,7 +923,7 @@ class Lexer {
                 this.error("Unterminated command substitution");
             this.position++;
             try {
-                parts.push({ kind: "substitution", script: parseSource(source, this.depth + this.operandDepth + 1, this.warnings, line - 1, this.byteLocale, this.budget, this.documentLine === undefined, sourceValues), line, quoted });
+                parts.push({ kind: "substitution", form: "backtick", script: parseSource(source, this.depth + this.operandDepth + 1, this.warnings, line - 1, this.byteLocale, this.budget, this.documentLine === undefined, sourceValues, this.byteSource, this.syntax), line, quoted });
             }
             catch (error) {
                 if (this.documentLine === undefined || !(error instanceof ShellSyntaxError) || /nesting|exceeds/u.test(error.reason))
@@ -699,7 +938,8 @@ class Lexer {
             return;
         }
         this.position++;
-        if (this.source[this.position] === "$" || (!quoted && ["'", '"'].includes(this.source[this.position] ?? "")))
+        if (this.source[this.position] === "$" || this.source[this.position] === "!" && !this.syntax.specialParameters.length
+            || (!quoted && ["'", '"'].includes(this.source[this.position] ?? "")))
             this.error("Unsupported shell quoting or special parameter");
         if (this.source.startsWith("((", this.position)) {
             const start = this.position + 2;
@@ -714,7 +954,7 @@ class Lexer {
             let script;
             try {
                 this.budget.admit();
-                nested = new Parser(this.budget, this.source.slice(start), this.depth + this.operandDepth + 1, this.warnings, this.lineAt(start) - 1, undefined, this.byteLocale, false, this.lineIndex, this.sourceOffset + start, false, this.sourceValues);
+                nested = new Parser(this.budget, this.source.slice(start), this.depth + this.operandDepth + 1, this.warnings, this.lineAt(start) - 1, undefined, this.byteLocale, false, this.lineIndex, this.sourceOffset + start, false, this.sourceValues, this.byteSource, this.syntax);
                 script = nested.script(new Set([")"]));
             }
             catch (error) {
@@ -736,18 +976,20 @@ class Lexer {
                 this.unprintedWords++;
             else
                 this.printedNewlineReduction += this.source.slice(start, this.position - 1).split("\n").length - 1 - script.printedNewlines;
-            parts.push({ kind: "substitution", script, line, sourceLine: script.line ?? line, quoted });
+            parts.push({ kind: "substitution", form: "dollar-parenthesis", script, line, sourceLine: script.line ?? line, quoted });
         }
         else if (this.source[this.position] === "{") {
             this.position++;
             const parameterStart = this.position - 2;
-            const listing = this.source[this.position] === "!" && /[a-zA-Z_]/u.test(this.source[this.position + 1] ?? "");
+            const listing = this.source[this.position] === "!" && /[a-zA-Z_0-9]/u.test(this.source[this.position + 1] ?? "");
             if (listing)
                 this.position++;
-            const length = !listing && this.source[this.position] === "#" && /[a-zA-Z_!]/u.test(this.source[this.position + 1] ?? "");
+            const length = !listing && this.source[this.position] === "#" && (/[a-zA-Z_0-9]/u.test(this.source[this.position + 1] ?? "")
+                || this.syntax.specialParameters.some(parameter => parameter.name === this.source[this.position + 1]));
             if (length)
                 this.position++;
-            const name = /^(?:[a-zA-Z_][a-zA-Z_0-9]*|[0-9]+|[?@*#!-])/u.exec(this.source.slice(this.position))?.[0];
+            const specialParameter = this.syntax.specialParameters.find(parameter => parameter.name === this.source[this.position]);
+            const name = specialParameter?.name ?? /^(?:[a-zA-Z_][a-zA-Z_0-9]*|[0-9]+|[?@*#-])/u.exec(this.source.slice(this.position))?.[0];
             if (!name)
                 this.error("Unsupported parameter expansion");
             this.position += name.length;
@@ -770,11 +1012,16 @@ class Lexer {
                     this.error("Unterminated indexed-array subscript");
                 selector = arraySelector(this.source.slice(start, end), start, this.budget, keyWord);
                 this.position = end + 1;
-                if (this.source[this.position] !== "}" && this.source[this.position] !== "@")
+                if (this.source[this.position] !== "}" && this.source[this.position] !== "@" && !(this.syntax.indexedElementOperators && !length && selector.kind === "element"
+                    && (this.source[this.position] === "-" || this.source[this.position] === "+")))
                     this.error("Unsupported indexed-array operator");
             }
             if (listing && selector?.kind === "element")
                 this.error("Unsupported indirect parameter expansion");
+            if (listing && selector?.kind === "members" && this.syntax.arrayKeys) {
+                this.budget.admit();
+                selector = { kind: "keys", separator: selector.separator };
+            }
             let transform;
             if (this.source[this.position] === "@") {
                 const operation = this.source[this.position + 1];
@@ -834,7 +1081,7 @@ class Lexer {
             }
             else {
                 this.position++;
-                const part = { kind: "variable", name, quoted, line, ...(prefixNames ? { prefixNames } : {}), ...(transform ? { transform } : {}), ...(length ? { length } : {}), ...(operator ? { operator, alternate: alternate } : {}), ...(replacement ? { replacement } : {}), ...(substring ? { substring } : {}) };
+                const part = { kind: "variable", name, quoted, line, ...(specialParameter ? { specialParameter } : {}), ...(prefixNames ? { prefixNames } : {}), ...(transform ? { transform } : {}), ...(length ? { length } : {}), ...(operator ? { operator, alternate: alternate } : {}), ...(replacement ? { replacement } : {}), ...(substring ? { substring } : {}) };
                 if (listing && selector)
                     part.keys = true;
                 if (selector)
@@ -843,10 +1090,11 @@ class Lexer {
             }
         }
         else {
-            const name = /^(?:[a-zA-Z_][a-zA-Z_0-9]*|[?@*#!0-9-])/u.exec(this.source.slice(this.position))?.[0];
+            const specialParameter = this.syntax.specialParameters.find(parameter => parameter.name === this.source[this.position]);
+            const name = specialParameter?.name ?? /^(?:[a-zA-Z_][a-zA-Z_0-9]*|[?@*#0-9-])/u.exec(this.source.slice(this.position))?.[0];
             if (name) {
                 this.position += name.length;
-                parts.push({ kind: "variable", name, quoted, line });
+                parts.push({ kind: "variable", name, quoted, line, ...(specialParameter ? { specialParameter } : {}) });
             }
             else
                 parts.push({ kind: "text", value: "$", quoted });
@@ -865,12 +1113,12 @@ class Parser {
     nesting = 0;
     openCommands = [];
     completedInput;
-    constructor(budget, source, depth, warnings = [], lineOffset = 0, position, byteLocale = false, partial = false, lineIndex = new SourceLineIndex(source, budget), sourceOffset = 0, ordinaryBacktick = false, sourceValues) {
+    constructor(budget, source, depth, warnings = [], lineOffset = 0, position, byteLocale = false, partial = false, lineIndex = new SourceLineIndex(source, budget), sourceOffset = 0, ordinaryBacktick = false, sourceValues, byteSource = false, syntax = defaultSyntax) {
         this.budget = budget;
         if (position === undefined && depth === 0 && source.includes("\0"))
             throw new ShellSyntaxError("NUL bytes are not valid shell source", source.indexOf("\0"));
         budget.admit();
-        this.lexer = new Lexer(budget, source, depth, warnings, lineOffset, byteLocale, undefined, partial, lineIndex, sourceOffset, ordinaryBacktick, sourceValues);
+        this.lexer = new Lexer(budget, source, depth, warnings, lineOffset, byteLocale, undefined, partial, lineIndex, sourceOffset, ordinaryBacktick, sourceValues, byteSource, syntax);
         this.lexer.position = position ?? 0;
         this.current = this.lexer.next();
     }
@@ -915,13 +1163,14 @@ class Parser {
                 this.newlines();
                 pipelines.push(this.pipeline());
             }
-            lists.push({ pipelines, operators, ...(this.is("&") ? { background: true } : {}) });
+            const terminator = this.is("&") ? Object.freeze({ operator: "&", offset: this.current.offset, line: this.lexer.lineAt(this.current.offset) }) : undefined;
+            lists.push({ pipelines, operators, ...(terminator ? { terminator } : {}) });
             separators.push(this.is("\n"));
             if (captureInputUnits && this.is("\n"))
                 this.completedInput.count = lists.length;
             if (inputUnit && this.is("\n"))
                 break;
-            if (this.is(";") || this.is("&") || this.is("\n")) {
+            if (terminator || this.is(";") || this.is("\n")) {
                 this.advance();
                 if (captureInputUnits && this.is("\n"))
                     this.completedInput.count = lists.length;
@@ -933,6 +1182,7 @@ class Parser {
                 this.error("Expected command separator");
         }
         const printed = printedSimpleLines(lists, separators, this.budget);
+        scriptSeparators.set(lists, Object.freeze(separators));
         return { lists, line, ...printed };
     }
     pipeline() {
@@ -1229,6 +1479,12 @@ class Parser {
                 this.error(`Unexpected or unsupported keyword ${this.current.value}`);
             const words = [];
             const redirects = [];
+            const indexedDeclaration = () => {
+                let index = 0;
+                while (words[index] && scalarAssignmentName(words[index]))
+                    index++;
+                return this.lexer.syntax.indexedDeclarations?.some(name => name === words[index]?.plain) === true;
+            };
             let line;
             while (true) {
                 const wordLine = this.lexer.lineAt(Math.max(this.current.offset, this.current.end - 1));
@@ -1263,7 +1519,7 @@ class Parser {
                         setArrayAssignment(word, { kind: "compound", ...head, entries });
                     }
                     else {
-                        const assignment = words.every(previous => getArrayAssignment(previous) || scalarAssignmentName(previous)) ? elementAssignment(word, this.budget, source => parseArraySubscript(source, this.budget, this.lexer.byteLocale, this.lexer.depth), (source, start) => { const lexer = new Lexer(this.budget, source, this.lexer.depth, [], 0, this.lexer.byteLocale); lexer.position = start; lexer.word("]"); return lexer.source[lexer.position] === "]" ? lexer.position : -1; }) : undefined;
+                        const assignment = words.every(previous => getArrayAssignment(previous) || scalarAssignmentName(previous)) ? elementAssignment(word, this.budget, source => parseArraySubscript(source, this.budget, this.lexer.byteLocale, this.lexer.depth, this.lexer.byteSource, this.lexer.syntax), (source, start) => { const lexer = new Lexer(this.budget, source, this.lexer.depth, [], 0, this.lexer.byteLocale, undefined, false, undefined, 0, false, undefined, this.lexer.byteSource, this.lexer.syntax); lexer.position = start; lexer.word("]"); return lexer.source[lexer.position] === "]" ? lexer.position : -1; }) : undefined;
                         if (assignment)
                             setArrayAssignment(word, assignment);
                     }
@@ -1274,7 +1530,7 @@ class Parser {
             }
             if (!words.length && !redirects.length)
                 this.error("Expected command");
-            if (words.some(word => getArrayAssignment(word)) && words.some(word => !getArrayAssignment(word) && !scalarAssignmentName(word)))
+            if (words.some(word => getArrayAssignment(word)) && words.some(word => !getArrayAssignment(word) && !scalarAssignmentName(word)) && !indexedDeclaration())
                 this.error("Indexed-array command prefixes are unsupported");
             return { kind: "simple", words, redirects, ...(line === undefined ? {} : { line }) };
         }
@@ -1309,15 +1565,35 @@ class Parser {
         return { descriptor, operator, target: target.word, line: this.lexer.lineAt(Math.max(target.offset, target.end - 1)), ...((operator === "<&" || operator === ">&") && this.lexer.source[target.end - 1] === "-" ? { move: true } : {}), ...(target.document ? { document: target.document } : {}) };
     }
 }
-export function parseShell(source, depth = 0, options = {}) {
-    const budget = new ParseBudget(options.maxParseUnits);
+export function parseCompoundArrayValue(source, byteLocale, byteSource, syntax = defaultSyntax, budget = new ParseBudget()) {
+    const lexer = new Lexer(budget, source, 0, [], 0, byteLocale, undefined, false, undefined, 0, false, undefined, byteSource, syntax);
+    if (lexer.next().value !== "(")
+        throw new ShellSyntaxError("Expected indexed-array compound value", 0);
+    const entries = [];
+    for (let token = lexer.next(); token.kind !== "end" && token.value !== ")"; token = lexer.next()) {
+        if (token.value === "\n")
+            continue;
+        if (token.kind !== "word")
+            throw new ShellSyntaxError("Unsupported indexed-array compound value", token.offset);
+        const entry = compoundEntry(token.word, budget);
+        if (entry.index) {
+            budget.admit();
+            compoundEntryWords.set(entry, token.word);
+        }
+        entries.push(entry);
+    }
+    return entries;
+}
+export function parseShell(source, depth = 0, options = {}, syntax) {
+    const budget = new ParseBudget("maxParseUnits" in options ? options.maxParseUnits : undefined);
+    const captured = captureShellSyntax(syntax === undefined ? ("maxParseUnits" in options ? undefined : options) : syntax);
     const warnings = [];
-    const script = parseSource(source, depth, warnings, 0, false, budget);
+    const script = parseSource(source, depth, warnings, 0, false, budget, false, undefined, false, captured);
     budget.admit();
     return { ...script, ...(warnings.length ? { warnings } : {}) };
 }
-export function parseArraySubscript(source, budget, byteLocale = false, depth = 0) {
-    const lexer = new Lexer(budget, source, depth, [], 0, byteLocale);
+export function parseArraySubscript(source, budget, byteLocale = false, depth = 0, byteSource = false, syntax = defaultSyntax) {
+    const lexer = new Lexer(budget, source, depth, [], 0, byteLocale, undefined, false, undefined, 0, false, undefined, byteSource, syntax);
     return lexer.word("\0");
 }
 export function parseBraceWord(source, opaque, budget) {
@@ -1326,31 +1602,39 @@ export function parseBraceWord(source, opaque, budget) {
     lexer.braceReplay = opaque;
     return lexer.word();
 }
-export function* hereDocumentWords(document, line, byteLocale, warnings, budget = new ParseBudget()) {
+export function hereDocumentWords(document, line, byteLocale, warnings, budgetOrSyntax = new ParseBudget(), syntax) {
+    const budget = budgetOrSyntax instanceof ParseBudget ? budgetOrSyntax : new ParseBudget();
+    const captured = captureShellSyntax(syntax === undefined ? (budgetOrSyntax instanceof ParseBudget ? hereDocumentSyntax.get(document) : budgetOrSyntax) : syntax);
     const values = documentValues.get(document);
-    if (document.quoted) {
-        let start = 0;
-        for (const [position, value] of values ?? []) {
-            budget.admit(4);
-            if (start < position)
-                yield { offset: document.offset, parts: [{ kind: "text", value: document.body.slice(start, position), quoted: true }] };
-            yield { offset: document.offset, parts: [{ kind: "text", value: shellValueText(value), byteValue: value, quoted: true }] };
-            start = position + 1;
+    return (function* () {
+        if (document.quoted) {
+            let start = 0;
+            for (const [position, value] of values ?? []) {
+                budget.admit(4);
+                if (start < position)
+                    yield { offset: document.offset, parts: [{ kind: "text", value: document.body.slice(start, position), quoted: true, ...(document.byteSource ? { byteValue: shellValueFromBytes(Buffer.from(document.body.slice(start, position), "latin1")) } : {}) }] };
+                yield { offset: document.offset, parts: [{ kind: "text", value: shellValueText(value), byteValue: value, quoted: true }] };
+                start = position + 1;
+            }
+            budget.admit(2);
+            yield { offset: document.offset, parts: [{ kind: "text", value: document.body.slice(start), quoted: true, ...(document.byteSource ? { byteValue: shellValueFromBytes(Buffer.from(document.body.slice(start), "latin1")) } : {}) }] };
         }
-        budget.admit(2);
-        yield { offset: document.offset, parts: [{ kind: "text", value: document.body.slice(start), quoted: true }] };
-    }
-    else {
-        budget.admit();
-        yield* new Lexer(budget, document.body, document.depth, warnings, line - 1, byteLocale, line, false, undefined, 0, false, values).documentWords();
-    }
+        else {
+            budget.admit();
+            yield* new Lexer(budget, document.body, document.depth, warnings, line - 1, byteLocale, line, false, undefined, 0, false, values, document.byteSource, captured).documentWords();
+        }
+    })();
 }
-export function parseShellUnit(source, position = 0, byteLocale = false, budget = new ParseBudget(), lineIndex = new SourceLineIndex(source, budget), sourceValues) {
+export function parseShellUnit(source, position = 0, byteLocale = false, budgetOrByteSource = new ParseBudget(), lineIndexOrSyntax, sourceValues, byteSource = false, syntax) {
+    const budget = budgetOrByteSource instanceof ParseBudget ? budgetOrByteSource : new ParseBudget();
+    const lineIndex = lineIndexOrSyntax instanceof SourceLineIndex ? lineIndexOrSyntax : new SourceLineIndex(source, budget);
+    const captured = captureShellSyntax(syntax === undefined ? (lineIndexOrSyntax instanceof SourceLineIndex ? undefined : lineIndexOrSyntax) : syntax);
+    const raw = typeof budgetOrByteSource === "boolean" ? budgetOrByteSource : byteSource;
     const warnings = [];
     budget.admit();
     if (lineIndex.source !== source || lineIndex.budget !== budget)
         throw new TypeError("Source line index belongs to a different source or parse budget");
-    const parser = new Parser(budget, source, 0, warnings, 0, position, byteLocale, false, lineIndex, 0, false, sourceValues);
+    const parser = new Parser(budget, source, 0, warnings, 0, position, byteLocale, false, lineIndex, 0, false, sourceValues, raw, captured);
     const script = parser.script(new Set(), true);
     const next = parser.current.end;
     const nul = source.indexOf("\0", position);
@@ -1359,13 +1643,16 @@ export function parseShellUnit(source, position = 0, byteLocale = false, budget
     budget.admit(2);
     return { script: { ...script, ...(warnings.length ? { warnings } : {}) }, next };
 }
-export function parseShellInputUnit(source, byteLocale = false, budget = new ParseBudget(), lineIndex = new SourceLineIndex(source, budget)) {
+export function parseShellInputUnit(source, byteLocale = false, budgetOrSyntax = new ParseBudget(), suppliedLineIndex, syntax) {
+    const budget = budgetOrSyntax instanceof ParseBudget ? budgetOrSyntax : new ParseBudget();
+    const lineIndex = suppliedLineIndex ?? new SourceLineIndex(source, budget);
+    const captured = captureShellSyntax(syntax === undefined ? (budgetOrSyntax instanceof ParseBudget ? undefined : budgetOrSyntax) : syntax);
     const warnings = [];
     try {
         budget.admit();
         if (lineIndex.source !== source || lineIndex.budget !== budget)
             throw new TypeError("Source line index belongs to a different source or parse budget");
-        const parser = new Parser(budget, source, 0, warnings, 0, 0, byteLocale, true, lineIndex);
+        const parser = new Parser(budget, source, 0, warnings, 0, 0, byteLocale, true, lineIndex, 0, false, undefined, false, captured);
         const script = parser.script(new Set(), true);
         budget.admit(2);
         return { script: { ...script, ...(warnings.length ? { warnings } : {}) }, next: parser.current.end };
@@ -1378,10 +1665,10 @@ export function parseShellInputUnit(source, byteLocale = false, budget = new Par
         throw error;
     }
 }
-function parseSource(source, depth, warnings, lineOffset, byteLocale, budget, ordinaryBacktick = false, sourceValues) {
+function parseSource(source, depth, warnings, lineOffset, byteLocale, budget, ordinaryBacktick = false, sourceValues, byteSource = false, syntax = defaultSyntax) {
     budget.admit();
     const warningCount = warnings.length;
-    const parser = new Parser(budget, source, depth, warnings, lineOffset, undefined, byteLocale, false, undefined, 0, ordinaryBacktick, sourceValues);
+    const parser = new Parser(budget, source, depth, warnings, lineOffset, undefined, byteLocale, false, undefined, 0, ordinaryBacktick, sourceValues, byteSource, syntax);
     try {
         const script = parser.script(new Set(), false, ordinaryBacktick);
         if (parser.current.kind !== "end")