tarsec 0.5.1 → 0.5.3

package/dist/parsers/bash/commands.js

@@ -1,197 +0,0 @@
-/** Commands: redirects, assignments, simple commands, compound commands,
- * and function definitions. */
-import { lazy, many, many1, many1WithJoin, map, not, optional, or, peek, seq, } from "../../combinators.js";
-import { char, oneOf, str } from "../../parsers.js";
-import { trace } from "../../trace.js";
-import { failure, success } from "../../types.js";
-import { bashLexemes, groupClose, groupOpen, linebreak, newlineToken, wordBoundary, } from "./lexemes.js";
-import { list0 as list0Import, list1 as list1Import, list1WithEnd as list1WithEndImport, } from "./lists.js";
-import { commandWord as commandWordImport, identifierRun as identifierRunImport, parenBody as parenBodyImport, wordParser as wordParserImport, } from "./words.js";
-const L = bashLexemes;
-// The words/lists/commands modules form an import cycle. Deferring every
-// cross-module reference to parse time (via lazy) keeps the cycle safe
-// regardless of module evaluation order or transform.
-const list0 = lazy(() => list0Import);
-const list1 = lazy(() => list1Import);
-const commandWord = lazy(() => commandWordImport);
-const identifierRun = lazy(() => identifierRunImport);
-const parenBody = lazy(() => parenBodyImport);
-const wordParser = lazy(() => wordParserImport);
-const list1WithEnd = lazy(() => list1WithEndImport);
-// ---------------------------------------------------------------------------
-// Redirects and assignments
-// ---------------------------------------------------------------------------
-// Longest first, so ">>" wins over ">". The bare "<" refuses a following
-// "<" so heredocs (unsupported) stay unparsed rather than half-parsed.
-const redirectOp = or(str("&>>"), str("&>"), str(">>"), str(">|"), str(">&"), str("<<<"), str("<&"), str("<>"), str(">"), seq([str("<"), not(char("<"))], (results) => results[0]));
-const fileDescriptor = many1WithJoin(oneOf("0123456789"));
-/** `> file`, `2>&1`, `<<< "$str"`, ... The file descriptor must be
- * attached to the operator (`2>` redirects fd 2; `2 >` is an argument). */
-export const redirectParser = trace("bash:redirect", seq([optional(fileDescriptor), L.lexeme(redirectOp), wordParser], (results) => ({
-    tag: "redirect",
-    fd: results[0] === null ? null : parseInt(results[0], 10),
-    op: results[1],
-    target: results[2],
-})));
-/** `name=value`, `name=`, or `name="$x"y` — value is a full word. */
-export const assignmentParser = L.lexeme(trace("bash:assignment", seq([identifierRun, str("="), optional(wordParser)], (results) => ({
-    tag: "assignment",
-    name: results[0],
-    value: results[2],
-}))));
-// ---------------------------------------------------------------------------
-// Simple commands
-// ---------------------------------------------------------------------------
-const prefixItem = or(assignmentParser, redirectParser);
-function buildSimpleCommand(prefix, first, rest) {
-    const assignments = prefix.filter((item) => item.tag === "assignment");
-    const redirects = [
-        ...prefix.filter((item) => item.tag === "redirect"),
-        ...rest.filter((item) => item.tag === "redirect"),
-    ];
-    const words = [
-        ...(first === null ? [] : [first]),
-        ...rest.filter((item) => item.tag === "word"),
-    ];
-    return { tag: "simpleCommand", assignments, words, redirects };
-}
-// "At least one of prefix/word" expressed as the two valid shapes.
-const simpleCommandParser = trace("bash:simpleCommand", or(seq([many(prefixItem), commandWord, many(or(redirectParser, wordParser))], (results) => buildSimpleCommand(results[0], results[1], results[2])), seq([many1(prefixItem)], (results) => buildSimpleCommand(results[0], null, []))));
-// ---------------------------------------------------------------------------
-// Compound commands
-// ---------------------------------------------------------------------------
-const elifClause = seq([L.keyword("elif"), list1, L.keyword("then"), list1], (results) => ({ cond: results[1], thenBody: results[3] }));
-const elseClause = seq([L.keyword("else"), list1], (results) => results[1]);
-const ifParser = seq([
-    L.keyword("if"), list1,
-    L.keyword("then"), list1,
-    many(elifClause),
-    optional(elseClause),
-    L.keyword("fi"),
-], (results) => ({
-    tag: "if",
-    cond: results[1],
-    thenBody: results[3],
-    elifs: results[4],
-    elseBody: results[5],
-    redirects: [],
-}));
-const loopParser = seq([
-    or(L.keyword("while"), L.keyword("until")), list1,
-    L.keyword("do"), list1, L.keyword("done"),
-], (results) => ({
-    tag: "loop",
-    kind: results[0],
-    cond: results[1],
-    body: results[3],
-    redirects: [],
-}));
-const forParser = seq([
-    L.keyword("for"), L.identifier,
-    optional(seq([L.keyword("in"), many(wordParser)], (results) => results[1])),
-    optional(or(L.operator(";"), newlineToken)),
-    linebreak,
-    L.keyword("do"), list1, L.keyword("done"),
-], (results) => ({
-    tag: "for",
-    variable: results[1],
-    words: results[2],
-    body: results[6],
-    redirects: [],
-}));
-// Patterns via explicit seq/many: sepBy1 silently swallows a trailing
-// separator when the next parse fails, which would hide a real error.
-const casePatterns = seq([
-    wordParser,
-    many(seq([L.operator("|"), wordParser], (results) => results[1])),
-], (results) => [results[0], ...results[1]]);
-// Every item needs `;;` (or `;&` / `;;&`) unless `esac` follows directly.
-const caseTerminator = or(seq([or(L.operator(";;&"), L.operator(";;"), L.operator(";&")), linebreak], (results) => results[0]), map(peek(L.keyword("esac")), () => null));
-// Without a leading `(`, a bare `esac` cannot start a pattern — it ends
-// the case statement (bash rejects `case x in esac) ...`).
-const bareEsac = seq([str("esac"), wordBoundary], () => "esac");
-const caseItemStart = or(seq([L.symbol("("), casePatterns], (results) => results[1]), seq([not(bareEsac), casePatterns], (results) => results[1]));
-const caseItemParser = seq([caseItemStart, L.symbol(")"), list0, caseTerminator], (results) => ({
-    patterns: results[0],
-    body: results[2],
-    terminator: results[3],
-}));
-const caseParser = seq([
-    L.keyword("case"), wordParser, L.keyword("in"), linebreak,
-    many(caseItemParser),
-    L.keyword("esac"),
-], (results) => ({
-    tag: "case",
-    subject: results[1],
-    items: results[4],
-    redirects: [],
-}));
-const arithmeticCommand = L.lexeme(seq([str("(("), parenBody, str("))")], (results) => ({
-    tag: "arithmeticCommand",
-    expression: results[1],
-    redirects: [],
-})));
-const subshellParser = seq([L.symbol("("), list1, L.symbol(")")], (results) => ({
-    tag: "subshell",
-    body: results[1],
-    redirects: [],
-}));
-/** Can `}` directly follow this command, as it can in bash? True for a
- * compound command with no trailing redirects (`{ { echo a; } }`), and
- * for a function definition whose body qualifies. A redirect re-enters
- * word context (`{ { cat; } > log }` is rejected by bash), and `(( ))`
- * does not qualify. */
-function closesGroup(command) {
-    if (command.tag === "functionDef")
-        return closesGroup(command.body);
-    const isCompound = command.tag === "if" ||
-        command.tag === "loop" ||
-        command.tag === "for" ||
-        command.tag === "case" ||
-        command.tag === "subshell" ||
-        command.tag === "group";
-    return isCompound && command.redirects.length === 0;
-}
-function endsAtCommandPosition({ list, endedWithSeparator }) {
-    if (endedWithSeparator)
-        return true;
-    const lastItem = list.items[list.items.length - 1];
-    const andOr = lastItem.command;
-    const lastPipeline = andOr.rest.length > 0 ? andOr.rest[andOr.rest.length - 1].pipeline : andOr.first;
-    return closesGroup(lastPipeline.commands[lastPipeline.commands.length - 1]);
-}
-// `}` is a reserved word, recognized only at command position: the group
-// body must end with a separator or a bare compound command. Without this
-// check, `{ echo a }` would fail OPEN (bash treats that `}` as an
-// argument to echo and rejects the unterminated group).
-const groupParser = (input) => {
-    const result = seq([groupOpen, list1WithEnd, groupClose], (results) => results[1])(input);
-    if (!result.success)
-        return result;
-    if (!endsAtCommandPosition(result.result)) {
-        return failure("expected ; & or newline before }", input);
-    }
-    return success({ tag: "group", body: result.result.list, redirects: [] }, result.rest);
-};
-const compoundParser = or(ifParser, loopParser, forParser, caseParser, arithmeticCommand, subshellParser, groupParser);
-const compoundWithRedirects = seq([compoundParser, many(redirectParser)], (results) => (Object.assign(Object.assign({}, results[0]), { redirects: results[1] })));
-const functionParens = seq([L.symbol("("), L.symbol(")")], () => "()");
-// "Needs `function` or `()`" expressed as the two valid shapes. The body
-// must be a compound command (bash rejects `f() echo hi` and nested
-// definitions like `f() g() { :; }`); trailing redirects are allowed.
-const functionDefParser = or(seq([L.keyword("function"), L.identifier, optional(functionParens), linebreak, compoundWithRedirects], (results) => ({
-    tag: "functionDef",
-    name: results[1],
-    body: results[4],
-})), seq([L.identifier, functionParens, linebreak, compoundWithRedirects], (results) => ({
-    tag: "functionDef",
-    name: results[0],
-    body: results[3],
-})));
-const commandParserImpl = trace("bash:command", or(compoundWithRedirects, functionDefParser, simpleCommandParser));
-/** Any single command: simple, compound (with trailing redirects), or a
- * function definition. Declared as a function so the words/lists/commands
- * module cycle is safe under any import order. */
-export function commandParser(input) {
-    return commandParserImpl(input);
-}

