parsanol 1.0.0

data/lib/parsanol/wasm/README.md

@@ -0,0 +1,80 @@
+# @parsanol/wasm
+
+High-performance PEG parser using WebAssembly. Designed for use with Opal (Ruby in JavaScript) and general JavaScript applications.
+
+## Features
+
+- **18-44x faster** than pure Ruby parser
+- **99.5% fewer allocations**
+- Works in browsers and Node.js
+- Full TypeScript support
+- Compatible with Opal
+
+## Installation
+
+```bash
+npm install @parsanol/wasm
+```
+
+## Usage
+
+### Browser/ESM
+
+```html
+<script type="module">
+  import { initParsanol, ParsanolParser } from '@parsanol/wasm';
+
+  // Initialize WASM (call once)
+  await initParsanol();
+
+  // Create parser from grammar JSON
+  const grammar = {
+    atoms: [
+      { Str: { pattern: "hello" } }
+    ],
+    root: 0
+  };
+
+  const parser = new ParsanolParser(grammar);
+
+  // Parse input
+  const result = parser.parse('hello');
+  console.log(result); // "hello"
+</script>
+```
+
+### Node.js
+
+```javascript
+const { initParsanol, ParsanolParser } = require('@parsanol/wasm');
+
+async function main() {
+  await initParsanol();
+
+  const parser = new ParsanolParser(grammarJson);
+  const result = parser.parse('input text');
+  console.log(result);
+}
+
+main();
+```
+
+### Opal (Ruby in Browser)
+
+```ruby
+# First initialize WASM in JavaScript:
+# Parsanol::WasmParser.init.then { puts "ready" }
+
+require 'parsanol/wasm_parser'
+
+grammar_json = {
+  atoms: [
+    { Str: { pattern: "hello" } }
+  ],
+  root: 0
+}.to_json
+
+parser = Parsanol::WasmParser.new(grammar_json)
+result = parser.parse('hello')
+puts result  # => "hello"
+```

data/lib/parsanol/wasm/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@parsanol/wasm",
+  "version": "0.1.0",
+  "description": "High-performance PEG parser using WebAssembly for Opal and JavaScript",
+  "main": "parsanol.js",
+  "module": "parsanol.js",
+  "types": "parsanol.d.ts",
+  "browser": "parsanol.js",
+  "files": [
+    "parsanol.js",
+    "parsanol.d.ts",
+    "parsanol_native.js",
+    "parsanol_native_bg.js",
+    "parsanol_native_bg.wasm",
+    "parsanol_native.d.ts"
+  ],
+  "scripts": {
+    "build": "cd ../../ext/parsanol_native && wasm-pack build --features wasm --target web --out-dir ../../lib/parsanol/wasm",
+    "build:node": "cd ../../ext/parsanol_native && wasm-pack build --features wasm --target nodejs --out-dir ../../lib/parsanol/wasm-node",
+    "test": "node test/parsanol.test.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "parser",
+    "peg",
+    "parsing-expression-grammar",
+    "wasm",
+    "webassembly",
+    "opal",
+    "ruby",
+    "performance"
+  ],
+  "author": "Ribose Inc. <open.source@ribose.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/parsanol/parsanol-rs.git",
+    "directory": "lib/parsanol/wasm"
+  },
+  "bugs": {
+    "url": "https://github.com/parsanol/parsanol-ruby/issues"
+  },
+  "homepage": "https://github.com/parsanol/parsanol-ruby#readme",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "sideEffects": [
+    "parsanol_native.js",
+    "parsanol_native_bg.js"
+  ]
+}

data/lib/parsanol/wasm/parsanol.js

