@futpib/parser 1.0.3 → 1.0.4

package/build/bash.d.ts

@@ -0,0 +1,84 @@
+export type BashWord = {
+    parts: BashWordPart[];
+};
+export type BashWordPart = BashWordPartLiteral | BashWordPartSingleQuoted | BashWordPartDoubleQuoted | BashWordPartVariable | BashWordPartVariableBraced | BashWordPartCommandSubstitution | BashWordPartBacktickSubstitution | BashWordPartArithmeticExpansion;
+export type BashWordPartLiteral = {
+    type: 'literal';
+    value: string;
+};
+export type BashWordPartSingleQuoted = {
+    type: 'singleQuoted';
+    value: string;
+};
+export type BashWordPartDoubleQuoted = {
+    type: 'doubleQuoted';
+    parts: BashWordPart[];
+};
+export type BashWordPartVariable = {
+    type: 'variable';
+    name: string;
+};
+export type BashWordPartVariableBraced = {
+    type: 'variableBraced';
+    name: string;
+    operator?: string;
+    operand?: BashWord;
+};
+export type BashWordPartCommandSubstitution = {
+    type: 'commandSubstitution';
+    command: BashCommand;
+};
+export type BashWordPartBacktickSubstitution = {
+    type: 'backtickSubstitution';
+    command: BashCommand;
+};
+export type BashWordPartArithmeticExpansion = {
+    type: 'arithmeticExpansion';
+    expression: string;
+};
+export type BashRedirect = {
+    fd?: number;
+    operator: '>' | '>>' | '<' | '<<' | '<<<' | '>&' | '<&' | '>|';
+    target: BashWord | BashHereDoc;
+};
+export type BashHereDoc = {
+    type: 'hereDoc';
+    delimiter: string;
+    content: string;
+    quoted: boolean;
+};
+export type BashAssignment = {
+    name: string;
+    value?: BashWord;
+};
+export type BashSimpleCommand = {
+    type: 'simple';
+    name?: BashWord;
+    args: BashWord[];
+    redirects: BashRedirect[];
+    assignments: BashAssignment[];
+};
+export type BashSubshell = {
+    type: 'subshell';
+    body: BashCommand;
+};
+export type BashBraceGroup = {
+    type: 'braceGroup';
+    body: BashCommand;
+};
+export type BashCommandUnit = BashSimpleCommand | BashSubshell | BashBraceGroup;
+export type BashPipeline = {
+    type: 'pipeline';
+    negated: boolean;
+    commands: BashCommandUnit[];
+};
+export type BashCommandListSeparator = '&&' | '||' | ';' | '&' | '\n';
+export type BashCommandList = {
+    type: 'list';
+    entries: {
+        pipeline: BashPipeline;
+        separator?: BashCommandListSeparator;
+    }[];
+};
+export type BashCommand = BashCommandList;
+export type BashScript = BashCommand;

package/build/bash.js

@@ -0,0 +1 @@
+export {};

package/build/bashParser.d.ts

@@ -0,0 +1,6 @@
+import { type Parser } from './parser.js';
+import { type BashWord, type BashSimpleCommand, type BashCommand } from './bash.js';
+export declare const bashWordParser: Parser<BashWord, string>;
+export declare const bashSimpleCommandParser: Parser<BashSimpleCommand, string>;
+export declare const bashCommandParser: Parser<BashCommand, string>;
+export declare const bashScriptParser: Parser<BashCommand, string>;

package/build/bashParser.js

