@mirascript/wasm 0.1.1 → 0.1.3

package/lib/wasm.d.ts

@@ -1,14 +1,14 @@
 /* tslint:disable */
 /* eslint-disable */
-export function compile_buffer(script: Uint8Array, config: Config): CompileResult;
+export function main(): void;
 export function compile(script: string, config: Config): CompileResult;
-export function get_diagnostic_message(code: DiagnosticCode): string | undefined;
+export function compile_buffer(script: Uint8Array, config: Config): CompileResult;
+export function reserved_keywords(): string[];
 export function keywords(): string[];
-export function control_keywords(): string[];
 export function numeric_keywords(): string[];
 export function constant_keywords(): string[];
-export function reserved_keywords(): string[];
-export function main(): void;
+export function control_keywords(): string[];
+export function get_diagnostic_message(code: DiagnosticCode): string | undefined;
 export enum DiagnosticCode {
   ErrorStart = 1000,
   InternalError = 1001,
@@ -708,8 +708,8 @@ export class CompileResult {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  chunk(): Uint8Array | undefined;
   diagnostics(): Uint32Array;
+  chunk(): Uint8Array | undefined;
 }
 export class Config {
   free(): void;
@@ -729,11 +729,11 @@ export class Config {
 export class MonacoCompiler {
   free(): void;
   [Symbol.dispose](): void;
+  diagnostics(): Uint32Array;
   constructor(input: string, config: Config);
-  parse(): boolean;
   emit(): Uint8Array | undefined;
+  parse(): boolean;
   format(): string | undefined;
-  diagnostics(): Uint32Array;
 }
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
@@ -741,48 +741,48 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
   readonly __wbg_compileresult_free: (a: number, b: number) => void;
+  readonly __wbg_monacocompiler_free: (a: number, b: number) => void;
+  readonly compile: (a: number, b: number, c: number) => number;
+  readonly compile_buffer: (a: number, b: number, c: number) => number;
   readonly compileresult_chunk: (a: number, b: number) => void;
   readonly compileresult_diagnostics: (a: number, b: number) => void;
-  readonly compile_buffer: (a: number, b: number, c: number) => number;
-  readonly compile: (a: number, b: number, c: number) => number;
+  readonly constant_keywords: (a: number) => void;
+  readonly control_keywords: (a: number) => void;
   readonly get_diagnostic_message: (a: number, b: number) => void;
   readonly keywords: (a: number) => void;
-  readonly control_keywords: (a: number) => void;
-  readonly numeric_keywords: (a: number) => void;
-  readonly constant_keywords: (a: number) => void;
-  readonly reserved_keywords: (a: number) => void;
-  readonly __wbg_monacocompiler_free: (a: number, b: number) => void;
-  readonly monacocompiler_new: (a: number, b: number, c: number) => number;
-  readonly monacocompiler_parse: (a: number) => number;
+  readonly main: () => void;
+  readonly monacocompiler_diagnostics: (a: number, b: number) => void;
   readonly monacocompiler_emit: (a: number, b: number) => void;
   readonly monacocompiler_format: (a: number, b: number) => void;
-  readonly monacocompiler_diagnostics: (a: number, b: number) => void;
-  readonly main: () => void;
+  readonly monacocompiler_new: (a: number, b: number, c: number) => number;
+  readonly monacocompiler_parse: (a: number) => number;
+  readonly numeric_keywords: (a: number) => void;
+  readonly reserved_keywords: (a: number) => void;
   readonly __wbg_config_free: (a: number, b: number) => void;
+  readonly __wbg_get_config_diagnostic_error: (a: number) => number;
+  readonly __wbg_get_config_diagnostic_hint: (a: number) => number;
+  readonly __wbg_get_config_diagnostic_info: (a: number) => number;
+  readonly __wbg_get_config_diagnostic_other: (a: number) => number;
+  readonly __wbg_get_config_diagnostic_position_encoding: (a: number) => number;
+  readonly __wbg_get_config_diagnostic_reference: (a: number) => number;
+  readonly __wbg_get_config_diagnostic_warning: (a: number) => number;
+  readonly __wbg_get_config_input_mode: (a: number) => number;
   readonly __wbg_get_config_track_references: (a: number) => number;
-  readonly __wbg_set_config_track_references: (a: number, b: number) => void;
   readonly __wbg_get_config_trivia: (a: number) => number;
-  readonly __wbg_set_config_trivia: (a: number, b: number) => void;
-  readonly __wbg_get_config_input_mode: (a: number) => number;
-  readonly __wbg_set_config_input_mode: (a: number, b: number) => void;
-  readonly __wbg_get_config_diagnostic_position_encoding: (a: number) => number;
-  readonly __wbg_set_config_diagnostic_position_encoding: (a: number, b: number) => void;
-  readonly __wbg_get_config_diagnostic_error: (a: number) => number;
   readonly __wbg_set_config_diagnostic_error: (a: number, b: number) => void;
-  readonly __wbg_get_config_diagnostic_warning: (a: number) => number;
-  readonly __wbg_set_config_diagnostic_warning: (a: number, b: number) => void;
-  readonly __wbg_get_config_diagnostic_info: (a: number) => number;
-  readonly __wbg_set_config_diagnostic_info: (a: number, b: number) => void;
-  readonly __wbg_get_config_diagnostic_hint: (a: number) => number;
   readonly __wbg_set_config_diagnostic_hint: (a: number, b: number) => void;
-  readonly __wbg_get_config_diagnostic_reference: (a: number) => number;
-  readonly __wbg_set_config_diagnostic_reference: (a: number, b: number) => void;
-  readonly __wbg_get_config_diagnostic_other: (a: number) => number;
+  readonly __wbg_set_config_diagnostic_info: (a: number, b: number) => void;
   readonly __wbg_set_config_diagnostic_other: (a: number, b: number) => void;
+  readonly __wbg_set_config_diagnostic_position_encoding: (a: number, b: number) => void;
+  readonly __wbg_set_config_diagnostic_reference: (a: number, b: number) => void;
+  readonly __wbg_set_config_diagnostic_warning: (a: number, b: number) => void;
+  readonly __wbg_set_config_input_mode: (a: number, b: number) => void;
+  readonly __wbg_set_config_track_references: (a: number, b: number) => void;
+  readonly __wbg_set_config_trivia: (a: number, b: number) => void;
   readonly config_new: () => number;
-  readonly __wbindgen_export_0: (a: number, b: number, c: number) => void;
-  readonly __wbindgen_export_1: (a: number, b: number) => number;
-  readonly __wbindgen_export_2: (a: number, b: number, c: number, d: number) => number;
+  readonly __wbindgen_export: (a: number, b: number, c: number) => void;
+  readonly __wbindgen_export2: (a: number, b: number) => number;
+  readonly __wbindgen_export3: (a: number, b: number, c: number, d: number) => number;
   readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
   readonly __wbindgen_start: () => void;
 }

package/lib/wasm.js

@@ -122,9 +122,8 @@ function takeObject(idx) {
     return ret;
 }
 
-function getArrayU8FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+export function main() {
+    wasm.main();
 }
 
 let cachedUint32ArrayMemory0 = null;
@@ -141,65 +140,48 @@ function getArrayU32FromWasm0(ptr, len) {
     return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
 }
 
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1, 1) >>> 0;
-    getUint8ArrayMemory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
-
 function _assertClass(instance, klass) {
     if (!(instance instanceof klass)) {
         throw new Error(`expected instance of ${klass.name}`);
     }
 }
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
 /**
- * @param {Uint8Array} script
+ * @param {string} script
  * @param {Config} config
  * @returns {CompileResult}
  */
-export function compile_buffer(script, config) {
-    const ptr0 = passArray8ToWasm0(script, wasm.__wbindgen_export_1);
+export function compile(script, config) {
+    const ptr0 = passStringToWasm0(script, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
     const len0 = WASM_VECTOR_LEN;
     _assertClass(config, Config);
-    const ret = wasm.compile_buffer(ptr0, len0, config.__wbg_ptr);
+    const ret = wasm.compile(ptr0, len0, config.__wbg_ptr);
     return CompileResult.__wrap(ret);
 }
 
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
 /**
- * @param {string} script
+ * @param {Uint8Array} script
  * @param {Config} config
  * @returns {CompileResult}
  */
-export function compile(script, config) {
-    const ptr0 = passStringToWasm0(script, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+export function compile_buffer(script, config) {
+    const ptr0 = passArray8ToWasm0(script, wasm.__wbindgen_export2);
     const len0 = WASM_VECTOR_LEN;
     _assertClass(config, Config);
-    const ret = wasm.compile(ptr0, len0, config.__wbg_ptr);
+    const ret = wasm.compile_buffer(ptr0, len0, config.__wbg_ptr);
     return CompileResult.__wrap(ret);
 }
 
-/**
- * @param {DiagnosticCode} code
- * @returns {string | undefined}
- */
-export function get_diagnostic_message(code) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.get_diagnostic_message(retptr, code);
-        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        let v1;
-        if (r0 !== 0) {
-            v1 = getStringFromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export_0(r0, r1 * 1, 1);
-        }
-        return v1;
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-    }
-}
-
 function getArrayJsValueFromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     const mem = getDataViewMemory0();
@@ -212,14 +194,14 @@ function getArrayJsValueFromWasm0(ptr, len) {
 /**
  * @returns {string[]}
  */
-export function keywords() {
+export function reserved_keywords() {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.keywords(retptr);
+        wasm.reserved_keywords(retptr);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
-        wasm.__wbindgen_export_0(r0, r1 * 4, 4);
+        wasm.__wbindgen_export(r0, r1 * 4, 4);
         return v1;
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
@@ -229,14 +211,14 @@ export function keywords() {
 /**
  * @returns {string[]}
  */
-export function control_keywords() {
+export function keywords() {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.control_keywords(retptr);
+        wasm.keywords(retptr);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
-        wasm.__wbindgen_export_0(r0, r1 * 4, 4);
+        wasm.__wbindgen_export(r0, r1 * 4, 4);
         return v1;
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
@@ -253,7 +235,7 @@ export function numeric_keywords() {
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
-        wasm.__wbindgen_export_0(r0, r1 * 4, 4);
+        wasm.__wbindgen_export(r0, r1 * 4, 4);
         return v1;
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
@@ -270,7 +252,7 @@ export function constant_keywords() {
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
-        wasm.__wbindgen_export_0(r0, r1 * 4, 4);
+        wasm.__wbindgen_export(r0, r1 * 4, 4);
         return v1;
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
@@ -280,22 +262,39 @@ export function constant_keywords() {
 /**
  * @returns {string[]}
  */
-export function reserved_keywords() {
+export function control_keywords() {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.reserved_keywords(retptr);
+        wasm.control_keywords(retptr);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
-        wasm.__wbindgen_export_0(r0, r1 * 4, 4);
+        wasm.__wbindgen_export(r0, r1 * 4, 4);
         return v1;
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
     }
 }
 
-export function main() {
-    wasm.main();
+/**
+ * @param {DiagnosticCode} code
+ * @returns {string | undefined}
+ */
+export function get_diagnostic_message(code) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.get_diagnostic_message(retptr, code);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        let v1;
+        if (r0 !== 0) {
+            v1 = getStringFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 1, 1);
+        }
+        return v1;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
 }
 
 /**
@@ -1028,35 +1027,35 @@ export class CompileResult {
         wasm.__wbg_compileresult_free(ptr, 0);
     }
     /**
-     * @returns {Uint8Array | undefined}
+     * @returns {Uint32Array}
      */
-    chunk() {
+    diagnostics() {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.compileresult_chunk(retptr, this.__wbg_ptr);
+            wasm.compileresult_diagnostics(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            let v1;
-            if (r0 !== 0) {
-                v1 = getArrayU8FromWasm0(r0, r1).slice();
-                wasm.__wbindgen_export_0(r0, r1 * 1, 1);
-            }
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 4, 4);
             return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * @returns {Uint32Array}
+     * @returns {Uint8Array | undefined}
      */
-    diagnostics() {
+    chunk() {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.compileresult_diagnostics(retptr, this.__wbg_ptr);
+            wasm.compileresult_chunk(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var v1 = getArrayU32FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export_0(r0, r1 * 4, 4);
+            let v1;
+            if (r0 !== 0) {
+                v1 = getArrayU8FromWasm0(r0, r1).slice();
+                wasm.__wbindgen_export(r0, r1 * 1, 1);
+            }
             return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
@@ -1238,12 +1237,28 @@ export class MonacoCompiler {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_monacocompiler_free(ptr, 0);
     }
+    /**
+     * @returns {Uint32Array}
+     */
+    diagnostics() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.monacocompiler_diagnostics(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * @param {string} input
      * @param {Config} config
      */
     constructor(input, config) {
-        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
         const len0 = WASM_VECTOR_LEN;
         _assertClass(config, Config);
         const ret = wasm.monacocompiler_new(ptr0, len0, config.__wbg_ptr);
@@ -1251,13 +1266,6 @@ export class MonacoCompiler {
         MonacoCompilerFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
-    /**
-     * @returns {boolean}
-     */
-    parse() {
-        const ret = wasm.monacocompiler_parse(this.__wbg_ptr);
-        return ret !== 0;
-    }
     /**
      * @returns {Uint8Array | undefined}
      */
@@ -1270,13 +1278,20 @@ export class MonacoCompiler {
             let v1;
             if (r0 !== 0) {
                 v1 = getArrayU8FromWasm0(r0, r1).slice();
-                wasm.__wbindgen_export_0(r0, r1 * 1, 1);
+                wasm.__wbindgen_export(r0, r1 * 1, 1);
             }
             return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * @returns {boolean}
+     */
+    parse() {
+        const ret = wasm.monacocompiler_parse(this.__wbg_ptr);
+        return ret !== 0;
+    }
     /**
      * @returns {string | undefined}
      */
@@ -1289,29 +1304,13 @@ export class MonacoCompiler {
             let v1;
             if (r0 !== 0) {
                 v1 = getStringFromWasm0(r0, r1).slice();
-                wasm.__wbindgen_export_0(r0, r1 * 1, 1);
+                wasm.__wbindgen_export(r0, r1 * 1, 1);
             }
             return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
-    /**
-     * @returns {Uint32Array}
-     */
-    diagnostics() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.monacocompiler_diagnostics(retptr, this.__wbg_ptr);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var v1 = getArrayU32FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export_0(r0, r1 * 4, 4);
-            return v1;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
 }
 if (Symbol.dispose) MonacoCompiler.prototype[Symbol.dispose] = MonacoCompiler.prototype.free;
 
@@ -1353,6 +1352,9 @@ async function __wbg_load(module, imports) {
 function __wbg_get_imports() {
     const imports = {};
     imports.wbg = {};
+    imports.wbg.__wbg___wbindgen_throw_b855445ff6a94295 = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
     imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
         let deferred0_0;
         let deferred0_1;
@@ -1361,7 +1363,7 @@ function __wbg_get_imports() {
             deferred0_1 = arg1;
             console.error(getStringFromWasm0(arg0, arg1));
         } finally {
-            wasm.__wbindgen_export_0(deferred0_0, deferred0_1, 1);
+            wasm.__wbindgen_export(deferred0_0, deferred0_1, 1);
         }
     };
     imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
@@ -1370,14 +1372,11 @@ function __wbg_get_imports() {
     };
     imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
         const ret = getObject(arg1).stack;
-        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
         const len1 = WASM_VECTOR_LEN;
         getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
     };
-    imports.wbg.__wbg_wbindgenthrow_451ec1a8469d7eb6 = function(arg0, arg1) {
-        throw new Error(getStringFromWasm0(arg0, arg1));
-    };
     imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
         // Cast intrinsic for `Ref(String) -> Externref`.
         const ret = getStringFromWasm0(arg0, arg1);
@@ -1390,10 +1389,6 @@ function __wbg_get_imports() {
     return imports;
 }
 
-function __wbg_init_memory(imports, memory) {
-
-}
-
 function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     __wbg_init.__wbindgen_wasm_module = module;
@@ -1420,8 +1415,6 @@ function initSync(module) {
 
     const imports = __wbg_get_imports();
 
-    __wbg_init_memory(imports);
-
     if (!(module instanceof WebAssembly.Module)) {
         module = new WebAssembly.Module(module);
     }
@@ -1452,8 +1445,6 @@ async function __wbg_init(module_or_path) {
         module_or_path = fetch(module_or_path);
     }
 
-    __wbg_init_memory(imports);
-
     const { instance, module } = await __wbg_load(await module_or_path, imports);
 
     return __wbg_finalize_init(instance, module);

package/lib/wasm_bg.wasm.d.ts

@@ -2,47 +2,47 @@
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
 export const __wbg_compileresult_free: (a: number, b: number) => void;
+export const __wbg_monacocompiler_free: (a: number, b: number) => void;
+export const compile: (a: number, b: number, c: number) => number;
+export const compile_buffer: (a: number, b: number, c: number) => number;
 export const compileresult_chunk: (a: number, b: number) => void;
 export const compileresult_diagnostics: (a: number, b: number) => void;
-export const compile_buffer: (a: number, b: number, c: number) => number;
-export const compile: (a: number, b: number, c: number) => number;
+export const constant_keywords: (a: number) => void;
+export const control_keywords: (a: number) => void;
 export const get_diagnostic_message: (a: number, b: number) => void;
 export const keywords: (a: number) => void;
-export const control_keywords: (a: number) => void;
-export const numeric_keywords: (a: number) => void;
-export const constant_keywords: (a: number) => void;
-export const reserved_keywords: (a: number) => void;
-export const __wbg_monacocompiler_free: (a: number, b: number) => void;
-export const monacocompiler_new: (a: number, b: number, c: number) => number;
-export const monacocompiler_parse: (a: number) => number;
+export const main: () => void;
+export const monacocompiler_diagnostics: (a: number, b: number) => void;
 export const monacocompiler_emit: (a: number, b: number) => void;
 export const monacocompiler_format: (a: number, b: number) => void;
-export const monacocompiler_diagnostics: (a: number, b: number) => void;
-export const main: () => void;
+export const monacocompiler_new: (a: number, b: number, c: number) => number;
+export const monacocompiler_parse: (a: number) => number;
+export const numeric_keywords: (a: number) => void;
+export const reserved_keywords: (a: number) => void;
 export const __wbg_config_free: (a: number, b: number) => void;
+export const __wbg_get_config_diagnostic_error: (a: number) => number;
+export const __wbg_get_config_diagnostic_hint: (a: number) => number;
+export const __wbg_get_config_diagnostic_info: (a: number) => number;
+export const __wbg_get_config_diagnostic_other: (a: number) => number;
+export const __wbg_get_config_diagnostic_position_encoding: (a: number) => number;
+export const __wbg_get_config_diagnostic_reference: (a: number) => number;
+export const __wbg_get_config_diagnostic_warning: (a: number) => number;
+export const __wbg_get_config_input_mode: (a: number) => number;
 export const __wbg_get_config_track_references: (a: number) => number;
-export const __wbg_set_config_track_references: (a: number, b: number) => void;
 export const __wbg_get_config_trivia: (a: number) => number;
-export const __wbg_set_config_trivia: (a: number, b: number) => void;
-export const __wbg_get_config_input_mode: (a: number) => number;
-export const __wbg_set_config_input_mode: (a: number, b: number) => void;
-export const __wbg_get_config_diagnostic_position_encoding: (a: number) => number;
-export const __wbg_set_config_diagnostic_position_encoding: (a: number, b: number) => void;
-export const __wbg_get_config_diagnostic_error: (a: number) => number;
 export const __wbg_set_config_diagnostic_error: (a: number, b: number) => void;
-export const __wbg_get_config_diagnostic_warning: (a: number) => number;
-export const __wbg_set_config_diagnostic_warning: (a: number, b: number) => void;
-export const __wbg_get_config_diagnostic_info: (a: number) => number;
-export const __wbg_set_config_diagnostic_info: (a: number, b: number) => void;
-export const __wbg_get_config_diagnostic_hint: (a: number) => number;
 export const __wbg_set_config_diagnostic_hint: (a: number, b: number) => void;
-export const __wbg_get_config_diagnostic_reference: (a: number) => number;
-export const __wbg_set_config_diagnostic_reference: (a: number, b: number) => void;
-export const __wbg_get_config_diagnostic_other: (a: number) => number;
+export const __wbg_set_config_diagnostic_info: (a: number, b: number) => void;
 export const __wbg_set_config_diagnostic_other: (a: number, b: number) => void;
+export const __wbg_set_config_diagnostic_position_encoding: (a: number, b: number) => void;
+export const __wbg_set_config_diagnostic_reference: (a: number, b: number) => void;
+export const __wbg_set_config_diagnostic_warning: (a: number, b: number) => void;
+export const __wbg_set_config_input_mode: (a: number, b: number) => void;
+export const __wbg_set_config_track_references: (a: number, b: number) => void;
+export const __wbg_set_config_trivia: (a: number, b: number) => void;
 export const config_new: () => number;
-export const __wbindgen_export_0: (a: number, b: number, c: number) => void;
-export const __wbindgen_export_1: (a: number, b: number) => number;
-export const __wbindgen_export_2: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_export: (a: number, b: number, c: number) => void;
+export const __wbindgen_export2: (a: number, b: number) => number;
+export const __wbindgen_export3: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_add_to_stack_pointer: (a: number) => number;
 export const __wbindgen_start: () => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mirascript/wasm",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "description": "MiraScript compiler for WebAssembly",
   "main": "dist/index.js",
@@ -16,7 +16,7 @@
     }
   },
   "devDependencies": {
-    "@types/node": "^24.9.1",
+    "@types/node": "^24.10.0",
     "nodemon": "^3.1.10"
   },
   "scripts": {