@ohm-js/wasm 0.4.3 → 0.6.0

package/dist/src/miniohm.js

@@ -0,0 +1,418 @@
+import { assert, checkNotNull } from "./assert.js";
+const CST_NODE_TYPE_MASK = 0b11;
+const CstNodeType = {
+    NONTERMINAL: 0,
+    TERMINAL: 1,
+    ITER_FLAG: 2,
+    OPTIONAL: 3,
+};
+const compileOptions = {
+    builtins: ['js-string'],
+};
+// Bit flags for Unicode categories, based on the order that they appear in
+// https://www.unicode.org/Public/16.0.0/ucd/extracted/DerivedGeneralCategory.txt
+const UnicodeCategoryNames = [
+    'Cn', // Unassigned
+    'Lu', // Uppercase_Letter
+    'Ll', // Lowercase_Letter
+    'Lt', // Titlecase_Letter
+    'Lm', // Modifier_Letter
+    'Lo', // Other_Letter
+];
+const utf8 = new TextDecoder('utf-8');
+function regexFromCategoryBitmap(bitmap) {
+    const cats = [];
+    for (let i = 0; i < 32; i++) {
+        const mask = 1 << i;
+        if (bitmap & mask)
+            cats.push(UnicodeCategoryNames[i]);
+    }
+    return new RegExp(cats.map(cat => `\\p{${cat}}`).join('|'), 'uy' // u: unicode, y: sticky
+    );
+}
+export class WasmGrammar {
+    name = '';
+    _instance = undefined;
+    _imports = {
+        // System-level AssemblyScript imports.
+        env: {
+            abort( /* message: usize, fileName: usize, line: u32, column: u32 */) {
+                throw new Error('abort');
+            },
+        },
+        // For imports from ohmRuntime.ts.
+        ohmRuntime: {
+            printI32(val) {
+                // eslint-disable-next-line no-console
+                console.log(val);
+            },
+            isRuleSyntactic: (ruleId) => {
+                // TODO: Precompute this for all rules, and encode it in the module?
+                const name = this._ruleNames[ruleId];
+                assert(!!name);
+                return name[0] === name[0].toUpperCase();
+            },
+            fillInputBuffer: this._fillInputBuffer.bind(this),
+            matchUnicodeChar: (catBitmap) => {
+                const { input, pos } = this._instance.exports;
+                const re = regexFromCategoryBitmap(catBitmap);
+                re.lastIndex = pos;
+                const arr = re.exec(input.value);
+                if (arr) {
+                    pos.value += arr[0].length;
+                }
+                return !!arr;
+            },
+        },
+        // Include a polyfill for js-string builtins for engines that don't
+        // support that feature (e.g., Safari).
+        'wasm:js-string': {
+            length(str) {
+                return str.length;
+            },
+            charCodeAt(str, idx) {
+                // NOTE: `index` is interpreted as a signed 32-bit integer when converted to
+                // a JS value using standard conversions. Reinterpret as unsigned here.
+                idx >>>= 0;
+                assert(idx < str.length, 'string index out of bounds');
+                return str.charCodeAt(idx);
+            },
+        },
+    };
+    _ruleIds = new Map();
+    _ruleNames = [];
+    _input = '';
+    _resultStack = [];
+    _managedResultCount = 0;
+    /**
+     * 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) {
+        if (bytes) {
+            // @ts-expect-error: TS2554: Expected 1 arguments, but got 2.
+            const mod = new WebAssembly.Module(bytes, compileOptions);
+            this._init(mod, new WebAssembly.Instance(mod, this._imports));
+        }
+    }
+    _init(module, instance) {
+        this._instance = instance;
+        this._extractRuleIds(module);
+        this.name = this._getGrammarName(module);
+        return this;
+    }
+    _beginUse(result) {
+        assert(this._resultStack.at(-1) === result, `You can only use() the most recent MatchResult`);
+        result.detach = () => {
+            throw new Error("MatchResult shouldn't be detached inside use()");
+        };
+        this._managedResultCount++;
+    }
+    _endUse(result) {
+        const r = this._resultStack.pop();
+        assert(r === result, 'Mismatched _endUse');
+        this._managedResultCount--;
+        if (this._resultStack.length === 0) {
+            this._instance.exports.resetHeap();
+        }
+    }
+    static async instantiate(source) {
+        return new WasmGrammar()._instantiate(source);
+    }
+    static async instantiateStreaming(source) {
+        return new WasmGrammar()._instantiateStreaming(source);
+    }
+    async _instantiate(source, debugImports = {}) {
+        const { module, instance } = await WebAssembly.instantiate(source, {
+            ...this._imports,
+            debug: debugImports,
+        }, 
+        // @ts-expect-error: Expected 1-2 arguments, but got 3.
+        compileOptions);
+        return this._init(module, instance);
+    }
+    async _instantiateStreaming(source, debugImports = {}) {
+        const { module, instance } = await WebAssembly.instantiateStreaming(source, {
+            ...this._imports,
+            debug: debugImports,
+        }, 
+        // @ts-expect-error: TS2554: Expected 1-2 arguments, but got 3.
+        compileOptions);
+        return this._init(module, instance);
+    }
+    _getGrammarName(module) {
+        const sections = WebAssembly.Module.customSections(module, 'name');
+        assert(sections.length === 1, `Expected one name section, found ${sections.length}`);
+        const data = new Uint8Array(sections[0]);
+        const decoder = new TextDecoder('utf-8');
+        return decoder.decode(data);
+    }
+    _extractRuleIds(module) {
+        const sections = WebAssembly.Module.customSections(module, 'ruleNames');
+        assert(sections.length === 1, `Expected one ruleNames section, found ${sections.length}`);
+        const data = new Uint8Array(sections[0]);
+        const dataView = new DataView(data.buffer);
+        let offset = 0;
+        const parseU32 = () => {
+            // Quick 'n dirty ULeb128 parsing, assuming no more than 2 bytes.
+            const b1 = dataView.getUint8(offset++);
+            let value = b1 & 0x7f;
+            if (b1 & 0x80) {
+                const b2 = dataView.getUint8(offset++);
+                assert((b2 & 0x80) === 0, 'Expected max two bytes');
+                value |= (b2 & 0x7f) << 7;
+            }
+            return value;
+        };
+        const decoder = new TextDecoder('utf-8');
+        const numEntries = parseU32();
+        for (let i = 0; i < numEntries; i++) {
+            const stringLen = parseU32();
+            const bytes = data.slice(offset, offset + stringLen);
+            offset += stringLen;
+            const name = decoder.decode(bytes);
+            this._ruleIds.set(name, i);
+            this._ruleNames.push(name);
+        }
+    }
+    _detachMatchResult(result) {
+        assert(this._resultStack.at(-1) === result, `You can only detach() the most recent MatchResult`);
+        this._beginUse(result);
+        this._endUse(result);
+    }
+    match(input, ruleName) {
+        assert(this._resultStack.length === this._managedResultCount, 'Cannot match while there are unmanaged MatchResults');
+        this._input = input;
+        if (process.env.OHM_DEBUG === '1')
+            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());
+        result.detach = this._detachMatchResult.bind(this, result);
+        this._resultStack.push(result);
+        return result;
+    }
+    getMemorySizeBytes() {
+        return this._instance.exports.memory.buffer.byteLength;
+    }
+    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);
+        if (firstNode.ctorName !== '$spaces') {
+            return firstNode;
+        }
+        assert(exports.getBindingsLength() > 1);
+        const nextAddr = exports.bindingsAt(1);
+        const root = new CstNode(this._ruleNames, new DataView(buffer), nextAddr, exports.input.value, firstNode.matchLength);
+        root.leadingSpaces = firstNode;
+        return root;
+    }
+    _fillInputBuffer(ptr, length) {
+        const encoder = new TextEncoder();
+        const { memory } = this._instance.exports;
+        const buf = new Uint8Array(memory.buffer, ptr, length);
+        const { read, written } = encoder.encodeInto(this._input, buf);
+        assert(read === this._input.length, 'Input was not fully read');
+        return written;
+    }
+    getRightmostFailurePosition() {
+        return this._instance.exports.rightmostFailurePos.value;
+    }
+}
+export class CstNode {
+    _ruleNames;
+    _view;
+    _children;
+    _base;
+    _input;
+    startIdx;
+    leadingSpaces;
+    source;
+    constructor(ruleNames, dataView, ptr, input, startIdx) {
+        // Non-enumerable properties
+        Object.defineProperties(this, {
+            _ruleNames: { value: ruleNames },
+            _view: { value: dataView },
+            _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;
+    }
+    isNonterminal() {
+        return this.type === CstNodeType.NONTERMINAL;
+    }
+    isTerminal() {
+        return this.type === CstNodeType.TERMINAL;
+    }
+    isIter() {
+        return (this._typeAndDetails & CstNodeType.ITER_FLAG) !== 0;
+    }
+    isOptional() {
+        return this.type === CstNodeType.OPTIONAL;
+    }
+    get ctorName() {
+        return this.isTerminal() ? '_terminal' : this.isIter() ? '_iter' : this.ruleName;
+    }
+    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 count() {
+        return this._view.getUint32(this._base, true);
+    }
+    get matchLength() {
+        return this._view.getUint32(this._base + 4, true);
+    }
+    get _typeAndDetails() {
+        return this._view.getInt32(this._base + 8, true);
+    }
+    get arity() {
+        return this._typeAndDetails >>> 2;
+    }
+    get children() {
+        if (!this._children) {
+            this._children = this._computeChildren();
+        }
+        return this._children;
+    }
+    _computeChildren() {
+        const children = [];
+        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);
+            // TODO: Avoid allocating $spaces nodes altogether?
+            const node = new CstNode(this._ruleNames, this._view, ptr, this._input, startIdx);
+            if (node.ctorName === '$spaces') {
+                assert(!spaces, 'Multiple $spaces nodes found');
+                spaces = node;
+            }
+            else {
+                if (spaces) {
+                    node.leadingSpaces = spaces;
+                    spaces = undefined;
+                }
+                children.push(node);
+            }
+            startIdx += node.matchLength;
+        }
+        assert(spaces === undefined, 'Unclaimed $spaces!');
+        return children;
+    }
+    get sourceString() {
+        return this._input.slice(this.startIdx, this.startIdx + this.matchLength);
+    }
+    isSyntactic(ruleName) {
+        const firstChar = this.ruleName[0];
+        return firstChar === firstChar.toUpperCase();
+    }
+    isLexical(ruleName) {
+        return !this.isSyntactic(ruleName);
+    }
+    toString() {
+        const ctorName = this.isTerminal() ? '_terminal' : this.isIter() ? '_iter' : this.ruleName;
+        const { sourceString, startIdx } = this;
+        return `CstNode {ctorName: ${ctorName}, sourceString: ${sourceString}, startIdx: ${startIdx} }`;
+    }
+    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 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 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;
+        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}`;
+        }
+    }
+    [Symbol.dispose]() {
+        this.detach();
+    }
+    detach() {
+        throw new Error('MatchResult is not attached to any grammar');
+    }
+    succeeded() {
+        return !!this._cst;
+    }
+    failed() {
+        return !this.succeeded();
+    }
+    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');
+        }
+        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,13 +1,19 @@
 {
   "name": "@ohm-js/wasm",
-  "version": "0.4.3",
+  "version": "0.6.0",
   "description": "Compile Ohm.js grammars to WebAsssembly",
   "main": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./compat": "./dist/src/compat.js",
+    "./compiler": "./dist/src/Compiler.js"
+  },
   "bin": {
-    "ohm2wasm": "dist/cli.js"
+    "ohm2wasm": "dist/src/cli.js"
   },
   "files": [
-    "dist"
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
   ],
   "type": "module",
   "keywords": [],
@@ -22,8 +28,7 @@
     "fast-check": "^4.2.0",
     "fast-glob": "^3.3.3",
     "mitata": "^1.0.34",
-    "wabt": "1.0.37-nightly.20250428",
-    "@ohm-js/miniohm-js": "^0.4.3"
+    "wabt": "1.0.37-nightly.20250428"
   },
   "peerDependencies": {
     "ohm-js": "^17.1.0"