package/dist/parsers/bash/lexemes.d.ts

@@ -1,27 +0,0 @@
-import { Parser } from "../../types.js";
-/** Words that are reserved at command position (and rejected as
- * identifiers). Includes constructs this parser deliberately does not
- * support — `select`, `coproc`, `time`, `[[ ]]` — so they fail the parse
- * instead of parsing as ordinary words. */
-export declare const WORD_RESERVED: string[];
-export declare const bashLexemes: import("../../lexeme.js").Lexemes;
-/** Characters that end a word. `{` and `}` are metacharacters here
- * (unlike bash) because brace expansion is unsupported: a brace can only
- * be a group delimiter or quoted. */
-export declare const METACHARACTERS = " \t\n|&;()<>{}";
-/** The next character (unconsumed) would end a word, or input is done. */
-export declare const wordBoundary: Parser<string | null>;
-/** A reserved word as a whole token. Order doesn't matter: each
- * alternative carries its own boundary check, so `do` cannot steal the
- * front of `done`. */
-export declare const reservedToken: Parser<string>;
-/** `{`, `}`, and `!` must be followed by whitespace. This is stricter
- * than bash on purpose: `!(` is extglob syntax (unsupported), not
- * negation. */
-export declare const groupOpen: Parser<string>;
-export declare const groupClose: Parser<string>;
-export declare const bangToken: Parser<string>;
-/** A significant newline, with trailing blanks and comments skipped. */
-export declare const newlineToken: Parser<"\n">;
-/** Zero or more blank (or comment-only) lines. */
-export declare const linebreak: Parser<"\n"[]>;

