timed-automata-analyzer 1.0.9 → 1.0.11

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 - 2025 Luthium
+Copyright (c) 2024 - 2026 Luthium
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -27,6 +27,10 @@ In case you want to contribute to the tool or fork the repository, only few step
   To run the linters, execute `cargo check` and `cargo clippy`, respectively.
 - For further information on compiling Rust to WebAssembly, see the [MDN Web Docs](https://developer.mozilla.org/en-US/docs/WebAssembly/Rust_to_Wasm).
 
+In addition to the Rust code for creating the Wasm binary, this project also contains a tiny TypeScript project in the folder `wasm_test`.
+The purpose of this Node project is to check whether the generated Wasm binary and the generate glue code work as intended (i.e., the Wasm binary can in principal be accessed).
+To execute these tests, just install Node and npm on your machine, open the `wasm_test` folder, and run `npm install` and `npm test`.
+
 ## 💡 Additional Information
 
 - Most of the algorithms for checking reachability are based on the paper [Timed Automata: Semantics, Algorithms and Tools](https://doi.org/10.1007/978-3-540-27755-2_3).

package/package.json

@@ -5,7 +5,7 @@
     "luth1um"
   ],
   "description": "An analyzer for Timed Automata written in Rust",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "license": "MIT",
   "repository": {
     "type": "git",

package/timed_automata_analyzer.d.ts

@@ -1,5 +1,49 @@
 /* tslint:disable */
 /* eslint-disable */
+
+export class Clause {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(lhs: Clock, op: ClockComparator, rhs: number);
+}
+
+export class Clock {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(name: string);
+}
+
+export enum ClockComparator {
+    LESSER = 0,
+    LEQ = 1,
+    GEQ = 2,
+    GREATER = 3,
+}
+
+export class ClockConstraint {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(clauses: Clause[]);
+}
+
+export class Location {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(name: string, is_initial: boolean, invariant?: ClockConstraint | null);
+}
+
+export class Switch {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(source: Location, guard: ClockConstraint | null | undefined, action: string, reset: Clock[], target: Location);
+}
+
+export class TimedAutomaton {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(locations: Location[], clocks: Clock[], switches: Switch[]);
+}
+
 /**
  * Checks all locations of the input TA for reachability and returns all unreachable locations. The
  * result will be empty if all locations are reachable.
@@ -20,39 +64,3 @@
  * </ul>
  */
 export function findUnreachableLocations(ta: TimedAutomaton): string[];
-export enum ClockComparator {
-  LESSER = 0,
-  LEQ = 1,
-  GEQ = 2,
-  GREATER = 3,
-}
-export class Clause {
-  free(): void;
-  [Symbol.dispose](): void;
-  constructor(lhs: Clock, op: ClockComparator, rhs: number);
-}
-export class Clock {
-  free(): void;
-  [Symbol.dispose](): void;
-  constructor(name: string);
-}
-export class ClockConstraint {
-  free(): void;
-  [Symbol.dispose](): void;
-  constructor(clauses: Clause[]);
-}
-export class Location {
-  free(): void;
-  [Symbol.dispose](): void;
-  constructor(name: string, is_initial: boolean, invariant?: ClockConstraint | null);
-}
-export class Switch {
-  free(): void;
-  [Symbol.dispose](): void;
-  constructor(source: Location, guard: ClockConstraint | null | undefined, action: string, reset: Clock[], target: Location);
-}
-export class TimedAutomaton {
-  free(): void;
-  [Symbol.dispose](): void;
-  constructor(locations: Location[], clocks: Clock[], switches: Switch[]);
-}

package/timed_automata_analyzer.js

@@ -1,5 +1,9 @@
+/* @ts-self-types="./timed_automata_analyzer.d.ts" */
+
 import * as wasm from "./timed_automata_analyzer_bg.wasm";
-export * from "./timed_automata_analyzer_bg.js";
 import { __wbg_set_wasm } from "./timed_automata_analyzer_bg.js";
 __wbg_set_wasm(wasm);
 wasm.__wbindgen_start();
+export {
+    Clause, Clock, ClockComparator, ClockConstraint, Location, Switch, TimedAutomaton, findUnreachableLocations
+} from "./timed_automata_analyzer_bg.js";

package/timed_automata_analyzer_bg.js

@@ -1,198 +1,16 @@
-let wasm;
-export function __wbg_set_wasm(val) {
-    wasm = val;
-}
-
-
-let cachedUint8ArrayMemory0 = null;
-
-function getUint8ArrayMemory0() {
-    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
-        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
-    }
-    return cachedUint8ArrayMemory0;
-}
-
-let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-
-cachedTextDecoder.decode();
-
-const MAX_SAFARI_DECODE_BYTES = 2146435072;
-let numBytesDecoded = 0;
-function decodeText(ptr, len) {
-    numBytesDecoded += len;
-    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
-        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-        cachedTextDecoder.decode();
-        numBytesDecoded = len;
-    }
-    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
-}
-
-function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return decodeText(ptr, len);
-}
-
-let WASM_VECTOR_LEN = 0;
-
-const cachedTextEncoder = new TextEncoder();
-
-if (!('encodeInto' in cachedTextEncoder)) {
-    cachedTextEncoder.encodeInto = function (arg, view) {
-        const buf = cachedTextEncoder.encode(arg);
-        view.set(buf);
-        return {
-            read: arg.length,
-            written: buf.length
-        };
-    }
-}
-
-function passStringToWasm0(arg, malloc, realloc) {
-
-    if (realloc === undefined) {
-        const buf = cachedTextEncoder.encode(arg);
-        const ptr = malloc(buf.length, 1) >>> 0;
-        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
-        WASM_VECTOR_LEN = buf.length;
-        return ptr;
-    }
-
-    let len = arg.length;
-    let ptr = malloc(len, 1) >>> 0;
-
-    const mem = getUint8ArrayMemory0();
-
-    let offset = 0;
-
-    for (; offset < len; offset++) {
-        const code = arg.charCodeAt(offset);
-        if (code > 0x7F) break;
-        mem[ptr + offset] = code;
-    }
-
-    if (offset !== len) {
-        if (offset !== 0) {
-            arg = arg.slice(offset);
-        }
-        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
-        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
-        const ret = cachedTextEncoder.encodeInto(arg, view);
-
-        offset += ret.written;
-        ptr = realloc(ptr, len, offset, 1) >>> 0;
-    }
-
-    WASM_VECTOR_LEN = offset;
-    return ptr;
-}
-
-function _assertClass(instance, klass) {
-    if (!(instance instanceof klass)) {
-        throw new Error(`expected instance of ${klass.name}`);
-    }
-}
-
-let cachedDataViewMemory0 = null;
-
-function getDataViewMemory0() {
-    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
-        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
-    }
-    return cachedDataViewMemory0;
-}
-
-function addToExternrefTable0(obj) {
-    const idx = wasm.__externref_table_alloc();
-    wasm.__wbindgen_export_0.set(idx, obj);
-    return idx;
-}
-
-function passArrayJsValueToWasm0(array, malloc) {
-    const ptr = malloc(array.length * 4, 4) >>> 0;
-    for (let i = 0; i < array.length; i++) {
-        const add = addToExternrefTable0(array[i]);
-        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
-    }
-    WASM_VECTOR_LEN = array.length;
-    return ptr;
-}
-
-function isLikeNone(x) {
-    return x === undefined || x === null;
-}
-
-function getArrayJsValueFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    const mem = getDataViewMemory0();
-    const result = [];
-    for (let i = ptr; i < ptr + 4 * len; i += 4) {
-        result.push(wasm.__wbindgen_export_0.get(mem.getUint32(i, true)));
-    }
-    wasm.__externref_drop_slice(ptr, len);
-    return result;
-}
-/**
- * Checks all locations of the input TA for reachability and returns all unreachable locations. The
- * result will be empty if all locations are reachable.
- *
- * This function will throw an error if one or more validation checks fail. The following
- * properties will be validated:
- * <ul>
- * <li>There exists exactly one initial location.</li>
- * <li>The set of locations is non-empty.</li>
- * <li>All invariants are downward-closed.</li>
- * <li>The highest constant used in any clock constraint is not greater than the highest allowed
- * value (536870909).</li>
- * <li>All locations names are unique.</li>
- * <li>All clock names are unique.</li>
- * <li>All clocks used in clock constraints are also contained in the set of clocks.</li>
- * <li>All location names used as source and target of switches are also contained in the set of
- * locations.</li>
- * </ul>
- * @param {TimedAutomaton} ta
- * @returns {string[]}
- */
-export function findUnreachableLocations(ta) {
-    _assertClass(ta, TimedAutomaton);
-    var ptr0 = ta.__destroy_into_raw();
-    const ret = wasm.findUnreachableLocations(ptr0);
-    var v2 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-    return v2;
-}
-
-/**
- * @enum {0 | 1 | 2 | 3}
- */
-export const ClockComparator = Object.freeze({
-    LESSER: 0, "0": "LESSER",
-    LEQ: 1, "1": "LEQ",
-    GEQ: 2, "2": "GEQ",
-    GREATER: 3, "3": "GREATER",
-});
-
-const ClauseFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_clause_free(ptr >>> 0, 1));
-
 export class Clause {
-
     static __unwrap(jsValue) {
         if (!(jsValue instanceof Clause)) {
             return 0;
         }
         return jsValue.__destroy_into_raw();
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         ClauseFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_clause_free(ptr, 0);
@@ -212,26 +30,19 @@ export class Clause {
 }
 if (Symbol.dispose) Clause.prototype[Symbol.dispose] = Clause.prototype.free;
 
-const ClockFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_clock_free(ptr >>> 0, 1));
-
 export class Clock {
-
     static __unwrap(jsValue) {
         if (!(jsValue instanceof Clock)) {
             return 0;
         }
         return jsValue.__destroy_into_raw();
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         ClockFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_clock_free(ptr, 0);
@@ -250,19 +61,23 @@ export class Clock {
 }
 if (Symbol.dispose) Clock.prototype[Symbol.dispose] = Clock.prototype.free;
 
-const ClockConstraintFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_clockconstraint_free(ptr >>> 0, 1));
+/**
+ * @enum {0 | 1 | 2 | 3}
+ */
+export const ClockComparator = Object.freeze({
+    LESSER: 0, "0": "LESSER",
+    LEQ: 1, "1": "LEQ",
+    GEQ: 2, "2": "GEQ",
+    GREATER: 3, "3": "GREATER",
+});
 
 export class ClockConstraint {
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         ClockConstraintFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_clockconstraint_free(ptr, 0);
@@ -281,26 +96,19 @@ export class ClockConstraint {
 }
 if (Symbol.dispose) ClockConstraint.prototype[Symbol.dispose] = ClockConstraint.prototype.free;
 
-const LocationFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_location_free(ptr >>> 0, 1));
-
 export class Location {
-
     static __unwrap(jsValue) {
         if (!(jsValue instanceof Location)) {
             return 0;
         }
         return jsValue.__destroy_into_raw();
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         LocationFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_location_free(ptr, 0);
@@ -326,26 +134,19 @@ export class Location {
 }
 if (Symbol.dispose) Location.prototype[Symbol.dispose] = Location.prototype.free;
 
-const SwitchFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_switch_free(ptr >>> 0, 1));
-
 export class Switch {
-
     static __unwrap(jsValue) {
         if (!(jsValue instanceof Switch)) {
             return 0;
         }
         return jsValue.__destroy_into_raw();
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         SwitchFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_switch_free(ptr, 0);
@@ -377,19 +178,13 @@ export class Switch {
 }
 if (Symbol.dispose) Switch.prototype[Symbol.dispose] = Switch.prototype.free;
 
-const TimedAutomatonFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_timedautomaton_free(ptr >>> 0, 1));
-
 export class TimedAutomaton {
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         TimedAutomatonFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_timedautomaton_free(ptr, 0);
@@ -414,44 +209,213 @@ export class TimedAutomaton {
 }
 if (Symbol.dispose) TimedAutomaton.prototype[Symbol.dispose] = TimedAutomaton.prototype.free;
 
+/**
+ * Checks all locations of the input TA for reachability and returns all unreachable locations. The
+ * result will be empty if all locations are reachable.
+ *
+ * This function will throw an error if one or more validation checks fail. The following
+ * properties will be validated:
+ * <ul>
+ * <li>There exists exactly one initial location.</li>
+ * <li>The set of locations is non-empty.</li>
+ * <li>All invariants are downward-closed.</li>
+ * <li>The highest constant used in any clock constraint is not greater than the highest allowed
+ * value (536870909).</li>
+ * <li>All locations names are unique.</li>
+ * <li>All clock names are unique.</li>
+ * <li>All clocks used in clock constraints are also contained in the set of clocks.</li>
+ * <li>All location names used as source and target of switches are also contained in the set of
+ * locations.</li>
+ * </ul>
+ * @param {TimedAutomaton} ta
+ * @returns {string[]}
+ */
+export function findUnreachableLocations(ta) {
+    _assertClass(ta, TimedAutomaton);
+    var ptr0 = ta.__destroy_into_raw();
+    const ret = wasm.findUnreachableLocations(ptr0);
+    var v2 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v2;
+}
+export function __wbg___wbindgen_throw_be289d5034ed271b(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+}
 export function __wbg_clause_unwrap(arg0) {
     const ret = Clause.__unwrap(arg0);
     return ret;
-};
-
+}
 export function __wbg_clock_unwrap(arg0) {
     const ret = Clock.__unwrap(arg0);
     return ret;
-};
-
+}
 export function __wbg_location_unwrap(arg0) {
     const ret = Location.__unwrap(arg0);
     return ret;
-};
-
+}
 export function __wbg_switch_unwrap(arg0) {
     const ret = Switch.__unwrap(arg0);
     return ret;
-};
-
-export function __wbg_wbindgenthrow_451ec1a8469d7eb6(arg0, arg1) {
-    throw new Error(getStringFromWasm0(arg0, arg1));
-};
-
-export function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
+}
+export function __wbindgen_cast_0000000000000001(arg0, arg1) {
     // Cast intrinsic for `Ref(String) -> Externref`.
     const ret = getStringFromWasm0(arg0, arg1);
     return ret;
-};
-
+}
 export function __wbindgen_init_externref_table() {
-    const table = wasm.__wbindgen_export_0;
+    const table = wasm.__wbindgen_externrefs;
     const offset = table.grow(4);
     table.set(0, undefined);
     table.set(offset + 0, undefined);
     table.set(offset + 1, null);
     table.set(offset + 2, true);
     table.set(offset + 3, false);
-    ;
-};
+}
+const ClauseFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_clause_free(ptr >>> 0, 1));
+const ClockFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_clock_free(ptr >>> 0, 1));
+const ClockConstraintFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_clockconstraint_free(ptr >>> 0, 1));
+const LocationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_location_free(ptr >>> 0, 1));
+const SwitchFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_switch_free(ptr >>> 0, 1));
+const TimedAutomatonFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_timedautomaton_free(ptr >>> 0, 1));
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_externrefs.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
 
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}