@mojir/dvala 0.0.1 → 0.0.2

package/dist/src/evaluator/step.d.ts

@@ -0,0 +1,159 @@
+/**
+ * Step types for the trampoline evaluator.
+ *
+ * The trampoline loop processes one `Step` per tick. Each tick produces a new
+ * `Step`, transforming the evaluation incrementally until a final `Value` step
+ * with an empty continuation stack signals completion.
+ *
+ * Step variants:
+ * - **Value**: A sub-expression produced a value. If `k` is empty, the program
+ *   is done. Otherwise, pop the top frame and apply it with `applyFrame`.
+ * - **Eval**: Evaluate an AST node in the given environment. `stepNode` maps
+ *   the node to the next step (either a `Value` for leaves or an `Eval`/`Apply`
+ *   with a new frame pushed onto `k`).
+ * - **Apply**: A frame has received a value and needs to determine the next step.
+ *   Dispatches to `applyFrame(frame, value, k)`.
+ * - **Perform**: An effect was invoked via `perform`. The trampoline searches `k`
+ *   for a matching `TryWithFrame` (local handler) or dispatches to a host handler.
+ *
+ * All step types are plain serializable objects (when `ContextStack` is replaced
+ * with a serializable representation in Phase 4).
+ */
+import type { Any, Arr } from '../interface';
+import type { AstNode, EffectRef } from '../parser/types';
+import type { ContinuationStack, Frame } from './frames';
+import type { ContextStack } from './ContextStack';
+/**
+ * A sub-expression has been fully evaluated to a value.
+ *
+ * The trampoline checks `k`:
+ * - If empty → the program is complete; `value` is the final result.
+ * - If non-empty → pop the top frame and call `applyFrame(frame, value, rest)`.
+ */
+export interface ValueStep {
+    type: 'Value';
+    value: Any;
+    k: ContinuationStack;
+}
+/**
+ * An AST node needs to be evaluated in the given environment.
+ *
+ * The trampoline calls `stepNode(node, env, k)` which inspects the node type
+ * and returns the next step:
+ * - Leaf nodes (number, string, symbol lookup) → `ValueStep`
+ * - Compound nodes → push a frame onto `k` and return `EvalStep` for the
+ *   first sub-expression.
+ */
+export interface EvalStep {
+    type: 'Eval';
+    node: AstNode;
+    env: ContextStack;
+    k: ContinuationStack;
+}
+/**
+ * A frame needs to process a completed sub-result.
+ *
+ * The trampoline calls `applyFrame(frame, value, k)` to determine the next
+ * step. For example, an `IfBranchFrame` receiving a truthy value returns an
+ * `EvalStep` for the then-branch.
+ */
+export interface ApplyStep {
+    type: 'Apply';
+    frame: Frame;
+    value: Any;
+    k: ContinuationStack;
+}
+/**
+ * An effect was invoked via `perform(effect, ...args)`.
+ *
+ * The trampoline searches the continuation stack `k` from top to bottom for
+ * a matching `TryWithFrame`. If found, the handler is dispatched locally.
+ * If not found, the effect is dispatched to the host handler registered
+ * in `run()` options, or to a standard effect default implementation.
+ *
+ * `args` is always an array (possibly empty for zero-argument effects).
+ */
+export interface PerformStep {
+    type: 'Perform';
+    effect: EffectRef;
+    args: Arr;
+    k: ContinuationStack;
+}
+/**
+ * A `parallel(...)` expression was encountered.
+ *
+ * The trampoline runs all branch expressions concurrently as independent
+ * trampoline invocations using `Promise.allSettled`. Each branch gets the
+ * same handlers and signal. Results are collected in order.
+ *
+ * If any branch suspends, a composite blob is created with completed values
+ * and suspended branch blobs, and a `SuspensionSignal` is thrown.
+ *
+ * Only available in async mode (`run()`). In `runSync()`, this step causes
+ * a "Unexpected async operation" error because it returns `Promise<Step>`.
+ */
+export interface ParallelStep {
+    type: 'Parallel';
+    branches: AstNode[];
+    env: ContextStack;
+    k: ContinuationStack;
+}
+/**
+ * A `race(...)` expression was encountered.
+ *
+ * The trampoline runs all branch expressions concurrently. The first branch
+ * to complete wins — its value becomes the result. Losers are cancelled via
+ * per-branch AbortControllers. Errored branches are silently dropped.
+ *
+ * If all branches error, throws an aggregate error. If no branch completes
+ * but some suspend, the race suspends with only the outer continuation.
+ * On resume, the host provides the winner value directly.
+ *
+ * Only available in async mode (`run()`).
+ */
+export interface RaceStep {
+    type: 'Race';
+    branches: AstNode[];
+    env: ContextStack;
+    k: ContinuationStack;
+}
+/**
+ * A parallel resumption is in progress.
+ *
+ * Created when a `ParallelResumeFrame` receives a value (the resume result
+ * of the first suspended branch). The trampoline resumes that branch's
+ * trampoline and processes the result.
+ *
+ * This step type is handled by `tick()` which has access to `handlers` and
+ * `signal` needed to run the branch trampoline.
+ */
+export interface ParallelResumeStep {
+    type: 'ParallelResume';
+    value: Any;
+    branchCount: number;
+    completedBranches: Array<{
+        index: number;
+        value: Any;
+    }>;
+    suspendedBranches: Array<{
+        index: number;
+        blob: string;
+        meta?: Any;
+    }>;
+    k: ContinuationStack;
+}
+/**
+ * Discriminated union of all step types.
+ *
+ * The trampoline loop processes one `Step` per iteration:
+ *
+ * ```
+ * while (true) {
+ *   step = tick(step)
+ *   if (step.type === 'Value' && step.k.length === 0) return step.value
+ * }
+ * ```
+ *
+ * The `type` field serves as the discriminant for exhaustive switching.
+ */
+export type Step = ValueStep | EvalStep | ApplyStep | PerformStep | ParallelStep | RaceStep | ParallelResumeStep;

