toon-ld 0.1.2 → 0.2.2

package/README.md

@@ -13,7 +13,7 @@ TOON-LD extends TOON in the same way that JSON-LD extends JSON: **every valid TO
 - **Full JSON-LD Compatibility**: Round-trip conversion without data loss
 - **Tabular Arrays**: Serialize arrays of objects as CSV-like rows with shared headers
 - **All JSON-LD 1.1 Keywords**: Complete support for `@context`, `@graph`, `@id`, `@type`, value nodes, etc.
-- **WebAssembly Performance**: Compiled from Rust for near-native speed
+- **WebAssembly Performance**: Compiled from Rust for high-performance parsing and serialization
 - **TypeScript Support**: Fully typed API with excellent IDE support
 - **Browser & Node.js**: Works in both environments
 
@@ -32,8 +32,9 @@ yarn add toon-ld
 ## Quick Start
 
 ```javascript
-import { convert_jsonld_to_toon, convert_toon_to_jsonld } from 'toon-ld';
+import { encode, decode, parse, stringify } from 'toon-ld';
 
+// 1. String Conversion
 // Convert JSON-LD to TOON-LD
 const jsonLd = JSON.stringify({
   "@context": {"foaf": "http://xmlns.com/foaf/0.1/"},
@@ -41,7 +42,7 @@ const jsonLd = JSON.stringify({
   "foaf:age": 30
 });
 
-const toon = convert_jsonld_to_toon(jsonLd);
+const toon = encode(jsonLd);
 console.log(toon);
 // Output:
 // @context:
@@ -50,9 +51,20 @@ console.log(toon);
 // foaf:age: 30
 
 // Convert back to JSON-LD
-const backToJson = convert_toon_to_jsonld(toon);
+const backToJson = decode(toon);
 const parsed = JSON.parse(backToJson);
 console.log(parsed);
+
+// 2. Object Helper Functions
+// Parse directly to JS Object
+const data = parse(toon);
+console.log(data['foaf:name']); // "Alice"
+
+// Serialize JS Object directly to TOON-LD
+const toonStr = stringify({
+  "@context": {"schema": "http://schema.org/"},
+  "schema:name": "Bob"
+});
 ```
 
 ## Tabular Arrays - The Key Feature
@@ -85,9 +97,9 @@ Notice how object keys appear once in the header instead of repeating for each o
 
 ## API Reference
 
-### `convert_jsonld_to_toon(json: string): string`
+### `encode(json: string): string`
 
-Convert a JSON-LD string to TOON-LD format.
+Convert (encode) a JSON-LD string to TOON-LD format.
 
 **Parameters:**
 - `json` - A JSON or JSON-LD formatted string
@@ -98,15 +110,9 @@ Convert a JSON-LD string to TOON-LD format.
 **Throws:**
 - Error with message if the input is invalid JSON
 
-**Example:**
-```javascript
-const jsonLd = '{"@context": {"foaf": "http://xmlns.com/foaf/0.1/"}, "foaf:name": "Alice"}';
-const toon = convert_jsonld_to_toon(jsonLd);
-```
-
-### `convert_toon_to_jsonld(toon: string): string`
+### `decode(toon: string): string`
 
-Convert a TOON-LD string to JSON-LD format.
+Convert (decode) a TOON-LD string to JSON-LD format.
 
 **Parameters:**
 - `toon` - A TOON-LD formatted string
@@ -117,15 +123,27 @@ Convert a TOON-LD string to JSON-LD format.
 **Throws:**
 - Error with message if the input is invalid TOON-LD
 
-**Example:**
-```javascript
-const toon = `@context:
-  foaf: http://xmlns.com/foaf/0.1/
-foaf:name: Alice`;
-const jsonLd = convert_toon_to_jsonld(toon);
-```
+### `parse(toon: string): any`
+
+Parse a TOON-LD string directly into a JavaScript Object.
+
+**Parameters:**
+- `toon` - A TOON-LD formatted string
+
+**Returns:**
+- JavaScript Object representing the data
+
+### `stringify(data: any): string`
+
+Stringify a JavaScript Object directly into a TOON-LD string.
+
+**Parameters:**
+- `data` - A JavaScript Object
+
+**Returns:**
+- TOON-LD formatted string
 