@@ -0,0 +1,294 @@
+import { setParserName } from './parser.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createTupleParser } from './tupleParser.js';
+import { createDisjunctionParser } from './disjunctionParser.js';
+import { createArrayParser } from './arrayParser.js';
+import { createParserAccessorParser } from './parserAccessorParser.js';
+import { createOptionalParser } from './optionalParser.js';
+import { createRegExpParser } from './regexpParser.js';
+import { createNonEmptyArrayParser } from './nonEmptyArrayParser.js';
+import { createSeparatedNonEmptyArrayParser } from './separatedNonEmptyArrayParser.js';
+// Whitespace (spaces and tabs, not newlines - those are significant)
+const bashInlineWhitespaceParser = promiseCompose(createRegExpParser(/[ \t]+/), match => match[0]);
+const bashOptionalInlineWhitespaceParser = promiseCompose(createRegExpParser(/[ \t]*/), match => match[0]);
+// Newline
+const bashNewlineParser = promiseCompose(createRegExpParser(/\n/), match => match[0]);
+// Word characters (unquoted, no special chars)
+// Note: {} are excluded so brace groups are parsed correctly
+const bashUnquotedWordCharsParser = promiseCompose(createRegExpParser(/[^\s\n|&;<>(){}$`"'\\#]+/), match => match[0]);
+// Single quoted string: '...'
+const bashSingleQuotedParser = promiseCompose(createTupleParser([
+    createExactSequenceParser("'"),
+    promiseCompose(createRegExpParser(/[^']*/), match => match[0]),
+    createExactSequenceParser("'"),
+]), ([, value]) => ({
+    type: 'singleQuoted',
+    value,
+}));
+// Variable name
+const bashVariableNameParser = promiseCompose(createRegExpParser(/[a-zA-Z_][a-zA-Z0-9_]*|[0-9]+|[@*#?$!-]/), match => match[0]);
+// Simple variable: $var
+const bashSimpleVariableParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('$'),
+    bashVariableNameParser,
+]), ([, name]) => ({
+    type: 'variable',
+    name,
+}));
+// Command substitution: $(...)
+const bashCommandSubstitutionParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('$('),
+    bashOptionalInlineWhitespaceParser,
+    createParserAccessorParser(() => bashCommandParser),
+    bashOptionalInlineWhitespaceParser,
+    createExactSequenceParser(')'),
+]), ([, , command]) => ({
+    type: 'commandSubstitution',
+    command,
+}));
+// Backtick substitution: `...`
+const bashBacktickSubstitutionParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('`'),
+    createParserAccessorParser(() => bashCommandParser),
+    createExactSequenceParser('`'),
+]), ([, command]) => ({
+    type: 'backtickSubstitution',
+    command,
+}));
+// Double quoted string parts (inside "...")
+const bashDoubleQuotedPartParser = createDisjunctionParser([
+    bashSimpleVariableParser,
+    bashCommandSubstitutionParser,
+    bashBacktickSubstitutionParser,
+    // Escape sequences in double quotes
+    promiseCompose(createRegExpParser(/\\[\\$`"!\n]/), match => ({
+        type: 'literal',
+        value: match[0].slice(1),
+    })),
+    // Literal text (no special chars)
+    promiseCompose(createRegExpParser(/[^$`"\\]+/), match => ({
+        type: 'literal',
+        value: match[0],
+    })),
+]);
+// Double quoted string: "..."
+const bashDoubleQuotedParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('"'),
+    createArrayParser(bashDoubleQuotedPartParser),
+    createExactSequenceParser('"'),
+]), ([, parts]) => ({
+    type: 'doubleQuoted',
+    parts,
+}));
+// Literal word part (unquoted)
+const bashLiteralWordPartParser = promiseCompose(bashUnquotedWordCharsParser, value => ({
+    type: 'literal',
+    value,
+}));
+// Escape sequence outside quotes
+const bashEscapeParser = promiseCompose(createRegExpParser(/\\./), match => ({
+    type: 'literal',
+    value: match[0].slice(1),
+}));
+// Word part (any part of a word)
+const bashWordPartParser = createDisjunctionParser([
+    bashSingleQuotedParser,
+    bashDoubleQuotedParser,
+    bashCommandSubstitutionParser,
+    bashBacktickSubstitutionParser,
+    bashSimpleVariableParser,
+    bashEscapeParser,
+    bashLiteralWordPartParser,
+]);
+// Word (sequence of word parts)
+export const bashWordParser = promiseCompose(createNonEmptyArrayParser(bashWordPartParser), parts => ({ parts }));
+setParserName(bashWordParser, 'bashWordParser');
+// Assignment: NAME=value or NAME=
+const bashAssignmentParser = promiseCompose(createTupleParser([
+    promiseCompose(createRegExpParser(/[a-zA-Z_][a-zA-Z0-9_]*=/), match => match[0].slice(0, -1)),
+    createOptionalParser(bashWordParser),
+]), ([name, value]) => ({
+    name,
+    value: value ?? undefined,
+}));
+// Redirect operators
+const bashRedirectOperatorParser = createDisjunctionParser([
+    promiseCompose(createExactSequenceParser('>>'), () => '>>'),
+    promiseCompose(createExactSequenceParser('>&'), () => '>&'),
+    promiseCompose(createExactSequenceParser('>|'), () => '>|'),
+    promiseCompose(createExactSequenceParser('>'), () => '>'),
+    promiseCompose(createExactSequenceParser('<<<'), () => '<<<'),
+    promiseCompose(createExactSequenceParser('<<'), () => '<<'),
+    promiseCompose(createExactSequenceParser('<&'), () => '<&'),
+    promiseCompose(createExactSequenceParser('<'), () => '<'),
+]);
+// Redirect: [n]op word
+const bashRedirectParser = promiseCompose(createTupleParser([
+    createOptionalParser(promiseCompose(createRegExpParser(/[0-9]+/), match => Number.parseInt(match[0], 10))),
+    bashRedirectOperatorParser,
+    bashOptionalInlineWhitespaceParser,
+    bashWordParser,
+]), ([fd, operator, , target]) => ({
+    fd: fd ?? undefined,
+    operator,
+    target,
+}));
+// Word with optional trailing whitespace - for use in arrays
+const bashWordWithWhitespaceParser = promiseCompose(createTupleParser([
+    bashWordParser,
+    bashOptionalInlineWhitespaceParser,
+]), ([word]) => word);
+// Redirect with optional trailing whitespace
+const bashRedirectWithWhitespaceParser = promiseCompose(createTupleParser([
+    bashRedirectParser,
+    bashOptionalInlineWhitespaceParser,
+]), ([redirect]) => redirect);
+// Word or redirect - for interleaved parsing in simple commands
+const bashWordOrRedirectParser = createDisjunctionParser([
+    promiseCompose(bashRedirectWithWhitespaceParser, redirect => ({ type: 'redirect', redirect })),
+    promiseCompose(bashWordWithWhitespaceParser, word => ({ type: 'word', word })),
+]);
+// Simple command: [assignments] [name] [args] [redirects]
+export const bashSimpleCommandParser = promiseCompose(createTupleParser([
+    // Assignments at the start
+    createArrayParser(promiseCompose(createTupleParser([
+        bashAssignmentParser,
+        bashOptionalInlineWhitespaceParser,
+    ]), ([assignment]) => assignment)),
+    // Command name, args, and redirects (interleaved)
+    createArrayParser(bashWordOrRedirectParser),
+]), ([assignments, items]) => {
+    const words = [];
+    const redirects = [];
+    for (const item of items) {
+        if (item.type === 'word') {
+            words.push(item.word);
+        }
+        else {
+            redirects.push(item.redirect);
+        }
+    }
+    const [name, ...args] = words;
+    return {
+        type: 'simple',
+        name,
+        args,
+        redirects,
+        assignments,
+    };
+});
+setParserName(bashSimpleCommandParser, 'bashSimpleCommandParser');
+// Subshell: ( command )
+const bashSubshellParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('('),
+    bashOptionalInlineWhitespaceParser,
+    createParserAccessorParser(() => bashCommandParser),
+    bashOptionalInlineWhitespaceParser,
+    createExactSequenceParser(')'),
+]), ([, , body]) => ({
+    type: 'subshell',
+    body,
+}));
+setParserName(bashSubshellParser, 'bashSubshellParser');
+// Brace group: { command; }
+const bashBraceGroupParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('{'),
+    bashInlineWhitespaceParser,
+    createParserAccessorParser(() => bashCommandParser),
+    bashOptionalInlineWhitespaceParser,
+    createOptionalParser(createExactSequenceParser(';')),
+    bashOptionalInlineWhitespaceParser,
+    createExactSequenceParser('}'),
+]), ([, , body]) => ({
+    type: 'braceGroup',
+    body,
+}));
+setParserName(bashBraceGroupParser, 'bashBraceGroupParser');
+// Command unit: simple command, subshell, or brace group
+const bashCommandUnitParser = createDisjunctionParser([
+    bashSubshellParser,
+    bashBraceGroupParser,
+    bashSimpleCommandParser,
+]);
+setParserName(bashCommandUnitParser, 'bashCommandUnitParser');
+// Single pipe (not ||) - matches | only when not followed by another |
+const bashSinglePipeParser = promiseCompose(createRegExpParser(/\|(?!\|)/), match => match[0]);
+// Pipeline: [!] cmd [| cmd]...
+const bashPipelineParser = promiseCompose(createTupleParser([
+    createOptionalParser(promiseCompose(createTupleParser([
+        createExactSequenceParser('!'),
+        bashInlineWhitespaceParser,
+    ]), () => true)),
+    createSeparatedNonEmptyArrayParser(bashCommandUnitParser, createTupleParser([
+        bashOptionalInlineWhitespaceParser,
+        bashSinglePipeParser,
+        bashOptionalInlineWhitespaceParser,
+    ])),
+]), ([negated, commands]) => ({
+    type: 'pipeline',
+    negated: negated ?? false,
+    commands,
+}));
+setParserName(bashPipelineParser, 'bashPipelineParser');
+// Command list separator
+const bashListSeparatorParser = createDisjunctionParser([
+    promiseCompose(createExactSequenceParser('&&'), () => '&&'),
+    promiseCompose(createExactSequenceParser('||'), () => '||'),
+    promiseCompose(createExactSequenceParser(';'), () => ';'),
+    promiseCompose(createExactSequenceParser('&'), () => '&'),
+    promiseCompose(bashNewlineParser, () => '\n'),
+]);
+// Command list: pipeline [sep pipeline]...
+const bashCommandListParser = promiseCompose(createTupleParser([
+    bashPipelineParser,
+    createArrayParser(promiseCompose(createTupleParser([
+        bashOptionalInlineWhitespaceParser,
+        bashListSeparatorParser,
+        bashOptionalInlineWhitespaceParser,
+        bashPipelineParser,
+    ]), ([, separator, , pipeline]) => ({ separator, pipeline }))),
+    createOptionalParser(promiseCompose(createTupleParser([
+        bashOptionalInlineWhitespaceParser,
+        bashListSeparatorParser,
+    ]), ([, separator]) => separator)),
+]), ([firstPipeline, rest, trailingSeparator]) => {
+    const entries = [];
+    if (rest.length === 0) {
+        entries.push({
+            pipeline: firstPipeline,
+            separator: trailingSeparator ?? undefined,
+        });
+    }
+    else {
+        entries.push({
+            pipeline: firstPipeline,
+            separator: rest[0].separator,
+        });
+        for (let i = 0; i < rest.length - 1; i++) {
+            entries.push({
+                pipeline: rest[i].pipeline,
+                separator: rest[i + 1].separator,
+            });
+        }
+        entries.push({
+            pipeline: rest[rest.length - 1].pipeline,
+            separator: trailingSeparator ?? undefined,
+        });
+    }
+    return {
+        type: 'list',
+        entries,
+    };
+});
+setParserName(bashCommandListParser, 'bashCommandListParser');
+// Top-level command parser
+export const bashCommandParser = bashCommandListParser;
+setParserName(bashCommandParser, 'bashCommandParser');
+// Script parser (handles leading/trailing whitespace)
+export const bashScriptParser = promiseCompose(createTupleParser([
+    bashOptionalInlineWhitespaceParser,
+    bashCommandParser,
+    bashOptionalInlineWhitespaceParser,
+]), ([, command]) => command);
+setParserName(bashScriptParser, 'bashScriptParser');