package/dist/src/evaluator/suspension.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Continuation stack serialization and deserialization.
+ *
+ * When a host handler calls `suspend(meta?)`, the trampoline captures the
+ * continuation stack (an array of Frame objects). This module converts that
+ * stack to/from a JSON string (the "suspension blob") that can be stored,
+ * transferred, and later resumed in a new process.
+ *
+ * The main challenge is that Frame objects contain `ContextStack` class
+ * instances (which hold lexical scope chains). These are not plain data
+ * and may form circular references (e.g., a global context containing a
+ * UserDefinedFunction whose captured env references the same global context).
+ *
+ * The serialization approach:
+ * 1. Walk the frame tree and collect all unique ContextStack instances (by identity)
+ * 2. Assign each a numeric ID
+ * 3. Serialize ContextStacks separately as plain objects
+ * 4. In the frame tree, replace ContextStack references with `{ __csRef: id }`
+ * 5. First occurrence of each ContextStack gets `{ __csDef: id, ... }` in the
+ *    contextStacks array — circular refs just become `{ __csRef: id }`
+ *
+ * Deserialization reverses this:
+ * 1. Parse the blob and create placeholder ContextStack instances
+ * 2. Deep-resolve all `__csRef` markers back to real instances
+ * 3. Fill in host bindings (values, nativeJsFunctions, modules) on each instance
+ */
+import type { Any } from '../interface';
+import type { NativeJsFunction } from '../parser/types';
+import type { DvalaModule } from '../builtin/modules/interface';
+import type { ContinuationStack } from './frames';
+/**
+ * Serialize a continuation stack and optional metadata into an opaque JSON blob.
+ *
+ * Validates that all values are serializable (no NativeJsFunctions in frames).
+ * Throws a descriptive `DvalaError` if non-serializable values are found.
+ */
+export declare function serializeSuspension(k: ContinuationStack, meta?: Any): string;
+/** Options for re-injecting host bindings on resume. */
+export interface DeserializeOptions {
+    values?: Record<string, unknown>;
+    nativeJsFunctions?: Record<string, NativeJsFunction>;
+    modules?: Map<string, DvalaModule>;
+}
+/**
+ * Deserialize a suspension blob back into a continuation stack and metadata.
+ *
+ * Reconstructs `ContextStack` instances with fresh host bindings from `options`.
+ * Handles circular references between ContextStacks and their contained values.
+ */
+export declare function deserializeSuspension(blob: string, options?: DeserializeOptions): {
+    k: ContinuationStack;
+    meta?: Any;
+};

