@ohm-js/wasm 0.6.7 → 0.6.9

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-export * from './src/AstBuilder.js';
 export { Compiler } from './src/Compiler.js';
 export * from './src/miniohm.ts';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,4 +1,3 @@
-export * from './src/AstBuilder.js';
 export { Compiler } from './src/Compiler.js';
 export * from "./src/miniohm.js";
 //# sourceMappingURL=index.js.map

package/dist/src/AstBuilder.d.ts

@@ -1,20 +1,19 @@
-import type { CstNode, MatchResult } from './miniohm.ts';
-export type AstNodeTemplate<T> = {
-    [property: string]: number | string | boolean | object | null | ((this: AstBuilder, children: CstNode[]) => T);
+import type { CstNode, CstNodeChildren, MatchResult, NonterminalNode, TerminalNode } from './miniohm.ts';
+export type AstNodeTemplate<R> = {
+    [property: string]: number | string | boolean | object | null | ((this: AstBuilder, children: CstNodeChildren) => R);
 };
-export type AstMapping<T> = Record<string, AstNodeTemplate<T> | number | ((this: AstBuilder, ...children: CstNode[]) => T)>;
-export declare class AstBuilder<T = any> {
+export type AstMapping<R> = Record<string, AstNodeTemplate<R> | number | ((this: AstBuilder, ...children: CstNodeChildren) => R)>;
+export declare class AstBuilder<TNode = any> {
     currNode?: CstNode;
     private _mapping;
     private _depth;
     private _debug;
-    constructor(mapping: AstMapping<T>, opts?: {
+    constructor(mapping: AstMapping<TNode>, opts?: {
         debug?: boolean;
     });
     private _debugLog;
-    _visitTerminal(node: CstNode): string;
-    _visitNonterminal(node: CstNode): unknown;
-    _visitIter(node: CstNode): T[] | T | null;
-    toAst(nodeOrResult: MatchResult | CstNode): T;
+    _visitTerminal(node: TerminalNode): string;
+    _visitNonterminal(node: NonterminalNode): unknown;
+    toAst(nodeOrResult: MatchResult | CstNode): TNode;
 }
 //# sourceMappingURL=AstBuilder.d.ts.map

package/dist/src/AstBuilder.js

@@ -4,7 +4,7 @@ function childAt(children, idx, ruleName, propName = '') {
         const path = propName ? `${ruleName}.${propName}` : ruleName;
         throw new Error(`${path}: Child index ${idx} out of range`);
     }
-    return children[idx];
+    return checkNotNull(children[idx]);
 }
 export class AstBuilder {
     currNode;
@@ -14,10 +14,10 @@ export class AstBuilder {
     constructor(mapping, opts = {}) {
         const handleListOf = (child) => this.toAst(child);
         const handleEmptyListOf = () => [];
-        const handleNonemptyListOf = (first, iterSepAndElem) => [
-            this.toAst(first),
-            ...iterSepAndElem.map((_, elem) => this.toAst(elem)),
-        ];
+        const handleNonemptyListOf = (first, sepAndElemList) => {
+            assert(!!sepAndElemList?.isList(), 'Expected a ListNode');
+            return [this.toAst(first), ...sepAndElemList.collect((_, elem) => this.toAst(elem))];
+        };
         this._mapping = {
             listOf: handleListOf,
             ListOf: handleListOf,
@@ -37,15 +37,15 @@ export class AstBuilder {
         return node.sourceString;
     }
     _visitNonterminal(node) {
-        const { children, ruleName } = node;
+        const { children, ctorName } = node;
         const mapping = this._mapping;
-        this._debugLog(`> ${ruleName}`);
+        this._debugLog(`> ${ctorName}`);
         const dbgReturn = (val) => {
-            this._debugLog(`| ${ruleName} DONE`);
+            this._debugLog(`| ${ctorName} DONE`);
             return val;
         };
         // without customization
-        if (!Object.hasOwn(mapping, ruleName)) {
+        if (!Object.hasOwn(mapping, ctorName)) {
             // lexical rule
             if (node.isLexical()) {
                 return node.sourceString;
@@ -58,22 +58,22 @@ export class AstBuilder {
             // rest: terms with multiple children
         }
         // direct forward
-        if (typeof mapping[ruleName] === 'number') {
-            const idx = mapping[ruleName];
-            return dbgReturn(this.toAst(childAt(children, idx, ruleName)));
+        if (typeof mapping[ctorName] === 'number') {
+            const idx = mapping[ctorName];
+            return dbgReturn(this.toAst(childAt(children, idx, ctorName)));
         }
-        assert(typeof mapping[ruleName] !== 'function', "shouldn't be possible");
+        assert(typeof mapping[ctorName] !== 'function', "shouldn't be possible");
         // named/mapped children or unnamed children ('0', '1', '2', ...)
-        const propMap = mapping[ruleName] || children;
+        const propMap = mapping[ctorName] || children;
         const ans = {
-            type: ruleName,
+            type: ctorName,
         };
         // eslint-disable-next-line guard-for-in
         for (const prop in propMap) {
-            const mappedProp = mapping[ruleName] && mapping[ruleName][prop];
+            const mappedProp = mapping[ctorName] && mapping[ctorName][prop];
             if (typeof mappedProp === 'number') {
                 // direct forward
-                ans[prop] = this.toAst(childAt(children, mappedProp, ruleName, prop));
+                ans[prop] = this.toAst(childAt(children, mappedProp, ctorName, prop));
             }
             else if (typeof mappedProp === 'string' ||
                 typeof mappedProp === 'boolean' ||
@@ -102,33 +102,26 @@ export class AstBuilder {
         }
         return dbgReturn(ans);
     }
-    _visitIter(node) {
-        const { children } = node;
-        if (node.isOptional()) {
-            if (children.length === 0) {
-                return null;
-            }
-            return this.toAst(children[0]);
-        }
-        return children.map(c => this.toAst(c));
-    }
     toAst(nodeOrResult) {
         let node = nodeOrResult;
         if (typeof nodeOrResult.succeeded === 'function') {
             const matchResult = nodeOrResult;
             assert(matchResult.succeeded(), 'Cannot convert failed match result to AST');
-            node = checkNotNull(matchResult._cst);
+            node = matchResult.grammar.getCstRoot();
         }
         let ans;
         this._depth++;
         if (node.isTerminal()) {
             ans = this._visitTerminal(node);
         }
-        else if (node.isIter()) {
-            ans = this._visitIter(node);
+        else if (node.isOptional()) {
+            ans = node.ifPresent((child) => this.toAst(child), () => null);
+        }
+        else if (node.isList() || node.isSeq()) {
+            ans = node.children.map(c => this.toAst(c));
         }
         else {
-            assert(node.isNonterminal(), `Unknown node type: ${node._type}`);
+            assert(node.isNonterminal(), `Unknown node type: ${node.type}`);
             this.currNode = node;
             ans =
                 typeof this._mapping[node.ctorName] === 'function'

package/dist/src/compat.d.ts

@@ -5,4 +5,5 @@ export interface Grammar extends WasmGrammar {
 }
 export declare function grammar(source: string): Grammar;
 export declare function grammars(source: string): Record<string, Grammar>;
+export { AstBuilder } from './AstBuilder.js';
 //# sourceMappingURL=compat.d.ts.map

package/dist/src/compat.js

@@ -21,4 +21,5 @@ export function grammars(source) {
     }
     return ans;
 }
+export { AstBuilder } from './AstBuilder.js';
 //# sourceMappingURL=compat.js.map

package/dist/src/miniohm.d.ts

@@ -1,3 +1,11 @@
+export declare const CstNodeType: {
+    readonly NONTERMINAL: 0;
+    readonly TERMINAL: 1;
+    readonly LIST: 2;
+    readonly OPT: 3;
+    readonly SEQ: 4;
+};
+export type CstNodeType = (typeof CstNodeType)[keyof typeof CstNodeType];
 export declare class WasmGrammar {
     name: string;
     private _instance?;
@@ -30,62 +38,184 @@ export declare class WasmGrammar {
     private _fillInputBuffer;
     getRightmostFailurePosition(): number;
 }
-export declare class CstNode {
-    _ruleNames: string[];
-    _view: DataView;
-    _children?: CstNode[];
+export interface MatchContext {
+    ruleNames: string[];
+    view: DataView;
+    input: string;
+}
+export type CstNode = NonterminalNode | TerminalNode | ListNode | OptNode | SeqNode;
+export type CstNodeChildren = readonly CstNode[];
+export interface CstNodeBase {
+    ctorName: string;
+    source: {
+        startIdx: number;
+        endIdx: number;
+    };
+    sourceString: string;
+    matchLength: number;
+    isNonterminal(): this is NonterminalNode;
+    isTerminal(): this is TerminalNode;
+    isOptional(): this is OptNode;
+    isSeq(): this is SeqNode;
+    isList(): this is ListNode;
+}
+export interface NonterminalNode<TChildren extends CstNodeChildren = CstNodeChildren> extends CstNodeBase {
+    type: typeof CstNodeType.NONTERMINAL;
+    ctorName: string;
+    leadingSpaces?: NonterminalNode;
+    children: TChildren;
+    isSyntactic(ruleName?: string): boolean;
+    isLexical(ruleName?: string): boolean;
+}
+export interface TerminalNode extends CstNodeBase {
+    type: typeof CstNodeType.TERMINAL;
+    ctorName: '_terminal';
+    leadingSpaces?: NonterminalNode;
+    value: string;
+}
+export interface ListNode<TNode extends CstNode = CstNode> extends CstNodeBase {
+    type: typeof CstNodeType.LIST;
+    ctorName: '_list';
+    children: readonly TNode[];
+    collect: <R>(cb: (...children: CstNode[]) => R) => R[];
+}
+export interface OptNode<TChild extends CstNode = CstNode> extends CstNodeBase {
+    type: typeof CstNodeType.OPT;
+    ctorName: '_opt';
+    children: [] | [TChild];
+    ifPresent<R>(consume: TChild extends SeqNode<infer T> ? (...children: T) => R : (child: TChild) => R, orElse?: () => R): R;
+    ifPresent<R>(consume: TChild extends SeqNode<infer T> ? (...children: T) => R : (child: TChild) => R): R | undefined;
+    isPresent(): boolean;
+    isEmpty(): boolean;
+}
+export interface SeqNode<TChildren extends CstNodeChildren = CstNodeChildren> extends CstNodeBase {
+    type: typeof CstNodeType.SEQ;
+    ctorName: '_seq';
+    children: TChildren;
+    unpack: <R>(cb: (...children: TChildren) => R) => R;
+}
+export declare class CstNodeImpl implements CstNodeBase {
+    _ctx: MatchContext;
+    _children?: CstNodeChildren;
     _base: number;
-    _input: string;
     startIdx: number;
-    leadingSpaces: CstNode | undefined;
+    leadingSpaces?: NonterminalNode;
     source: {
         startIdx: number;
         endIdx: number;
     };
-    constructor(ruleNames: string[], dataView: DataView, ptr: number, input: string, startIdx: number);
-    get type(): number;
-    isNonterminal(): boolean;
-    isTerminal(): boolean;
-    isIter(): boolean;
-    isOptional(): boolean;
+    constructor(ctx: MatchContext, ptr: number, startIdx: number);
+    get type(): CstNodeType;
+    private get matchRecordType();
+    isNonterminal(): this is NonterminalNode;
+    isTerminal(): this is TerminalNode;
+    isList(): this is ListNode;
+    isOptional(): this is OptNode;
+    isSeq(): this is SeqNode;
     get ctorName(): string;
-    get ruleName(): string;
     get count(): number;
     get matchLength(): number;
     get _typeAndDetails(): number;
     get arity(): number;
-    get children(): CstNode[];
-    _computeChildren(): CstNode[];
+    get children(): CstNodeChildren;
+    _computeChildren(): CstNodeImpl[];
     get sourceString(): string;
     isSyntactic(ruleName?: string): boolean;
     isLexical(ruleName?: string): boolean;
     toString(): string;
-    map<T>(callbackFn: (...args: CstNode[]) => T): T[];
-    when<T>({ some, none }: {
-        some: (...args: CstNode[]) => T;
-        none: () => T;
-    }): T;
 }
-export declare function dumpCstNode(node: CstNode, depth?: number): void;
+export declare class SeqNodeImpl<TChildren extends CstNodeChildren = CstNodeChildren> implements SeqNode<TChildren> {
+    type: 4;
+    ctorName: "_seq";
+    children: TChildren;
+    source: {
+        startIdx: number;
+        endIdx: number;
+    };
+    sourceString: string;
+    get matchLength(): number;
+    constructor(children: TChildren, source: {
+        startIdx: number;
+        endIdx: number;
+    }, sourceString: string);
+    isNonterminal(): this is NonterminalNode;
+    isTerminal(): this is TerminalNode;
+    isOptional(): this is OptNode;
+    isSeq(): this is SeqNode;
+    isList(): this is ListNode;
+    unpack<R>(cb: (...args: TChildren) => R): R;
+}
+export declare class ListNodeImpl<TNode extends CstNode = CstNode> implements ListNode<TNode> {
+    type: 2;
+    ctorName: "_list";
+    children: readonly TNode[];
+    source: {
+        startIdx: number;
+        endIdx: number;
+    };
+    sourceString: string;
+    get matchLength(): number;
+    constructor(children: readonly TNode[], source: {
+        startIdx: number;
+        endIdx: number;
+    }, sourceString: string);
+    isNonterminal(): this is NonterminalNode;
+    isTerminal(): this is TerminalNode;
+    isList(): this is ListNode;
+    isOptional(): this is OptNode;
+    isSeq(): this is SeqNode;
+    collect<R>(cb: (...args: CstNode[]) => R): R[];
+}
+export declare class OptNodeImpl<TNode extends CstNode = CstNode> implements OptNode<TNode> {
+    type: 3;
+    ctorName: "_opt";
+    children: [] | [TNode];
+    source: {
+        startIdx: number;
+        endIdx: number;
+    };
+    sourceString: string;
+    get matchLength(): number;
+    constructor(child: TNode | undefined, source: {
+        startIdx: number;
+        endIdx: number;
+    }, sourceString: string);
+    isNonterminal(): this is NonterminalNode;
+    isTerminal(): this is TerminalNode;
+    isList(): this is ListNode;
+    isOptional(): this is OptNode;
+    isSeq(): this is SeqNode;
+    ifPresent<R>(consume: TNode extends SeqNode<infer T> ? (...children: T) => R : (child: TNode) => R, orElse?: () => R): R | undefined;
+    isPresent(): boolean;
+    isEmpty(): boolean;
+}
 export declare class MatchResult {
     grammar: WasmGrammar;
-    input: string;
     startExpr: string;
-    _cst: CstNode | null;
+    _ctx: MatchContext;
+    _succeeded: boolean;
+    constructor(grammar: WasmGrammar, startExpr: string, ctx: MatchContext, succeeded: boolean);
+    [Symbol.dispose](): void;
+    detach(): void;
+    succeeded(): this is SucceededMatchResult;
+    failed(): this is FailedMatchResult;
+    toString(): string;
+    use<T>(cb: (r: MatchResult) => T): T;
+}
+declare class SucceededMatchResult extends MatchResult {
+    _cst: CstNode;
+    constructor(grammar: WasmGrammar, startExpr: string, ctx: MatchContext, succeeded: boolean);
+}
+declare class FailedMatchResult extends MatchResult {
+    constructor(grammar: WasmGrammar, startExpr: string, ctx: MatchContext, succeeded: boolean, rightmostFailurePosition: number, optRecordedFailures?: any);
     _rightmostFailurePosition: number;
     _rightmostFailures: any;
     shortMessage?: string;
     message?: string;
-    constructor(matcher: WasmGrammar, input: string, startExpr: string, cst: CstNode | null, rightmostFailurePosition: number, optRecordedFailures?: any);
-    [Symbol.dispose](): void;
-    detach(): void;
-    succeeded(): boolean;
-    failed(): boolean;
     getRightmostFailurePosition(): number;
     getRightmostFailures(): any;
-    toString(): string;
     getExpectedText(): string;
     getInterval(): void;
-    use<T>(cb: (r: MatchResult) => T): T;
 }
+export {};
 //# sourceMappingURL=miniohm.d.ts.map

package/dist/src/miniohm.js

@@ -1,11 +1,20 @@
 import { assert, checkNotNull } from "./assert.js";
-const CST_NODE_TYPE_MASK = 0b11;
-const CstNodeType = {
+const MATCH_RECORD_TYPE_MASK = 0b11;
+// A MatchRecord is the representation of a CstNode in Wasm linear memory.
+const MatchRecordType = {
     NONTERMINAL: 0,
     TERMINAL: 1,
     ITER_FLAG: 2,
     OPTIONAL: 3,
 };
+// A _CST node_ is the user-facing representation, built from a match record.
+export const CstNodeType = {
+    NONTERMINAL: 0,
+    TERMINAL: 1,
+    LIST: 2,
+    OPT: 3,
+    SEQ: 4,
+};
 const compileOptions = {
     builtins: ['js-string'],
 };
@@ -189,7 +198,12 @@ export class WasmGrammar {
             debugger; // eslint-disable-line no-debugger
         const ruleId = checkNotNull(this._ruleIds.get(ruleName || this._ruleNames[0]), `unknown rule: '${ruleName}'`);
         const succeeded = this._instance.exports.match(input, ruleId);
-        const result = new MatchResult(this, this._input, ruleName || this._ruleNames[0], succeeded ? this.getCstRoot() : null, this.getRightmostFailurePosition());
+        const ctx = {
+            ruleNames: this._ruleNames,
+            view: new DataView(this._instance.exports.memory.buffer),
+            input: this._instance.exports.input.value,
+        };
+        const result = createMatchResult(this, ruleName || this._ruleNames[0], ctx, !!succeeded);
         result.detach = this._detachMatchResult.bind(this, result);
         this._resultStack.push(result);
         return result;
@@ -200,13 +214,19 @@ export class WasmGrammar {
     getCstRoot() {
         const { exports } = this._instance;
         const { buffer } = exports.memory;
-        const firstNode = new CstNode(this._ruleNames, new DataView(buffer), exports.bindingsAt(0), exports.input.value, 0);
+        const ctx = {
+            ruleNames: this._ruleNames,
+            view: new DataView(buffer),
+            input: exports.input.value,
+        };
+        const firstNode = new CstNodeImpl(ctx, exports.bindingsAt(0), 0);
+        assert(firstNode.isNonterminal());
         if (firstNode.ctorName !== '$spaces') {
             return firstNode;
         }
-        assert(exports.getBindingsLength() > 1);
+        assert(exports.getBindingsLength() > 1 && firstNode.ctorName === '$spaces');
         const nextAddr = exports.bindingsAt(1);
-        const root = new CstNode(this._ruleNames, new DataView(buffer), nextAddr, exports.input.value, firstNode.matchLength);
+        const root = new CstNodeImpl(ctx, nextAddr, firstNode.matchLength);
         root.leadingSpaces = firstNode;
         return root;
     }
@@ -222,33 +242,40 @@ export class WasmGrammar {
         return this._instance.exports.rightmostFailurePos.value;
     }
 }
-export class CstNode {
-    _ruleNames;
-    _view;
-    _children;
+export class CstNodeImpl {
+    _ctx;
+    _children = undefined;
     _base;
-    _input;
     startIdx;
-    leadingSpaces;
+    leadingSpaces = undefined;
     source;
-    constructor(ruleNames, dataView, ptr, input, startIdx) {
+    constructor(ctx, ptr, startIdx) {
         // Non-enumerable properties
         Object.defineProperties(this, {
-            _ruleNames: { value: ruleNames },
-            _view: { value: dataView },
+            _ctx: { value: ctx },
             _children: { writable: true },
         });
         this._base = ptr;
-        this._input = input;
         this.startIdx = startIdx;
-        this.leadingSpaces = undefined;
         this.source = {
             startIdx,
             endIdx: startIdx + this.sourceString.length,
         };
     }
     get type() {
-        return this._typeAndDetails & CST_NODE_TYPE_MASK;
+        switch (this._typeAndDetails & MATCH_RECORD_TYPE_MASK) {
+            case MatchRecordType.NONTERMINAL:
+                return CstNodeType.NONTERMINAL;
+            case MatchRecordType.TERMINAL:
+                return CstNodeType.TERMINAL;
+            case MatchRecordType.ITER_FLAG:
+                return CstNodeType.LIST;
+            default:
+                throw new Error('unreachable');
+        }
+    }
+    get matchRecordType() {
+        return (this._typeAndDetails & MATCH_RECORD_TYPE_MASK);
     }
     isNonterminal() {
         return this.type === CstNodeType.NONTERMINAL;
@@ -256,50 +283,90 @@ export class CstNode {
     isTerminal() {
         return this.type === CstNodeType.TERMINAL;
     }
-    isIter() {
-        return (this._typeAndDetails & CstNodeType.ITER_FLAG) !== 0;
+    isList() {
+        return this.type === CstNodeType.LIST;
     }
     isOptional() {
-        return this.type === CstNodeType.OPTIONAL;
+        return this.type === CstNodeType.OPT;
     }
-    get ctorName() {
-        return this.isTerminal() ? '_terminal' : this.isIter() ? '_iter' : this.ruleName;
+    isSeq() {
+        return this.type === CstNodeType.SEQ;
     }
-    get ruleName() {
-        assert(this.isNonterminal(), 'Not a non-terminal');
-        const ruleId = this._view.getInt32(this._base + 8, true) >>> 2;
-        return this._ruleNames[ruleId].split('<')[0];
+    get ctorName() {
+        switch (this.type) {
+            case CstNodeType.NONTERMINAL: {
+                const { ruleNames, view } = this._ctx;
+                const ruleId = view.getInt32(this._base + 8, true) >>> 2;
+                return ruleNames[ruleId].split('<')[0];
+            }
+            case CstNodeType.TERMINAL:
+                return '_terminal';
+            case CstNodeType.LIST:
+                return '_list';
+            case CstNodeType.OPT:
+                return '_opt';
+            case CstNodeType.SEQ:
+                return '_seq';
+        }
     }
     get count() {
-        return this._view.getUint32(this._base, true);
+        return this._ctx.view.getUint32(this._base, true);
     }
     get matchLength() {
-        return this._view.getUint32(this._base + 4, true);
+        return this._ctx.view.getUint32(this._base + 4, true);
     }
     get _typeAndDetails() {
-        return this._view.getInt32(this._base + 8, true);
+        return this._ctx.view.getInt32(this._base + 8, true);
     }
     get arity() {
         return this._typeAndDetails >>> 2;
     }
     get children() {
         if (!this._children) {
-            this._children = this._computeChildren();
+            this._children = this._computeChildren().map((n) => {
+                const { matchRecordType } = n;
+                if (matchRecordType === MatchRecordType.OPTIONAL) {
+                    const child = n.children.length <= 1
+                        ? n.children[0]
+                        : new SeqNodeImpl(n.children, n.source, n.sourceString);
+                    return new OptNodeImpl(child, n.source, n.sourceString);
+                }
+                else if (matchRecordType === MatchRecordType.ITER_FLAG) {
+                    if (n.arity <= 1) {
+                        return new ListNodeImpl(n.children, n.source, n.sourceString);
+                    }
+                    const arr = [];
+                    let startIdx = n.startIdx;
+                    for (let i = 0; i < n.children.length; i += n.arity) {
+                        // FIXME: We don't need any of this nonsense if we actually build the SeqNodes at parse time.
+                        const seqChildren = n.children.slice(i, i + n.arity);
+                        const endIdx = checkNotNull(seqChildren.at(-1)).source.endIdx;
+                        const sourceString = n._ctx.input.slice(startIdx, endIdx);
+                        arr.push(new SeqNodeImpl(seqChildren, { startIdx, endIdx }, sourceString));
+                        startIdx = endIdx;
+                    }
+                    assert(startIdx === n.source.endIdx);
+                    return new ListNodeImpl(arr, n.source, n.sourceString);
+                }
+                return n; // FIXME
+            });
         }
         return this._children;
     }
     _computeChildren() {
         const children = [];
+        const { ruleNames, view, input } = this._ctx;
         let spaces;
         let { startIdx } = this;
         for (let i = 0; i < this.count; i++) {
             const slotOffset = this._base + 16 + i * 4;
-            const ptr = this._view.getUint32(slotOffset, true);
+            const ptr = view.getUint32(slotOffset, true);
             // TODO: Avoid allocating $spaces nodes altogether?
-            const node = new CstNode(this._ruleNames, this._view, ptr, this._input, startIdx);
-            if (node.ctorName === '$spaces') {
+            const node = new CstNodeImpl(this._ctx, ptr, startIdx);
+            if (node.matchRecordType === MatchRecordType.NONTERMINAL &&
+                node.ctorName === '$spaces') {
                 assert(!spaces, 'Multiple $spaces nodes found');
-                spaces = node;
+                spaces = node; // FIXME
             }
             else {
                 if (spaces) {
@@ -314,70 +381,161 @@ export class CstNode {
         return children;
     }
     get sourceString() {
-        return this._input.slice(this.startIdx, this.startIdx + this.matchLength);
+        return this._ctx.input.slice(this.startIdx, this.startIdx + this.matchLength);
     }
     isSyntactic(ruleName) {
-        const firstChar = this.ruleName[0];
+        assert(this.isNonterminal(), 'Not a nonterminal');
+        const firstChar = this.ctorName[0];
         return firstChar === firstChar.toUpperCase();
     }
     isLexical(ruleName) {
+        assert(this.isNonterminal(), 'Not a nonterminal');
         return !this.isSyntactic(ruleName);
     }
     toString() {
-        const ctorName = this.isTerminal() ? '_terminal' : this.isIter() ? '_iter' : this.ruleName;
+        const ctorName = this.isTerminal() ? '_terminal' : this.isSeq() ? '_iter' : this.ctorName;
         const { sourceString, startIdx } = this;
         return `CstNode {ctorName: ${ctorName}, sourceString: ${sourceString}, startIdx: ${startIdx} }`;
     }
-    // Other possible names: collect, mapChildren, mapUnpack, unpackEach, …
-    map(callbackFn) {
-        const { arity, children } = this;
-        assert(callbackFn.length === arity, 'bad arity');
-        const ans = [];
-        for (let i = 0; i < children.length; i += arity) {
-            ans.push(callbackFn(...children.slice(i, i + arity)));
-        }
-        return ans;
+}
+export class SeqNodeImpl {
+    type = CstNodeType.SEQ;
+    ctorName = '_seq';
+    children;
+    source;
+    sourceString;
+    get matchLength() {
+        return this.sourceString.length;
+    }
+    constructor(children, source, sourceString) {
+        this.children = children;
+        this.source = source;
+        this.sourceString = sourceString;
+    }
+    isNonterminal() {
+        return false;
     }
-    when({ some, none }) {
-        assert(this.isOptional(), 'Not an optional');
-        if (this.children.length === 0)
-            return none();
-        assert(some.length === this.children.length, `bad arity: expected ${this.children.length}, got ${some.length}`);
-        return some(...this.children);
+    isTerminal() {
+        return false;
+    }
+    isOptional() {
+        return false;
+    }
+    isSeq() {
+        return true;
+    }
+    isList() {
+        return false;
+    }
+    unpack(cb) {
+        assert(cb.length === this.children.length, `bad arity: expected ${this.children.length}, got ${cb.length}`);
+        return cb.call(null, ...this.children); // FIXME
     }
 }
-export function dumpCstNode(node, depth = 0) {
-    const { _base, children, ctorName, matchLength, startIdx } = node;
-    const indent = Array.from({ length: depth }).join('  ');
-    const addr = _base.toString(16);
-    // eslint-disable-next-line no-console
-    console.log(`${indent}${addr} ${ctorName}@${startIdx}, matchLength ${matchLength}, children ${children.length}` // eslint-disable-line max-len
-    );
-    node.children.forEach(c => dumpCstNode(c, depth + 1));
+export class ListNodeImpl {
+    type = CstNodeType.LIST;
+    ctorName = '_list';
+    children;
+    source;
+    sourceString;
+    get matchLength() {
+        return this.sourceString.length;
+    }
+    constructor(children, source, sourceString) {
+        this.children = children;
+        this.source = source;
+        this.sourceString = sourceString;
+    }
+    isNonterminal() {
+        return false;
+    }
+    isTerminal() {
+        return false;
+    }
+    isList() {
+        return true;
+    }
+    isOptional() {
+        return false;
+    }
+    isSeq() {
+        return false;
+    }
+    collect(cb) {
+        return this.children.map(c => {
+            return c?.isSeq() ? c.unpack(cb) : cb(c);
+        });
+    }
 }
+export class OptNodeImpl {
+    type = CstNodeType.OPT;
+    ctorName = '_opt';
+    children;
+    source;
+    sourceString;
+    get matchLength() {
+        return this.sourceString.length;
+    }
+    constructor(child, source, sourceString) {
+        this.children = child ? [child] : [];
+        this.source = source;
+        this.sourceString = sourceString;
+    }
+    isNonterminal() {
+        return false;
+    }
+    isTerminal() {
+        return false;
+    }
+    isList() {
+        return false;
+    }
+    isOptional() {
+        return true;
+    }
+    isSeq() {
+        return false;
+    }
+    ifPresent(consume, orElse) {
+        const child = this.children[0];
+        if (child) {
+            return child.isSeq()
+                ? child.unpack(consume)
+                : consume(child);
+        }
+        if (orElse)
+            return orElse();
+    }
+    isPresent() {
+        return this.children.length > 0;
+    }
+    isEmpty() {
+        return this.children.length === 0;
+    }
+}
+// export function dumpCstNode(node: CstNode, depth = 0): void {
+//   const {_base, children, ctorName, matchLength, startIdx} = node;
+//   const indent = Array.from({length: depth}).join('  ');
+//   const addr = _base.toString(16);
+//   // eslint-disable-next-line no-console
+//   console.log(
+//     `${indent}${addr} ${ctorName}@${startIdx}, matchLength ${matchLength}, children ${children.length}` // eslint-disable-line max-len
+//   );
+//   node.children.forEach(c => dumpCstNode(c, depth + 1));
+// }
 export class MatchResult {
     // Note: This is different from the JS implementation, which has:
     //    matcher: Matcher;
     // …instead.
     grammar;
-    input;
     startExpr;
-    _cst;
-    _rightmostFailurePosition;
-    _rightmostFailures;
-    shortMessage;
-    message;
-    constructor(matcher, input, startExpr, cst, rightmostFailurePosition, optRecordedFailures) {
-        this.grammar = matcher;
-        this.input = input;
+    _ctx;
+    _succeeded;
+    constructor(grammar, startExpr, ctx, succeeded) {
+        this.grammar = grammar;
         this.startExpr = startExpr;
-        this._cst = cst;
-        this._rightmostFailurePosition = rightmostFailurePosition;
-        this._rightmostFailures = optRecordedFailures;
-        // TODO: Define these as lazy properties, like in the JS implementation.
-        if (this.failed()) {
-            this.shortMessage = this.message = `Match failed at pos ${rightmostFailurePosition}`;
-        }
+        this._ctx = ctx;
+        this._succeeded = succeeded;
     }
     [Symbol.dispose]() {
         this.detach();
@@ -386,41 +544,66 @@ export class MatchResult {
         throw new Error('MatchResult is not attached to any grammar');
     }
     succeeded() {
-        return !!this._cst;
+        return this._succeeded;
     }
     failed() {
-        return !this.succeeded();
+        return !this._succeeded;
+    }
+    toString() {
+        return this.failed()
+            ? '[match failed at position ' + this.getRightmostFailurePosition() + ']'
+            : '[match succeeded]';
+    }
+    use(cb) {
+        try {
+            this.grammar._beginUse(this);
+            return cb(this);
+        }
+        finally {
+            this.grammar._endUse(this);
+        }
+    }
+}
+function createMatchResult(grammar, startExpr, ctx, succeeded) {
+    return succeeded
+        ? new SucceededMatchResult(grammar, startExpr, ctx, succeeded)
+        : new FailedMatchResult(grammar, startExpr, ctx, succeeded, grammar.getRightmostFailurePosition());
+}
+class SucceededMatchResult extends MatchResult {
+    _cst;
+    constructor(grammar, startExpr, ctx, succeeded) {
+        super(grammar, startExpr, ctx, succeeded);
+        this._cst = grammar.getCstRoot();
+    }
+}
+class FailedMatchResult extends MatchResult {
+    constructor(grammar, startExpr, ctx, succeeded, rightmostFailurePosition, optRecordedFailures) {
+        super(grammar, startExpr, ctx, succeeded);
+        this._rightmostFailurePosition = rightmostFailurePosition;
+        this._rightmostFailures = optRecordedFailures;
+        // TODO: Define these as lazy properties, like in the JS implementation.
+        if (this.failed()) {
+            this.shortMessage = this.message = `Match failed at pos ${rightmostFailurePosition}`;
+        }
     }
+    _rightmostFailurePosition;
+    _rightmostFailures;
+    shortMessage;
+    message;
     getRightmostFailurePosition() {
         return this._rightmostFailurePosition;
     }
     getRightmostFailures() {
         throw new Error('Not implemented yet: getRightmostFailures');
     }
-    toString() {
-        return this.succeeded()
-            ? '[match succeeded]'
-            : '[match failed at position ' + this.getRightmostFailurePosition() + ']';
-    }
     // Return a string summarizing the expected contents of the input stream when
     // the match failure occurred.
     getExpectedText() {
-        if (this.succeeded()) {
-            throw new Error('cannot get expected text of a successful MatchResult');
-        }
+        assert(!this._succeeded, 'cannot get expected text of a successful MatchResult');
         throw new Error('Not implemented yet: getExpectedText');
     }
     getInterval() {
         throw new Error('Not implemented yet: getInterval');
     }
-    use(cb) {
-        try {
-            this.grammar._beginUse(this);
-            return cb(this);
-        }
-        finally {
-            this.grammar._endUse(this);
-        }
-    }
 }
 //# sourceMappingURL=miniohm.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ohm-js/wasm",
-  "version": "0.6.7",
+  "version": "0.6.9",
   "description": "Compile Ohm.js grammars to WebAsssembly",
   "main": "dist/index.js",
   "exports": {