-### `validate_json(json: string): boolean`
+### `validateJson(json: string): boolean`
 
 Validate a JSON-LD string.
 
@@ -135,13 +153,7 @@ Validate a JSON-LD string.
 **Returns:**
 - `true` if the string is valid JSON, `false` otherwise
 
-**Example:**
-```javascript
-const isValid = validate_json('{"name": "Alice"}');
-console.log(isValid); // true
-```
-
-### `validate_toon(toon: string): boolean`
+### `validateToonld(toon: string): boolean`
 
 Validate a TOON-LD string.
 
@@ -151,12 +163,6 @@ Validate a TOON-LD string.
 **Returns:**
 - `true` if the string is valid TOON-LD, `false` otherwise
 
-**Example:**
-```javascript
-const isValid = validate_toon('name: Alice');
-console.log(isValid); // true
-```
-
 ### `init(): void`
 
 Initialize panic hook for better error messages in the browser console. This is optional but recommended for development.
@@ -174,15 +180,15 @@ This package includes TypeScript type definitions out of the box:
 
 ```typescript
 import { 
-  convert_jsonld_to_toon, 
-  convert_toon_to_jsonld,
-  validate_json,
-  validate_toon 
+  encode, 
+  decode,
+  validateJson,
+  validateToonld 
 } from 'toon-ld';
 
 const jsonLd: string = '{"name": "Alice"}';
-const toon: string = convert_jsonld_to_toon(jsonLd);
-const isValid: boolean = validate_toon(toon);
+const toon: string = encode(jsonLd);
+const isValid: boolean = validateToonld(toon);
 ```
 
 ## Usage Examples
@@ -191,14 +197,14 @@ const isValid: boolean = validate_toon(toon);
 
 ```javascript
 import express from 'express';
-import { convert_jsonld_to_toon, convert_toon_to_jsonld } from 'toon-ld';
+import { encode, decode } from 'toon-ld';
 
 const app = express();
 app.use(express.text({ type: 'text/toon' }));
 
 app.post('/convert/to-toon', (req, res) => {
   try {
-    const toon = convert_jsonld_to_toon(req.body);
+    const toon = encode(req.body);
     res.type('text/toon').send(toon);
   } catch (error) {
     res.status(400).json({ error: error.message });
@@ -207,7 +213,7 @@ app.post('/convert/to-toon', (req, res) => {
 
 app.post('/convert/to-jsonld', (req, res) => {
   try {
-    const jsonLd = convert_toon_to_jsonld(req.body);
+    const jsonLd = decode(req.body);
     res.json(JSON.parse(jsonLd));
   } catch (error) {
     res.status(400).json({ error: error.message });
@@ -225,7 +231,7 @@ app.post('/convert/to-jsonld', (req, res) => {
 </head>
 <body>
   <script type="module">
-    import { convert_jsonld_to_toon, init } from 'https://unpkg.com/toon-ld';
+    import { encode, init } from 'https://unpkg.com/toon-ld';
     
     init(); // Better error messages
     
@@ -234,7 +240,7 @@ app.post('/convert/to-jsonld', (req, res) => {
       "schema:name": "Example"
     });
     
-    const toon = convert_jsonld_to_toon(jsonLd);
+    const toon = encode(jsonLd);
     console.log(toon);
   </script>
 </body>
@@ -254,7 +260,7 @@ const jsonLd = JSON.stringify({
   ]
 });
 
-const toon = convert_jsonld_to_toon(jsonLd);
+const toon = encode(jsonLd);
 console.log(toon);
 // Output:
 // @context:
@@ -267,10 +273,10 @@ console.log(toon);
 ### Error Handling
 
 ```javascript