package/dist/src/evaluator/trampoline.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Trampoline evaluator — explicit-stack evaluation engine.
+ *
+ * `stepNode(node, env, k)` maps an AST node to the next `Step`.
+ * `applyFrame(frame, value, k)` processes a completed sub-result against a frame.
+ * `tick(step)` processes one step and returns the next (or a Promise<Step> for async).
+ * `runSyncTrampoline(step)` runs the trampoline synchronously to completion.
+ * `runAsyncTrampoline(step)` runs the trampoline asynchronously to completion.
+ *
+ * Entry points:
+ * - `evaluate(ast, contextStack)` — evaluate an AST (sync or async)
+ * - `evaluateNode(node, contextStack)` — evaluate a single node (sync or async)
+ *
+ * Design principles:
+ * - `stepNode` is always synchronous and returns `Step`.
+ * - `applyFrame` may return `Step | Promise<Step>` when normal expressions
+ *   or compound function types produce async results.
+ * - Normal built-in expressions are called directly with pre-evaluated args
+ *   (they may still use the old recursive `evaluateNode` internally for
+ *   higher-order callbacks — suspension through them is deferred).
+ * - Binding utilities (`evaluateBindingNodeValues`, `tryMatch`) are called
+ *   with a recursive `evaluateNode` helper. This is acceptable for Phase 1.
+ * - All state lives in frames (no JS closures) — enabling serialization later.
+ */
+import type { Any } from '../interface';
+import type { Ast, AstNode } from '../parser/types';
+import type { MaybePromise } from '../utils/maybePromise';
+import type { Handlers, RunResult } from './effectTypes';
+import type { ContextStack } from './ContextStack';
+import type { ContinuationStack, Frame } from './frames';
+import type { Step } from './step';
+export type { Step };
+/**
+ * Given an AST node, its environment, and a continuation stack, return
+ * the next Step for the trampoline to process.
+ *
+ * Leaf nodes (numbers, strings, symbols) immediately produce values.
+ * Compound nodes (expressions) push frames and return sub-evaluations.
+ */
+export declare function stepNode(node: AstNode, env: ContextStack, k: ContinuationStack): Step | Promise<Step>;
+/**
+ * Given a completed sub-expression value and the top frame from the
+ * continuation stack, determine the next Step.
+ */
+export declare function applyFrame(frame: Frame, value: Any, k: ContinuationStack): Step | Promise<Step>;
+/**
+ * Extract all visible bindings from a ContextStack as a flat record.
+ * Iterates from outermost to innermost scope so that inner bindings
+ * shadow outer ones, matching Dvala scoping semantics.
+ */
+export declare function extractBindings(env: ContextStack): Record<string, Any>;
+/**
+ * Process one step of the trampoline. Returns the next step, or a
+ * Promise<Step> when an async operation (e.g., native JS function) is
+ * encountered.
+ *
+ * - `Value` with empty `k`: the program is done (terminal state).
+ * - `Value` with non-empty `k`: pop the top frame and apply it.
+ * - `Eval`: evaluate an AST node via `stepNode` (always synchronous).
+ * - `Apply`: apply a frame to a value (may return Promise<Step>).
+ * - `Perform`: effect dispatch — local (try/with) first, then host handlers.
+ *
+ * When `handlers` and `signal` are provided (from `run()`), host handlers are
+ * available as a fallback for effects not matched by any local `try/with`.
+ */
+export declare function tick(step: Step, handlers?: Handlers, signal?: AbortSignal): Step | Promise<Step>;
+/**
+ * Run the trampoline synchronously to completion.
+ * Throws if any step produces a Promise (i.e., an async operation was
+ * encountered in a synchronous context).
+ */
+export declare function runSyncTrampoline(initial: Step): Any;
+/**
+ * Run the trampoline asynchronously to completion.
+ * Awaits any Promise<Step> that surfaces from async operations.
+ */
+export declare function runAsyncTrampoline(initial: Step): Promise<Any>;
+/**
+ * Evaluate an AST using the trampoline.
+ * Returns the final value synchronously, or a Promise if async operations
+ * are involved (e.g., native JS functions returning Promises).
+ */
+export declare function evaluate(ast: Ast, contextStack: ContextStack): MaybePromise<Any>;
+/**
+ * Evaluate an AST using the async trampoline directly.
+ * Use this when the caller knows that async operations may be involved
+ * (e.g., from Dvala.async.run) to avoid the sync-first-then-retry pattern
+ * which can cause side effects to be executed twice.
+ */
+export declare function evaluateAsync(ast: Ast, contextStack: ContextStack): Promise<Any>;
+/**
+ * Evaluate a single AST node using the trampoline.
+ * Used as the `evaluateNode` callback passed to `getUndefinedSymbols`
+ * and other utilities.
+ */
+export declare function evaluateNode(node: AstNode, contextStack: ContextStack): MaybePromise<Any>;
+/**
+ * Evaluate an AST with full effect handler support.
+ *
+ * Uses the async trampoline loop, passing `handlers` and `signal` to `tick`
+ * so that `dispatchPerform` can fall back to host handlers when no local
+ * `try/with` matches.
+ *
+ * Always resolves — never rejects. All errors are captured in
+ * `RunResult.error`. Suspension is signaled via `RunResult.suspended`.
+ *
+ * The `AbortController` is created internally per `run()` call. The signal
+ * is passed to every host handler. Used for `race()` cancellation (Phase 6)
+ * and host-side timeouts.
+ */
+export declare function evaluateWithEffects(ast: Ast, contextStack: ContextStack, handlers?: Handlers): Promise<RunResult>;
+/**
+ * Resume a suspended continuation with a value.
+ *
+ * Re-enters the trampoline with `{ type: 'Value', value, k }` where `k` is
+ * the deserialized continuation stack. Host handlers and signal are provided
+ * fresh for this run.
+ */
+export declare function resumeWithEffects(k: ContinuationStack, value: Any, handlers?: Handlers): Promise<RunResult>;