package/build/bashParser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/bashParser.test.js

@@ -0,0 +1,181 @@
+import test from 'ava';
+import { runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { bashScriptParser, bashWordParser, bashSimpleCommandParser } from './bashParser.js';
+test('simple command parser - single word', async (t) => {
+    const result = await runParser(bashSimpleCommandParser, 'cmd', stringParserInputCompanion, { errorStack: true });
+    t.is(result.type, 'simple');
+    t.deepEqual(result.name, { parts: [{ type: 'literal', value: 'cmd' }] });
+});
+test('simple command parser - two words', async (t) => {
+    const result = await runParser(bashSimpleCommandParser, 'echo hello', stringParserInputCompanion);
+    t.is(result.type, 'simple');
+    t.deepEqual(result.name, { parts: [{ type: 'literal', value: 'echo' }] });
+    t.is(result.args.length, 1);
+});
+test('word parser - simple literal', async (t) => {
+    const result = await runParser(bashWordParser, 'hello', stringParserInputCompanion);
+    t.deepEqual(result, {
+        parts: [{ type: 'literal', value: 'hello' }],
+    });
+});
+test('word parser - variable', async (t) => {
+    const result = await runParser(bashWordParser, '$HOME', stringParserInputCompanion);
+    t.deepEqual(result, {
+        parts: [{ type: 'variable', name: 'HOME' }],
+    });
+});
+test('simple command', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo hello', stringParserInputCompanion);
+    t.deepEqual(result, {
+        type: 'list',
+        entries: [{
+                pipeline: {
+                    type: 'pipeline',
+                    negated: false,
+                    commands: [{
+                            type: 'simple',
+                            name: { parts: [{ type: 'literal', value: 'echo' }] },
+                            args: [{ parts: [{ type: 'literal', value: 'hello' }] }],
+                            redirects: [],
+                            assignments: [],
+                        }],
+                },
+                separator: undefined,
+            }],
+    });
+});
+test('simple command with multiple args', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo hello world', stringParserInputCompanion);
+    t.is(result.entries[0].pipeline.commands[0].type, 'simple');
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args.length, 2);
+    }
+});
+test('pipeline', async (t) => {
+    const result = await runParser(bashScriptParser, 'cat file | grep pattern', stringParserInputCompanion);
+    t.is(result.entries[0].pipeline.commands.length, 2);
+});
+test('redirect output', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo foo > file', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.redirects.length, 1);
+        t.is(cmd.redirects[0].operator, '>');
+    }
+});
+test('redirect with fd', async (t) => {
+    const result = await runParser(bashScriptParser, 'cmd 2>&1', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.redirects.length, 1);
+        t.is(cmd.redirects[0].fd, 2);
+        t.is(cmd.redirects[0].operator, '>&');
+    }
+});
+test('single quoted string', async (t) => {
+    const result = await runParser(bashScriptParser, "echo 'hello world'", stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [{ type: 'singleQuoted', value: 'hello world' }],
+        });
+    }
+});
+test('double quoted string with variable', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo "hello $name"', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [{
+                    type: 'doubleQuoted',
+                    parts: [
+                        { type: 'literal', value: 'hello ' },
+                        { type: 'variable', name: 'name' },
+                    ],
+                }],
+        });
+    }
+});
+test('simple variable', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo $HOME', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.args[0], {
+            parts: [{ type: 'variable', name: 'HOME' }],
+        });
+    }
+});
+test('command substitution', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo $(pwd)', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args[0].parts[0].type, 'commandSubstitution');
+    }
+});
+test('backtick substitution', async (t) => {
+    const result = await runParser(bashScriptParser, 'echo `pwd`', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.args[0].parts[0].type, 'backtickSubstitution');
+    }
+});
+test('subshell', async (t) => {
+    const result = await runParser(bashScriptParser, '(cd dir; pwd)', stringParserInputCompanion);
+    t.is(result.entries[0].pipeline.commands[0].type, 'subshell');
+});
+test('brace group', async (t) => {
+    const result = await runParser(bashScriptParser, '{ echo hello; }', stringParserInputCompanion);
+    t.is(result.entries[0].pipeline.commands[0].type, 'braceGroup');
+});
+test('command list with &&', async (t) => {
+    const result = await runParser(bashScriptParser, 'cmd1 && cmd2', stringParserInputCompanion);
+    t.is(result.entries.length, 2);
+    t.is(result.entries[0].separator, '&&');
+});
+test('command list with ||', async (t) => {
+    const result = await runParser(bashScriptParser, 'cmd1 || cmd2', stringParserInputCompanion);
+    t.is(result.entries.length, 2);
+    t.is(result.entries[0].separator, '||');
+});
+test('command list with ;', async (t) => {
+    const result = await runParser(bashScriptParser, 'cmd1; cmd2', stringParserInputCompanion);
+    t.is(result.entries.length, 2);
+    t.is(result.entries[0].separator, ';');
+});
+test('background command', async (t) => {
+    const result = await runParser(bashScriptParser, 'cmd &', stringParserInputCompanion);
+    t.is(result.entries[0].separator, '&');
+});
+test('assignment', async (t) => {
+    const result = await runParser(bashScriptParser, 'VAR=value cmd', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.is(cmd.assignments.length, 1);
+        t.is(cmd.assignments[0].name, 'VAR');
+    }
+});
+test('negated pipeline', async (t) => {
+    const result = await runParser(bashScriptParser, '! cmd', stringParserInputCompanion);
+    t.is(result.entries[0].pipeline.negated, true);
+});
+test('complex pipeline with redirects', async (t) => {
+    const result = await runParser(bashScriptParser, 'cat file 2>/dev/null | grep pattern | sort > output', stringParserInputCompanion);
+    t.is(result.entries[0].pipeline.commands.length, 3);
+});
+test('[[ treated as command name', async (t) => {
+    const result = await runParser(bashScriptParser, '[[ -f file ]]', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.name, { parts: [{ type: 'literal', value: '[[' }] });
+        t.is(cmd.args.length, 3); // -f, file, ]]
+    }
+});
+test('if treated as command name', async (t) => {
+    const result = await runParser(bashScriptParser, 'if true', stringParserInputCompanion);
+    const cmd = result.entries[0].pipeline.commands[0];
+    if (cmd.type === 'simple') {
+        t.deepEqual(cmd.name, { parts: [{ type: 'literal', value: 'if' }] });
+    }
+});

