usfm3 0.1.0 → 0.1.5

package/README.md

@@ -0,0 +1,90 @@
+# usfm3
+
+An error-tolerant [USFM 3.x](https://docs.usfm.bible/usfm/3.1.1/index.html) parser for JavaScript and TypeScript. Outputs [USJ](https://docs.usfm.bible/usfm/3.1.1/usj/index.html) (JSON), [USX](https://docs.usfm.bible/usfm/3.1.1/usx/index.html) (XML), normalized USFM, and vref format (a key-value map of verse references to text).
+
+Built in Rust and compiled to WebAssembly. Works in browsers, Node.js, Deno, and Bun.
+
+Also available as a [Rust crate](https://crates.io/crates/usfm3) and [Python package](https://pypi.org/project/usfm3/).
+
+## Installation
+
+```sh
+npm install usfm3
+```
+
+## Usage
+
+WASM is automatically initialized in Node.js, Deno, and Bun. In a browser, call `init()` first:
+
+```typescript
+import init from "usfm3";
+await init(); // browser only
+```
+
+Then parse USFM text:
+
+```typescript
+import { parse } from "usfm3";
+
+const result = parse(usfmText);
+
+if (result.hasErrors()) {
+    console.error("Document has errors");
+}
+
+// Output formats (lazy — only serialized when called)
+const usj = result.toUsj();    // USJ object
+const usx = result.toUsx();    // USX XML string
+const usfm = result.toUsfm();  // Normalized USFM string
+const vref = result.toVref();  // Vref pairs like { "GEN 1:1": "In the beginning...", ... }
+
+// Diagnostics
+for (const d of result.diagnostics) {
+    console.log(`[${d.severity}] ${d.message} (${d.start}..${d.end})`);
+    // d.code is a machine-readable string like "UnknownMarker", "ImplicitClose", etc.
+}
+
+// Skip semantic validation
+const result2 = parse(usfmText, { validate: false });
+
+// Free WASM memory when done
+result.free();
+```
+
+## API
+
+### `parse(usfm: string, options?: ParseOptions): ParseResult`
+
+Parse a USFM string. Returns a `ParseResult` with lazy output methods and diagnostics.
+
+**ParseOptions:**
+
+| Field | Type | Default | Description |
+|---|---|---|---|
+| `validate` | `boolean` | `true` | Run semantic validation after parsing |
+
+### `ParseResult`
+
+| Method / Property | Returns | Description |
+|---|---|---|
+| `toUsj()` | `object` | USJ (Unified Scripture JSON) |
+| `toUsx()` | `string` | USX (Unified Scripture XML) |
+| `toUsfm()` | `string` | Normalized USFM |
+| `toVref()` | `Record<string, string>` | Verse reference to plain text map |
+| `hasErrors()` | `boolean` | True if any error-severity diagnostics |
+| `diagnostics` | `Diagnostic[]` | Parser and validation diagnostics |
+| `free()` | `void` | Free WASM memory |
+
+### `Diagnostic`
+
+| Property | Type | Description |
+|---|---|---|
+| `severity` | `string` | `"error"`, `"warning"`, or `"info"` |
+| `code` | `string` | Machine-readable code (e.g. `"UnknownMarker"`) |
+| `message` | `string` | Human-readable message |
+| `start` | `number` | Start byte offset in source |
+| `end` | `number` | End byte offset in source |
+
+## License
+
+MIT

package/node.js

@@ -0,0 +1,10 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { initSync } from "./usfm3_wasm.js";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const wasmBytes = readFileSync(join(__dirname, "usfm3_wasm_bg.wasm"));
+initSync({ module: wasmBytes });
+
+export { parse, ParseResult } from "./usfm3_wasm.js";

package/package.json

@@ -1,15 +1,28 @@
 {
   "name": "usfm3",
   "type": "module",
-  "version": "0.1.0",
+  "version": "0.1.5",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jcuenod/usfm3"
+  },
   "files": [
     "usfm3_wasm_bg.wasm",
     "usfm3_wasm.js",
-    "usfm3_wasm.d.ts"
+    "usfm3_wasm.d.ts",
+    "node.js"
   ],
   "main": "usfm3_wasm.js",
   "types": "usfm3_wasm.d.ts",
   "sideEffects": [
     "./snippets/*"
-  ]
-}
+  ],
+  "exports": {
+    ".": {
+      "node": {
+        "import": "./node.js"
+      },
+      "default": "./usfm3_wasm.js"
+    }
+  }
+}

package/usfm3_wasm.d.ts

@@ -8,6 +8,7 @@ export class ParseResult {
     toUsj(): any;
     toUsx(): string;
     toUsfm(): string;
+    toVref(): Record<string, string>;
 }
 export function parse(usfm: string, options?: ParseOptions): ParseResult;
 
@@ -52,6 +53,7 @@ export interface InitOutput {
     readonly parseresult_toUsfm: (a: number) => [number, number];
     readonly parseresult_toUsj: (a: number) => [number, number, number];
     readonly parseresult_toUsx: (a: number) => [number, number, number, number];
+    readonly parseresult_toVref: (a: number) => [number, number, number];
     readonly __wbindgen_malloc: (a: number, b: number) => number;
     readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_externrefs: WebAssembly.Table;

package/usfm3_wasm.js

@@ -83,6 +83,17 @@ export class ParseResult {
             wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
         }
     }
+    /**
+     * Returns a verse reference map: `{ "GEN 1:1": "In the beginning ...", ... }`.
+     * @returns {any}
+     */
+    toVref() {
+        const ret = wasm.parseresult_toVref(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
 }
 if (Symbol.dispose) ParseResult.prototype[Symbol.dispose] = ParseResult.prototype.free;
 
@@ -136,6 +147,10 @@ function __wbg_get_imports() {
             const ret = typeof(val) === 'object' && val !== null;
             return ret;
         },
+        __wbg___wbindgen_is_string_cd444516edc5b180: function(arg0) {
+            const ret = typeof(arg0) === 'string';
+            return ret;
+        },
         __wbg___wbindgen_is_undefined_9e4d92534c42d778: function(arg0) {
             const ret = arg0 === undefined;
             return ret;
@@ -197,6 +212,10 @@ function __wbg_get_imports() {
             const ret = new Array();
             return ret;
         },
+        __wbg_new_dca287b076112a51: function() {
+            const ret = new Map();
+            return ret;
+        },
         __wbg_new_dd2b680c8bf6ae29: function(arg0) {
             const ret = new Uint8Array(arg0);
             return ret;
@@ -204,6 +223,10 @@ function __wbg_get_imports() {
         __wbg_prototypesetcall_bdcdcc5842e4d77d: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
         },
+        __wbg_set_1eb0999cf5d27fc8: function(arg0, arg1, arg2) {
+            const ret = arg0.set(arg1, arg2);
+            return ret;
+        },
         __wbg_set_3f1d0b984ed272ed: function(arg0, arg1, arg2) {
             arg0[arg1] = arg2;
         },
@@ -215,12 +238,17 @@ function __wbg_get_imports() {
             const ret = arg0;
             return ret;
         },
-        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000002: function(arg0) {
+            // Cast intrinsic for `I64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
         },
-        __wbindgen_cast_0000000000000003: function(arg0) {
+        __wbindgen_cast_0000000000000004: function(arg0) {
             // Cast intrinsic for `U64 -> Externref`.
             const ret = BigInt.asUintN(64, arg0);
             return ret;