package/dist/src/full.d.ts

@@ -0,0 +1,17 @@
+import './initReferenceData';
+export * from './index';
+export { allBuiltinModules } from './allModules';
+export { assertModule } from './builtin/modules/assertion';
+export { gridModule } from './builtin/modules/grid';
+export { randomModule } from './builtin/modules/random';
+export { vectorModule } from './builtin/modules/vector';
+export { linearAlgebraModule } from './builtin/modules/linear-algebra';
+export { matrixModule } from './builtin/modules/matrix';
+export { numberTheoryModule } from './builtin/modules/number-theory';
+export { mathUtilsModule } from './builtin/modules/math';
+export { functionalUtilsModule } from './builtin/modules/functional';
+export { bitwiseUtilsModule } from './builtin/modules/bitwise';
+export { apiReference, isCustomReference, isDatatypeReference, isFunctionReference, isShorthandReference } from '../reference';
+export type { Argument, CommonReference, CustomReference, DatatypeReference, FunctionReference, Reference, ShorthandReference } from '../reference';
+export type { ApiName, FunctionName, ShorthandName, DatatypeName } from '../reference/api';
+export { isApiName, isDataType } from '../reference/api';

package/dist/src/getUndefinedSymbols/index.d.ts

@@ -0,0 +1,7 @@
+import type { Builtin } from '../builtin/interface';
+import type { ContextStack } from '../evaluator/ContextStack';
+import type { EvaluateNode } from '../evaluator/interface';
+import type { Ast, AstNode } from '../parser/types';
+export type UndefinedSymbols = Set<string>;
+export declare const getUndefinedSymbols: GetUndefinedSymbols;
+export type GetUndefinedSymbols = (ast: Ast | AstNode[], contextStack: ContextStack, builtin: Builtin, evaluateNode: EvaluateNode) => UndefinedSymbols;

