@rfanth/tjson 0.3.1 → 0.4.1

package/README.md

@@ -1,103 +1,127 @@
-# tjson-rs
-
-A Rust library and CLI tool for [TJSON](https://textjson.com)
-
-TJSON is a hyper-readable, round trip safe and data preserving substitute for JSON that feels like text and represents the same data while looking quite different and allowing different generator rules to optimize readibility.  It is not a superset or a subset of JSON.  It's commonality is that it represents the same underlying data, not the format itself.  It's position based to emphasize locality of meaning, and adds bare strings, pipe tables, comments, multiline string literals, and line folding to make the contained data easier to read while remaining fully convertible to and from standard JSON without data loss.  TJSON is optimized for reading and deterministic data, not human editing.
-
-Usage as a binary, library (including WASM too), and through serde Serialize are all fully supported.
-
-## Installation
-
-Add to your `Cargo.toml`:
-
-```toml
-[dependencies]
-tjson = "0.1"
+# @rfanth/tjson
+
+JavaScript/TypeScript bindings for [TJSON](https://textjson.com) — a readable, round-trip-safe alternative to JSON.
+
+TJSON represents the same data model as JSON but renders it in a way that feels like text: bare strings and keys, pipe tables for arrays of objects, multiline string literals, line folding, and comments. It is not a superset or subset of JSON — it is a different surface syntax for the same underlying data, fully convertible in both directions without data loss.
+
+**Input JSON**
+```json
+{
+  "name": "Alice",
+  "age": 30,
+  "active": true,
+  "bio": "She is a developer.\nShe loves Rust.",
+  "scores": [90, 85, 92],
+  "tags": ["rust", "wasm", "json", "serialization"],
+  "team": [
+    {"name": "Alice", "age": 30, "role": "admin"},
+    {"name": "Bob",   "age": 25, "role": "user"},
+    {"name": "Carol", "age": 35, "role": "user"}
+  ]
+}
 ```
 
-Install the CLI:
-
-```sh
-cargo install tjson-rs
+**TJSON output**
 ```
-
-## Library Usage
-
-### Parse TJSON
-
-```rust
-use tjson::TjsonValue;
-
-// Parse a TJSON object (keys indented 2 spaces at the top level)
-let value: TjsonValue = "  name: Alice\n  age:30".parse()?;
-
-// Parse a bare string
-let value: TjsonValue = " hello world".parse()?;
+  name: Alice  age:30  active:true
+  bio: ``
+  | She is a developer.
+  | She loves Rust.
+   ``
+  scores:  90, 85, 92
+  tags:   rust,  wasm,  json,  serialization
+  team:
+    |name    |age  |role    |
+    | Alice  |30   | admin  |
+    | Bob    |25   | user   |
+    | Carol  |35   | user   |
 ```
 
-### Render to TJSON
-
-```rust
-use tjson::{TjsonValue, TjsonOptions};
-
-let value = TjsonValue::from(serde_json::json!({"name": "Alice", "age": 30}));
-
-// Default options
-let tjson = value.to_tjson_with(TjsonOptions::default())?;
+## Installation
 
-// Canonical (one key per line, no packing)
-let canonical = value.to_tjson_with(TjsonOptions::canonical())?;
+```sh
+npm install @rfanth/tjson
 ```
 
-### Serde integration
-
-```rust
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize)]
-struct Person {
-    name: String,
-    age: u32,
-}
+Or via CDN (no bundler needed):
 
-// Deserialize from TJSON
-let person: Person = tjson::from_str("  name: Alice\n  age:30")?;
-
-// Serialize to TJSON
-let tjson = tjson::to_string(&person)?;
+```js
+import { parse, stringify, fromJson, toJson } from 'https://esm.sh/@rfanth/tjson';
 ```
 
-## CLI Usage
-
-```sh
-# JSON to TJSON
-echo '{"name":"Alice","scores":[1,2,3]}' | tjson
+## Usage
 
-# TJSON to JSON
-echo '  name: Alice' | tjson --json
+```ts
+import { parse, stringify, fromJson, toJson } from '@rfanth/tjson';
 
-# From/to files
-tjson -i data.json -o data.tjson
-tjson --json -i data.tjson -o data.json
+// JS value → TJSON
+const tjson = stringify({ name: 'Alice', scores: [95, 87, 92] });
 
-# Canonical output
-tjson --canonical -i data.json
-```
+// TJSON → JS value
+const value = parse(tjson);
 
-## WASM / JavaScript
+// With options
+const canonical = stringify({ name: 'Alice' }, { canonical: true });
+const narrow    = stringify({ name: 'Alice' }, { wrapWidth: 40, stringArrayStyle: 'preferSpaces' });
 
-The library compiles to WebAssembly via [wasm-pack](https://rustwasm.github.io/wasm-pack/):
-
-```sh
-wasm-pack build --target bundler
+// String pipeline variants (if you already have a JSON string)
+const tjson2 = fromJson('{"name":"Alice"}');
+const json   = toJson(tjson2);
 ```
 
+`stringify` accepts any JSON-serializable JS value and returns a TJSON string.
+`parse` accepts a TJSON string and returns a JS value — just like `JSON.parse`.
+`fromJson`/`toJson` are the string-in/string-out variants for JSON string pipelines.
+
+All four functions throw an `Error` on invalid input.
+
+## Options
+
+`stringify` and `fromJson` accept an optional [`StringifyOptions`](https://github.com/rfanth/tjson/blob/master/src/wasm.rs) object. TypeScript users get full autocomplete and inline documentation for all options — hover over any field in your editor.
+
+Options use **camelCase** in JavaScript. The underlying library's Rust API uses snake_case and idiomatic Rust, but exposes the same options.
+
+Key options at a glance:
+
+| Option | Default | Description |
+|---|---|---|
+| `canonical` | `false` | One key per line, no packing, no tables |
+| `wrapWidth` | `80` | Column wrap limit; `0` for unlimited |
+| `tables` | `true` | Render arrays-of-objects as pipe tables |
+| `multilineStrings` | `true` | Use `\`\`` blocks for strings containing newlines |
+| `bareStrings` | `"prefer"` | Use bare (unquoted) string values when spec permits |
+| `bareKeys` | `"prefer"` | Use bare (unquoted) object keys when spec permits |
+| `inlineObjects` | `true` | Pack multiple key-value pairs onto one line |
+| `inlineArrays` | `true` | Pack multiple array items onto one line |
+| `stringArrayStyle` | `"preferComma"` | How to pack all-string arrays |
+| `indentGlyphStyle` | `"auto"` | When to emit `/<` `/>` glyphs for deeply nested content |
+| `forceMarkers` | `false` | Always emit `=` / `:` markers, even when inferrable |
+| `multilineStyle` | `"bold"` | Multiline block style (`"bold"`, `"floating"`, etc.) |
+| `multilineMinLines` | `1` | Min newlines in a string before using a block |
+| `multilineMaxLines` | `10` | Max lines in a block before falling back |
+| `tableFold` | `false` | Fold long table rows across continuation lines |
+| `tableUnindentStyle` | `"auto"` | How to reposition wide tables using indent glyphs |
+| `tableMinRows` | `3` | Min rows required to render a table |
+| `tableMinCols` | `3` | Min columns required to render a table |
+| `tableMinSimilarity` | `0.8` | Min fraction of rows sharing a column |
+| `tableColumnMaxWidth` | `40` | Bail on table if any column exceeds this width |
+| `fold` | — | Set all four fold styles at once; more specific options override |
+| `numberFoldStyle` | `"auto"` | How to fold long numbers across lines |
+| `stringBareFoldStyle` | `"auto"` | How to fold long bare strings |
+| `stringQuotedFoldStyle` | `"auto"` | How to fold long quoted strings |
+| `stringMultilineFoldStyle` | `"none"` | How to fold multiline block continuation lines |
+| `indentGlyphMarkerStyle` | `"compact"` | Where to place the opening `/<` glyph |
+
+Full option reference with documentation is in the TypeScript types bundled with the package.
+
 ## Resources
 
-- Website and online demo: [textjson.com](https://textjson.com)
-- Specification: _coming soon_
-- Test suite: _coming soon_
+- **Website and live demo**: [textjson.com](https://textjson.com)
+- **Specification**: [tjson-specification.md](https://github.com/rfanth/tjson-spec/blob/master/tjson-specification.md)
+- **Test suite**: [tjson-tests](https://github.com/rfanth/tjson-tests)
+- **Rust/WASM crate**: [tjson-rs](https://crates.io/crates/tjson-rs) — same options, snake_case API
+- **MariaDB/MySQL UDF**: [tjson-udf](https://github.com/rfanth/tjson-udf) — same options in SQL
 
 ## License
 
-BSD-3-Clause. See [LICENSE](LICENSE).
+BSD-3-Clause

package/package.json

@@ -2,7 +2,7 @@
   "name": "@rfanth/tjson",
   "type": "module",
   "description": "Text JSON (TJSON) - a readability optimized, round trip compatible alternative to JSON",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "license": "BSD-3-Clause",
   "repository": {
     "type": "git",

package/tjson.d.ts

@@ -1,12 +1,92 @@
 /* tslint:disable */
 /* eslint-disable */
 
-/**
- * Parse a TJSON string and return it as a JSON string.
- */
-export function parse(input: string): string;
+export type BareStyle = "prefer" | "none";
+export type FoldStyle = "auto" | "fixed" | "none";
+export type MultilineStyle = "floating" | "bold" | "boldFloating" | "transparent" | "light" | "foldingQuotes";
+export type TableUnindentStyle = "left" | "auto" | "floating" | "none";
+export type StringArrayStyle = "spaces" | "preferSpaces" | "comma" | "preferComma" | "none";
+export type IndentGlyphStyle = "auto" | "fixed" | "none";
+export type IndentGlyphMarkerStyle = "compact" | "separate";
+
+export interface StringifyOptions {
+    /** Start from a preset canonical configuration (one pair per line, no packing, no tables). */
+    canonical?: boolean;
+    /** Wrap width in columns. 0 means unlimited. Values between 1 and 19 are clamped to 20. */
+    wrapWidth?: number;
+    /** Force explicit `[` / `{` indent markers on arrays and objects, even for single-step indents that would normally be implicit. */
+    forceMarkers?: boolean;
+    /** Whether to use bare (unquoted) strings. Default: `"prefer"`. */
+    bareStrings?: BareStyle;
+    /** Whether to use bare (unquoted) object keys. Default: `"prefer"`. */
+    bareKeys?: BareStyle;
+    /** Allow packing multiple key-value pairs onto one line. Default: `true`. */
+    inlineObjects?: boolean;
+    /** Allow packing multiple array items onto one line. Default: `true`. */
+    inlineArrays?: boolean;
+    /** Allow multiline string blocks for strings containing newlines. Default: `true`. */
+    multilineStrings?: boolean;
+    /** Multiline block style. Default: `"bold"`. */
+    multilineStyle?: MultilineStyle;
+    /** Minimum number of lines before a multiline block is used. Default: `1`. */
+    multilineMinLines?: number;
+    /** Maximum number of lines in a multiline block before falling back. Default: `10`. */
+    multilineMaxLines?: number;
+    /** Enable table rendering for uniform arrays-of-objects. Default: `true`. */
+    tables?: boolean;
+    /** Allow folding long table rows across continuation lines. Default: `false`. */
+    tableFold?: boolean;
+    /** How to horizontally reposition tables using indent-offset glyphs. Default: `"auto"`. */
+    tableUnindentStyle?: TableUnindentStyle;
+    /** Minimum rows required to render a table. Default: `3`. */
+    tableMinRows?: number;
+    /** Minimum columns required to render a table. Default: `3`. */
+    tableMinCols?: number;
+    /** Minimum fraction [0–1] of rows sharing a column before it's included. Default: `0.8`. */
+    tableMinSimilarity?: number;
+    /** If any column's content width (including the leading space on bare string values) exceeds this value, the table is abandoned and falls back to block layout. `0` means no limit. Default: `40`. */
+    tableColumnMaxWidth?: number;
+    /** How to pack short-string arrays onto one line. Default: `"preferComma"`. */
+    stringArrayStyle?: StringArrayStyle;
+    /** Set all fold styles at once. More specific fold options override this if also set. */
+    fold?: FoldStyle;
+    /** How to fold long numbers across lines. Default: `"auto"`. */
+    numberFoldStyle?: FoldStyle;
+    /** How to fold bare strings. Default: `"auto"`. */
+    stringBareFoldStyle?: FoldStyle;
+    /** How to fold quoted strings. Default: `"auto"`. */
+    stringQuotedFoldStyle?: FoldStyle;
+    /** How to fold multiline string continuation lines. Default: `"none"`. */
+    stringMultilineFoldStyle?: FoldStyle;
+    /** When to emit `/<` `/>` indent-offset glyphs. Default: `"auto"`. */
+    indentGlyphStyle?: IndentGlyphStyle;
+    /** Where to place the opening `/<` glyph. Default: `"compact"`. */
+    indentGlyphMarkerStyle?: IndentGlyphMarkerStyle;
+}
+
+/** Parse a TJSON string and return a JSON string. */
+export function toJson(input: string): string;
+
+/** Render a JSON string as TJSON, with optional options. */
+export function fromJson(input: string, options?: StringifyOptions): string;
+
+/** Render a JavaScript value as TJSON, with optional options. */
+export function stringify(input: any, options?: StringifyOptions): string;
+
+
 
 /**
- * Render a JSON string as TJSON, with optional options object.
+ * Parse a TJSON string and return a JavaScript value.
+ *
+ * Accepts the full TJSON format: bare strings and keys, multiline strings,
+ * pipe tables, line folding, and comments. The output is a live JavaScript
+ * value — object, array, string, number, boolean, or null.
+ *
+ * ```js
+ * const value = parse("  name: Alice\n  age: 30");
+ * // → { name: "Alice", age: 30 }
+ * ```
+ *
+ * Throws an `Error` if the input is not valid TJSON.
  */
-export function stringify(input: string, options: any): string;
+export function parse(input: string): any;

package/tjson.js

@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./tjson_bg.js";
 __wbg_set_wasm(wasm);
 wasm.__wbindgen_start();
 export {
-    parse, stringify
+    fromJson, parse, stringify, toJson
 } from "./tjson_bg.js";

package/tjson_bg.js

@@ -1,15 +1,21 @@
 /**
- * Parse a TJSON string and return it as a JSON string.
+ * Render a JSON string as TJSON, with optional options object.
+ *
+ * Like `stringify`, but accepts a JSON string instead of a JavaScript value.
+ * Useful when you already have a JSON string and want to avoid parsing it first.
+ *
+ * Throws an `Error` if the input is not valid JSON, or if an option value is unrecognised.
  * @param {string} input
+ * @param {any} options
  * @returns {string}
  */
-export function parse(input) {
+export function fromJson(input, options) {
     let deferred3_0;
     let deferred3_1;
     try {
         const ptr0 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.parse(ptr0, len0);
+        const ret = wasm.fromJson(ptr0, len0, options);
         var ptr2 = ret[0];
         var len2 = ret[1];
         if (ret[3]) {
@@ -25,18 +31,90 @@ export function parse(input) {
 }
 
 /**
- * Render a JSON string as TJSON, with optional options object.
+ * Parse a TJSON string and return a JavaScript value.
+ *
+ * Accepts the full TJSON format: bare strings and keys, multiline strings,
+ * pipe tables, line folding, and comments. The output is a live JavaScript
+ * value — object, array, string, number, boolean, or null.
+ *
+ * ```js
+ * const value = parse("  name: Alice\n  age: 30");
+ * // → { name: "Alice", age: 30 }
+ * ```
+ *
+ * Throws an `Error` if the input is not valid TJSON.
  * @param {string} input
+ * @returns {any}
+ */
+export function parse(input) {
+    const ptr0 = passStringToWasm0(input, 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]);
+}
+
+/**
+ * Render a JavaScript value as TJSON, with optional options object.
+ *
+ * Accepts any JSON-serializable value — object, array, string, number,
+ * boolean, or null. Options control formatting details — wrap width, tables,
+ * multiline strings, folding, and more. Omit `options` to
+ * use defaults (80-column wrap, tables enabled, bare strings preferred).
+ *
+ * ```js
+ * const tjson = stringify({ name: "Alice", scores: [1, 2, 3] });
+ *
+ * // Canonical: one key per line, no packing, no tables
+ * const canonical = stringify({ name: "Alice" }, { canonical: true });
+ *
+ * // Narrow output with space-separated string arrays
+ * const narrow = stringify({ name: "Alice" }, { wrapWidth: 40, stringArrayStyle: "preferSpaces" });
+ * ```
+ *
+ * Throws an `Error` if the value is not JSON-serializable, or if an option value is unrecognised.
+ * @param {any} input
  * @param {any} options
  * @returns {string}
  */
 export function stringify(input, options) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.stringify(input, options);
+        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);
+    }
+}
+
+/**
+ * Parse a TJSON string and return a JSON string.
+ *
+ * Like `parse`, but returns a JSON string instead of a JavaScript value.
+ * Useful when you need to pass the result to another JSON consumer.
+ *
+ * Throws an `Error` if the input is not valid TJSON.
+ * @param {string} input
+ * @returns {string}
+ */
+export function toJson(input) {
     let deferred3_0;
     let deferred3_1;
     try {
         const ptr0 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.stringify(ptr0, len0, options);
+        const ret = wasm.toJson(ptr0, len0);
         var ptr2 = ret[0];
         var len2 = ret[1];
         if (ret[3]) {
@@ -50,11 +128,11 @@ export function stringify(input, options) {
         wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
     }
 }
-export function __wbg_Error_55538483de6e3abe(arg0, arg1) {
+export function __wbg_Error_2e59b1b37a9a34c3(arg0, arg1) {
     const ret = Error(getStringFromWasm0(arg0, arg1));
     return ret;
 }
-export function __wbg_Number_f257194b7002d6f9(arg0) {
+export function __wbg_Number_e6ffdb596c888833(arg0) {
     const ret = Number(arg0);
     return ret;
 }
@@ -65,60 +143,68 @@ export function __wbg_String_8564e559799eccda(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
-export function __wbg___wbindgen_bigint_get_as_i64_a738e80c0fe6f6a7(arg0, arg1) {
+export function __wbg___wbindgen_bigint_get_as_i64_2c5082002e4826e2(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);
 }
-export function __wbg___wbindgen_boolean_get_fe2a24fdfdb4064f(arg0) {
+export function __wbg___wbindgen_boolean_get_a86c216575a75c30(arg0) {
     const v = arg0;
     const ret = typeof(v) === 'boolean' ? v : undefined;
     return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
 }
-export function __wbg___wbindgen_debug_string_d89627202d0155b7(arg0, arg1) {
+export function __wbg___wbindgen_debug_string_dd5d2d07ce9e6c57(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);
 }
-export function __wbg___wbindgen_in_fe3eb6a509f75744(arg0, arg1) {
+export function __wbg___wbindgen_in_4bd7a57e54337366(arg0, arg1) {
     const ret = arg0 in arg1;
     return ret;
 }
-export function __wbg___wbindgen_is_bigint_ca270ac12ef71091(arg0) {
+export function __wbg___wbindgen_is_bigint_6c98f7e945dacdde(arg0) {
     const ret = typeof(arg0) === 'bigint';
     return ret;
 }
-export function __wbg___wbindgen_is_null_8d90524c9e0af183(arg0) {
+export function __wbg___wbindgen_is_function_49868bde5eb1e745(arg0) {
+    const ret = typeof(arg0) === 'function';
+    return ret;
+}
+export function __wbg___wbindgen_is_null_344c8750a8525473(arg0) {
     const ret = arg0 === null;
     return ret;
 }
-export function __wbg___wbindgen_is_object_59a002e76b059312(arg0) {
+export function __wbg___wbindgen_is_object_40c5a80572e8f9d3(arg0) {
     const val = arg0;
     const ret = typeof(val) === 'object' && val !== null;
     return ret;
 }
-export function __wbg___wbindgen_is_undefined_87a3a837f331fef5(arg0) {
+export function __wbg___wbindgen_is_string_b29b5c5a8065ba1a(arg0) {
+    const ret = typeof(arg0) === 'string';
+    return ret;
+}
+export function __wbg___wbindgen_is_undefined_c0cca72b82b86f4d(arg0) {
     const ret = arg0 === undefined;
     return ret;
 }
-export function __wbg___wbindgen_jsval_eq_eedd705f9f2a4f35(arg0, arg1) {
+export function __wbg___wbindgen_jsval_eq_7d430e744a913d26(arg0, arg1) {
     const ret = arg0 === arg1;
     return ret;
 }
-export function __wbg___wbindgen_jsval_loose_eq_cf851f110c48f9ba(arg0, arg1) {
+export function __wbg___wbindgen_jsval_loose_eq_3a72ae764d46d944(arg0, arg1) {
     const ret = arg0 == arg1;
     return ret;
 }
-export function __wbg___wbindgen_number_get_769f3676dc20c1d7(arg0, arg1) {
+export function __wbg___wbindgen_number_get_7579aab02a8a620c(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);
 }
-export function __wbg___wbindgen_string_get_f1161390414f9b59(arg0, arg1) {
+export function __wbg___wbindgen_string_get_914df97fcfa788f2(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);
@@ -126,14 +212,38 @@ export function __wbg___wbindgen_string_get_f1161390414f9b59(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
-export function __wbg___wbindgen_throw_5549492daedad139(arg0, arg1) {
+export function __wbg___wbindgen_throw_81fc77679af83bc6(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
 }
+export function __wbg_call_7f2987183bb62793() { return handleError(function (arg0, arg1) {
+    const ret = arg0.call(arg1);
+    return ret;
+}, arguments); }
+export function __wbg_done_547d467e97529006(arg0) {
+    const ret = arg0.done;
+    return ret;
+}
+export function __wbg_entries_616b1a459b85be0b(arg0) {
+    const ret = Object.entries(arg0);
+    return ret;
+}
+export function __wbg_get_4848e350b40afc16(arg0, arg1) {
+    const ret = arg0[arg1 >>> 0];
+    return ret;
+}
+export function __wbg_get_ed0642c4b9d31ddf() { return handleError(function (arg0, arg1) {
+    const ret = Reflect.get(arg0, arg1);
+    return ret;
+}, arguments); }
+export function __wbg_get_unchecked_7d7babe32e9e6a54(arg0, arg1) {
+    const ret = arg0[arg1 >>> 0];
+    return ret;
+}
 export function __wbg_get_with_ref_key_6412cf3094599694(arg0, arg1) {
     const ret = arg0[arg1];
     return ret;
 }
-export function __wbg_instanceof_ArrayBuffer_8d855993947fc3a2(arg0) {
+export function __wbg_instanceof_ArrayBuffer_ff7c1337a5e3b33a(arg0) {
     let result;
     try {
         result = arg0 instanceof ArrayBuffer;
@@ -143,7 +253,17 @@ export function __wbg_instanceof_ArrayBuffer_8d855993947fc3a2(arg0) {
     const ret = result;
     return ret;
 }
-export function __wbg_instanceof_Uint8Array_ce24d58a5f4bdcc3(arg0) {
+export function __wbg_instanceof_Map_a10a2795ef4bfe97(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Map;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_instanceof_Uint8Array_4b8da683deb25d72(arg0) {
     let result;
     try {
         result = arg0 instanceof Uint8Array;
@@ -153,27 +273,82 @@ export function __wbg_instanceof_Uint8Array_ce24d58a5f4bdcc3(arg0) {
     const ret = result;
     return ret;
 }
-export function __wbg_isSafeInteger_1dfae065cbfe1915(arg0) {
+export function __wbg_isArray_db61795ad004c139(arg0) {
+    const ret = Array.isArray(arg0);
+    return ret;
+}
+export function __wbg_isSafeInteger_ea83862ba994770c(arg0) {
     const ret = Number.isSafeInteger(arg0);
     return ret;
 }
-export function __wbg_length_e6e1633fbea6cfa9(arg0) {
+export function __wbg_iterator_de403ef31815a3e6() {
+    const ret = Symbol.iterator;
+    return ret;
+}
+export function __wbg_length_0c32cb8543c8e4c8(arg0) {
     const ret = arg0.length;
     return ret;
 }
-export function __wbg_new_1d96678aaacca32e(arg0) {
+export function __wbg_length_6e821edde497a532(arg0) {
+    const ret = arg0.length;
+    return ret;
+}
+export function __wbg_new_4f9fafbb3909af72() {
+    const ret = new Object();
+    return ret;
+}
+export function __wbg_new_99cabae501c0a8a0() {
+    const ret = new Map();
+    return ret;
+}
+export function __wbg_new_a560378ea1240b14(arg0) {
     const ret = new Uint8Array(arg0);
     return ret;
 }
-export function __wbg_prototypesetcall_3875d54d12ef2eec(arg0, arg1, arg2) {
+export function __wbg_new_e3b04b4d53d1b593(arg0, arg1) {
+    const ret = new Error(getStringFromWasm0(arg0, arg1));
+    return ret;
+}
+export function __wbg_new_f3c9df4f38f3f798() {
+    const ret = new Array();
+    return ret;
+}
+export function __wbg_next_01132ed6134b8ef5(arg0) {
+    const ret = arg0.next;
+    return ret;
+}
+export function __wbg_next_b3713ec761a9dbfd() { return handleError(function (arg0) {
+    const ret = arg0.next();
+    return ret;
+}, arguments); }
+export function __wbg_prototypesetcall_3e05eb9545565046(arg0, arg1, arg2) {
     Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
 }
-export function __wbindgen_cast_0000000000000001(arg0, arg1) {
+export function __wbg_set_08463b1df38a7e29(arg0, arg1, arg2) {
+    const ret = arg0.set(arg1, arg2);
+    return ret;
+}
+export function __wbg_set_6be42768c690e380(arg0, arg1, arg2) {
+    arg0[arg1] = arg2;
+}
+export function __wbg_set_6c60b2e8ad0e9383(arg0, arg1, arg2) {
+    arg0[arg1 >>> 0] = arg2;
+}
+export function __wbg_value_7f6052747ccf940f(arg0) {
+    const ret = arg0.value;
+    return ret;
+}
+export function __wbindgen_cast_0000000000000001(arg0) {
+    // Cast intrinsic for `I64 -> Externref`.
+    const ret = arg0;
+    return ret;
+}
+export function __wbindgen_cast_0000000000000002(arg0, arg1) {
     // Cast intrinsic for `Ref(String) -> Externref`.
     const ret = getStringFromWasm0(arg0, arg1);
     return ret;
 }
-export function __wbindgen_cast_0000000000000002(arg0) {
+export function __wbindgen_cast_0000000000000003(arg0) {
     // Cast intrinsic for `U64 -> Externref`.
     const ret = BigInt.asUintN(64, arg0);
     return ret;
@@ -187,6 +362,12 @@ export function __wbindgen_init_externref_table() {
     table.set(offset + 2, true);
     table.set(offset + 3, false);
 }
+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;
@@ -278,6 +459,15 @@ 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;
 }