package/dist/parsers/bash/lexemes.js

@@ -1,44 +0,0 @@
-/** Lexeme layer and shared tokens for the bash grammar. */
-import { many, or, peek, seq } from "../../combinators.js";
-import { makeLexemes } from "../../lexeme.js";
-import { char, eof, oneOf, str } from "../../parsers.js";
-/** Words that are reserved at command position (and rejected as
- * identifiers). Includes constructs this parser deliberately does not
- * support — `select`, `coproc`, `time`, `[[ ]]` — so they fail the parse
- * instead of parsing as ordinary words. */
-export const WORD_RESERVED = [
-    "if", "then", "elif", "else", "fi",
-    "do", "done", "while", "until", "for", "in",
-    "case", "esac", "function",
-    "select", "coproc", "time", "[[", "]]",
-];
-const RESERVED_TOKENS = [...WORD_RESERVED, "{", "}", "!"];
-export const bashLexemes = makeLexemes({
-    // Newlines are command separators, never skippable whitespace.
-    whitespace: " \t",
-    lineComment: "#",
-    lineContinuation: true,
-    operatorChars: "&|;<>",
-    keywords: WORD_RESERVED,
-});
-/** Characters that end a word. `{` and `}` are metacharacters here
- * (unlike bash) because brace expansion is unsupported: a brace can only
- * be a group delimiter or quoted. */
-export const METACHARACTERS = " \t\n|&;()<>{}";
-/** The next character (unconsumed) would end a word, or input is done. */
-export const wordBoundary = or(peek(oneOf(METACHARACTERS)), eof);
-/** A reserved word as a whole token. Order doesn't matter: each
- * alternative carries its own boundary check, so `do` cannot steal the
- * front of `done`. */
-export const reservedToken = or(...RESERVED_TOKENS.map((word) => seq([str(word), wordBoundary], (results) => results[0])));
-const whitespaceOrEnd = or(peek(oneOf(" \t\n")), eof);
-/** `{`, `}`, and `!` must be followed by whitespace. This is stricter
- * than bash on purpose: `!(` is extglob syntax (unsupported), not
- * negation. */
-export const groupOpen = bashLexemes.lexeme(seq([str("{"), whitespaceOrEnd], () => "{"));
-export const groupClose = bashLexemes.lexeme(seq([str("}"), wordBoundary], () => "}"));
-export const bangToken = bashLexemes.lexeme(seq([str("!"), whitespaceOrEnd], () => "!"));
-/** A significant newline, with trailing blanks and comments skipped. */
-export const newlineToken = bashLexemes.lexeme(char("\n"));
-/** Zero or more blank (or comment-only) lines. */
-export const linebreak = many(newlineToken);