package/dist/src/index.d.ts

@@ -0,0 +1,18 @@
+export { isBuiltinFunction, isDvalaFunction, asDvalaFunction, assertDvalaFunction, isUserDefinedFunction, asUserDefinedFunction, assertUserDefinedFunction, isNativeJsFunction, asNativeJsFunction, assertNativeJsFunction, } from './typeGuards/dvalaFunction';
+export { type Arity } from './builtin/interface';
+export { type DvalaFunction, type NativeJsFunction } from './parser/types';
+export type { Context } from './evaluator/interface';
+export type { Ast } from './parser/types';
+export type { SourceCodeInfo } from './tokenizer/token';
+export type { Token, TokenType } from './tokenizer/token';
+export { normalExpressionKeys, specialExpressionKeys } from './builtin';
+export { Dvala } from './Dvala/Dvala';
+export type { DvalaModule } from './builtin/modules/interface';
+export type { DvalaBundle } from './bundler/interface';
+export { isDvalaBundle } from './bundler/interface';
+export { type DvalaError, isDvalaError } from './errors';
+export type { ContextParams, FilePathParams, MinifyParams, PureParams, DvalaRuntimeInfo, JsFunction } from './Dvala/Dvala';
+export { isGrid, isMatrix, isVector } from './typeGuards/annotatedArrays';
+export type { AutoCompleter } from './AutoCompleter/AutoCompleter';
+export { run, runSync, resume } from './effects';
+export type { EffectContext, EffectHandler, Handlers, RunResult, RunOptions, RunSyncOptions, SuspensionBlob, ResumeOptions } from './effects';

package/dist/src/initReferenceData.d.ts

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

package/dist/src/interface.d.ts

@@ -0,0 +1,7 @@
+import type { DvalaFunction, EffectRef, RegularExpression } from './parser/types';
+export type Arr = unknown[];
+export type Seq = string | Arr;
+export type Obj = Record<string, unknown>;
+export type Coll = Seq | Obj;
+export type Any = Coll | string | number | boolean | null | DvalaFunction | RegularExpression | EffectRef;
+export type UnknownRecord = Record<string, unknown>;

package/dist/src/modules/assertion.d.ts

@@ -0,0 +1,2 @@
+export { assertModule } from '../builtin/modules/assertion';
+export type { DvalaModule } from '../builtin/modules/interface';

package/dist/src/modules/bitwise.d.ts

@@ -0,0 +1,2 @@
+export { bitwiseUtilsModule } from '../builtin/modules/bitwise';
+export type { DvalaModule } from '../builtin/modules/interface';

package/dist/src/modules/collection.d.ts

@@ -0,0 +1,2 @@
+export { collectionUtilsModule } from '../builtin/modules/collection';
+export type { DvalaModule } from '../builtin/modules/interface';

package/dist/src/modules/convert.d.ts

@@ -0,0 +1,2 @@
+export { convertModule } from '../builtin/modules/convert';
+export type { DvalaModule } from '../builtin/modules/interface';

package/dist/src/modules/functional.d.ts

@@ -0,0 +1,2 @@
+export { functionalUtilsModule } from '../builtin/modules/functional';
+export type { DvalaModule } from '../builtin/modules/interface';

package/dist/src/modules/grid.d.ts

@@ -0,0 +1,2 @@
+export { gridModule } from '../builtin/modules/grid';
+export type { DvalaModule } from '../builtin/modules/interface';

package/dist/src/modules/linear-algebra.d.ts

@@ -0,0 +1,2 @@
+export { linearAlgebraModule } from '../builtin/modules/linear-algebra';
+export type { DvalaModule } from '../builtin/modules/interface';

package/dist/src/modules/math.d.ts

@@ -0,0 +1,2 @@
+export { mathUtilsModule } from '../builtin/modules/math';
+export type { DvalaModule } from '../builtin/modules/interface';

package/dist/src/modules/matrix.d.ts

@@ -0,0 +1,2 @@
+export { matrixModule } from '../builtin/modules/matrix';
+export type { DvalaModule } from '../builtin/modules/interface';

