@ohm-js/wasm 0.4.3 → 0.6.0

package/dist/src/assert.d.ts

@@ -0,0 +1,3 @@
+export declare function assert(cond: boolean, message?: string): asserts cond;
+export declare function checkNotNull<T>(x: T, msg?: string): NonNullable<T>;
+//# sourceMappingURL=assert.d.ts.map

package/dist/src/assert.js

@@ -0,0 +1,9 @@
+export function assert(cond, message = 'Assertion failed') {
+    if (!cond)
+        throw new Error(message);
+}
+export function checkNotNull(x, msg = 'unexpected null value') {
+    assert(x != null, msg);
+    return x;
+}
+//# sourceMappingURL=assert.js.map

package/dist/src/cli.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/src/cli.js

@@ -0,0 +1,56 @@
+/* global process */
+import * as ohm from 'ohm-js';
+import fs from 'node:fs';
+import { basename } from 'node:path';
+import { parseArgs } from 'node:util';
+import { Compiler } from './Compiler.js';
+// Compile an Ohm grammar file (.ohm) to WebAssembly (.wasm).
+function main() {
+    const argsConfig = {
+        options: {
+            grammarName: { short: 'g', type: 'string' },
+            output: { short: 'o', type: 'string' },
+        },
+        allowPositionals: true,
+    };
+    let args;
+    try {
+        args = parseArgs(argsConfig);
+    }
+    catch (e) {
+        // eslint-disable-next-line no-console
+        console.error(e.message);
+        printUsage();
+        process.exit(1);
+    }
+    if (args.positionals.length !== 1) {
+        printUsage();
+        process.exit(1);
+    }
+    const filename = args.positionals[0];
+    const ns = ohm.grammars(fs.readFileSync(filename, 'utf8'));
+    // By default, use the last grammar in the file.
+    let g = Object.values(ns).at(-1);
+    const { grammarName } = args.values;
+    if (grammarName) {
+        if (!ns[grammarName]) {
+            // eslint-disable-next-line no-console
+            console.error(`Grammar '${grammarName}' not found in ${filename}`);
+            process.exit(1);
+        }
+        g = ns[grammarName];
+    }
+    const bytes = new Compiler(g).compile();
+    const outFilename = args.values.output ?? filename.replace('.ohm', '.wasm');
+    fs.writeFileSync(outFilename, bytes);
+    // eslint-disable-next-line no-console
+    console.log(`Wrote Wasm to ${outFilename}`);
+}
+// Print usage information
+function printUsage() {
+    const exeName = basename(process.argv[1]);
+    // eslint-disable-next-line no-console
+    console.log(`usage: ${exeName} [(--grammarName|-g) <name>] [(--output|-o) <file>] <ohm-grammar-file>`);
+}
+main();
+//# sourceMappingURL=cli.js.map

package/dist/src/compat.d.ts

@@ -0,0 +1,4 @@
+import { WasmGrammar } from './miniohm.ts';
+export declare function grammar(source: string): WasmGrammar;
+export declare function grammars(source: string): Record<string, WasmGrammar>;
+//# sourceMappingURL=compat.d.ts.map

package/dist/src/compat.js

@@ -0,0 +1,18 @@
+import { grammars as grammarsJs, grammar as grammarJs } from 'ohm-js';
+import { Compiler } from './Compiler.js';
+import { WasmGrammar } from "./miniohm.js";
+// TODO: Support a namespace parameter.
+export function grammar(source) {
+    const compiler = new Compiler(grammarJs(source));
+    return new WasmGrammar(compiler.compile());
+}
+// TODO: Support a namespace parameter.
+export function grammars(source) {
+    const ans = {};
+    for (const g of Object.values(grammarsJs(source))) {
+        const compiler = new Compiler(g);
+        ans[g.name] = new WasmGrammar(compiler.compile());
+    }
+    return ans;
+}
+//# sourceMappingURL=compat.js.map

package/dist/src/ir.d.ts