@@ -0,0 +1,252 @@
+/**
+ * Parsanol WASM Parser
+ *
+ * High-performance parser using WebAssembly for use in browsers and Node.js.
+ * Compatible with Opal (Ruby in JavaScript) for parsing in the browser.
+ *
+ * @example
+ * // Browser/ESM
+ * import { ParsanolParser } from '@parsanol/wasm';
+ * const parser = new ParsanolParser(grammarJson);
+ * const result = parser.parse('input text');
+ *
+ * @example
+ * // Node.js
+ * const { ParsanolParser } = require('@parsanol/wasm');
+ * const parser = new ParsanolParser(grammarJson);
+ * const result = parser.parse('input text');
+ *
+ * @example
+ * // Opal
+ * %x{
+ *   var parser = new ParsanolNative.WasmParser(#{grammar_json});
+ *   var result = parser.parse(#{input});
+ *   return result;
+ * }
+ */
+
+import init, { WasmParser } from './parsanol_native.js';
+
+let initialized = false;
+let initPromise = null;
+
+/**
+ * Initialize the WASM module
+ * Must be called before creating parsers (automatically called on first use)
+ *
+ * @returns {Promise<void>}
+ */
+export async function initParsanol() {
+  if (initialized) return;
+  if (initPromise) return initPromise;
+
+  initPromise = init().then(() => {
+    initialized = true;
+  });
+
+  return initPromise;
+}
+
+/**
+ * Check if the WASM module is initialized
+ *
+ * @returns {boolean}
+ */
+export function isInitialized() {
+  return initialized;
+}
+
+/**
+ * High-performance parser using WebAssembly
+ *
+ * Usage:
+ *   const parser = new ParsanolParser(grammarJson);
+ *   const result = parser.parse('input');
+ *   console.log(result);
+ */
+export class ParsanolParser {
+  #parser = null;
+  #grammarJson = null;
+
+  /**
+   * Create a new parser instance
+   *
+   * @param {string|object} grammar - Grammar JSON string or object
+   * @throws {Error} If WASM not initialized or grammar is invalid
+   */
+  constructor(grammar) {
+    if (!initialized) {
+      throw new Error('Parsanol WASM not initialized. Call initParsanol() first.');
+    }
+
+    this.#grammarJson = typeof grammar === 'string' ? grammar : JSON.stringify(grammar);
+    this.#parser = new WasmParser(this.#grammarJson);
+  }
+
+  /**
+   * Parse input string and return AST
+   *
+   * @param {string} input - Input string to parse
+   * @returns {object} Parsed AST as JavaScript object
+   * @throws {Error} If parsing fails
+   */
+  parse(input) {
+    return this.#parser.parse(input);
+  }
+
+  /**
+   * Parse input and return flat array format
+   * More efficient for large results (avoids object creation)
+   *
+   * @param {string} input - Input string to parse
+   * @returns {BigUint64Array} Flat array with tagged values
+   * @throws {Error} If parsing fails
+   */
+  parseFlat(input) {
+    return this.#parser.parse_flat(input);
+  }
+
+  /**
+   * Parse input and return JSON string
+   * Useful for transferring to other contexts
+   *
+   * @param {string} input - Input string to parse
+   * @returns {string} JSON string of parsed AST
+   * @throws {Error} If parsing fails
+   */
+  parseJson(input) {
+    return this.#parser.parse_json(input);
+  }
+
+  /**
+   * Reset parser state for reuse
+   */
+  reset() {
+    // Parser state is reset automatically on each parse
+  }
+}
+
+/**
+ * Decode flat array format to JavaScript object
+ *
+ * Tag format:
+ * - 0x00: nil
+ * - 0x01: bool (followed by 0 or 1)
+ * - 0x02: int (followed by value)
+ * - 0x03: float (followed by bits)
+ * - 0x04: string (followed by offset, length)
+ * - 0x05: array start
+ * - 0x06: array end
+ * - 0x07: hash start
+ * - 0x08: hash end
+ * - 0x09: hash key
+ *
+ * @param {BigUint64Array} flat - Flat array from parseFlat()
+ * @param {string} input - Original input string for string references
+ * @returns {any} Decoded JavaScript value
+ */
+export function decodeFlatArray(flat, input) {
+  const TAG_NIL = 0x00n;
+  const TAG_BOOL = 0x01n;
+  const TAG_INT = 0x02n;
+  const TAG_FLOAT = 0x03n;
+  const TAG_STRING = 0x04n;
+  const TAG_ARRAY_START = 0x05n;
+  const TAG_ARRAY_END = 0x06n;
+  const TAG_HASH_START = 0x07n;
+  const TAG_HASH_END = 0x08n;
+  const TAG_HASH_KEY = 0x09n;
+
+  let pos = 0;
+
+  function decode() {
+    const tag = flat[pos++];
+
+    switch (tag) {
+      case TAG_NIL:
+        return null;
+
+      case TAG_BOOL:
+        return flat[pos++] !== 0n;
+
+      case TAG_INT:
+        return Number(flat[pos++]);
+
+      case TAG_FLOAT: {
+        const bits = flat[pos++];
+        return new Float64Array(new BigUint64Array([bits]).buffer)[0];
+      }
+
+      case TAG_STRING: {
+        const offset = Number(flat[pos++]);
+        const length = Number(flat[pos++]);
+        return input.substring(offset, offset + length);
+      }
+
+      case TAG_ARRAY_START: {
+        const arr = [];
+        while (flat[pos] !== TAG_ARRAY_END) {
+          arr.push(decode());
+        }
+        pos++; // Skip ARRAY_END
+        return arr;
+      }
+
+      case TAG_HASH_START: {
+        const obj = {};
+        while (flat[pos] !== TAG_HASH_END) {
+          // Skip TAG_HASH_KEY
+          pos++;
+
+          // Read key
+          const keyLen = Number(flat[pos++]);
+          // Skip placeholder
+          pos++;
+
+          // Read key bytes
+          let key = '';
+          const numChunks = Math.ceil(keyLen / 8);
+          for (let i = 0; i < numChunks; i++) {
+            const chunk = flat[pos++];
+            for (let j = 0; j < 8 && key.length < keyLen; j++) {
+              const byte = Number((chunk >> BigInt(j * 8)) & 0xffn);
+              key += String.fromCharCode(byte);
+            }
+          }
+
+          // Read value
+          const value = decode();
+          obj[key] = value;
+        }
+        pos++; // Skip HASH_END
+        return obj;
+      }
+
+      default:
+        throw new Error(`Unknown tag: ${tag}`);
+    }
+  }
+
+  return decode();
+}
+
+/**
+ * Create a parser with automatic initialization
+ * Convenience function that handles async initialization
+ *
+ * @param {string|object} grammar - Grammar JSON string or object
+ * @returns {Promise<ParsanolParser>} Initialized parser
+ */
+export async function createParser(grammar) {
+  await initParsanol();
+  return new ParsanolParser(grammar);
+}
+
+// Default export
+export default {
+  initParsanol,
+  isInitialized,
+  ParsanolParser,
+  decodeFlatArray,
+  createParser
+};