package/dist/src/modules/number-theory.d.ts

@@ -0,0 +1,2 @@
+export { numberTheoryModule } from '../builtin/modules/number-theory';
+export type { DvalaModule } from '../builtin/modules/interface';

package/dist/src/modules/random.d.ts

@@ -0,0 +1,2 @@
+export { randomModule } from '../builtin/modules/random';
+export type { DvalaModule } from '../builtin/modules/interface';

package/dist/src/modules/sequence.d.ts

@@ -0,0 +1,2 @@
+export { sequenceUtilsModule } from '../builtin/modules/sequence';
+export type { DvalaModule } from '../builtin/modules/interface';

package/dist/src/modules/string.d.ts

@@ -0,0 +1,2 @@
+export { stringUtilsModule } from '../builtin/modules/string';
+export type { DvalaModule } from '../builtin/modules/interface';

package/dist/src/modules/vector.d.ts

@@ -0,0 +1,2 @@
+export { vectorModule } from '../builtin/modules/vector';
+export type { DvalaModule } from '../builtin/modules/interface';

package/dist/src/parser/ParserContext.d.ts

@@ -0,0 +1,20 @@
+import type { SourceCodeInfo, Token } from '../tokenizer/token';
+import type { TokenStream } from '../tokenizer/tokenize';
+import type { AstNode } from './types';
+export declare class ParserContext {
+    private readonly tokens;
+    private position;
+    private storedPosition;
+    parseExpression: (precedence?: number) => AstNode;
+    constructor(tokenStream: TokenStream);
+    advance(): void;
+    tryPeek(): Token | undefined;
+    peek(): Token;
+    isAtEnd(): boolean;
+    peekSourceCodeInfo(): SourceCodeInfo | undefined;
+    storePosition(): number;
+    restorePosition(): void;
+    peekAhead(count: number): Token | undefined;
+    getPosition(): number;
+    getTokenAt(pos: number): Token | undefined;
+}

package/dist/src/parser/getPrecedence.d.ts

@@ -0,0 +1,3 @@
+import type { SourceCodeInfo } from '../tokenizer/token';
+import type { SymbolicBinaryOperator } from '../tokenizer/operators';
+export declare function getPrecedence(operatorSign: SymbolicBinaryOperator, sourceCodeInfo: SourceCodeInfo | undefined): number;

package/dist/src/parser/helpers.d.ts

@@ -0,0 +1,19 @@
+import type { OperatorToken, SourceCodeInfo } from '../tokenizer/token';
+import type { AstNode, BindingTarget, NormalBuiltinSymbolNode, NormalExpressionNodeWithName, SymbolNode, UserDefinedSymbolNode } from './types';
+import type { ParserContext } from './ParserContext';
+export declare const exponentiationPrecedence = 12;
+export declare const binaryFunctionalOperatorPrecedence = 3;
+export declare const conditionalOperatorPrecedence = 1;
+export declare function withSourceCodeInfo<T extends AstNode | BindingTarget>(node: T, sourceCodeInfo: SourceCodeInfo | undefined): T;
+export declare function stringToSymbolNode(value: string, sourceCodeInfo: SourceCodeInfo | undefined): SymbolNode;
+export declare function stringFromQuotedSymbol(value: string): string;
+/**
+ * Extract the symbol name from any symbol node type.
+ * UserDefinedSymbolNode: node[1] is the string name
+ * NormalBuiltinSymbolNode: node[1] is an index, need reverse lookup
+ * SpecialBuiltinSymbolNode: node[1] is an index, need reverse lookup
+ */
+export declare function getSymbolName(symbol: SymbolNode): string;
+export declare function createNamedNormalExpressionNode(symbolNode: NormalBuiltinSymbolNode | UserDefinedSymbolNode, params: AstNode[], sourceCodeInfo: SourceCodeInfo | undefined): NormalExpressionNodeWithName;
+export declare function isAtExpressionEnd(ctx: ParserContext): boolean;
+export declare function fromBinaryOperatorToNode(operator: OperatorToken, symbolNode: SymbolNode, left: AstNode, right: AstNode, sourceCodeInfo: SourceCodeInfo | undefined): AstNode;