package/build/index.d.ts

@@ -1,5 +1,11 @@
-export { type Parser, runParser, setParserName, getParserName, } from './parser.js';
+export { type Parser, runParser, runParserWithRemainingInput, setParserName, getParserName, cloneParser, type RunParserOptions, type RunParserWithRemainingInputResult, } from './parser.js';
 export type { ParserContext, } from './parserContext.js';
+export { type ParserInputCompanion, StringParserInputCompanion, stringParserInputCompanion, Uint8ArrayParserInputCompanion, uint8ArrayParserInputCompanion, } from './parserInputCompanion.js';
+export { type UnparserOutputCompanion, StringUnparserOutputCompanion, stringUnparserOutputCompanion, Uint8ArrayUnparserOutputCompanion, uint8ArrayUnparserOutputCompanion, } from './unparserOutputCompanion.js';
+export { type ParserError, type ParserParsingFailedError, type ParserParsingJoinError, type ParserErrorModule, isParserError, isParserParsingFailedError, isParserParsingJoinError, normalParserErrorModule, noStackCaptureOverheadParserErrorModule, } from './parserError.js';
+export { parserCreatorCompose, parserCreatorComposeMem, } from './parserCreatorCompose.js';
+export { promiseCompose, } from './promiseCompose.js';
+export type { DeriveSequenceElement, } from './sequence.js';
 export { createTupleParser, } from './tupleParser.js';
 export { createExactSequenceParser, } from './exactSequenceParser.js';
 export { createFixedLengthSequenceParser, } from './fixedLengthSequenceParser.js';