-import { convert_toon_to_jsonld } from 'toon-ld';
+import { decode } from 'toon-ld';
 
 try {
-  const result = convert_toon_to_jsonld("invalid: [unclosed");
+  const result = decode("invalid: [unclosed");
 } catch (error) {
   console.error("Conversion failed:", error.message);
   // Error message includes line numbers and helpful context

package/package.json

@@ -5,31 +5,16 @@
     "Kush Bisen"
   ],
   "description": "WASM bindings for TOON-LD serializer/parser",
-  "version": "0.1.2",
+  "version": "0.2.2",
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/argahsuknesib/toon-ld"
-  },
-  "homepage": "https://github.com/argahsuknesib/toon-ld#readme",
-  "keywords": [
-    "toon",
-    "json-ld",
-    "rdf",
-    "linked-data",
-    "serialization",
-    "wasm",
-    "webassembly"
-  ],
   "files": [
     "toon_wasm_bg.wasm",
     "toon_wasm.js",
-    "toon_wasm.d.ts",
-    "README.md"
+    "toon_wasm.d.ts"
   ],
   "main": "toon_wasm.js",
   "types": "toon_wasm.d.ts",
   "sideEffects": [
     "./snippets/*"
   ]
-}
+}

package/toon_wasm.d.ts

@@ -1,34 +1,60 @@
 /* tslint:disable */
 /* eslint-disable */
 
+export function convert_jsonld_to_toonld(json: string): string;
+
 /**
- * Convert JSON-LD string to TOON-LD format
+ * Convert TOON-LD string to JSON-LD format
  *
  * # Arguments
- * * `json` - A JSON or JSON-LD formatted string
+ * * `toon` - A TOON-LD formatted string
  *
  * # Returns
- * * TOON-LD formatted string on success
+ * * JSON-LD formatted string (pretty-printed) on success
  * * Error message on failure
  */
-export function convert_jsonld_to_toon(json: string): string;
+export function convert_toonld_to_jsonld(toon: string): string;
 
 /**
- * Convert TOON-LD string to JSON-LD format
+ * Decode TOON-LD string to JSON-LD format
+ *
+ * Alias for `convert_toonld_to_jsonld`
+ */
+export function decode(toon: string): string;
+
+/**
+ * Encode JSON-LD string to TOON-LD format
+ *
+ * Alias for `convert_jsonld_to_toonld`
+ */
+export function encode(json: string): string;
+
+/**
+ * Initialize panic hook for better error messages in browser console
+ */
+export function init(): void;
+
+/**
+ * Parse TOON-LD string to a JavaScript Object
  *
  * # Arguments
  * * `toon` - A TOON-LD formatted string
  *
  * # Returns
- * * JSON-LD formatted string (pretty-printed) on success
- * * Error message on failure
+ * * JavaScript Object representing the parsed data
  */
-export function convert_toon_to_jsonld(toon: string): string;
+export function parse(toon: string): any;
 
 /**
- * Initialize panic hook for better error messages in browser console
+ * Stringify a JavaScript Object to TOON-LD format
+ *
+ * # Arguments
+ * * `data` - A JavaScript Object
+ *
+ * # Returns
+ * * TOON-LD formatted string
  */
-export function init(): void;
+export function stringify(data: any): string;
 
 /**
  * Validate a JSON-LD string
@@ -40,7 +66,7 @@ export function init(): void;
  * * `true` if the string is valid JSON
  * * `false` otherwise
  */
-export function validate_json(json: string): boolean;
+export function validateJson(json: string): boolean;
 
 /**
  * Validate a TOON-LD string
@@ -52,21 +78,27 @@ export function validate_json(json: string): boolean;
  * * `true` if the string is valid TOON-LD
  * * `false` otherwise
  */
-export function validate_toon(toon: string): boolean;
+export function validateToonld(toon: string): boolean;
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
   readonly init: () => void;
