@mirascript/wasm 0.1.0

package/lib/wasm.js

@@ -0,0 +1,1463 @@
+let wasm;
+
+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 heap = new Array(128).fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function getObject(idx) { return heap[idx]; }
+
+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;
+}
+
+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 dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedUint32ArrayMemory0 = null;
+
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    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}`);
+    }
+}
+/**
+ * @param {Uint8Array} script
+ * @param {Config} config
+ * @returns {CompileResult}
+ */
+export function compile_buffer(script, config) {
+    const ptr0 = passArray8ToWasm0(script, wasm.__wbindgen_export_1);
+    const len0 = WASM_VECTOR_LEN;
+    _assertClass(config, Config);
+    const ret = wasm.compile_buffer(ptr0, len0, config.__wbg_ptr);
+    return CompileResult.__wrap(ret);
+}
+
+/**
+ * @param {string} script
+ * @param {Config} config
+ * @returns {CompileResult}
+ */
+export function compile(script, config) {
+    const ptr0 = passStringToWasm0(script, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+    const len0 = WASM_VECTOR_LEN;
+    _assertClass(config, Config);
+    const ret = wasm.compile(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();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(takeObject(mem.getUint32(i, true)));
+    }
+    return result;
+}
+/**
+ * @returns {string[]}
+ */
+export function keywords() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        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);
+        return v1;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * @returns {string[]}
+ */
+export function control_keywords() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        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);
+        return v1;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * @returns {string[]}
+ */
+export function numeric_keywords() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.numeric_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);
+        return v1;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * @returns {string[]}
+ */
+export function constant_keywords() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.constant_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);
+        return v1;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * @returns {string[]}
+ */
+export function reserved_keywords() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        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);
+        return v1;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+export function main() {
+    wasm.main();
+}
+
+/**
+ * @enum {1000 | 1001 | 1002 | 1003 | 1004 | 1005 | 1006 | 1007 | 1008 | 1009 | 1010 | 1011 | 1012 | 1013 | 1014 | 1015 | 1016 | 1017 | 1018 | 1019 | 1020 | 1021 | 1022 | 1023 | 1024 | 1025 | 1026 | 1027 | 1028 | 1029 | 1030 | 1031 | 1032 | 1033 | 1034 | 1035 | 1036 | 1037 | 1038 | 1039 | 1040 | 1041 | 1042 | 1043 | 1044 | 1045 | 1046 | 1047 | 1048 | 1049 | 1050 | 1051 | 1052 | 1053 | 1054 | 1055 | 1056 | 1057 | 1058 | 1059 | 1060 | 1061 | 1062 | 1063 | 1064 | 1065 | 1066 | 1067 | 1068 | 1999 | 2000 | 2001 | 2002 | 2003 | 2004 | 2999 | 3000 | 3999 | 4000 | 4001 | 4002 | 4999 | 5000 | 5001 | 5002 | 5003 | 5004 | 5005 | 5006 | 5999 | 10000 | 10001 | 10002 | 10003 | 10004 | 10005 | 10006 | 10007 | 10008 | 10009 | 10010 | 10011 | 10012 | 10013 | 10014 | 10015 | 10016 | 10017 | 10018 | 10019 | 10020 | 10021 | 10022 | 10023 | 10024 | 10025 | 10026 | 10027 | 10028 | 10029 | 10030 | 10031 | 10032 | 10033 | 10034 | 10035 | 10036 | 10037 | 10038 | 10039 | 10040 | 10041 | 10042 | 10999 | 11000 | 11001 | 11002 | 11003 | 11004 | 11005 | 11006 | 11007 | 11008 | 11009 | 11010 | 11011 | 11012 | 11013 | 11014 | 11015 | 11016 | 11017 | 11018 | 11019 | 11020 | 11021 | 11022 | 11023 | 11999}
+ */
+export const DiagnosticCode = Object.freeze({
+    ErrorStart: 1000, "1000": "ErrorStart",
+    InternalError: 1001, "1001": "InternalError",
+    LexerError: 1002, "1002": "LexerError",
+    ParserError: 1003, "1003": "ParserError",
+    EmitterError: 1004, "1004": "EmitterError",
+    OptimizerError: 1005, "1005": "OptimizerError",
+    Unimplemented: 1006, "1006": "Unimplemented",
+    UnknownToken: 1007, "1007": "UnknownToken",
+    UnexpectedToken: 1008, "1008": "UnexpectedToken",
+    InvalidReservedKeyword: 1009, "1009": "InvalidReservedKeyword",
+    InvalidKeyword: 1010, "1010": "InvalidKeyword",
+    InvalidNumberLiteralUnderscore: 1011, "1011": "InvalidNumberLiteralUnderscore",
+    InvalidNumberLiteral: 1012, "1012": "InvalidNumberLiteral",
+    OverflowNumberLiteral: 1013, "1013": "OverflowNumberLiteral",
+    OverflowIntegerLiteral: 1014, "1014": "OverflowIntegerLiteral",
+    InvalidOrdinalLiteral: 1015, "1015": "InvalidOrdinalLiteral",
+    UnterminatedString: 1016, "1016": "UnterminatedString",
+    InvalidEscapeSequence: 1017, "1017": "InvalidEscapeSequence",
+    InvalidHexEscapeSequence: 1018, "1018": "InvalidHexEscapeSequence",
+    InvalidUnicodeEscapeSequence: 1019, "1019": "InvalidUnicodeEscapeSequence",
+    BadArraySpread: 1020, "1020": "BadArraySpread",
+    UnterminatedInterpolation: 1021, "1021": "UnterminatedInterpolation",
+    BadInterpolation: 1022, "1022": "BadInterpolation",
+    UnexpectedUnderscore: 1023, "1023": "UnexpectedUnderscore",
+    UnexpectedGlobal: 1024, "1024": "UnexpectedGlobal",
+    MissingComma: 1025, "1025": "MissingComma",
+    MissingCloseBracket: 1026, "1026": "MissingCloseBracket",
+    MissingOpenBrace: 1027, "1027": "MissingOpenBrace",
+    MissingCloseBrace: 1028, "1028": "MissingCloseBrace",
+    MissingCloseParen: 1029, "1029": "MissingCloseParen",
+    MissingSemicolon: 1030, "1030": "MissingSemicolon",
+    MissingBindOperator: 1031, "1031": "MissingBindOperator",
+    InvalidConstName: 1032, "1032": "InvalidConstName",
+    MissingFunctionName: 1033, "1033": "MissingFunctionName",
+    MissingOpenParenAfterExtension: 1034, "1034": "MissingOpenParenAfterExtension",
+    MissingOpenParenAfterType: 1035, "1035": "MissingOpenParenAfterType",
+    InvalidTypeCall: 1036, "1036": "InvalidTypeCall",
+    RecordLiteralInExtensionCaller: 1037, "1037": "RecordLiteralInExtensionCaller",
+    MissingCase: 1038, "1038": "MissingCase",
+    UnknownExpression: 1039, "1039": "UnknownExpression",
+    UnmatchedCloseBrace: 1040, "1040": "UnmatchedCloseBrace",
+    UnmatchedCloseBracket: 1041, "1041": "UnmatchedCloseBracket",
+    UnmatchedCloseParen: 1042, "1042": "UnmatchedCloseParen",
+    UnknownPattern: 1043, "1043": "UnknownPattern",
+    UnknownStatement: 1044, "1044": "UnknownStatement",
+    ExpressionExpected: 1045, "1045": "ExpressionExpected",
+    PatternExpected: 1046, "1046": "PatternExpected",
+    ExclamationInLiteralPattern: 1047, "1047": "ExclamationInLiteralPattern",
+    UnexpectedOperatorInLiteralPattern: 1048, "1048": "UnexpectedOperatorInLiteralPattern",
+    MutInRebindPattern: 1049, "1049": "MutInRebindPattern",
+    ConstantInBindPattern: 1050, "1050": "ConstantInBindPattern",
+    MutInDiscardPattern: 1051, "1051": "MutInDiscardPattern",
+    DiscardInSpreadPattern: 1052, "1052": "DiscardInSpreadPattern",
+    SpreadDiscardInRecordPattern: 1053, "1053": "SpreadDiscardInRecordPattern",
+    MispositionedSpreadInRecordPattern: 1054, "1054": "MispositionedSpreadInRecordPattern",
+    InterpolatedNameRecordPattern: 1055, "1055": "InterpolatedNameRecordPattern",
+    BadOmitKeyRecordPattern: 1056, "1056": "BadOmitKeyRecordPattern",
+    AmbiguousRangePattern: 1057, "1057": "AmbiguousRangePattern",
+    DuplicateSpreadPattern: 1058, "1058": "DuplicateSpreadPattern",
+    MispositionedRestParameter: 1059, "1059": "MispositionedRestParameter",
+    UndefinedVariableAssignment: 1060, "1060": "UndefinedVariableAssignment",
+    ImmutableVariableAssignment: 1061, "1061": "ImmutableVariableAssignment",
+    UninitializedVariable: 1062, "1062": "UninitializedVariable",
+    DuplicateVariableDeclaration: 1063, "1063": "DuplicateVariableDeclaration",
+    UnexpectedBreak: 1064, "1064": "UnexpectedBreak",
+    UnexpectedContinue: 1065, "1065": "UnexpectedContinue",
+    MisuseOfGlobalKeyword: 1066, "1066": "MisuseOfGlobalKeyword",
+    BadOmitKeyRecordExpression: 1067, "1067": "BadOmitKeyRecordExpression",
+    UnassignableExpression: 1068, "1068": "UnassignableExpression",
+    ErrorEnd: 1999, "1999": "ErrorEnd",
+    WarningStart: 2000, "2000": "WarningStart",
+    UnnecessaryParentheses: 2001, "2001": "UnnecessaryParentheses",
+    MisleadingNilVariable: 2002, "2002": "MisleadingNilVariable",
+    UnnecessaryIrrefutablePattern: 2003, "2003": "UnnecessaryIrrefutablePattern",
+    MisleadingOrInIrrefutablePattern: 2004, "2004": "MisleadingOrInIrrefutablePattern",
+    WarningEnd: 2999, "2999": "WarningEnd",
+    InfoStart: 3000, "3000": "InfoStart",
+    InfoEnd: 3999, "3999": "InfoEnd",
+    HintStart: 4000, "4000": "HintStart",
+    UnusedLocalVariable: 4001, "4001": "UnusedLocalVariable",
+    UnusedLocalFunction: 4002, "4002": "UnusedLocalFunction",
+    HintEnd: 4999, "4999": "HintEnd",
+    ReferenceStart: 5000, "5000": "ReferenceStart",
+    VariableDeclaredHere: 5001, "5001": "VariableDeclaredHere",
+    FunctionDeclaredHere: 5002, "5002": "FunctionDeclaredHere",
+    ParameterDeclaredHere: 5003, "5003": "ParameterDeclaredHere",
+    ParameterItDeclaredHere: 5004, "5004": "ParameterItDeclaredHere",
+    ParameterRestDeclaredHere: 5005, "5005": "ParameterRestDeclaredHere",
+    ParameterSubPatternDeclaredHere: 5006, "5006": "ParameterSubPatternDeclaredHere",
+    ReferenceEnd: 5999, "5999": "ReferenceEnd",
+    TagStart: 10000, "10000": "TagStart",
+    LocalConst: 10001, "10001": "LocalConst",
+    LocalImmutable: 10002, "10002": "LocalImmutable",
+    LocalMutable: 10003, "10003": "LocalMutable",
+    LocalFunction: 10004, "10004": "LocalFunction",
+    ParameterIt: 10005, "10005": "ParameterIt",
+    ParameterImmutable: 10006, "10006": "ParameterImmutable",
+    ParameterMutable: 10007, "10007": "ParameterMutable",
+    ParameterImmutableRest: 10008, "10008": "ParameterImmutableRest",
+    ParameterMutableRest: 10009, "10009": "ParameterMutableRest",
+    ParameterPattern: 10010, "10010": "ParameterPattern",
+    ParameterRestPattern: 10011, "10011": "ParameterRestPattern",
+    ParameterSubPatternImmutable: 10012, "10012": "ParameterSubPatternImmutable",
+    ParameterSubPatternMutable: 10013, "10013": "ParameterSubPatternMutable",
+    GlobalVariable: 10014, "10014": "GlobalVariable",
+    GlobalDynamicAccess: 10015, "10015": "GlobalDynamicAccess",
+    RecordFieldIdName: 10016, "10016": "RecordFieldIdName",
+    RecordFieldOrdinalName: 10017, "10017": "RecordFieldOrdinalName",
+    RecordFieldStringName: 10018, "10018": "RecordFieldStringName",
+    UnnamedRecordField0: 10019, "10019": "UnnamedRecordField0",
+    UnnamedRecordField1: 10020, "10020": "UnnamedRecordField1",
+    UnnamedRecordField2: 10021, "10021": "UnnamedRecordField2",
+    UnnamedRecordField3: 10022, "10022": "UnnamedRecordField3",
+    UnnamedRecordField4: 10023, "10023": "UnnamedRecordField4",
+    UnnamedRecordField5: 10024, "10024": "UnnamedRecordField5",
+    UnnamedRecordField6: 10025, "10025": "UnnamedRecordField6",
+    UnnamedRecordField7: 10026, "10026": "UnnamedRecordField7",
+    UnnamedRecordField8: 10027, "10027": "UnnamedRecordField8",
+    UnnamedRecordField9: 10028, "10028": "UnnamedRecordField9",
+    UnnamedRecordFieldN: 10029, "10029": "UnnamedRecordFieldN",
+    OmitNamedRecordField: 10030, "10030": "OmitNamedRecordField",
+    FunctionCall: 10031, "10031": "FunctionCall",
+    ExtensionCall: 10032, "10032": "ExtensionCall",
+    Scope: 10033, "10033": "Scope",
+    String: 10034, "10034": "String",
+    Interpolation: 10035, "10035": "Interpolation",
+    ForExpression: 10036, "10036": "ForExpression",
+    WhileExpression: 10037, "10037": "WhileExpression",
+    LoopExpression: 10038, "10038": "LoopExpression",
+    FnDeclaration: 10039, "10039": "FnDeclaration",
+    FnExpression: 10040, "10040": "FnExpression",
+    IfExpression: 10041, "10041": "IfExpression",
+    MatchExpression: 10042, "10042": "MatchExpression",
+    TagEnd: 10999, "10999": "TagEnd",
+    TagRefStart: 11000, "11000": "TagRefStart",
+    ReadLocal: 11001, "11001": "ReadLocal",
+    ReadWriteLocal: 11002, "11002": "ReadWriteLocal",
+    WriteLocal: 11003, "11003": "WriteLocal",
+    RedeclareLocal: 11004, "11004": "RedeclareLocal",
+    Callable: 11005, "11005": "Callable",
+    ArgumentExtension: 11006, "11006": "ArgumentExtension",
+    ArgumentStart: 11007, "11007": "ArgumentStart",
+    ArgumentEnd: 11008, "11008": "ArgumentEnd",
+    ArgumentComma: 11009, "11009": "ArgumentComma",
+    ArgumentSpread: 11010, "11010": "ArgumentSpread",
+    KeywordFor: 11011, "11011": "KeywordFor",
+    KeywordIn: 11012, "11012": "KeywordIn",
+    KeywordWhile: 11013, "11013": "KeywordWhile",
+    KeywordLoop: 11014, "11014": "KeywordLoop",
+    KeywordBreak: 11015, "11015": "KeywordBreak",
+    KeywordContinue: 11016, "11016": "KeywordContinue",
+    KeywordIf: 11017, "11017": "KeywordIf",
+    KeywordElse: 11018, "11018": "KeywordElse",
+    KeywordMatch: 11019, "11019": "KeywordMatch",
+    KeywordCase: 11020, "11020": "KeywordCase",
+    KeywordFn: 11021, "11021": "KeywordFn",
+    KeywordReturn: 11022, "11022": "KeywordReturn",
+    /**
+     * Work with [DiagnosticCode::OmitNamedRecordField]
+     */
+    OmitNamedRecordFieldName: 11023, "11023": "OmitNamedRecordFieldName",
+    TagRefEnd: 11999, "11999": "TagRefEnd",
+});
+/**
+ * Encoding for counting positions in diagnostics.
+ * @enum {0 | 1 | 2 | 3}
+ */
+export const DiagnosticPositionEncoding = Object.freeze({
+    /**
+     * Use the default encoding (UTF-8) and
+     * 0-based indexing from the start of the file.
+     * Do not convert positions to line-column format.
+     */
+    None: 0, "0": "None",
+    /**
+     * Convert positions to 1-based UTF-8 line-column format.
+     */
+    Utf8: 1, "1": "Utf8",
+    /**
+     * Convert positions to 1-based UTF-16 line-column format.
+     */
+    Utf16: 2, "2": "Utf16",
+    /**
+     * Convert positions to 1-based UTF-32 line-column format.
+     */
+    Utf32: 3, "3": "Utf32",
+});
+/**
+ * Mode for reading input.
+ * @enum {0 | 1}
+ */
+export const InputMode = Object.freeze({
+    Script: 0, "0": "Script",
+    Template: 1, "1": "Template",
+});
+/**
+ * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98}
+ */
+export const OpCode = Object.freeze({
+    /**
+     * No operation
+     */
+    Noop: 0, "0": "Noop",
+    /**
+     * ADD %ret %1 %2\
+     * %ret = %1 + %2
+     */
+    Add: 1, "1": "Add",
+    /**
+     * SUB %ret %1 %2\
+     * %ret = %1 - %2
+     */
+    Sub: 2, "2": "Sub",
+    /**
+     * MUL %ret %1 %2\
+     * %ret = %1 * %2
+     */
+    Mul: 3, "3": "Mul",
+    /**
+     * DIV %ret %1 %2\
+     * %ret = %1 / %2
+     */
+    Div: 4, "4": "Div",
+    /**
+     * MOD %ret %1 %2\
+     * %ret = %1 % %2
+     */
+    Mod: 5, "5": "Mod",
+    /**
+     * EXP %ret %1 %2\
+     * %ret = %1 ^ %2
+     */
+    Pow: 6, "6": "Pow",
+    /**
+     * POS %ret %1\
+     * %ret = +%1
+     */
+    Pos: 7, "7": "Pos",
+    /**
+     * NEG %ret %1\
+     * %ret = -%1
+     */
+    Neg: 8, "8": "Neg",
+    /**
+     * NOT %ret %1\
+     * %ret = !%1
+     */
+    Not: 9, "9": "Not",
+    /**
+     * PLUS %ret %1\
+     * %ret = +%1
+     */
+    Plus: 10, "10": "Plus",
+    /**
+     * EQ %ret %1 %2\
+     * %ret = %1 == %2
+     */
+    Eq: 11, "11": "Eq",
+    /**
+     * NEQ %ret %1 %2\
+     * %ret = %1 != %2
+     */
+    Neq: 12, "12": "Neq",
+    /**
+     * LT %ret %1 %2\
+     * %ret = %1 < %2
+     */
+    Lt: 13, "13": "Lt",
+    /**
+     * LTE %ret %1 %2\
+     * %ret = %1 <= %2
+     */
+    Lte: 14, "14": "Lte",
+    /**
+     * GT %ret %1 %2\
+     * %ret = %1 > %2
+     */
+    Gt: 15, "15": "Gt",
+    /**
+     * GTE %ret %1 %2\
+     * %ret = %1 >= %2
+     */
+    Gte: 16, "16": "Gte",
+    /**
+     * AEQ %ret %1 %2\
+     * %ret = %1 =~ %2
+     */
+    Aeq: 17, "17": "Aeq",
+    /**
+     * NAEQ %ret %1 %2\
+     * %ret = %1 !~ %2
+     */
+    Naeq: 18, "18": "Naeq",
+    /**
+     * SAME %ret %1 %2\
+     * %ret = %1 === %2 // Same value zero
+     */
+    Same: 19, "19": "Same",
+    /**
+     * Nsame %ret %1 %2\
+     * %ret = %1 !== %2
+     */
+    Nsame: 20, "20": "Nsame",
+    /**
+     * IN %ret %1 %2\
+     * %ret = %1 in %2
+     */
+    In: 21, "21": "In",
+    /**
+     * IN_GLOBAL %ret %1 %2\
+     * %ret = %1 in global
+     */
+    InGlobal: 22, "22": "InGlobal",
+    /**
+     * CONCAT %ret `n` %1 %2 ... %n\
+     * %ret = %1 .. %2 .. ... .. %n
+     */
+    Concat: 23, "23": "Concat",
+    /**
+     * FORMAT %ret %1 %2\
+     * %ret = format(%1, %2)
+     */
+    Format: 24, "24": "Format",
+    /**
+     * AND %ret %1 %2\
+     * %ret = %1 && %2
+     */
+    And: 25, "25": "And",
+    /**
+     * OR %ret %1 %2\
+     * %ret = %1 || %2
+     */
+    Or: 26, "26": "Or",
+    /**
+     * ASSERT_INIT %v\
+     * assert(%v != uninitialized)
+     */
+    AssertInit: 27, "27": "AssertInit",
+    /**
+     * ASSERT_NON_NIL %v\
+     * assert(%v != nil)
+     */
+    AssertNonNil: 28, "28": "AssertNonNil",
+    /**
+     * TYPE %ret %1\
+     * %ret = type(%1)
+     */
+    Type: 29, "29": "Type",
+    /**
+     * TO_BOOLEAN %ret %1\
+     * %ret = boolean(%1)
+     */
+    ToBoolean: 30, "30": "ToBoolean",
+    /**
+     * TO_NUMBER %ret %1\
+     * %ret = number(%1)
+     */
+    ToNumber: 31, "31": "ToNumber",
+    /**
+     * TO_STRING %ret %1\
+     * %ret = string(%1)
+     */
+    ToString: 32, "32": "ToString",
+    /**
+     * IS_BOOLEAN %ret %1\
+     * %ret = type(%1) == "boolean"
+     */
+    IsBoolean: 33, "33": "IsBoolean",
+    /**
+     * IS_NUMBER %ret %1\
+     * %ret = type(%1) == "number"
+     */
+    IsNumber: 34, "34": "IsNumber",
+    /**
+     * IS_STRING %ret %1\
+     * %ret = type(%1) == "string"
+     */
+    IsString: 35, "35": "IsString",
+    /**
+     * IS_RECORD %ret %1\
+     * %ret = type(%1) == "record"
+     */
+    IsRecord: 36, "36": "IsRecord",
+    /**
+     * IS_ARRAY %ret %1\
+     * %ret = type(%1) == "array"
+     */
+    IsArray: 37, "37": "IsArray",
+    /**
+     * CONSTANT %reg `index`\
+     * %reg = CONSTANTS\[index]
+     */
+    Constant: 38, "38": "Constant",
+    /**
+     * UNINIT %reg
+     * %reg = uninitialized
+     */
+    Uninit: 39, "39": "Uninit",
+    /**
+     * ASSIGN %ret %1\
+     * %ret = %1
+     */
+    Assign: 40, "40": "Assign",
+    /**
+     * SWAP %1 %2\
+     * (%1, %2) = (%2, %1)
+     */
+    Swap: 41, "41": "Swap",
+    /**
+     * GET_UPVALUE %ret `level` %%up\
+     * %ret = UPVALUES\[level]\[%%up]
+     */
+    GetUpvalue: 42, "42": "GetUpvalue",
+    /**
+     * SET_UPVALUE %value `level` %%up \
+     * UPVALUES\[level]\[%%up] = %value
+     */
+    SetUpvalue: 43, "43": "SetUpvalue",
+    /**
+     * GET_GLOBAL %ret `name` \
+     * %ret = GLOBALS\[CONSTANTS\[name]]
+     */
+    GetGlobal: 44, "44": "GetGlobal",
+    /**
+     * GET_GLOBAL_DYN %ret %name \
+     * %ret = GLOBALS\[%name]
+     */
+    GetGlobalDyn: 45, "45": "GetGlobalDyn",
+    /**
+     * RECORD %ret\
+     * %ret = (
+     */
+    Record: 46, "46": "Record",
+    /**
+     * FIELD `name` %field\
+     * \[CONSTANTS\[name]]: %field,
+     */
+    Field: 47, "47": "Field",
+    /**
+     * FIELD_DYN %name %field\
+     * \[%name]: %field,
+     */
+    FieldDyn: 48, "48": "FieldDyn",
+    /**
+     * FIELD_INDEX `index` %field\
+     * \[index]: %field,
+     */
+    FieldIndex: 49, "49": "FieldIndex",
+    /**
+     * FIELD_OPT `name` %field\
+     * \[CONSTANTS\[name]]?: %field,
+     */
+    FieldOpt: 50, "50": "FieldOpt",
+    /**
+     * FIELD_OPT_DYN %name %field\
+     * \[%name]?: %field,
+     */
+    FieldOptDyn: 51, "51": "FieldOptDyn",
+    /**
+     * FIELD_OPT_INDEX `index` %field\
+     * \[index]?: %field,
+     */
+    FieldOptIndex: 52, "52": "FieldOptIndex",
+    /**
+     * PICK %ret %var `n` `key_1` `key_2` ... `key_n`\
+     * %ret = %var pick keys CONSTANTS\[key_1], CONSTANTS\[key_2], ..., CONSTANTS\[key_n]
+     */
+    Pick: 53, "53": "Pick",
+    /**
+     * OMIT %ret %var `n` `key_1` `key_2` ... `key_n`\
+     * %ret = %var omit keys CONSTANTS\[key_1], CONSTANTS\[key_2], ..., CONSTANTS\[key_n]
+     */
+    Omit: 54, "54": "Omit",
+    /**
+     * ARRAY %ret\
+     * %ret = \[
+     */
+    Array: 55, "55": "Array",
+    /**
+     * ITEM %item\
+     * %item,
+     */
+    Item: 56, "56": "Item",
+    /**
+     * ITEM_RANGE `start` `end`\
+     * `start`..`end`,
+     */
+    ItemRange: 57, "57": "ItemRange",
+    /**
+     * ITEM_RANGE_DYN %start %end\
+     * %start..%end,
+     */
+    ItemRangeDyn: 58, "58": "ItemRangeDyn",
+    /**
+     * ITEM_RANGE_EXCLUSIVE_DYN %start %end\
+     * %start..<%end,
+     */
+    ItemRangeExclusiveDyn: 59, "59": "ItemRangeExclusiveDyn",
+    /**
+     * SPREAD %var\
+     * ..%var,
+     */
+    Spread: 60, "60": "Spread",
+    /**
+     * FREEZE\
+     * ) for record or ] for array
+     */
+    Freeze: 61, "61": "Freeze",
+    /**
+     * HAS %ret %var `key`\
+     * %ret = initialized(%var\[CONSTANTS\[key]])
+     */
+    Has: 62, "62": "Has",
+    /**
+     * HAS_DYN %ret %var %key\
+     * %ret = initialized(%var\[%key])
+     */
+    HasDyn: 63, "63": "HasDyn",
+    /**
+     * HAS_INDEX %ret %var `index`\
+     * %ret = initialized(%var\[index])
+     */
+    HasIndex: 64, "64": "HasIndex",
+    /**
+     * GET %ret %var `key`\
+     * %ret = %var\[CONSTANTS\[key]] ?? nil
+     */
+    Get: 65, "65": "Get",
+    /**
+     * GET_DYN %ret %var %key\
+     * %ret = %var\[%key] ?? nil
+     */
+    GetDyn: 66, "66": "GetDyn",
+    /**
+     * GET_INDEX %ret %var `index`\
+     * %ret = %var\[index] ?? nil
+     */
+    GetIndex: 67, "67": "GetIndex",
+    /**
+     * SET %value %var `key`\
+     * %var\[CONSTANTS\[key]] = %value
+     */
+    Set: 68, "68": "Set",
+    /**
+     * SET_DYN %value %var %key\
+     * %var\[%key] = %value
+     */
+    SetDyn: 69, "69": "SetDyn",
+    /**
+     * SET_INDEX %value %var `index`\
+     * %var\[index] = %value
+     */
+    SetIndex: 70, "70": "SetIndex",
+    /**
+     * SLICE %ret %var `start` `end`\
+     * %ret = %var\[start..end]
+     */
+    Slice: 71, "71": "Slice",
+    /**
+     * SLICE_START %ret %var `end`\
+     * %ret = %var\[..end]
+     */
+    SliceStart: 72, "72": "SliceStart",
+    /**
+     * SLICE_END %ret %var `start`\
+     * %ret = %var\[start..]
+     */
+    SliceEnd: 73, "73": "SliceEnd",
+    /**
+     * SLICE_DYN %ret %var %start %end\
+     * %ret = %var\[%start..%end]
+     */
+    SliceDyn: 74, "74": "SliceDyn",
+    /**
+     * SLICE_EXCLUSIVE_DYN %ret %var %start %end\
+     * %ret = %var\[%start..<%end]
+     */
+    SliceExclusiveDyn: 75, "75": "SliceExclusiveDyn",
+    /**
+     * LENGTH %ret %var\
+     * %ret = $Length(%var)
+     */
+    Length: 76, "76": "Length",
+    /**
+     * LOOP `regn`\
+     * loop { let %1, .. ,%regn;
+     */
+    Loop: 77, "77": "Loop",
+    /**
+     * LOOP_FOR `regn` %iterable\
+     * for %1 in %iterable { let %2, .. ,%regn;
+     */
+    LoopFor: 78, "78": "LoopFor",
+    /**
+     * LOOP_RANGE `regn` %start %end\
+     * for %1 in %start..%end { let %2, .. ,%regn;
+     */
+    LoopRange: 79, "79": "LoopRange",
+    /**
+     * LOOP_RANGE_EXCLUSIVE `regn` %start %end\
+     * for %1 in %start..<%end { let %2, .. ,%regn;
+     */
+    LoopRangeExclusive: 80, "80": "LoopRangeExclusive",
+    /**
+     * LOOP_END\
+     * }
+     */
+    LoopEnd: 81, "81": "LoopEnd",
+    /**
+     * BREAK\
+     * break;
+     */
+    Break: 82, "82": "Break",
+    /**
+     * CONTINUE\
+     * continue;
+     */
+    Continue: 83, "83": "Continue",
+    /**
+     * IF %cond\
+     * if (%cond) {
+     */
+    If: 84, "84": "If",
+    /**
+     * IF_NOT %cond\
+     * if (!%cond) {
+     */
+    IfNot: 85, "85": "IfNot",
+    /**
+     * IF_INIT %var\
+     * if (initialized(%var)) {
+     */
+    IfInit: 86, "86": "IfInit",
+    /**
+     * IF_NOT_INIT %var\
+     * if (!initialized(%var)) {
+     */
+    IfNotInit: 87, "87": "IfNotInit",
+    /**
+     * IF_NIL %var\
+     * if (%var == nil) {
+     */
+    IfNil: 88, "88": "IfNil",
+    /**
+     * IF_NOT_NIL %var\
+     * if (%var != nil) {
+     */
+    IfNotNil: 89, "89": "IfNotNil",
+    /**
+     * ELSE\
+     * } else {
+     */
+    Else: 90, "90": "Else",
+    /**
+     * EL_IF IF*\
+     * } else if *** {\
+     * This instruction must be followed by an `IF*` instruction\
+     */
+    ElIf: 91, "91": "ElIf",
+    /**
+     * IF_END\
+     * }
+     */
+    IfEnd: 92, "92": "IfEnd",
+    /**
+     * FUNC %f `argn` `regn`\
+     * %f = (%1, %2, ... , %argn) => { let %argn+1, ... , %regn;
+     */
+    Func: 93, "93": "Func",
+    /**
+     * FUNC_VARG %f `argn` `regn`\
+     * %f = (%1, %2, ... , %argn-1, ...%argn) => { let %argn+1, ... , %regn;
+     */
+    FuncVarg: 94, "94": "FuncVarg",
+    /**
+     * FUNC_END\
+     * }
+     */
+    FuncEnd: 95, "95": "FuncEnd",
+    /**
+     * RETURN %value\
+     * return %value;
+     */
+    Return: 96, "96": "Return",
+    /**
+     * CALL %ret `f` `argn` %1 %2 ... %argn `spread_n` `spread_arg_a` ...\
+     * %ret = GLOBAL[CONSTANTS[f]](%1, %2, ... , %argn);
+     *
+     * If spread_arg_a is present, arg at that index will be spread
+     */
+    Call: 97, "97": "Call",
+    /**
+     * CALL_DYN %ret %f `argn` %1 %2 ... %argn `spread_n` `spread_arg_a` ...\
+     * %ret = %f(%1, %2, ... , %argn);
+     *
+     * If spread_arg_a is present, arg at that index will be spread
+     */
+    CallDyn: 98, "98": "CallDyn",
+});
+
+const CompileResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_compileresult_free(ptr >>> 0, 1));
+
+export class CompileResult {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(CompileResult.prototype);
+        obj.__wbg_ptr = ptr;
+        CompileResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CompileResultFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_compileresult_free(ptr, 0);
+    }
+    /**
+     * @returns {Uint8Array | undefined}
+     */
+    chunk() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.compileresult_chunk(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);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    diagnostics() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.compileresult_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) CompileResult.prototype[Symbol.dispose] = CompileResult.prototype.free;
+
+const ConfigFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_config_free(ptr >>> 0, 1));
+
+export class Config {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ConfigFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_config_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get track_references() {
+        const ret = wasm.__wbg_get_config_track_references(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set track_references(arg0) {
+        wasm.__wbg_set_config_track_references(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get trivia() {
+        const ret = wasm.__wbg_get_config_trivia(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set trivia(arg0) {
+        wasm.__wbg_set_config_trivia(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {InputMode}
+     */
+    get input_mode() {
+        const ret = wasm.__wbg_get_config_input_mode(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {InputMode} arg0
+     */
+    set input_mode(arg0) {
+        wasm.__wbg_set_config_input_mode(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {DiagnosticPositionEncoding}
+     */
+    get diagnostic_position_encoding() {
+        const ret = wasm.__wbg_get_config_diagnostic_position_encoding(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {DiagnosticPositionEncoding} arg0
+     */
+    set diagnostic_position_encoding(arg0) {
+        wasm.__wbg_set_config_diagnostic_position_encoding(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get diagnostic_error() {
+        const ret = wasm.__wbg_get_config_diagnostic_error(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set diagnostic_error(arg0) {
+        wasm.__wbg_set_config_diagnostic_error(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get diagnostic_warning() {
+        const ret = wasm.__wbg_get_config_diagnostic_warning(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set diagnostic_warning(arg0) {
+        wasm.__wbg_set_config_diagnostic_warning(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get diagnostic_info() {
+        const ret = wasm.__wbg_get_config_diagnostic_info(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set diagnostic_info(arg0) {
+        wasm.__wbg_set_config_diagnostic_info(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get diagnostic_hint() {
+        const ret = wasm.__wbg_get_config_diagnostic_hint(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set diagnostic_hint(arg0) {
+        wasm.__wbg_set_config_diagnostic_hint(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get diagnostic_reference() {
+        const ret = wasm.__wbg_get_config_diagnostic_reference(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set diagnostic_reference(arg0) {
+        wasm.__wbg_set_config_diagnostic_reference(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get diagnostic_other() {
+        const ret = wasm.__wbg_get_config_diagnostic_other(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set diagnostic_other(arg0) {
+        wasm.__wbg_set_config_diagnostic_other(this.__wbg_ptr, arg0);
+    }
+    constructor() {
+        const ret = wasm.config_new();
+        this.__wbg_ptr = ret >>> 0;
+        ConfigFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) Config.prototype[Symbol.dispose] = Config.prototype.free;
+
+const MonacoCompilerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_monacocompiler_free(ptr >>> 0, 1));
+
+export class MonacoCompiler {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MonacoCompilerFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_monacocompiler_free(ptr, 0);
+    }
+    /**
+     * @param {string} input
+     * @param {Config} config
+     */
+    constructor(input, config) {
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(config, Config);
+        const ret = wasm.monacocompiler_new(ptr0, len0, config.__wbg_ptr);
+        this.__wbg_ptr = ret >>> 0;
+        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}
+     */
+    emit() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.monacocompiler_emit(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);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    format() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.monacocompiler_format(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 = getStringFromWasm0(r0, r1).slice();
+                wasm.__wbindgen_export_0(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;
+
+const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+
+            } catch (e) {
+                const validResponse = module.ok && EXPECTED_RESPONSE_TYPES.has(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else {
+                    throw e;
+                }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+
+        } else {
+            return instance;
+        }
+    }
+}
+
+function __wbg_get_imports() {
+    const imports = {};
+    imports.wbg = {};
+    imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
+        let deferred0_0;
+        let deferred0_1;
+        try {
+            deferred0_0 = arg0;
+            deferred0_1 = arg1;
+            console.error(getStringFromWasm0(arg0, arg1));
+        } finally {
+            wasm.__wbindgen_export_0(deferred0_0, deferred0_1, 1);
+        }
+    };
+    imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
+        const ret = new Error();
+        return addHeapObject(ret);
+    };
+    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 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);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
+        takeObject(arg0);
+    };
+
+    return imports;
+}
+
+function __wbg_init_memory(imports, memory) {
+
+}
+
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    __wbg_init.__wbindgen_wasm_module = module;
+    cachedDataViewMemory0 = null;
+    cachedUint32ArrayMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+
+
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (typeof module !== 'undefined') {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+
+    __wbg_init_memory(imports);
+
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+
+    const instance = new WebAssembly.Instance(module, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (typeof module_or_path !== 'undefined') {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (typeof module_or_path === 'undefined') {
+        module_or_path = new URL('wasm_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        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);
+}
+
+export { initSync };
+export default __wbg_init;