@@ -16,6 +22,22 @@ export { createSkipParser, } from './skipParser.js';
 export { createEndOfInputParser, } from './endOfInputParser.js';
 export { createListParser, } from './listParser.js';
 export { createDebugLogParser, } from './debugLogParser.js';
-export { type Unparser, runUnparser, } from './unparser.js';
+export { createNonEmptyArrayParser, } from './nonEmptyArrayParser.js';
+export { createSeparatedArrayParser, } from './separatedArrayParser.js';
+export { createSeparatedNonEmptyArrayParser, } from './separatedNonEmptyArrayParser.js';
+export { createLookaheadParser, } from './lookaheadParser.js';
+export { createNegativeLookaheadParser, } from './negativeLookaheadParser.js';
+export { createElementTerminatedSequenceParser, } from './elementTerminatedSequenceParser.js';
+export { createElementTerminatedSequenceArrayParser, } from './elementTerminatedSequenceArrayParser.js';
+export { createElementTerminatedArrayParserUnsafe, } from './elementTerminatedArrayParser.js';
+export { createSequenceTerminatedSequenceParser, } from './sequenceTerminatedSequenceParser.js';
+export { createQuantifierParser, } from './quantifierParser.js';
+export { createSkipToParser, } from './skipToParser.js';
+export { createDebugLogInputParser, } from './debugLogInputParser.js';
+export { createElementSwitchParser, } from './exactElementSwitchParser.js';
+export { createParserConsumedSequenceParser, } from './parserConsumedSequenceParser.js';
+export { type Unparser, type UnparserResult, runUnparser, } from './unparser.js';
+export { type UnparserContext, WriteLater, WriteEarlier, UnparserContextImplementation, } from './unparserContext.js';
 export { createArrayUnparser, } from './arrayUnparser.js';
 export { createSequenceUnparser, } from './sequenceUnparser.js';