@@ -0,0 +1,121 @@
+export type Expr = Alt | Any | Apply | ApplyGeneralized | CaseInsensitive | Dispatch | End | Lex | LiftedTerminal | Lookahead | Opt | Not | Param | Plus | Range | Seq | Star | Terminal | UnicodeChar;
+export interface Alt {
+    type: 'Alt';
+    children: Expr[];
+    outArity: number;
+}
+export declare const alt: (children: Expr[]) => Alt;
+export interface Any {
+    type: 'Any';
+}
+export declare const any: () => Any;
+type ApplyLike = Extract<Expr, {
+    type: 'Apply' | 'LiftedTerminal' | 'Param';
+}>;
+export interface Apply {
+    type: 'Apply';
+    ruleName: string;
+    children: ApplyLike[];
+}
+export declare const apply: (ruleName: string, children?: ApplyLike[]) => Apply;
+export interface ApplyGeneralized {
+    type: 'ApplyGeneralized';
+    ruleName: string;
+    caseIdx: number;
+}
+export declare const applyGeneralized: (ruleName: string, caseIdx: number) => ApplyGeneralized;
+export interface CaseInsensitive {
+    type: 'CaseInsensitive';
+    value: string;
+}
+export declare const caseInsensitive: (value: string) => CaseInsensitive;
+export interface Dispatch {
+    type: 'Dispatch';
+    child: Expr;
+    patterns: Expr[][];
+}
+export declare const dispatch: (child: Apply | Param, patterns: Expr[][]) => Dispatch;
+export interface End {
+    type: 'End';
+}
+export declare const end: () => End;
+export interface Lex {
+    type: 'Lex';
+    child: Expr;
+    outArity: number;
+}
+export declare const lex: (child: Expr) => Lex;
+export interface Lookahead {
+    type: 'Lookahead';
+    child: Expr;
+    outArity: number;
+}
+export declare const lookahead: (child: Expr) => Lookahead;
+export interface Opt {
+    type: 'Opt';
+    child: Expr;
+}
+export declare const opt: (child: Expr) => Opt;
+export interface Not {
+    type: 'Not';
+    child: Expr;
+}
+export declare const not: (child: Expr) => Not;
+export interface Param {
+    type: 'Param';
+    index: number;
+}
+export declare const param: (index: number) => Param;
+export interface Plus {
+    type: 'Plus';
+    child: Expr;
+}
+export declare const plus: (child: Expr) => Plus;
+export interface Range {
+    type: 'Range';
+    lo: number;
+    hi: number;
+}
+export declare const range: (lo: number, hi: number) => Range;
+export interface Seq {
+    type: 'Seq';
+    children: Expr[];
+    outArity: number;
+}
+export declare const seq: (children: Expr[]) => Seq;
+export interface Star {
+    type: 'Star';
+    child: Expr;
+}
+export declare const star: (child: Expr) => Star;
+export interface Terminal {
+    type: 'Terminal';
+    value: string;
+}
+export declare const terminal: (value: string, caseInsensitive?: boolean) => Terminal;
+export interface UnicodeChar {
+    type: 'UnicodeChar';
+    categoryOrProp: string;
+}
+export declare const unicodeChar: (categoryOrProp: string) => UnicodeChar;
+export interface LiftedTerminal {
+    type: 'LiftedTerminal';
+    terminalId: number;
+}
+export declare const liftedTerminal: (terminalId: number) => LiftedTerminal;
+export declare function collectParams(exp: Expr, seen?: Set<number>): Param[];
+export declare function substituteParams<T extends Expr>(exp: T, actuals: Exclude<Expr, Param>[]): Exclude<Expr, Param>;
+export declare function specializedName(app: Apply | LiftedTerminal): string;
+export type ExprType = Expr extends {
+    type: infer U;
+} ? U : never;
+export type RewriteActions = {
+    [K in ExprType]?: (exp: Extract<Expr, {
+        type: K;
+    }>) => Expr;
+};
+export declare function rewrite(exp: Expr, actions: RewriteActions): Expr;
+export declare function toString(exp: Expr): string;
+export declare function outArity(exp: Expr): number;
+export {};
+//# sourceMappingURL=ir.d.ts.map