package/dist/parsers/bash/lists.d.ts

@@ -1,18 +0,0 @@
-import { ParserResult } from "../../types.js";
-import { List } from "./types.js";
-/** A parsed list plus whether it ended with an explicit separator —
- * group parsing needs this to decide whether `}` is at command position. */
-export type ListWithEnd = {
-    list: List;
-    endedWithSeparator: boolean;
-};
-/** A possibly-empty command list. Empty lists are only legal where bash
- * allows them: the top level, `$()`, and case-item bodies. Declared as a
- * function so the words/lists/commands module cycle is safe under any
- * import order. */
-export declare function list0(input: string): ParserResult<List>;
-/** A command list with at least one command — the body of every compound
- * command, subshell, and group. */
-export declare function list1(input: string): ParserResult<List>;
-/** `list1`, but also reporting whether it ended with a separator. */
-export declare function list1WithEnd(input: string): ParserResult<ListWithEnd>;

package/dist/parsers/bash/lists.js

@@ -1,85 +0,0 @@
-/** Pipelines, `&&`/`||` chains, and command lists.
- *
- * The core fail-closed rule lives here: commands are SEPARATED by `;`,
- * `&`, or newline. A construct that stops early leaves text no separator
- * precedes, which fails the enclosing parse instead of becoming a
- * phantom second command (the way `files=(a b c)` would otherwise parse
- * as an assignment followed by a subshell). */
-import { lazy, many, optional, or, seq } from "../../combinators.js";
-import { trace } from "../../trace.js";
-import { bangToken, bashLexemes, linebreak, newlineToken, } from "./lexemes.js";
-import { commandParser as commandParserImport } from "./commands.js";
-const L = bashLexemes;
-// Deferred to parse time: see the module-cycle note in commands.ts.
-const commandParser = lazy(() => commandParserImport);
-const pipeOperator = seq([or(L.operator("|&"), L.operator("|")), linebreak], (results) => results[0]);
-// Explicit seq/many instead of sepBy1: `echo hi |` must FAIL, not parse
-// as `echo hi` with the `|` silently swallowed.
-const pipelineParser = seq([
-    optional(bangToken),
-    commandParser,
-    many(seq([pipeOperator, commandParser], (results) => results[1])),
-], (results) => ({
-    tag: "pipeline",
-    negated: results[0] !== null,
-    commands: [results[1], ...results[2]],
-}));
-const andOrTail = seq([or(L.operator("&&"), L.operator("||")), linebreak, pipelineParser], (results) => ({
-    op: results[0],
-    pipeline: results[2],
-}));
-const andOrParser = seq([pipelineParser, many(andOrTail)], (results) => ({
-    tag: "andOr",
-    first: results[0],
-    rest: results[1],
-}));
-const itemSeparator = or(seq([L.operator("&"), linebreak], () => ({ background: true })), seq([L.operator(";"), linebreak], () => ({ background: false })), seq([newlineToken, linebreak], () => ({ background: false })));
-const listBody = seq([
-    andOrParser,
-    many(seq([itemSeparator, andOrParser], (results) => ({
-        separator: results[0],
-        command: results[1],
-    }))),
-    optional(itemSeparator),
-], (results) => {
-    const pairs = results[1];
-    const trailing = results[2];
-    const commands = [results[0], ...pairs.map((pair) => pair.command)];
-    // Separator i follows command i and carries its `&` marker.
-    const separators = [
-        ...pairs.map((pair) => pair.separator),
-        trailing,
-    ];
-    const items = commands.map((command, index) => {
-        var _a;
-        return ({
-            tag: "listItem",
-            command,
-            background: ((_a = separators[index]) === null || _a === void 0 ? void 0 : _a.background) === true,
-        });
-    });
-    return {
-        list: { tag: "list", items },
-        endedWithSeparator: trailing !== null,
-    };
-});
-const EMPTY_LIST = { tag: "list", items: [] };
-const list0Impl = trace("bash:list0", seq([L.whitespace, linebreak, optional(listBody)], (results) => { var _a, _b; return (_b = (_a = results[2]) === null || _a === void 0 ? void 0 : _a.list) !== null && _b !== void 0 ? _b : EMPTY_LIST; }));
-const list1Impl = trace("bash:list1", seq([L.whitespace, linebreak, listBody], (results) => results[2].list));
-const list1WithEndImpl = seq([L.whitespace, linebreak, listBody], (results) => results[2]);
-/** A possibly-empty command list. Empty lists are only legal where bash
- * allows them: the top level, `$()`, and case-item bodies. Declared as a
- * function so the words/lists/commands module cycle is safe under any
- * import order. */
-export function list0(input) {
-    return list0Impl(input);
-}
-/** A command list with at least one command — the body of every compound
- * command, subshell, and group. */
-export function list1(input) {
-    return list1Impl(input);
-}
-/** `list1`, but also reporting whether it ended with a separator. */
-export function list1WithEnd(input) {
-    return list1WithEndImpl(input);
-}