+export { createRegExpParser, } from './regexpParser.js';

package/build/index.js

@@ -1,4 +1,9 @@
-export { runParser, setParserName, getParserName, } from './parser.js';
+export { runParser, runParserWithRemainingInput, setParserName, getParserName, cloneParser, } from './parser.js';
+export { StringParserInputCompanion, stringParserInputCompanion, Uint8ArrayParserInputCompanion, uint8ArrayParserInputCompanion, } from './parserInputCompanion.js';
+export { StringUnparserOutputCompanion, stringUnparserOutputCompanion, Uint8ArrayUnparserOutputCompanion, uint8ArrayUnparserOutputCompanion, } from './unparserOutputCompanion.js';
+export { isParserError, isParserParsingFailedError, isParserParsingJoinError, normalParserErrorModule, noStackCaptureOverheadParserErrorModule, } from './parserError.js';
+export { parserCreatorCompose, parserCreatorComposeMem, } from './parserCreatorCompose.js';
+export { promiseCompose, } from './promiseCompose.js';
 export { createTupleParser, } from './tupleParser.js';
 export { createExactSequenceParser, } from './exactSequenceParser.js';
 export { createFixedLengthSequenceParser, } from './fixedLengthSequenceParser.js';
@@ -15,6 +20,22 @@ export { createSkipParser, } from './skipParser.js';
 export { createEndOfInputParser, } from './endOfInputParser.js';
 export { createListParser, } from './listParser.js';
 export { createDebugLogParser, } from './debugLogParser.js';