package/dist/src/parser/index.d.ts

@@ -0,0 +1,5 @@
+import type { TokenStream } from '../tokenizer/tokenize';
+import type { AstNode } from './types';
+import { createParserContext, parseExpression } from './subParsers/parseExpression';
+export { createParserContext, parseExpression };
+export declare function parse(tokenStream: TokenStream): AstNode[];

package/dist/src/parser/subParsers/parseArray.d.ts

@@ -0,0 +1,3 @@
+import type { ArrayNode } from '../../builtin/specialExpressions/array';
+import type { ParserContext } from '../ParserContext';
+export declare function parseArray(ctx: ParserContext): ArrayNode;

package/dist/src/parser/subParsers/parseBindingTarget.d.ts

@@ -0,0 +1,8 @@
+import type { BindingTarget } from '../types';
+import type { ParserContext } from '../ParserContext';
+export interface ParseBindingTargetOptions {
+    requireDefaultValue?: true;
+    noRest?: true;
+    allowLiteralPatterns?: true;
+}
+export declare function parseBindingTarget(ctx: ParserContext, { requireDefaultValue, noRest, allowLiteralPatterns }?: ParseBindingTargetOptions): BindingTarget;

package/dist/src/parser/subParsers/parseCond.d.ts

@@ -0,0 +1,4 @@
+import type { CondNode } from '../../builtin/specialExpressions/cond';
+import { type SymbolToken } from '../../tokenizer/token';
+import type { ParserContext } from '../ParserContext';
+export declare function parseCond(ctx: ParserContext, token: SymbolToken): CondNode;

package/dist/src/parser/subParsers/parseDo.d.ts

@@ -0,0 +1,3 @@
+import type { DoNode } from '../../builtin/specialExpressions/block';
+import type { ParserContext } from '../ParserContext';
+export declare function parseDo(ctx: ParserContext, allowDocString?: boolean): [DoNode, string];

package/dist/src/parser/subParsers/parseExpression.d.ts

@@ -0,0 +1,5 @@
+import type { TokenStream } from '../../tokenizer/tokenize';
+import { ParserContext } from '../ParserContext';
+import type { AstNode } from '../types';
+export declare function createParserContext(tokenStream: TokenStream): ParserContext;
+export declare function parseExpression(ctx: ParserContext, precedence?: number): AstNode;

package/dist/src/parser/subParsers/parseForOrDoseq.d.ts

@@ -0,0 +1,4 @@
+import type { DoSeqNode, ForNode } from '../../builtin/specialExpressions/loops';
+import type { SymbolToken } from '../../tokenizer/token';
+import type { ParserContext } from '../ParserContext';
+export declare function parseForOrDoseq(ctx: ParserContext, firstToken: SymbolToken): ForNode | DoSeqNode;

package/dist/src/parser/subParsers/parseFunction.d.ts

@@ -0,0 +1,4 @@
+import type { LambdaNode } from '../../builtin/specialExpressions/functions';
+import type { ParserContext } from '../ParserContext';
+export declare function parseLambdaFunction(ctx: ParserContext): LambdaNode | null;
+export declare function parseShorthandLambdaFunction(ctx: ParserContext): LambdaNode;

package/dist/src/parser/subParsers/parseFunctionCall.d.ts

@@ -0,0 +1,3 @@
+import type { AstNode } from '../types';
+import type { ParserContext } from '../ParserContext';
+export declare function parseFunctionCall(ctx: ParserContext, symbol: AstNode): AstNode;

package/dist/src/parser/subParsers/parseIfOrUnless.d.ts

@@ -0,0 +1,5 @@
+import type { IfNode } from '../../builtin/specialExpressions/if';
+import type { UnlessNode } from '../../builtin/specialExpressions/unless';
+import type { SymbolToken } from '../../tokenizer/token';
+import type { ParserContext } from '../ParserContext';
+export declare function parseIfOrUnless(ctx: ParserContext, token: SymbolToken): IfNode | UnlessNode;

package/dist/src/parser/subParsers/parseImplicitBlock.d.ts

