tarsec 0.5.1 → 0.5.3

package/dist/parsers/bash/parsers.js

@@ -0,0 +1,306 @@
+import { failure, success } from "../../types.js";
+import { literalWord } from "./types.js";
+import { buildExpressionParser, capture, char, digit, eof, label, lazy, letter, many, many1, many1WithJoin, manyWithJoin, map, noneOf, num, oneOf, optional, or, peek, sepBy1, seqC, seqR, set, str, trace } from "../../index.js";
+export const RESERVED_WORDS = [
+    "if", "then", "elif", "else", "fi",
+    "do", "done", "while", "until", "for", "in",
+    "case", "esac", "function",
+    "select", "coproc", "time", "[[", "]]",
+];
+function result(parser) {
+    return capture(parser, "result");
+}
+function getResult(parser) {
+    return (input) => {
+        const result = parser(input);
+        if (result.success) {
+            return success(result.result.result, result.rest);
+        }
+        else {
+            return result;
+        }
+    };
+}
+const LETTERS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+const DIGITS = "0123456789";
+/** Characters allowed inside a VARIABLE name. Deliberately narrower than
+ * `wordChars`: a dot or hyphen ends the name, so `$HOME.txt` is `$HOME`
+ * followed by the text ".txt", as in bash. */
+export const varNameChars = label("a variable name character", oneOf(LETTERS + DIGITS + "_"));
+/** Characters allowed in a flag name or a flag value. Wider than
+ * `varNameChars` because filenames routinely contain dots and hyphens
+ * (`my-file.txt`).
+ *
+ * Deliberately excludes `=`, unlike `bareWordChars`: `--format=oneline`
+ * splits into a name and a value on that `=`, so a flag name that could
+ * swallow it would take the whole thing as the name. */
+export const wordChars = label("a word character", oneOf(LETTERS + DIGITS + "_-./"));
+/** Characters allowed in a bare word — a command name, a filename, an
+ * argument. Includes `=` because an assignment-shaped ARGUMENT is an
+ * ordinary word: `env FOO=bar` passes "FOO=bar" to env in one piece.
+ * (A leading assignment is still an assignment: those are parsed before
+ * the command name.) */
+export const bareWordChars = label("a word character", oneOf(LETTERS + DIGITS + "_-.=:+"));
+/** A bare word may not START with `-`: that is a flag. Without this rule
+ * `subcommands` (bare literals, parsed before `args`) swallows a leading
+ * flag as a literal and `FlagWord` is unreachable for `ls -la`. A hyphen
+ * inside a word (`my-file`) is still fine. */
+export const bareWordStartChars = label("a word character", oneOf(LETTERS + DIGITS + "_.=:+"));
+/** Characters that end a bare word: whitespace and the operators that
+ * separate commands. */
+const WORD_END_CHARS = " \t\n\r&|;()<>";
+/**
+ * Whitespace WITHIN a command: spaces and tabs only.
+ *
+ * Deliberately not tarsec's `spaces`, which includes `\n`. A newline is a
+ * command SEPARATOR, and eating it as whitespace merges commands —
+ * `ls\nrm -rf /tmp/x` becomes a single `ls` with arguments, so anything
+ * that inspects the command name sees `ls` while bash runs the `rm`.
+ */
+const blanks = manyWithJoin(oneOf(" \t"));
+/**
+ * Require that a word ran all the way to a boundary.
+ *
+ * Without this a word parser happily matches the FRONT of a longer token
+ * — `src` out of `src/main.ts`, `FOO` out of `FOO=bar` — and the leftover
+ * (`/main.ts`) matches nothing, so the whole command fails to parse with
+ * no indication of why. Stopping mid-token is never right: whatever
+ * follows is part of the same word.
+ */
+function wholeWord(parser) {
+    // The boundary is REQUIRED, not optional: `optional(peek(...))` succeeds
+    // whether or not a boundary follows, which makes the whole check a no-op
+    // and lets `src` match out of `src/main.ts` again. `eof` covers the word
+    // that ends the input, which is the only reason it looked optional.
+    return getResult(seqC(result(parser), or(peek(oneOf(WORD_END_CHARS)), eof)));
+}
+/** An identifier: `[A-Za-z_][A-Za-z0-9_]*`. `manyWithJoin`, not `many1`,
+ * so a one-character name (`x=1`, `$A`) is valid. */
+const identifierParser = map(seqR(or(letter, char("_")), manyWithJoin(varNameChars)), (result) => result.join(""));
+/** The name in `$name` / `${name}`. A lone digit is a positional
+ * parameter (`$1`); unbraced, `$12` is `$1` followed by "2". */
+export const varNameParser = trace("varNameParser", or(identifierParser, digit));
+/** The target of an assignment. Unlike `varNameParser` this refuses a
+ * digit: bash runs `1x=1` as a command literally named "1x=1", so
+ * recording it as an assignment would misreport what runs. */
+export const assignmentNameParser = trace("assignmentNameParser", identifierParser);
+/** Reserved words are refused everywhere, not only at command position:
+ * this is a small subset of bash, and refusing to parse something valid is
+ * cheaper than mis-parsing it. */
+function rejectReservedWord(result, input) {
+    if (result.success && RESERVED_WORDS.includes(result.result.text)) {
+        return failure(`Reserved word "${result.result.text}" cannot be used.`, input);
+    }
+    return result;
+}
+export const literalWordParser = wholeWord((input) => {
+    const result = trace("literalWordParser", seqC(set("tag", "literal"), capture(map(seqR(bareWordStartChars, manyWithJoin(bareWordChars)), (r) => r.join("")), "text")))(input);
+    return rejectReservedWord(result, input);
+});
+// Slashes are scanned as part of the run rather than used as separators,
+// so a LEADING slash is just another character: `sepBy1` needed a segment
+// before the first separator, which made every absolute path unparseable.
+// A bare "/" and a trailing "/" are both real paths (`ls /`, `ls src/`).
+export const pathWordParser = wholeWord((input) => {
+    const result = trace("pathWordParser", seqC(set("tag", "path"), capture(many1WithJoin(or(bareWordChars, char("/"))), "text")))(input);
+    if (result.success) {
+        const text = result.result.text;
+        if (!text.includes("/")) {
+            return failure(`Path must contain at least one "/".`, input);
+        }
+    }
+    return result;
+});
+export const flagNameParser = trace("flagNameParser", map(seqR(char("-"), optional(char("-")), many1WithJoin(wordChars)), (result) => result.join("")));
+export const flagWordNameOnlyParser = trace("flagWordNameOnlyParser", seqC(set("tag", "flag"), capture(flagNameParser, "flagName")));
+export const flagWordNameAndValueParser = trace("flagWordNameAndValueParser", seqC(set("tag", "flag"), capture(flagNameParser, "flagName"), char("="), capture(many1WithJoin(wordChars), "flagValue")));
+export const flagWordParser = trace("flagWordParser", wholeWord(or(flagWordNameAndValueParser, flagWordNameOnlyParser)));
+export const singleQuotedWordParser = trace("singleQuotedWordParser", seqC(set("tag", "singleQuoted"), char("'"), capture(manyWithJoin(noneOf("'")), "text"), char("'")));
+// A run of ordinary text inside double quotes. Stops at `$` so an
+// expansion is not swallowed as text, and at `\` so an escape is not.
+const doubleQuotedLiteralParser = trace("doubleQuotedLiteralParser", map(many1WithJoin(noneOf('"$\\')), literalWord));
+/** The characters a backslash escapes inside double quotes. Before
+ * anything else the backslash is ordinary text: bash prints `"a\zb"` as
+ * `a\zb`, but `"a\"b"` as `a"b`. */
+const DOUBLE_QUOTE_ESCAPABLE = '"$`\\';
+const doubleQuotedEscapeParser = trace("doubleQuotedEscapeParser", or(map(seqR(char("\\"), oneOf(DOUBLE_QUOTE_ESCAPABLE)), (results) => literalWord(results[1])), map(char("\\"), () => literalWord("\\"))));
+// No alternative can match empty, so `many` below always terminates.
+const doubleQuotedPartParser = trace("doubleQuotedPartParser", or(lazy(() => variableWordParser), doubleQuotedEscapeParser, doubleQuotedLiteralParser));
+/** Merge adjacent literal parts. An escape splits the text run in three
+ * (`a`, `"`, `b`), which is an artifact of how it was parsed rather than
+ * anything a consumer should have to reassemble. */
+function mergeLiterals(parts) {
+    return parts.reduce((merged, part) => {
+        const previous = merged[merged.length - 1];
+        if (part.tag === "literal" && (previous === null || previous === void 0 ? void 0 : previous.tag) === "literal") {
+            merged[merged.length - 1] = literalWord(previous.text + part.text);
+            return merged;
+        }
+        merged.push(part);
+        return merged;
+    }, []);
+}
+/** Double quotes interpolate: `"$HOME"` expands, so the parts are text runs
+ * interleaved with variables. Recording the whole thing as literal text
+ * would pass a dollar sign through to the command instead of its value.
+ *
+ * A `$` that starts no supported expansion (`"$(date)"`, a bare `"$"`)
+ * fails the parse rather than degrading to text. */
+export const doubleQuotedWordParser = trace("doubleQuotedWordParser", seqC(set("tag", "doubleQuoted"), char('"'), capture(map(many(doubleQuotedPartParser), mergeLiterals), "parts"), char('"')));
+export const variableWordNoBracesParser = trace("variableWordNoBracesParser", seqC(set("tag", "variable"), char("$"), capture(varNameParser, "name")));
+export const variableWordWithBracesParser = trace("variableWordWithBracesParser", seqC(set("tag", "variable"), char("$"), char("{"), capture(varNameParser, "name"), char("}")));
+export const variableWordParser = trace("variableWordParser", or(variableWordWithBracesParser, variableWordNoBracesParser));
+// A run of ordinary text inside an unquoted word. Slashes are included so
+// `$HOME/bin` keeps its suffix; `$` is excluded so a variable is not eaten
+// as text.
+const interpolatedLiteralParser = trace("interpolatedLiteralParser", map(many1WithJoin(or(bareWordChars, char("/"))), literalWord));
+// Quoted words are parts too: `"$HOME"/x` and `"a"b` are single words.
+// The literal run cannot contain a quote, so these never overlap.
+const interpolatedPartParser = trace("interpolatedPartParser", or(variableWordParser, singleQuotedWordParser, doubleQuotedWordParser, interpolatedLiteralParser));
+/**
+ * An unquoted word that mixes literal text and variables: `$HOME.txt`,
+ * `$HOME/bin`, `prefix$NAME`, `$A$B`.
+ *
+ * These are ONE word in bash. Parsed as separate words they become
+ * separate arguments, which changes what the command means — and in an
+ * assignment (`PATH=$HOME/bin cmd`) it changes which program runs.
+ *
+ * Only matches when the word genuinely mixes: two or more adjacent
+ * parts, in any combination. A single part keeps its own simpler type, so
+ * a plain `file.txt` stays a `LiteralWord` and a lone `$HOME` stays a
+ * `VariableWord` rather than every word acquiring a `parts` array a
+ * consumer has to walk.
+ */
+export const interpolatedVariableWordParser = wholeWord((input) => {
+    const result = trace("interpolatedVariableWordParser", many1(interpolatedPartParser))(input);
+    if (!result.success)
+        return result;
+    const parts = result.result;
+    // Two or more parts is what makes a word interpolated. A single part
+    // keeps its own simpler type: `file.txt` stays a LiteralWord, `$HOME`
+    // a VariableWord, `"a b"` a DoubleQuotedWord.
+    if (parts.length < 2) {
+        return failure("Not an interpolated word: nothing to interpolate.", input);
+    }
+    return success({ tag: "interpolatedVariable", parts }, result.rest);
+});
+export const wordParser = trace("wordParser", or(flagWordParser, 
+// Before every single-part parser: each of those would match only the
+// FIRST part of an interpolated word and leave the rest to become a
+// separate argument.
+interpolatedVariableWordParser, singleQuotedWordParser, doubleQuotedWordParser, variableWordParser, pathWordParser, literalWordParser));
+export const scriptNameParser = trace("scriptNameParser", or(pathWordParser, literalWordParser));
+export const emptyAssignmentParser = trace("emptyAssignmentParser", seqC(set("tag", "assignment"), capture(assignmentNameParser, "name"), char("="), set("value", null)));
+export const assignmentWithValueParser = trace("assignmentWithValueParser", seqC(set("tag", "assignment"), capture(assignmentNameParser, "name"), char("="), capture(wordParser, "value")));
+export const assignmentParser = trace("assignmentParser", or(assignmentWithValueParser, emptyAssignmentParser));
+// No `<<` or `<<<`: a heredoc's body lives on the lines AFTER the
+// command, so `cat <<EOF` is not a redirect to a file named "EOF".
+// Parsing it as one is a silent mis-parse; leaving the operator out means
+// the `<` alternative fails on the second `<` and the command is rejected
+// instead. Longest alternative first, so `>>` beats `>`.
+const fdRedirectOp = or(str(">>"), str(">"), str("<"));
+// `&>` takes NO file descriptor. Bash reads the `2` in `cmd 2&> f` as an
+// ordinary argument, so accepting `2&>` as "fd 2" makes that argument
+// vanish from the AST — a silent mis-parse, not a rejection.
+const bareRedirectOp = str("&>");
+export const redirectParser = trace("redirectParser", or(seqC(set("tag", "redirect"), optional(capture(map(num, parseInt), "fd")), capture(fdRedirectOp, "op"), blanks, capture(wordParser, "target")), seqC(set("tag", "redirect"), capture(bareRedirectOp, "op"), blanks, capture(wordParser, "target"))));
+export const argParser = trace("argParser", or(flagWordParser, wordParser));
+/** Run a parser, then eat any trailing whitespace.
+ *
+ * The discipline: every token-shaped parser consumes its own TRAILING
+ * space, and leading space is eaten once at the start of the command.
+ * `sepBy(spaces, ...)` cannot express this — it only puts a separator
+ * BETWEEN elements of one group, so the space between the command name
+ * and its first argument, or between the last argument and a redirect,
+ * had nothing to consume it and the rest of the command was left
+ * unparsed. */
+function token(parser) {
+    return map(seqR(parser, blanks), (results) => results[0]);
+}
+/** A redirect or an argument, tried in that order.
+ *
+ * Interleaved rather than parsed as two separate groups, for two reasons.
+ * A digit attached to an operator is a FILE DESCRIPTOR, not an argument —
+ * bash reads `cmd 3> x` as "redirect fd 3, no arguments" — and args-first
+ * would always claim the `3`. And bash allows a redirect anywhere among
+ * the arguments (`cmd > out.txt arg`), which two fixed groups reject. */
+const argOrRedirectParser = trace("argOrRedirectParser", or(redirectParser, argParser));
+const isRedirect = (item) => item.tag === "redirect";
+const simpleCommandShape = seqC(set("tag", "simpleCommand"), blanks, capture(many(token(assignmentParser)), "assignments"), 
+// Optional so a bare `FOO=bar` line parses. Bash requires at least one
+// of a command name or an assignment; that check is below.
+capture(optional(token(scriptNameParser)), "command"), capture(many(token(argOrRedirectParser)), "items"));
+export const simpleCommandParser = trace("simpleCommandParser", (input) => {
+    const parsed = simpleCommandShape(input);
+    if (!parsed.success)
+        return parsed;
+    const { assignments, command, items } = parsed.result;
+    // Neither a command nor an assignment means nothing was parsed at all;
+    // without this every input "succeeds" as an empty command.
+    if (command === null && assignments.length === 0) {
+        return failure("Expected a command or an assignment.", input);
+    }
+    return success({
+        tag: "simpleCommand",
+        assignments,
+        command,
+        args: items.filter((item) => !isRedirect(item)),
+        redirects: items.filter(isRedirect),
+    }, parsed.rest);
+});
+/** An operator in a `&&` / `||` chain, absorbing the whitespace around it.
+ * `buildExpressionParser` applies this directly to the remaining input, so
+ * it has to eat its own surrounding space; optional, so `a&&b` works too. */
+const chainOperator = (symbol) => map(seqR(blanks, str(symbol), blanks), () => symbol);
+/**
+ * `a && b || c`, plus `( ... )` grouping.
+ *
+ * Built with `buildExpressionParser` rather than by hand because the naive
+ * shape is left-recursive: an `and` parser whose first move is to call the
+ * command parser recurses forever on the same input. Here the atom
+ * (`simpleCommandParser`) always consumes before any operator is tried.
+ *
+ * Both operators sit at ONE precedence level, left-associative, because
+ * that is what bash does: `a || b && c` is `((a || b) && c)`, not
+ * `(a || (b && c))`. Splitting them across two levels would silently
+ * change the meaning of every mixed chain.
+ */
+export const commandParser = trace("commandParser", buildExpressionParser(simpleCommandParser, [[
+        {
+            op: chainOperator("&&"),
+            assoc: "left",
+            apply: (left, right) => ({ tag: "and", left, right }),
+        },
+        {
+            op: chainOperator("||"),
+            assoc: "left",
+            apply: (left, right) => ({ tag: "or", left, right }),
+        },
+    ]], 
+// Passed explicitly: the default paren parser returns the inner
+// expression unwrapped, which would drop the `Parens` node.
+lazy(() => parensParser)));
+export const parensParser = trace("parensParser", seqC(set("tag", "parens"), char("("), capture(lazy(() => commandParser), "command"), char(")")));
+/** What separates two commands: a `;` or a newline.
+ *
+ * The trailing run absorbs blank lines and a `;` followed by a newline,
+ * but NOT a second `;` — `echo a ;; echo b` stays a parse error. */
+export const commandSeparator = seqR(blanks, or(char(";"), char("\n"), char("\r")), manyWithJoin(oneOf(" \t\n\r")));
+/** Blank lines before the first command. `simpleCommandParser` only eats
+ *  blanks (spaces and tabs), so without this a script starting with a
+ *  newline — or any CRLF file — is rejected outright. */
+const leadingSeparators = manyWithJoin(oneOf(" \t\n\r"));
+/** Parse a whole script: commands separated by `;` or newlines. */
+export function bashParser(input) {
+    const result = trace("bashParser", seqR(leadingSeparators, sepBy1(commandSeparator, commandParser)))(input);
+    if (!result.success)
+        return result;
+    const commands = result.result[1];
+    if (result.rest.trim() !== "") {
+        // `result.rest`, not `input`: tarsec derives position from
+        // originalInput.length - rest.length, so returning the whole input
+        // would report every error at column 1.
+        return failure(`Unexpected input after commands: "${result.rest}"`, result.rest);
+    }
+    return success(commands, result.rest);
+}

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.3",
   "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>;