+export { createNonEmptyArrayParser, } from './nonEmptyArrayParser.js';
+export { createSeparatedArrayParser, } from './separatedArrayParser.js';
+export { createSeparatedNonEmptyArrayParser, } from './separatedNonEmptyArrayParser.js';
+export { createLookaheadParser, } from './lookaheadParser.js';
+export { createNegativeLookaheadParser, } from './negativeLookaheadParser.js';
+export { createElementTerminatedSequenceParser, } from './elementTerminatedSequenceParser.js';
+export { createElementTerminatedSequenceArrayParser, } from './elementTerminatedSequenceArrayParser.js';
+export { createElementTerminatedArrayParserUnsafe, } from './elementTerminatedArrayParser.js';
+export { createSequenceTerminatedSequenceParser, } from './sequenceTerminatedSequenceParser.js';
+export { createQuantifierParser, } from './quantifierParser.js';
+export { createSkipToParser, } from './skipToParser.js';
+export { createDebugLogInputParser, } from './debugLogInputParser.js';
+export { createElementSwitchParser, } from './exactElementSwitchParser.js';
+export { createParserConsumedSequenceParser, } from './parserConsumedSequenceParser.js';
 export { runUnparser, } from './unparser.js';
+export { WriteLater, WriteEarlier, UnparserContextImplementation, } from './unparserContext.js';
 export { createArrayUnparser, } from './arrayUnparser.js';
 export { createSequenceUnparser, } from './sequenceUnparser.js';
+export { createRegExpParser, } from './regexpParser.js';

package/build/regexpParser.d.ts

@@ -0,0 +1,2 @@
+import { type Parser } from './parser.js';
+export declare const createRegExpParser: (regexp: RegExp) => Parser<RegExpExecArray, string, string>;