@@ -0,0 +1,5 @@
+import type { AstNode } from '../types';
+import type { ParserContext } from '../ParserContext';
+type ImplicitBlockEnd = 'end' | 'else' | 'catch' | 'case' | 'with';
+export declare function parseImplicitBlock(ctx: ParserContext, ends: ImplicitBlockEnd[]): AstNode;
+export {};

package/dist/src/parser/subParsers/parseLet.d.ts

@@ -0,0 +1,4 @@
+import type { LetNode } from '../../builtin/specialExpressions/let';
+import type { SymbolToken } from '../../tokenizer/token';
+import type { ParserContext } from '../ParserContext';
+export declare function parseLet(ctx: ParserContext, token: SymbolToken): LetNode;

package/dist/src/parser/subParsers/parseLoop.d.ts

@@ -0,0 +1,4 @@
+import type { LoopNode } from '../../builtin/specialExpressions/loop';
+import type { SymbolToken } from '../../tokenizer/token';
+import type { ParserContext } from '../ParserContext';
+export declare function parseLoop(ctx: ParserContext, firstToken: SymbolToken): LoopNode;

package/dist/src/parser/subParsers/parseMatch.d.ts

@@ -0,0 +1,4 @@
+import type { MatchNode } from '../../builtin/specialExpressions/match';
+import { type SymbolToken } from '../../tokenizer/token';
+import type { ParserContext } from '../ParserContext';
+export declare function parseMatch(ctx: ParserContext, token: SymbolToken): MatchNode;

package/dist/src/parser/subParsers/parseNumber.d.ts

@@ -0,0 +1,3 @@
+import type { NumberNode } from '../types';
+import type { ParserContext } from '../ParserContext';
+export declare function parseNumber(ctx: ParserContext): NumberNode;

package/dist/src/parser/subParsers/parseObject.d.ts

@@ -0,0 +1,3 @@
+import type { ObjectNode } from '../../builtin/specialExpressions/object';
+import type { ParserContext } from '../ParserContext';
+export declare function parseObject(ctx: ParserContext): ObjectNode;

package/dist/src/parser/subParsers/parseOperand.d.ts

@@ -0,0 +1,3 @@
+import type { AstNode } from '../types';
+import type { ParserContext } from '../ParserContext';
+export declare function parseOperand(ctx: ParserContext): AstNode;

package/dist/src/parser/subParsers/parseRegexpShorthand.d.ts

@@ -0,0 +1,3 @@
+import type { NormalExpressionNodeWithName } from '../types';
+import type { ParserContext } from '../ParserContext';
+export declare function parseRegexpShorthand(ctx: ParserContext): NormalExpressionNodeWithName;

package/dist/src/parser/subParsers/parseReservedSymbol.d.ts

@@ -0,0 +1,3 @@
+import type { NumberNode, ReservedSymbolNode } from '../types';
+import type { ParserContext } from '../ParserContext';
+export declare function parseReservedSymbol(ctx: ParserContext): ReservedSymbolNode | NumberNode;

package/dist/src/parser/subParsers/parseString.d.ts

@@ -0,0 +1,4 @@
+import type { StringNode } from '../types';
+import type { StringToken } from '../../tokenizer/token';
+import type { ParserContext } from '../ParserContext';
+export declare function parseString(ctx: ParserContext, token: StringToken): StringNode;

package/dist/src/parser/subParsers/parseSymbol.d.ts

@@ -0,0 +1,3 @@
+import type { NormalBuiltinSymbolNode, SpecialBuiltinSymbolNode, SymbolNode } from '../types';
+import type { ParserContext } from '../ParserContext';
+export declare function parseSymbol(ctx: ParserContext): SymbolNode | NormalBuiltinSymbolNode | SpecialBuiltinSymbolNode;

package/dist/src/parser/subParsers/parseTry.d.ts

@@ -0,0 +1,4 @@
+import type { TryNode } from '../../builtin/specialExpressions/try';
+import type { SymbolToken } from '../../tokenizer/token';
+import type { ParserContext } from '../ParserContext';
+export declare function parseTry(ctx: ParserContext, token: SymbolToken): TryNode;