package/dist/parsers/bash/words.d.ts

@@ -1,22 +0,0 @@
-import { Parser, ParserResult } from "../../types.js";
-import { BashWord } from "./types.js";
-/** Balanced parens, for `$(( ))` and `(( ))`. Sound because quotes are
- * not delimiters in bash arithmetic. Declared as a function so the
- * words/commands module cycle is safe under any import order. */
-export declare function parenBody(input: string): ParserResult<string>;
-/** A word: quoting and expansions handled, trailing whitespace eaten.
- * Declared as a function so the words/lists/commands module cycle is
- * safe under any import order. */
-export declare function wordParser(input: string): ParserResult<BashWord>;
-/** A word shaped like an assignment (`name=` / `name+=`). At command
- * position this is never a plain command word: `name=` was already taken
- * by the assignment parser, so what reaches here is unsupported syntax
- * (append, arrays) and must fail rather than parse as a command. */
-export declare const assignmentLookalike: Parser<string>;
-/** A word at command position: rejects reserved words standing alone,
- * which is how body lists stop at `fi`/`done`/`esac`. Quoted or extended
- * words (`"fi"`, `fi.txt`) pass, matching bash. */
-export declare function commandWord(input: string): ParserResult<BashWord>;
-/** A run of identifier characters, shared with the assignment parser.
- * Declared as a function for module-cycle safety. */
-export declare function identifierRun(input: string): ParserResult<string>;