data/lib/parsanol/wasm/parslet.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Type definitions for Parslet WASM Parser
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Initialize the WASM module
+ * Must be called before creating parsers
+ */
+export function initParslet(): Promise<void>;
+
+/**
+ * Check if the WASM module is initialized
+ */
+export function isInitialized(): boolean;
+
+/**
+ * Grammar specification for the parser
+ *
+ * The grammar is a JSON object with atoms and a root index.
+ */
+export interface Grammar {
+  /** Array of atom definitions */
+  atoms: Atom[];
+  /** Index of the root atom */
+  root: number;
+}
+
+/**
+ * Atom types in the grammar
+ */
+export type Atom =
+  | { Str: { pattern: string } }
+  | { Re: { pattern: string } }
+  | { Sequence: { atoms: number[] } }
+  | { Alternative: { atoms: number[] } }
+  | { Repetition: { atom: number; min: number; max: number | null } }
+  | { Named: { name: string; atom: number } }
+  | { Entity: { atom: number } }
+  | { Lookahead: { atom: number; positive: boolean } }
+  | 'Cut';
+
+/**
+ * Parse result - can be various types
+ */
+export type ParseResult =
+  | null
+  | boolean
+  | number
+  | string
+  | ParseResult[]
+  | { [key: string]: ParseResult };
+
+/**
+ * High-performance parser using WebAssembly
+ */
+export class ParsletParser {
+  /**
+   * Create a new parser instance
+   *
+   * @param grammar - Grammar JSON string or object
+   * @throws {Error} If WASM not initialized or grammar is invalid
+   */
+  constructor(grammar: string | Grammar);
+
+  /**
+   * Parse input string and return AST
+   *
+   * @param input - Input string to parse
+   * @returns Parsed AST as JavaScript object
+   * @throws {Error} If parsing fails
+   */
+  parse(input: string): ParseResult;
+
+  /**
+   * Parse input and return flat array format
+   *
+   * @param input - Input string to parse
+   * @returns Flat array with tagged values
+   * @throws {Error} If parsing fails
+   */
+  parseFlat(input: string): BigUint64Array;
+
+  /**
+   * Parse input and return JSON string
+   *
+   * @param input - Input string to parse
+   * @returns JSON string of parsed AST
+   * @throws {Error} If parsing fails
+   */
+  parseJson(input: string): string;
+}
+
+/**
+ * Decode flat array format to JavaScript object
+ *
+ * @param flat - Flat array from parseFlat()
+ * @param input - Original input string for string references
+ * @returns Decoded JavaScript value
+ */
+export function decodeFlatArray(flat: BigUint64Array, input: string): ParseResult;
+
+/**
+ * Create a parser with automatic initialization
+ *
+ * @param grammar - Grammar JSON string or object
+ * @returns Promise resolving to initialized parser
+ */
+export function createParser(grammar: string | Grammar): Promise<ParsletParser>;
+
+/**
+ * Low-level WASM parser (from wasm-bindgen)
+ *
+ * @internal
+ */
+export class WasmParser {
+  constructor(grammarJson: string);
+  parse(input: string): any;
+  parse_flat(input: string): BigUint64Array;
+  parse_json(input: string): string;
+}
+
+/**
+ * WASM module initialization function
+ *
+ * @internal
+ */
+export default function init(): Promise<void>;