package/dist/src/ir.js

@@ -0,0 +1,297 @@
+// Types
+// -------
+export const alt = (children) => ({
+    type: 'Alt',
+    children,
+    outArity: outArity(children[0]),
+});
+export const any = () => ({ type: 'Any' });
+export const apply = (ruleName, children = []) => ({
+    type: 'Apply',
+    ruleName,
+    children,
+});
+export const applyGeneralized = (ruleName, caseIdx) => ({
+    type: 'ApplyGeneralized',
+    ruleName,
+    caseIdx,
+});
+export const caseInsensitive = (value) => ({
+    type: 'CaseInsensitive',
+    value,
+});
+export const dispatch = (child, patterns) => ({
+    type: 'Dispatch',
+    child,
+    patterns,
+});
+export const end = () => ({ type: 'End' });
+export const lex = (child) => ({
+    type: 'Lex',
+    child,
+    outArity: outArity(child),
+});
+export const lookahead = (child) => ({
+    type: 'Lookahead',
+    child,
+    outArity: outArity(child),
+});
+export const opt = (child) => ({ type: 'Opt', child });
+export const not = (child) => ({ type: 'Not', child });
+export const param = (index) => ({ type: 'Param', index });
+export const plus = (child) => ({ type: 'Plus', child });
+export const range = (lo, hi) => ({ type: 'Range', lo, hi });
+export const seq = (children) => ({
+    type: 'Seq',
+    children,
+    outArity: children.reduce((acc, child) => acc + outArity(child), 0),
+});
+export const star = (child) => ({ type: 'Star', child });
+export const terminal = (value, caseInsensitive = false) => ({
+    type: 'Terminal',
+    value,
+});
+export const unicodeChar = (categoryOrProp) => ({
+    type: 'UnicodeChar',
+    categoryOrProp,
+});
+export const liftedTerminal = (terminalId) => ({
+    type: 'LiftedTerminal',
+    terminalId,
+});
+// Helpers
+// -------
+function unreachable(x, msg) {
+    throw new Error(msg);
+}
+function checkNotNull(x, msg = 'unexpected null value') {
+    if (x == null)
+        throw new Error(msg);
+    return x;
+}
+function checkApplyLike(exp) {
+    return checkExprType(exp, 'Apply', 'LiftedTerminal', 'Param');
+}
+function checkExprType(exp, ...types) {
+    if (!types.includes(exp.type)) {
+        throw new Error(`Expected one of [${types.join(', ')}], but got '${exp.type}'`);
+    }
+    return exp;
+}
+export function collectParams(exp, seen = new Set()) {
+    switch (exp.type) {
+        case 'Param':
+            if (!seen.has(exp.index)) {
+                seen.add(exp.index);
+                return [exp];
+            }
+            return [];
+        case 'Alt':
+        case 'Apply':
+        case 'Seq':
+            return exp.children.flatMap(c => collectParams(c, seen));
+        case 'Dispatch':
+        case 'Lex':
+        case 'Lookahead':
+        case 'Not':
+        case 'Opt':
+        case 'Plus':
+        case 'Star':
+            return collectParams(exp.child, seen);
+        case 'Any':
+        case 'ApplyGeneralized':
+        case 'CaseInsensitive':
+        case 'End':
+        case 'LiftedTerminal':
+        case 'Range':
+        case 'Terminal':
+        case 'UnicodeChar':
+            return [];
+        default:
+            unreachable(exp, `not handled: ${exp}`);
+    }
+}
+// TODO: Maybe make the types tighter here, to avoid the use checkApplyLike.
+export function substituteParams(exp, actuals) {
+    switch (exp.type) {
+        case 'Param':
+            return checkNotNull(actuals[exp.index]);
+        case 'Apply':
+            if (exp.children.length === 0)
+                return exp;
+            return apply(exp.ruleName, exp.children.map((c) => {
+                const ans = substituteParams(c, actuals);
+                return checkApplyLike(ans);
+            }));
+        case 'Dispatch': {
+            const newChild = substituteParams(exp.child, actuals);
+            return dispatch(checkExprType(newChild, 'Apply'), exp.patterns);
+        }
+        case 'Alt':
+        case 'Seq':
+            return {
+                type: exp.type,
+                children: exp.children.map(c => substituteParams(c, actuals)),
+                outArity: exp.outArity,
+            };
+        case 'Lex':
+        case 'Lookahead':
+            return {
+                type: exp.type,
+                child: substituteParams(exp.child, actuals),
+                outArity: exp.outArity,
+            };
+        case 'Not':
+        case 'Opt':
+        case 'Plus':
+        case 'Star':
+            return {
+                type: exp.type,
+                child: substituteParams(exp.child, actuals),
+            };
+        case 'Any':
+        case 'ApplyGeneralized':
+        case 'CaseInsensitive':
+        case 'End':
+        case 'LiftedTerminal':
+        case 'Range':
+        case 'Terminal':
+        case 'UnicodeChar':
+            return exp;
+        default:
+            unreachable(exp, `not handled: ${exp}`);
+    }
+}
+export function specializedName(app) {
+    if (app.type === 'LiftedTerminal') {
+        return `$term$${app.terminalId}`;
+    }
+    const argsNames = app.children
+        .map(c => {
+        if (c.type === 'Param')
+            throw new Error(`unexpected Param`);
+        return specializedName(c);
+    })
+        .join(',');
+    return app.ruleName + (argsNames.length > 0 ? `<${argsNames}>` : '');
+}
+export function rewrite(exp, actions) {
+    const action = actions[exp.type];
+    if (action) {
+        return action(exp);
+    }
+    switch (exp.type) {
+        case 'Alt':
+            return alt(exp.children.map((e) => rewrite(e, actions)));
+        case 'Seq':
+            return seq(exp.children.map((e) => rewrite(e, actions)));
+        case 'Any':
+        case 'Apply':
+        case 'ApplyGeneralized':
+        case 'CaseInsensitive':
+        case 'End':
+        case 'LiftedTerminal':
+        case 'Param':
+        case 'Range':
+        case 'Terminal':
+        case 'UnicodeChar':
+            return exp;
+        case 'Dispatch':
+            // We don't use the constructor here, to avoid type checking issues.
+            return { type: exp.type, child: rewrite(exp.child, actions), patterns: exp.patterns };
+        case 'Lex':
+            return lex(rewrite(exp.child, actions));
+        case 'Lookahead':
+            return lookahead(rewrite(exp.child, actions));
+        case 'Not':
+            return not(rewrite(exp.child, actions));
+        case 'Opt':
+            return opt(rewrite(exp.child, actions));
+        case 'Plus':
+            return plus(rewrite(exp.child, actions));
+        case 'Star':
+            return star(rewrite(exp.child, actions));
+        default:
+            unreachable(exp, `not handled: ${exp}`);
+    }
+}
+export function toString(exp) {
+    switch (exp.type) {
+        case 'Alt':
+            return `(${exp.children.map(toString).join(' | ')})`;
+        case 'Seq':
+            return `(${exp.children.map(toString).join(' ')})`;
+        case 'Any':
+            return '$any';
+        case 'Apply':
+            return exp.children.length > 0
+                ? `${exp.ruleName}<${exp.children.map(toString).join(',')}>`
+                : exp.ruleName;
+        case 'ApplyGeneralized':
+            return `${exp.ruleName}<#${exp.caseIdx}>`;
+        case 'CaseInsensitive':
+            return `$caseInsensitive<${JSON.stringify(exp.value)}>`;
+        case 'End':
+            return '$end';
+        case 'LiftedTerminal':
+            return `$term$${exp.terminalId}`;
+        case 'Param':
+            return `$${exp.index}`;
+        case 'Range':
+            return `${JSON.stringify(exp.lo)}..${JSON.stringify(exp.hi)}`;
+        case 'Terminal':
+            return JSON.stringify(exp.value);
+        case 'UnicodeChar':
+            return `$unicodeChar<${JSON.stringify(exp.categoryOrProp)}>`;
+        case 'Dispatch':
+            return `$dispatch`; // TODO: Improve this.
+        case 'Lex':
+            return `#${toString(exp.child)}`;
+        case 'Lookahead':
+            return `&${toString(exp.child)}`;
+        case 'Not':
+            return `~${toString(exp.child)}`;
+        case 'Opt':
+            return `${toString(exp.child)}?`;
+        case 'Plus':
+            return `${toString(exp.child)}+`;
+        case 'Star':
+            return `${toString(exp.child)}*`;
+        default:
+            unreachable(exp, `not handled: ${exp}`);
+    }
+}
+// Returns the number of bindings that `expr` produces in its parent — the
+// "out arity" or "upwards arity". Note that there is potential confusion
+// with iter nodes: they produce a single binding, but an expression like
+// `(letter digit)*` can be said to have "arity 2".
+export function outArity(exp) {
+    switch (exp.type) {
+        case 'Alt':
+        case 'Seq':
+        case 'Lex':
+        case 'Lookahead':
+            return exp.outArity;
+        case 'Any':
+        case 'Apply':
+        case 'ApplyGeneralized':
+        case 'CaseInsensitive':
+        case 'End':
+        case 'LiftedTerminal':
+        case 'Param':
+        case 'Range':
+        case 'Terminal':
+        case 'UnicodeChar':
+        case 'Dispatch':
+            return 1;
+        case 'Not':
+            return 0;
+        case 'Opt':
+        case 'Plus':
+        case 'Star':
+            return 1;
+        default:
+            unreachable(exp, `not handled: ${exp}`);
+    }
+}
+//# sourceMappingURL=ir.js.map