package/dist/parsers/bash/words.js

@@ -1,112 +0,0 @@
-/** Words: quoting, escapes, and expansions. A word is one or more
- * adjacent parts; only the whole word is a lexeme, so parts never eat
- * trailing whitespace (`$(pwd) x` must not glue `x` onto the word). */
-import { lazy, many, many1, many1WithJoin, map, not, or, seq, } from "../../combinators.js";
-import { anyChar, char, compileCharPredicate, label, oneOf, str, takeWhile, takeWhile1, } from "../../parsers.js";
-import { trace } from "../../trace.js";
-import { bashLexemes, METACHARACTERS, reservedToken } from "./lexemes.js";
-import { list0 as list0Import } from "./lists.js";
-function literal(text) {
-    return { tag: "literal", text };
-}
-/** Merge adjacent literal parts so ASTs read naturally. */
-function mergeLiterals(parts) {
-    const merged = [];
-    for (const part of parts) {
-        const previous = merged[merged.length - 1];
-        if (part.tag === "literal" && (previous === null || previous === void 0 ? void 0 : previous.tag) === "literal") {
-            merged[merged.length - 1] = literal(previous.text + part.text);
-        }
-        else {
-            merged.push(part);
-        }
-    }
-    return merged;
-}
-const WORD_STOP = METACHARACTERS + "'\"`$\\";
-const isWordStop = compileCharPredicate(WORD_STOP);
-const NOT_SINGLE_QUOTE = (code) => code !== 0x27; // '
-const plainRun = map(takeWhile1((code) => !isWordStop(code), "word characters"), literal);
-// No escapes exist inside single quotes; scanning to the next quote is
-// exactly bash's rule.
-const singleQuoted = label("a single-quoted string", seq([char("'"), takeWhile(NOT_SINGLE_QUOTE), char("'")], (results) => ({ tag: "singleQuoted", text: results[1] })));
-const IDENT_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
-const SPECIAL_VARIABLES = "?!#@*$-0123456789";
-// No lone-`$` fallback: a `$` that starts no supported expansion is a
-// parse error, which is what makes `$'...'` and `$"..."` fail loudly.
-const variablePart = seq([char("$"), or(oneOf(SPECIAL_VARIABLES), many1WithJoin(oneOf(IDENT_CHARS)))], (results) => ({ tag: "variable", name: results[1] }));
-// Balanced braces by recursion instead of a depth counter: a body is a
-// sequence of non-brace runs and nested `{...}` groups.
-const braceBody = map(many(or(takeWhile1((code) => code !== 0x7b && code !== 0x7d, "brace content"), // { }
-seq([char("{"), lazy(() => braceBody), char("}")], (results) => "{" + results[1] + "}"))), (chunks) => chunks.join(""));
-const paramExpansion = seq([str("${"), braceBody, char("}")], (results) => ({
-    tag: "paramExpansion",
-    expression: results[1],
-}));
-const parenBodyImpl = map(many(or(takeWhile1((code) => code !== 0x28 && code !== 0x29, "paren content"), // ( )
-seq([char("("), lazy(() => parenBodyImpl), char(")")], (results) => "(" + results[1] + ")"))), (chunks) => chunks.join(""));
-/** Balanced parens, for `$(( ))` and `(( ))`. Sound because quotes are
- * not delimiters in bash arithmetic. Declared as a function so the
- * words/commands module cycle is safe under any import order. */
-export function parenBody(input) {
-    return parenBodyImpl(input);
-}
-const arithmeticExpansion = seq([str("$(("), parenBody, str("))")], (results) => ({
-    tag: "arithmeticExpansion",
-    expression: results[1],
-}));
-// `char(")")`, not `symbol(")")`: word parts must not eat trailing
-// whitespace. `list0` is deferred to parse time: see the module-cycle
-// note in commands.ts.
-const commandSubstitution = seq([str("$("), lazy(() => list0Import), char(")")], (results) => ({
-    tag: "commandSubstitution",
-    command: results[1],
-}));
-const unquotedEscape = seq([char("\\"), anyChar], 
-// Backslash-newline inside a word disappears (line continuation).
-(results) => literal(results[1] === "\n" ? "" : results[1]));
-const DQ_ESCAPABLE = '"$`\\';
-const doubleQuoteEscape = or(seq([char("\\"), oneOf(DQ_ESCAPABLE)], (results) => literal(results[1])), seq([char("\\"), char("\n")], () => literal("")), 
-// Backslash before any other character stays literal.
-map(char("\\"), () => literal("\\")));
-const isDoubleQuoteStop = compileCharPredicate('"$`\\');
-const doubleQuoteLiteral = map(takeWhile1((code) => !isDoubleQuoteStop(code), "string characters"), literal);
-// No backtick alternative: an unescaped backtick inside double quotes
-// fails the parse (backtick substitution is unsupported; use `$()`).
-const doubleQuoted = seq([
-    char('"'),
-    many(or(arithmeticExpansion, commandSubstitution, paramExpansion, variablePart, doubleQuoteEscape, doubleQuoteLiteral)),
-    char('"'),
-], (results) => ({
-    tag: "doubleQuoted",
-    parts: mergeLiterals(results[1]),
-}));
-const wordPart = or(singleQuoted, doubleQuoted, arithmeticExpansion, commandSubstitution, paramExpansion, variablePart, unquotedEscape, plainRun);
-const wordParserImpl = bashLexemes.lexeme(trace("bash:word", map(many1(wordPart), (parts) => ({
-    tag: "word",
-    parts: mergeLiterals(parts),
-}))));
-/** A word: quoting and expansions handled, trailing whitespace eaten.
- * Declared as a function so the words/lists/commands module cycle is
- * safe under any import order. */
-export function wordParser(input) {
-    return wordParserImpl(input);
-}
-/** A word shaped like an assignment (`name=` / `name+=`). At command
- * position this is never a plain command word: `name=` was already taken
- * by the assignment parser, so what reaches here is unsupported syntax
- * (append, arrays) and must fail rather than parse as a command. */
-export const assignmentLookalike = seq([many1WithJoin(oneOf(IDENT_CHARS)), or(str("+="), str("="))], (results) => results[0]);
-const commandWordImpl = seq([not(reservedToken), not(assignmentLookalike), wordParser], (results) => results[2]);
-/** A word at command position: rejects reserved words standing alone,
- * which is how body lists stop at `fi`/`done`/`esac`. Quoted or extended
- * words (`"fi"`, `fi.txt`) pass, matching bash. */
-export function commandWord(input) {
-    return commandWordImpl(input);
-}
-const identifierRunImpl = many1WithJoin(oneOf(IDENT_CHARS));
-/** A run of identifier characters, shared with the assignment parser.
- * Declared as a function for module-cycle safety. */
-export function identifierRun(input) {
-    return identifierRunImpl(input);
-}