@poe-platform/safe-bash 0.1.802 → 0.1.804

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

@@ -80,6 +80,13 @@ export class HereDocumentSyntaxError extends Error {
         this.diagnostic = diagnostic;
     }
 }
+function isSelfDelimitingCompound(command) {
+    if (!command || command.redirects.length > 0)
+        return false;
+    if (command.kind === "function")
+        return isSelfDelimitingCompound(command.body);
+    return command.kind !== "simple" && command.kind !== "arithmetic" && command.kind !== "conditional";
+}
 const scriptSeparators = new WeakMap();
 const functionLayouts = new WeakMap();
 export function functionReprintedLines(script) {
@@ -286,6 +293,7 @@ class Lexer {
     sourceValues;
     byteSource;
     syntax;
+    aliases;
     position = 0;
     operandDepth = 0;
     printedNewlineReduction = 0;
@@ -295,7 +303,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, byteSource = false, syntax = defaultSyntax) {
+    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, aliases) {
         this.budget = budget;
         this.source = source;
         this.depth = depth;
@@ -310,6 +318,7 @@ class Lexer {
         this.sourceValues = sourceValues;
         this.byteSource = byteSource;
         this.syntax = syntax;
+        this.aliases = aliases;
         if (depth > this.budget.maxSyntaxDepth)
             throw new ShellSyntaxError(`Syntax nesting exceeds ${this.budget.maxSyntaxDepth}`, 0);
     }
@@ -594,7 +603,7 @@ class Lexer {
         }
         this.error("Unterminated delimiter expansion syntax");
     }
-    word(terminator, enclosingQuoted = false, literal = false, arithmetic = false, arithmeticExpansion = false) {
+    word(terminator, enclosingQuoted = false, literal = false, arithmetic = false, arithmeticExpansion = false, assignmentSubscriptEnd = -1) {
         this.budget.admit();
         const offset = this.position;
         const reduction = this.printedNewlineReduction;
@@ -693,7 +702,7 @@ class Lexer {
                 else if (terminator.includes(current) && (!arithmetic || current !== ":" || parentheses === 0 && conditionals === 0))
                     break;
             }
-            else if (!this.braceReplay) {
+            else if (!this.braceReplay && this.position > assignmentSubscriptEnd) {
                 if (!enclosingQuoted && !literal && current === "(" && (patternParentheses > 0 || (this.position > offset
                     && "?*+@!".includes(this.source[this.position - 1] ?? " ")
                     && (this.position - 1 === offset || this.source[this.position - 2] !== "\\")
@@ -722,7 +731,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, this.byteSource, this.syntax);
+                    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, this.aliases);
                     script = nested.script(new Set([")"]));
                 }
                 catch (error) {
@@ -747,7 +756,7 @@ class Lexer {
                 parts.push({ kind: "process-substitution", direction, script, line, sourceLine: script.line ?? line, quoted: true });
                 continue;
             }
-            if (current === "$" && this.source[this.position + 1] === "'" && !enclosingQuoted && !literal) {
+            if (current === "$" && this.source[this.position + 1] === "'" && !enclosingQuoted) {
                 plain = false;
                 this.unprintedWords++;
                 const start = this.position;
@@ -779,8 +788,10 @@ class Lexer {
                     text(this.source.slice(this.position + 1, end), true, false, this.position, Math.min(end + 1, this.source.length));
                 this.position = Math.min(end + 1, this.source.length);
             }
-            else if (current === '"') {
+            else if (current === '"' || current === "$" && this.source[this.position + 1] === '"' && !enclosingQuoted) {
                 plain = false;
+                if (current === "$")
+                    this.position++;
                 const quoteLine = this.lineAt(this.position);
                 this.position++;
                 text("", true, true, this.position - 1, this.position);
@@ -853,8 +864,6 @@ class Lexer {
             else if (current === "$" || current === "`") {
                 plain = false;
                 if (literal) {
-                    if (current === "$" && ["'", '"'].includes(this.source[this.position + 1] ?? ""))
-                        this.error("Unsupported shell quoting in here-document delimiter");
                     text(this.literalExpansion(), current === "`");
                 }
                 else
@@ -999,6 +1008,51 @@ class Lexer {
         }
         this.error("Unterminated ANSI-C quote", { quote: "'", line: quoteLine });
     }
+    readExpansionName() {
+        while (this.source.startsWith("\\\n", this.position))
+            this.position += 2;
+        const first = this.source[this.position];
+        if (first && /^[?@*#-]$/u.test(first)) {
+            this.position++;
+            return first;
+        }
+        if (first && /^[0-9]$/u.test(first)) {
+            let name = "";
+            while (this.position < this.source.length) {
+                if (this.source.startsWith("\\\n", this.position)) {
+                    this.position += 2;
+                    continue;
+                }
+                const ch = this.source[this.position];
+                if (!ch || !/^[0-9]$/u.test(ch))
+                    break;
+                name += ch;
+                this.position++;
+            }
+            return name;
+        }
+        if (first && /^[a-zA-Z_]$/u.test(first)) {
+            let name = "";
+            while (this.position < this.source.length) {
+                if (this.source.startsWith("\\\n", this.position)) {
+                    this.position += 2;
+                    continue;
+                }
+                const ch = this.source[this.position];
+                if (!ch || !/^[a-zA-Z_0-9]$/u.test(ch))
+                    break;
+                name += ch;
+                this.position++;
+            }
+            return name;
+        }
+        return undefined;
+    }
+    peekAfterContinuation(offset = this.position) {
+        while (this.source.startsWith("\\\n", offset))
+            offset += 2;
+        return offset;
+    }
     expansion(parts, quoted) {
         this.budget.admit();
         const spellingStart = this.position;
@@ -1012,8 +1066,9 @@ class Lexer {
             this.position++;
             let source = "";
             const sourceValues = this.sourceValues ? new Map() : undefined;
+            const backtickEscapable = quoted && this.documentLine === undefined ? /[$`\\"]/u : /[$`\\]/u;
             while (this.position < this.source.length && this.source[this.position] !== "`") {
-                if (this.source[this.position] === "\\" && /[$`\\]/u.test(this.source[this.position + 1] ?? ""))
+                if (this.source[this.position] === "\\" && backtickEscapable.test(this.source[this.position + 1] ?? ""))
                     this.position++;
                 const opaque = this.sourceValues?.get(this.sourceOffset + this.position);
                 if (opaque !== undefined) {
@@ -1026,7 +1081,7 @@ class Lexer {
                 this.error("Unterminated command substitution");
             this.position++;
             try {
-                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 });
+                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, this.aliases), line, quoted });
             }
             catch (error) {
                 if (this.documentLine === undefined || !(error instanceof ShellSyntaxError) || /nesting|exceeds/u.test(error.reason))
@@ -1041,15 +1096,19 @@ class Lexer {
             return;
         }
         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;
-            const end = arithmeticEnd(this.source, start, false, this.budget.maxSyntaxDepth);
+        while (this.source.startsWith("\\\n", this.position))
+            this.position += 2;
+        const firstParen = this.source[this.position] === "(" ? this.position : -1;
+        const secondParen = firstParen !== -1 ? this.peekAfterContinuation(firstParen + 1) : -1;
+        const arithmeticEndPos = secondParen !== -1 && this.source[secondParen] === "("
+            ? arithmeticEnd(this.source, secondParen + 1, true, this.budget.maxSyntaxDepth) : -1;
+        if (arithmeticEndPos !== -1) {
+            const start = secondParen + 1;
+            const end = arithmeticEndPos;
             const source = this.source.slice(start, end);
             parts.push({ kind: "arithmetic", expression: prepareArithmetic(source, this.budget), source, line, quoted });
-            this.position = end + 2;
+            const afterFirstClose = this.peekAfterContinuation(end + 1);
+            this.position = afterFirstClose + 1;
         }
         else if (this.source[this.position] === "(") {
             const start = this.position + 1;
@@ -1057,7 +1116,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, this.byteSource, this.syntax);
+                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, this.aliases);
                 script = nested.script(new Set([")"]));
             }
             catch (error) {
@@ -1082,28 +1141,34 @@ class Lexer {
             parts.push({ kind: "substitution", form: "dollar-parenthesis", script, line, sourceLine: script.line ?? line, quoted });
         }
         else if (this.source[this.position] === "{") {
-            this.position++;
+            this.position = this.peekAfterContinuation(this.position + 1);
             const parameterStart = this.position - 2;
-            const listing = this.source[this.position] === "!" && /[a-zA-Z_0-9]/u.test(this.source[this.position + 1] ?? "");
+            const afterBang = this.peekAfterContinuation(this.position + 1);
+            const listing = this.source[this.position] === "!" && /[a-zA-Z_0-9]/u.test(this.source[afterBang] ?? "");
             if (listing)
-                this.position++;
-            const length = !listing && this.source[this.position] === "#" && (/[a-zA-Z_0-9]/u.test(this.source[this.position + 1] ?? "")
-                || ["@", "*"].includes(this.source[this.position + 1] ?? "") && this.source[this.position + 2] === "}"
-                || this.syntax.specialParameters.some(parameter => parameter.name === this.source[this.position + 1]));
+                this.position = afterBang;
+            const afterHash = this.peekAfterContinuation(this.position + 1);
+            const length = !listing && this.source[this.position] === "#" && (/[a-zA-Z_0-9]/u.test(this.source[afterHash] ?? "")
+                || ["@", "*"].includes(this.source[afterHash] ?? "") && this.source[this.peekAfterContinuation(afterHash + 1)] === "}"
+                || this.syntax.specialParameters.some(parameter => parameter.name === this.source[afterHash]));
             if (length)
-                this.position++;
+                this.position = afterHash;
             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 (specialParameter)
+                this.position += specialParameter.name.length;
+            const dollarBang = !specialParameter && "$!".includes(this.source[this.position] ?? " ") ? this.source[this.position++] : undefined;
+            const name = specialParameter?.name ?? dollarBang ?? this.readExpansionName();
             if (!name)
                 this.error("Unsupported parameter expansion");
-            this.position += name.length;
+            this.position = this.peekAfterContinuation(this.position);
             let prefixNames;
             let indirect = false;
             if (listing && this.source[this.position] !== "[") {
                 const separator = this.source[this.position];
-                if ((separator === "*" || separator === "@") && this.source[this.position + 1] === "}") {
+                const afterSep = this.peekAfterContinuation(this.position + 1);
+                if ((separator === "*" || separator === "@") && this.source[afterSep] === "}") {
                     prefixNames = separator;
-                    this.position++;
+                    this.position = afterSep;
                 }
                 else
                     indirect = true;
@@ -1118,7 +1183,7 @@ class Lexer {
                 if (this.source[end] !== "]")
                     this.error("Unterminated indexed-array subscript");
                 selector = arraySelector(this.source.slice(start, end), start, this.budget, keyWord);
-                this.position = end + 1;
+                this.position = this.peekAfterContinuation(end + 1);
                 if (listing && selector.kind === "members" && this.source[this.position] !== "}" && this.source[this.position] !== "@")
                     this.error("Unsupported array-key operator");
             }
@@ -1130,15 +1195,38 @@ class Lexer {
             }
             let transform;
             if (this.source[this.position] === "@") {
-                const operation = this.source[this.position + 1];
-                if (length || prefixNames || !["Q", "E", "a", "A", "K", "k", "P", "u", "U", "L"].includes(operation ?? "") || this.source[this.position + 2] !== "}")
+                const opPos = this.peekAfterContinuation(this.position + 1);
+                const operation = this.source[opPos];
+                const closePos = this.peekAfterContinuation(opPos + 1);
+                if (length || prefixNames || !["Q", "E", "a", "A", "K", "k", "P", "u", "U", "L"].includes(operation ?? "") || this.source[closePos] !== "}")
                     this.error("Unsupported parameter transform");
                 transform = operation;
-                this.position += 2;
+                this.position = closePos;
+            }
+            const firstOpChar = this.source[this.position];
+            const secondOpPos = this.peekAfterContinuation(this.position + 1);
+            const secondOpChar = this.source[secondOpPos];
+            const caseOperator = firstOpChar === "^" || firstOpChar === "," ? firstOpChar.repeat(secondOpChar === firstOpChar ? 2 : 1) : undefined;
+            let operator = caseOperator;
+            let operatorEnd = caseOperator ? (caseOperator.length === 2 ? secondOpPos + 1 : this.position + 1) : this.position;
+            if (!operator) {
+                if (firstOpChar === ":" && secondOpChar && "-=+?".includes(secondOpChar)) {
+                    operator = `:${secondOpChar}`;
+                    operatorEnd = secondOpPos + 1;
+                }
+                else if ((firstOpChar === "#" || firstOpChar === "%") && secondOpChar === firstOpChar) {
+                    operator = `${firstOpChar}${secondOpChar}`;
+                    operatorEnd = secondOpPos + 1;
+                }
+                else if (firstOpChar === "/" && secondOpChar && "/#%".includes(secondOpChar)) {
+                    operator = `/${secondOpChar}`;
+                    operatorEnd = secondOpPos + 1;
+                }
+                else if (firstOpChar && "-=+?#%/".includes(firstOpChar)) {
+                    operator = firstOpChar;
+                    operatorEnd = this.position + 1;
+                }
             }
-            const caseCharacter = this.source[this.position];
-            const caseOperator = caseCharacter === "^" || caseCharacter === "," ? caseCharacter.repeat(this.source[this.position + 1] === caseCharacter ? 2 : 1) : undefined;
-            const operator = caseOperator ?? /^(?::[-=+?]|##|%%|\/\/|\/[#%]?|[-=+?#%])/u.exec(this.source.slice(this.position))?.[0];
             let alternate;
             let replacement;
             let substring;
@@ -1150,7 +1238,7 @@ class Lexer {
                     if (operator) {
                         if (length)
                             this.error("Invalid length expansion");
-                        this.position += operator.length;
+                        this.position = operatorEnd;
                         alternate = this.word(operator.startsWith("/") ? "/}" : "}", quoted && !caseOperator && !["#", "##", "%", "%%"].includes(operator) && !operator.startsWith("/"));
                         if (operator.startsWith("/") && this.source[this.position] === "/") {
                             this.position++;
@@ -1160,7 +1248,7 @@ class Lexer {
                     else {
                         if (length || (name !== "@" && name !== "*" && !/^(?:[a-zA-Z_][a-zA-Z_0-9]*|[0-9]+)$/u.test(name)))
                             this.error("Unsupported non-scalar substring expansion");
-                        this.position++;
+                        this.position = secondOpPos;
                         const offset = this.word(":}", true, false, true);
                         let substringLength;
                         if (this.source[this.position] === ":") {
@@ -1175,6 +1263,7 @@ class Lexer {
                     this.operandDepth--;
                 }
             }
+            this.position = this.peekAfterContinuation(this.position);
             if (this.source[this.position] !== "}") {
                 let end = this.position;
                 if (this.ordinaryBacktick && !selector && !operator && !substring && /^[a-zA-Z_]/u.test(name)
@@ -1199,9 +1288,11 @@ class Lexer {
         }
         else {
             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 (specialParameter)
+                this.position += specialParameter.name.length;
+            const dollarBang = !specialParameter && "$!".includes(this.source[this.position] ?? " ") ? this.source[this.position++] : undefined;
+            const name = specialParameter?.name ?? dollarBang ?? (this.source[this.position] && /^[0-9]$/u.test(this.source[this.position]) ? this.source[this.position++] : this.readExpansionName());
             if (name) {
-                this.position += name.length;
                 parts.push({ kind: "variable", name, quoted, line, ...(specialParameter ? { specialParameter } : {}) });
             }
             else
@@ -1215,18 +1306,24 @@ class Lexer {
 }
 class Parser {
     budget;
+    aliases;
     lexer;
+    aliasFrames = [];
+    aliasNextWords = new WeakSet();
+    tokenAliases = new WeakMap();
+    tokenLexers = new WeakMap();
     current;
     lookahead;
     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, byteSource = false, syntax = defaultSyntax) {
+    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, aliases) {
         this.budget = budget;
+        this.aliases = aliases;
         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, byteSource, syntax);
+        this.lexer = new Lexer(budget, source, depth, warnings, lineOffset, byteLocale, undefined, partial, lineIndex, sourceOffset, ordinaryBacktick, sourceValues, byteSource, syntax, aliases);
         this.lexer.position = position ?? 0;
         this.current = this.lexer.next();
     }
@@ -1238,12 +1335,79 @@ class Parser {
     }
     advance() {
         const previous = this.current;
-        this.current = this.lookahead ?? this.lexer.next();
+        this.current = this.lookahead ?? this.nextToken();
+        this.lexer = this.tokenLexers.get(this.current) ?? this.lexer;
         this.lookahead = undefined;
         return previous;
     }
     peek() {
-        return this.lookahead ??= this.lexer.next();
+        if (!this.lookahead) {
+            const lexer = this.lexer;
+            this.lookahead = this.nextToken();
+            this.lexer = lexer;
+        }
+        return this.lookahead;
+    }
+    nextToken() {
+        let token = this.lexer.next();
+        if (!this.aliases?.size)
+            return token;
+        this.tokenLexers.set(token, this.lexer);
+        this.tokenAliases.set(token, this.aliasFrames.map(frame => frame.name));
+        let trailing = false;
+        while (token.kind === "end" && this.aliasFrames.length) {
+            const frame = this.aliasFrames.pop();
+            this.lexer = frame.lexer;
+            trailing ||= frame.trailing;
+            token = frame.next;
+        }
+        if (trailing)
+            this.aliasNextWords.add(token);
+        return token;
+    }
+    expandAlias() {
+        while (this.current.kind === "word") {
+            const name = this.current.word?.plain;
+            if (name === undefined || this.current.word.parts.some(part => part.quoted) || this.tokenAliases.get(this.current)?.includes(name))
+                return;
+            const value = this.aliases?.get(name);
+            if (value === undefined)
+                return;
+            this.budget.admit(value.length + 1);
+            const lexer = this.lexer;
+            const line = lexer.lineAt(this.current.offset);
+            const next = this.lookahead ?? lexer.next();
+            this.tokenLexers.set(next, this.tokenLexers.get(next) ?? lexer);
+            this.lookahead = undefined;
+            this.aliasFrames.push({ lexer, next, name, trailing: value.endsWith(" ") || value.endsWith("\t") });
+            this.lexer = new Lexer(this.budget, value, lexer.depth, lexer.warnings, line - 1, lexer.byteLocale, undefined, false, undefined, 0, false, undefined, lexer.byteSource, lexer.syntax, this.aliases);
+            this.current = this.nextToken();
+        }
+    }
+    assignmentWord(compound = false) {
+        const word = this.current.word;
+        const bracket = word.spelling?.indexOf("[") ?? -1;
+        const prefix = word.spelling?.slice(0, bracket);
+        if (bracket >= 0 && (compound && bracket === 0 || prefix && scalarAssignmentName({ offset: word.offset,
+            parts: [{ kind: "text", quoted: false, value: prefix + "=" }] }) === prefix)) {
+            const scanner = new Lexer(this.budget, this.lexer.source, this.lexer.depth, [], this.lexer.lineOffset, this.lexer.byteLocale, undefined, false, this.lexer.lineIndex, this.lexer.sourceOffset, this.lexer.ordinaryBacktick, this.lexer.sourceValues, this.lexer.byteSource, this.lexer.syntax);
+            scanner.position = word.offset + bracket + 1;
+            scanner.word("]");
+            const end = scanner.position;
+            if (end >= this.current.end && this.lexer.source[end] === "]"
+                && (this.lexer.source[end + 1] === "=" || this.lexer.source.slice(end + 1, end + 3) === "+=")) {
+                // Only assignment positions may keep whitespace inside a subscript.
+                // Ordinary argv words such as `echo a[x y]=z` retain their boundaries.
+                this.lexer.position = word.offset;
+                const parsed = this.lexer.word(undefined, false, false, false, false, end);
+                this.budget.admit();
+                const complete = { ...parsed, spelling: this.lexer.source.slice(word.offset, this.lexer.position) };
+                this.lookahead = undefined;
+                this.current = this.lexer.next();
+                return complete;
+            }
+        }
+        return this.advance().word;
     }
     is(value) { return this.current.value === value; }
     isEnd() { return this.current.kind === "end"; }
@@ -1263,6 +1427,9 @@ class Parser {
         if (captureInputUnits)
             this.completedInput = { lists, count: 0, line };
         while (this.current.kind !== "end" && !stops.has(this.current.value)) {
+            this.expandAlias();
+            if (this.isEnd() || stops.has(this.current.value))
+                break;
             this.budget.admit();
             const pipelines = [this.pipeline()];
             const operators = [];
@@ -1276,17 +1443,17 @@ class Parser {
             separators.push(this.is("\n"));
             if (captureInputUnits && this.is("\n"))
                 this.completedInput.count = lists.length;
-            if (inputUnit && this.is("\n"))
+            if (inputUnit && !this.aliasFrames.length && this.is("\n"))
                 break;
             if (terminator || this.is(";") || this.is("\n")) {
                 this.advance();
                 if (captureInputUnits && this.is("\n"))
                     this.completedInput.count = lists.length;
-                if (inputUnit && this.is("\n"))
+                if (inputUnit && !this.aliasFrames.length && this.is("\n"))
                     break;
                 this.newlines();
             }
-            else if (!this.isEnd() && !this.is(")") && !(stops.has(this.current.value) && [";;", ";&", ";;&"].includes(this.current.value)))
+            else if (!this.isEnd() && !this.is(")") && !(stops.has(this.current.value) && ([";;", ";&", ";;&"].includes(this.current.value) || isSelfDelimitingCompound(pipelines.at(-1)?.commands.at(-1)))))
                 this.error("Expected command separator");
         }
         const printed = printedSimpleLines(lists, separators, this.budget);
@@ -1314,6 +1481,7 @@ class Parser {
         return { commands, negate };
     }
     command() {
+        this.expandAlias();
         if (++this.nesting + this.lexer.depth > this.lexer.budget.maxSyntaxDepth)
             this.error(`Syntax nesting exceeds ${this.lexer.budget.maxSyntaxDepth}`);
         this.budget.admit();
@@ -1331,8 +1499,9 @@ class Parser {
     }
     commandInner() {
         this.budget.admit();
-        const arithmeticCommandEnd = this.is("(") && this.lexer.source.startsWith("((", this.current.offset)
-            ? arithmeticEnd(this.lexer.source, this.current.offset + 2, true, this.lexer.budget.maxSyntaxDepth) : -1;
+        const arithmeticSecondOpen = this.is("(") ? this.lexer.peekAfterContinuation(this.current.offset + 1) : -1;
+        const arithmeticCommandEnd = arithmeticSecondOpen !== -1 && this.lexer.source[arithmeticSecondOpen] === "("
+            ? arithmeticEnd(this.lexer.source, arithmeticSecondOpen + 1, true, this.lexer.budget.maxSyntaxDepth) : -1;
         let command;
         if (this.is("[[")) {
             const start = this.current.end;
@@ -1409,11 +1578,11 @@ class Parser {
             command = { kind: "conditional", expression, source, redirects: [] };
         }
         else if (arithmeticCommandEnd !== -1) {
-            const start = this.current.offset + 2;
+            const start = arithmeticSecondOpen + 1;
             const end = arithmeticCommandEnd;
             const source = this.lexer.source.slice(start, end);
             command = { kind: "arithmetic", expression: prepareArithmetic(source, this.budget), source, redirects: [] };
-            this.lexer.position = end + 2;
+            this.lexer.position = this.lexer.peekAfterContinuation(end + 1) + 1;
             this.lookahead = undefined;
             this.current = this.lexer.next();
         }
@@ -1493,24 +1662,54 @@ class Parser {
             this.expect("done", true);
             command = { kind, condition, body, redirects: [] };
         }
-        else if (this.is("for") && this.peek().value === "(" && this.lexer.source.startsWith("((", this.peek().offset)) {
+        else if (this.is("for") && this.peek().value === "(" && this.lexer.source[this.lexer.peekAfterContinuation(this.peek().offset + 1)] === "(") {
             this.advance();
-            const start = this.current.offset + 2;
+            const start = this.lexer.peekAfterContinuation(this.current.offset + 1) + 1;
             let partStart = start;
             let depth = 0;
             let end = start;
+            let quote = "";
+            let ansiQuote = false;
+            const quotedSubstitutions = [];
             this.budget.admit(4);
             const sources = [];
             for (; end < this.lexer.source.length; end++) {
                 this.budget.admit();
                 const character = this.lexer.source[end];
+                if (character === "\\" && (quote !== "'" || ansiQuote)) {
+                    end++;
+                    continue;
+                }
+                if (quote === '"' && character === "$" && this.lexer.source[end + 1] === "(") {
+                    if (quotedSubstitutions.length >= 64)
+                        this.error("Syntax nesting exceeds 64");
+                    quotedSubstitutions.push(depth);
+                    depth++;
+                    end++;
+                    quote = "";
+                    continue;
+                }
+                if (quote) {
+                    if (character === quote)
+                        quote = "";
+                    continue;
+                }
+                if (character === "'" || character === '"' || character === "`") {
+                    quote = character;
+                    ansiQuote = character === "'" && this.lexer.source[end - 1] === "$";
+                    continue;
+                }
                 if (character === "(")
                     depth++;
                 else if (character === ")") {
-                    if (!depth && this.lexer.source[end + 1] === ")")
+                    if (!depth && this.lexer.source[this.lexer.peekAfterContinuation(end + 1)] === ")")
                         break;
                     if (--depth < 0)
                         this.error("Unterminated arithmetic for", true);
+                    if (quotedSubstitutions.at(-1) === depth) {
+                        quotedSubstitutions.pop();
+                        quote = '"';
+                    }
                 }
                 else if (character === ";" && !depth) {
                     if (sources.length === 2)
@@ -1519,13 +1718,13 @@ class Parser {
                     partStart = end + 1;
                 }
             }
-            if (end === this.lexer.source.length)
+            if (quote || end === this.lexer.source.length)
                 this.error("Unterminated arithmetic for", true);
             if (sources.length !== 2)
                 this.error("Arithmetic for requires three expressions");
             sources.push(this.lexer.source.slice(partStart, end));
             const expressions = sources.map(source => source.trim() ? prepareArithmetic(source, this.budget) : undefined);
-            this.lexer.position = end + 2;
+            this.lexer.position = this.lexer.peekAfterContinuation(end + 1) + 1;
             this.lookahead = undefined;
             this.current = this.lexer.next();
             if (this.is(";"))
@@ -1597,6 +1796,10 @@ class Parser {
             };
             let line;
             while (true) {
+                if (this.aliasNextWords.has(this.current) || words.every(previous => getArrayAssignment(previous) || scalarAssignmentName(previous))) {
+                    this.aliasNextWords.delete(this.current);
+                    this.expandAlias();
+                }
                 const wordLine = this.lexer.lineAt(Math.max(this.current.offset, this.current.end - 1));
                 const redirect = this.redirect();
                 if (redirect) {
@@ -1605,14 +1808,15 @@ class Parser {
                 }
                 else if (this.current.kind === "word") {
                     line ??= wordLine;
-                    let word = this.advance().word;
+                    let word = words.every(previous => getArrayAssignment(previous) || scalarAssignmentName(previous)) || indexedDeclaration()
+                        ? this.assignmentWord() : this.advance().word;
                     const head = compoundHead(word, this.budget);
                     if (head && this.is("(")) {
                         this.advance();
                         const entries = [];
                         this.newlines();
                         while (this.current.kind === "word") {
-                            const original = this.advance().word;
+                            const original = this.assignmentWord(true);
                             const entry = compoundEntry(original, 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; });
                             if (entry.index) {
                                 this.budget.admit();
@@ -1740,7 +1944,7 @@ export function hereDocumentWords(document, line, byteLocale, warnings, budgetOr
         }
     })();
 }
-export function parseShellUnit(source, position = 0, byteLocale = false, budgetOrByteSource = new ParseBudget(), lineIndexOrSyntax, sourceValues, byteSource = false, syntax) {
+export function parseShellUnit(source, position = 0, byteLocale = false, budgetOrByteSource = new ParseBudget(), lineIndexOrSyntax, sourceValues, byteSource = false, syntax, aliases) {
     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);
@@ -1749,7 +1953,7 @@ export function parseShellUnit(source, position = 0, byteLocale = false, budgetO
     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, raw, captured);
+    const parser = new Parser(budget, source, 0, warnings, 0, position, byteLocale, false, lineIndex, 0, false, sourceValues, raw, captured, aliases);
     const script = parser.script(new Set(), true);
     const next = parser.current.end;
     const nul = source.indexOf("\0", position);
@@ -1758,7 +1962,7 @@ export function parseShellUnit(source, position = 0, byteLocale = false, budgetO
     budget.admit(2);
     return { script: { ...script, ...(warnings.length ? { warnings } : {}) }, next };
 }
-export function parseShellInputUnit(source, byteLocale = false, budgetOrSyntax = new ParseBudget(), suppliedLineIndex, syntax) {
+export function parseShellInputUnit(source, byteLocale = false, budgetOrSyntax = new ParseBudget(), suppliedLineIndex, syntax, aliases) {
     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);
@@ -1767,7 +1971,7 @@ export function parseShellInputUnit(source, byteLocale = false, budgetOrSyntax =
         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, 0, false, undefined, false, captured);
+        const parser = new Parser(budget, source, 0, warnings, 0, 0, byteLocale, true, lineIndex, 0, false, undefined, false, captured, aliases);
         const script = parser.script(new Set(), true);
         budget.admit(2);
         return { script: { ...script, ...(warnings.length ? { warnings } : {}) }, next: parser.current.end };
@@ -1780,10 +1984,10 @@ export function parseShellInputUnit(source, byteLocale = false, budgetOrSyntax =
         throw error;
     }
 }
-function parseSource(source, depth, warnings, lineOffset, byteLocale, budget, ordinaryBacktick = false, sourceValues, byteSource = false, syntax = defaultSyntax) {
+function parseSource(source, depth, warnings, lineOffset, byteLocale, budget, ordinaryBacktick = false, sourceValues, byteSource = false, syntax = defaultSyntax, aliases) {
     budget.admit();
     const warningCount = warnings.length;
-    const parser = new Parser(budget, source, depth, warnings, lineOffset, undefined, byteLocale, false, undefined, 0, ordinaryBacktick, sourceValues, byteSource, syntax);
+    const parser = new Parser(budget, source, depth, warnings, lineOffset, undefined, byteLocale, false, undefined, 0, ordinaryBacktick, sourceValues, byteSource, syntax, aliases);
     try {
         const script = parser.script(new Set(), false, ordinaryBacktick);
         if (parser.current.kind !== "end")