package/dist/src/miniohm.d.ts

@@ -0,0 +1,87 @@
+export declare class WasmGrammar {
+    name: string;
+    private _instance?;
+    private _imports;
+    private _ruleIds;
+    private _ruleNames;
+    private _input;
+    private _resultStack;
+    private _managedResultCount;
+    /**
+     * Create a new WasmGrammar object.
+     * If `bytes` is specified, the WebAssembly module will be synchronously
+     * compiled and instantiated. Use `instantiate` or `instantiateStreaming`
+     * to instantiate asynchronously.
+     */
+    constructor(bytes?: BufferSource);
+    private _init;
+    _beginUse(result: MatchResult): void;
+    _endUse(result: MatchResult): void;
+    static instantiate(source: BufferSource): Promise<WasmGrammar>;
+    static instantiateStreaming(source: Response | Promise<Response>): Promise<WasmGrammar>;
+    _instantiate(source: BufferSource, debugImports?: any): Promise<this>;
+    _instantiateStreaming(source: Response | Promise<Response>, debugImports?: any): Promise<WasmGrammar>;
+    private _getGrammarName;
+    private _extractRuleIds;
+    private _detachMatchResult;
+    match<T>(input: string, ruleName?: string): MatchResult;
+    getMemorySizeBytes(): number;
+    getCstRoot(): CstNode;
+    private _fillInputBuffer;
+    getRightmostFailurePosition(): number;
+}
+export declare class CstNode {
+    _ruleNames: string[];
+    _view: DataView;
+    _children?: CstNode[];
+    _base: number;
+    _input: string;
+    startIdx: number;
+    leadingSpaces: CstNode | undefined;
+    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;
+    get ctorName(): string;
+    get ruleName(): string;
+    get count(): number;
+    get matchLength(): number;
+    get _typeAndDetails(): number;
+    get arity(): number;
+    get children(): CstNode[];
+    _computeChildren(): CstNode[];
+    get sourceString(): string;
+    isSyntactic(ruleName?: string): boolean;
+    isLexical(ruleName?: string): boolean;
+    toString(): string;
+    map<T>(callbackFn: (...args: CstNode[]) => T): T[];
+}
+export declare function dumpCstNode(node: CstNode, depth?: number): void;
+export declare class MatchResult {
+    grammar: WasmGrammar;
+    input: string;
+    startExpr: string;
+    _cst: CstNode | null;
+    _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;
+}
+//# sourceMappingURL=miniohm.d.ts.map