-  readonly convert_jsonld_to_toon: (a: number, b: number) => [number, number, number, number];
-  readonly convert_toon_to_jsonld: (a: number, b: number) => [number, number, number, number];
-  readonly validate_toon: (a: number, b: number) => number;
-  readonly validate_json: (a: number, b: number) => number;
-  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+  readonly convert_jsonld_to_toonld: (a: number, b: number) => [number, number, number, number];
+  readonly convert_toonld_to_jsonld: (a: number, b: number) => [number, number, number, number];
+  readonly validateToonld: (a: number, b: number) => number;
+  readonly validateJson: (a: number, b: number) => number;
+  readonly parse: (a: number, b: number) => [number, number, number];
+  readonly stringify: (a: any) => [number, number, number, number];
+  readonly encode: (a: number, b: number) => [number, number, number, number];
+  readonly decode: (a: number, b: number) => [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_exn_store: (a: number) => void;
+  readonly __externref_table_alloc: () => number;
   readonly __wbindgen_externrefs: WebAssembly.Table;
+  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
   readonly __externref_table_dealloc: (a: number) => void;
   readonly __wbindgen_start: () => void;
 }

package/toon_wasm.js

@@ -1,5 +1,81 @@
 let wasm;
 
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
@@ -21,6 +97,19 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);
@@ -94,24 +183,16 @@ if (!('encodeInto' in cachedTextEncoder)) {
 let WASM_VECTOR_LEN = 0;
 
 /**
- * Convert JSON-LD string to TOON-LD format
- *
- * # Arguments
- * * `json` - A JSON or JSON-LD formatted string
- *
- * # Returns
- * * TOON-LD formatted string on success
- * * Error message on failure
  * @param {string} json
  * @returns {string}
  */
-export function convert_jsonld_to_toon(json) {
+export function convert_jsonld_to_toonld(json) {
     let deferred3_0;
     let deferred3_1;
     try {
         const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.convert_jsonld_to_toon(ptr0, len0);
+        const ret = wasm.convert_jsonld_to_toonld(ptr0, len0);
         var ptr2 = ret[0];
         var len2 = ret[1];
         if (ret[3]) {
@@ -138,13 +219,69 @@ export function convert_jsonld_to_toon(json) {
  * @param {string} toon
  * @returns {string}
  */
-export function convert_toon_to_jsonld(toon) {
+export function convert_toonld_to_jsonld(toon) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(toon, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.convert_toonld_to_jsonld(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Decode TOON-LD string to JSON-LD format
+ *
+ * Alias for `convert_toonld_to_jsonld`
+ * @param {string} toon
+ * @returns {string}
+ */
+export function decode(toon) {
     let deferred3_0;
     let deferred3_1;
     try {
         const ptr0 = passStringToWasm0(toon, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.convert_toon_to_jsonld(ptr0, len0);
+        const ret = wasm.decode(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Encode JSON-LD string to TOON-LD format
+ *
+ * Alias for `convert_jsonld_to_toonld`
+ * @param {string} json
+ * @returns {string}
+ */
+export function encode(json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.encode(ptr0, len0);
         var ptr2 = ret[0];
         var len2 = ret[1];
         if (ret[3]) {
@@ -166,6 +303,57 @@ export function init() {
     wasm.init();
 }
 
+/**
+ * Parse TOON-LD string to a JavaScript Object
+ *
+ * # Arguments
+ * * `toon` - A TOON-LD formatted string
+ *
+ * # Returns
+ * * JavaScript Object representing the parsed data
+ * @param {string} toon
+ * @returns {any}
+ */
+export function parse(toon) {
+    const ptr0 = passStringToWasm0(toon, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.parse(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Stringify a JavaScript Object to TOON-LD format
+ *
+ * # Arguments
+ * * `data` - A JavaScript Object
+ *
+ * # Returns
+ * * TOON-LD formatted string
+ * @param {any} data
+ * @returns {string}
+ */
+export function stringify(data) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.stringify(data);
+        var ptr1 = ret[0];
+        var len1 = ret[1];
+        if (ret[3]) {
+            ptr1 = 0; len1 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred2_0 = ptr1;
+        deferred2_1 = len1;
+        return getStringFromWasm0(ptr1, len1);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
 /**
  * Validate a JSON-LD string
  *
@@ -178,10 +366,10 @@ export function init() {
  * @param {string} json
  * @returns {boolean}
  */
-export function validate_json(json) {
+export function validateJson(json) {
     const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.validate_json(ptr0, len0);
+    const ret = wasm.validateJson(ptr0, len0);
     return ret !== 0;
 }
 
@@ -197,10 +385,10 @@ export function validate_json(json) {
  * @param {string} toon
  * @returns {boolean}
  */
-export function validate_toon(toon) {
+export function validateToonld(toon) {
     const ptr0 = passStringToWasm0(toon, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.validate_toon(ptr0, len0);
+    const ret = wasm.validateToonld(ptr0, len0);
     return ret !== 0;
 }
 
@@ -239,6 +427,93 @@ async function __wbg_load(module, imports) {
 function __wbg_get_imports() {
     const imports = {};
     imports.wbg = {};
+    imports.wbg.__wbg_Error_52673b7de5a0ca89 = function(arg0, arg1) {
+        const ret = Error(getStringFromWasm0(arg0, arg1));
+        return ret;
+    };
+    imports.wbg.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {
+        const ret = String(arg1);
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg___wbindgen_bigint_get_as_i64_6e32f5e6aff02e1d = function(arg0, arg1) {
+        const v = arg1;
+        const ret = typeof(v) === 'bigint' ? v : undefined;
+        getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+    };
+    imports.wbg.__wbg___wbindgen_boolean_get_dea25b33882b895b = function(arg0) {
+        const v = arg0;
+        const ret = typeof(v) === 'boolean' ? v : undefined;
+        return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+    };
+    imports.wbg.__wbg___wbindgen_debug_string_adfb662ae34724b6 = function(arg0, arg1) {
+        const ret = debugString(arg1);
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg___wbindgen_in_0d3e1e8f0c669317 = function(arg0, arg1) {
+        const ret = arg0 in arg1;
+        return ret;
+    };
+    imports.wbg.__wbg___wbindgen_is_bigint_0e1a2e3f55cfae27 = function(arg0) {
+        const ret = typeof(arg0) === 'bigint';
+        return ret;
+    };
+    imports.wbg.__wbg___wbindgen_is_function_8d400b8b1af978cd = function(arg0) {
+        const ret = typeof(arg0) === 'function';
+        return ret;
+    };
+    imports.wbg.__wbg___wbindgen_is_object_ce774f3490692386 = function(arg0) {
+        const val = arg0;
+        const ret = typeof(val) === 'object' && val !== null;
+        return ret;
+    };
+    imports.wbg.__wbg___wbindgen_is_string_704ef9c8fc131030 = function(arg0) {
+        const ret = typeof(arg0) === 'string';
+        return ret;
+    };
+    imports.wbg.__wbg___wbindgen_jsval_eq_b6101cc9cef1fe36 = function(arg0, arg1) {
+        const ret = arg0 === arg1;
+        return ret;
+    };
+    imports.wbg.__wbg___wbindgen_jsval_loose_eq_766057600fdd1b0d = function(arg0, arg1) {
+        const ret = arg0 == arg1;
+        return ret;
+    };
+    imports.wbg.__wbg___wbindgen_number_get_9619185a74197f95 = function(arg0, arg1) {
+        const obj = arg1;
+        const ret = typeof(obj) === 'number' ? obj : undefined;
+        getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+    };
+    imports.wbg.__wbg___wbindgen_string_get_a2a31e16edf96e42 = function(arg0, arg1) {
+        const obj = arg1;
+        const ret = typeof(obj) === 'string' ? obj : undefined;
+        var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbg_call_abb4ff46ce38be40 = function() { return handleError(function (arg0, arg1) {
+        const ret = arg0.call(arg1);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_done_62ea16af4ce34b24 = function(arg0) {
+        const ret = arg0.done;
+        return ret;
+    };
+    imports.wbg.__wbg_entries_83c79938054e065f = function(arg0) {
+        const ret = Object.entries(arg0);
+        return ret;
+    };
     imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
         let deferred0_0;
         let deferred0_1;
@@ -250,10 +525,105 @@ function __wbg_get_imports() {
             wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
         }
     };
+    imports.wbg.__wbg_get_6b7bd52aca3f9671 = function(arg0, arg1) {
+        const ret = arg0[arg1 >>> 0];
+        return ret;
+    };
+    imports.wbg.__wbg_get_af9dab7e9603ea93 = function() { return handleError(function (arg0, arg1) {
+        const ret = Reflect.get(arg0, arg1);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_instanceof_ArrayBuffer_f3320d2419cd0355 = function(arg0) {
+        let result;
+        try {
+            result = arg0 instanceof ArrayBuffer;
+        } catch (_) {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
+    imports.wbg.__wbg_instanceof_Map_084be8da74364158 = function(arg0) {
+        let result;
+        try {
+            result = arg0 instanceof Map;
+        } catch (_) {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
+    imports.wbg.__wbg_instanceof_Uint8Array_da54ccc9d3e09434 = function(arg0) {
+        let result;
+        try {
+            result = arg0 instanceof Uint8Array;
+        } catch (_) {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
+    imports.wbg.__wbg_isArray_51fd9e6422c0a395 = function(arg0) {
+        const ret = Array.isArray(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_isSafeInteger_ae7d3f054d55fa16 = function(arg0) {
+        const ret = Number.isSafeInteger(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_iterator_27b7c8b35ab3e86b = function() {
+        const ret = Symbol.iterator;
+        return ret;
+    };
+    imports.wbg.__wbg_length_22ac23eaec9d8053 = function(arg0) {
+        const ret = arg0.length;
+        return ret;
+    };
+    imports.wbg.__wbg_length_d45040a40c570362 = function(arg0) {
+        const ret = arg0.length;
+        return ret;
+    };
+    imports.wbg.__wbg_new_1ba21ce319a06297 = function() {
+        const ret = new Object();
+        return ret;
+    };
+    imports.wbg.__wbg_new_25f239778d6112b9 = function() {
+        const ret = new Array();
+        return ret;
+    };
+    imports.wbg.__wbg_new_6421f6084cc5bc5a = function(arg0) {
+        const ret = new Uint8Array(arg0);
+        return ret;
+    };
     imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
         const ret = new Error();
         return ret;
     };
+    imports.wbg.__wbg_new_b546ae120718850e = function() {
+        const ret = new Map();
+        return ret;
+    };
+    imports.wbg.__wbg_next_138a17bbf04e926c = function(arg0) {
+        const ret = arg0.next;
+        return ret;
+    };
+    imports.wbg.__wbg_next_3cfe5c0fe2a4cc53 = function() { return handleError(function (arg0) {
+        const ret = arg0.next();
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_prototypesetcall_dfe9b766cdc1f1fd = function(arg0, arg1, arg2) {
+        Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+    };
+    imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
+        arg0[arg1] = arg2;
+    };
+    imports.wbg.__wbg_set_7df433eea03a5c14 = function(arg0, arg1, arg2) {
+        arg0[arg1 >>> 0] = arg2;
+    };
+    imports.wbg.__wbg_set_efaaf145b9377369 = function(arg0, arg1, arg2) {
+        const ret = arg0.set(arg1, arg2);
+        return ret;
+    };
     imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
         const ret = arg1.stack;
         const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -261,11 +631,30 @@ function __wbg_get_imports() {
         getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
     };
+    imports.wbg.__wbg_value_57b7b035e117f7ee = function(arg0) {
+        const ret = arg0.value;
+        return ret;
+    };
     imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
         // Cast intrinsic for `Ref(String) -> Externref`.
         const ret = getStringFromWasm0(arg0, arg1);
         return ret;
     };
+    imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
+        // Cast intrinsic for `U64 -> Externref`.
+        const ret = BigInt.asUintN(64, arg0);
+        return ret;
+    };
+    imports.wbg.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
+        // Cast intrinsic for `I64 -> Externref`.
+        const ret = arg0;
+        return ret;
+    };
+    imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
+        // Cast intrinsic for `F64 -> Externref`.
+        const ret = arg0;
+        return ret;
+    };
     imports.wbg.__wbindgen_init_externref_table = function() {
         const table = wasm.__wbindgen_externrefs;
         const offset = table.grow(4);