tarsec 0.5.1 → 0.5.2

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

@@ -1,136 +1,85 @@
 /** AST types for the bash parser. See `index.ts` for the supported subset. */
-/** One piece of a word. Adjacent parts concatenate: `e'f'"g"$h` is a single
- * word of four parts. */
-export type WordPart = {
+export type Word = LiteralWord | PathWord | FlagWord | SingleQuotedWord | DoubleQuotedWord | VariableWord | InterpolatedVariableWord;
+export type ScriptName = LiteralWord | PathWord;
+export type LiteralWord = {
     tag: "literal";
     text: string;
-} | {
+};
+export type PathWord = {
+    tag: "path";
+    text: string;
+};
+export type FlagWord = {
+    tag: "flag";
+    flagName: string;
+    flagValue?: string;
+};
+export type SingleQuotedWord = {
     tag: "singleQuoted";
     text: string;
-} | {
+};
+export type DoubleQuotedWord = {
     tag: "doubleQuoted";
-    parts: WordPart[];
-} | {
+    parts: Word[];
+};
+export type VariableWord = {
     tag: "variable";
     name: string;
-} | {
-    tag: "paramExpansion";
-    expression: string;
-} | {
-    tag: "commandSubstitution";
-    command: List;
-} | {
-    tag: "arithmeticExpansion";
-    expression: string;
-};
-export type BashWord = {
-    tag: "word";
-    parts: WordPart[];
 };
+/** A word built from two or more adjacent parts: `$HOME.txt`, `"a"b`,
+ * `"$HOME"/x`. These are ONE word in bash; split into separate words they
+ * become separate arguments and the command means something else.
+ *
+ * Quoted parts belong here as much as variables do — quoting a variable
+ * and appending to it (`"$HOME"/bin`) is idiomatic shell. */
+export type InterpolatedVariableWord = {
+    tag: "interpolatedVariable";
+    parts: (LiteralWord | VariableWord | SingleQuotedWord | DoubleQuotedWord)[];
+};
+export declare function literalWord(text: string): LiteralWord;
 /** `name=value` (or `name=` with a null value) before a command. */
 export type Assignment = {
     tag: "assignment";
     name: string;
-    value: BashWord | null;
+    value: Word | null;
 };
-/** A redirect like `> out.txt`, `2>&1`, or `<<< "$str"`. `fd` is the
- * explicit file descriptor (`2` in `2>`), or null for the default. */
+/** A redirect like `> out.txt`, `>> log`, `2> err.txt` or `< in.txt`.
+ * `fd` is the explicit file descriptor (`2` in `2>`), or undefined for the
+ * default. Only `>`, `>>`, `<` and `&>` are recognized; `2>&1`, heredocs
+ * and here-strings are rejected rather than parsed. */
 export type Redirect = {
     tag: "redirect";
-    fd: number | null;
+    fd?: number;
     op: string;
-    target: BashWord;
+    target: Word;
 };
 export type SimpleCommand = {
     tag: "simpleCommand";
     assignments: Assignment[];
-    words: BashWord[];
-    redirects: Redirect[];
-};
-export type IfCommand = {
-    tag: "if";
-    cond: List;
-    thenBody: List;
-    elifs: {
-        cond: List;
-        thenBody: List;
-    }[];
-    elseBody: List | null;
-    redirects: Redirect[];
-};
-export type LoopCommand = {
-    tag: "loop";
-    kind: "while" | "until";
-    cond: List;
-    body: List;
-    redirects: Redirect[];
-};
-export type ForCommand = {
-    tag: "for";
-    variable: string;
-    /** The `in word...` list, or null for the implicit `in "$@"`. */
-    words: BashWord[] | null;
-    body: List;
+    /** The command name, or null for an assignment-only line (`FOO=bar`).
+     *  Bash requires at least one of a command name or an assignment. */
+    command: ScriptName | null;
+    /** Every word after the command name, in source order. There is no
+     *  `subcommands` field: no syntactic rule separates `git status` from
+     *  `echo status`, so splitting them would put a command's real
+     *  arguments in whichever bucket the preceding word happened to pick. */
+    args: Word[];
     redirects: Redirect[];
 };
-export type CaseItem = {
-    patterns: BashWord[];
-    body: List;
-    /** `;;`, `;&`, `;;&`, or null when the final item ends at `esac`. */
-    terminator: string | null;
-};
-export type CaseCommand = {
-    tag: "case";
-    subject: BashWord;
-    items: CaseItem[];
-    redirects: Redirect[];
-};
-export type Subshell = {
-    tag: "subshell";
-    body: List;
-    redirects: Redirect[];
-};
-export type Group = {
-    tag: "group";
-    body: List;
-    redirects: Redirect[];
-};
-/** `(( expression ))` as a command. The expression is kept as raw text. */
-export type ArithmeticCommand = {
-    tag: "arithmeticCommand";
-    expression: string;
-    redirects: Redirect[];
-};
-export type FunctionDef = {
-    tag: "functionDef";
-    name: string;
-    body: Command;
-};
-export type Command = SimpleCommand | IfCommand | LoopCommand | ForCommand | CaseCommand | Subshell | Group | ArithmeticCommand | FunctionDef;
-/** One or more commands joined by `|` (or `|&`), optionally negated. */
-export type Pipeline = {
-    tag: "pipeline";
-    negated: boolean;
-    commands: Command[];
-};
-/** Pipelines joined by `&&` / `||`, left to right. */
-export type AndOr = {
-    tag: "andOr";
-    first: Pipeline;
-    rest: {
-        op: "&&" | "||";
-        pipeline: Pipeline;
-    }[];
+export type Command = SimpleCommand | And | Or | Parens;
+export type And = {
+    tag: "and";
+    left: Command;
+    right: Command;
 };
-export type ListItem = {
-    tag: "listItem";
-    command: AndOr;
-    /** True when the command was followed by `&`. */
-    background: boolean;
+export type Or = {
+    tag: "or";
+    left: Command;
+    right: Command;
 };
-/** A sequence of commands separated by `;`, `&`, or newlines — the top
- * level of a script, and the body of every compound command. */
-export type List = {
-    tag: "list";
-    items: ListItem[];
+export type Parens = {
+    tag: "parens";
+    command: Command;
 };
+export type BashNode = Command | SimpleCommand | Assignment | Redirect | Word | ScriptName;
+export type BashAST = Command[];

package/dist/parsers/bash/types.js

@@ -1,2 +1,4 @@
 /** AST types for the bash parser. See `index.ts` for the supported subset. */
-export {};
+export function literalWord(text) {
+    return { tag: "literal", text };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tarsec",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "A parser combinator library for TypeScript, inspired by Parsec.",
   "homepage": "https://github.com/egonSchiele/tarsec",
   "scripts": {

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

@@ -1,11 +0,0 @@
-import { Parser, ParserResult } from "../../types.js";
-import { Assignment, Command, Redirect } from "./types.js";
-/** `> file`, `2>&1`, `<<< "$str"`, ... The file descriptor must be
- * attached to the operator (`2>` redirects fd 2; `2 >` is an argument). */
-export declare const redirectParser: Parser<Redirect>;
-/** `name=value`, `name=`, or `name="$x"y` — value is a full word. */
-export declare const assignmentParser: Parser<Assignment>;
-/** 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 declare function commandParser(input: string): ParserResult<Command>;

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>;