@arborium/arborium 1.2.3 → 1.2.4

package/dist/arborium_host.js

@@ -1,3084 +1,482 @@
-export function instantiate(getCoreModule, imports, instantiateCore = WebAssembly.instantiate) {
-  
-  let dv = new DataView(new ArrayBuffer());
-  const dataView = mem => dv.buffer === mem.buffer ? dv : dv = new DataView(mem.buffer);
-  
-  const toUint64 = val => BigInt.asUintN(64, BigInt(val));
-  
-  function toUint32(val) {
-    return val >>> 0;
-  }
-  
-  const utf8Decoder = new TextDecoder();
-  
-  const utf8Encoder = new TextEncoder();
-  let utf8EncodedLen = 0;
-  function utf8Encode(s, realloc, memory) {
-    if (typeof s !== 'string') throw new TypeError('expected a string');
-    if (s.length === 0) {
-      utf8EncodedLen = 0;
-      return 1;
-    }
-    let buf = utf8Encoder.encode(s);
-    let ptr = realloc(0, 0, 1, buf.length);
-    new Uint8Array(memory.buffer).set(buf, ptr);
-    utf8EncodedLen = buf.length;
-    return ptr;
-  }
-  
-  const T_FLAG = 1 << 30;
-  
-  function rscTableCreateOwn (table, rep) {
-    const free = table[0] & ~T_FLAG;
-    if (free === 0) {
-      table.push(0);
-      table.push(rep | T_FLAG);
-      return (table.length >> 1) - 1;
-    }
-    table[0] = table[free << 1];
-    table[free << 1] = 0;
-    table[(free << 1) + 1] = rep | T_FLAG;
-    return free;
-  }
-  
-  function rscTableRemove (table, handle) {
-    const scope = table[handle << 1];
-    const val = table[(handle << 1) + 1];
-    const own = (val & T_FLAG) !== 0;
-    const rep = val & ~T_FLAG;
-    if (val === 0 || (scope & T_FLAG) !== 0) throw new TypeError('Invalid handle');
-    table[handle << 1] = table[0] | T_FLAG;
-    table[0] = handle | T_FLAG;
-    return { rep, scope, own };
-  }
-  
-  let curResourceBorrows = [];
-  
-  let NEXT_TASK_ID = 0n;
-  function startCurrentTask(componentIdx, isAsync, entryFnName) {
-    _debugLog('[startCurrentTask()] args', { componentIdx, isAsync });
-    if (componentIdx === undefined || componentIdx === null) {
-      throw new Error('missing/invalid component instance index while starting task');
-    }
-    const tasks = ASYNC_TASKS_BY_COMPONENT_IDX.get(componentIdx);
-    
-    const nextId = ++NEXT_TASK_ID;
-    const newTask = new AsyncTask({ id: nextId, componentIdx, isAsync, entryFnName });
-    const newTaskMeta = { id: nextId, componentIdx, task: newTask };
-    
-    ASYNC_CURRENT_TASK_IDS.push(nextId);
-    ASYNC_CURRENT_COMPONENT_IDXS.push(componentIdx);
-    
-    if (!tasks) {
-      ASYNC_TASKS_BY_COMPONENT_IDX.set(componentIdx, [newTaskMeta]);
-      return nextId;
-    } else {
-      tasks.push(newTaskMeta);
-    }
-    
-    return nextId;
-  }
-  
-  function endCurrentTask(componentIdx, taskId) {
-    _debugLog('[endCurrentTask()] args', { componentIdx });
-    componentIdx ??= ASYNC_CURRENT_COMPONENT_IDXS.at(-1);
-    taskId ??= ASYNC_CURRENT_TASK_IDS.at(-1);
-    if (componentIdx === undefined || componentIdx === null) {
-      throw new Error('missing/invalid component instance index while ending current task');
-    }
-    const tasks = ASYNC_TASKS_BY_COMPONENT_IDX.get(componentIdx);
-    if (!tasks || !Array.isArray(tasks)) {
-      throw new Error('missing/invalid tasks for component instance while ending task');
-    }
-    if (tasks.length == 0) {
-      throw new Error('no current task(s) for component instance while ending task');
-    }
-    
-    if (taskId) {
-      const last = tasks[tasks.length - 1];
-      if (last.id !== taskId) {
-        throw new Error('current task does not match expected task ID');
-      }
-    }
-    
-    ASYNC_CURRENT_TASK_IDS.pop();
-    ASYNC_CURRENT_COMPONENT_IDXS.pop();
-    
-    return tasks.pop();
-  }
-  const ASYNC_TASKS_BY_COMPONENT_IDX = new Map();
-  const ASYNC_CURRENT_TASK_IDS = [];
-  const ASYNC_CURRENT_COMPONENT_IDXS = [];
-  
-  class AsyncTask {
-    static State = {
-      INITIAL: 'initial',
-      CANCELLED: 'cancelled',
-      CANCEL_PENDING: 'cancel-pending',
-      CANCEL_DELIVERED: 'cancel-delivered',
-      RESOLVED: 'resolved',
-    }
-    
-    static BlockResult = {
-      CANCELLED: 'block.cancelled',
-      NOT_CANCELLED: 'block.not-cancelled',
-    }
-    
-    #id;
-    #componentIdx;
-    #state;
-    #isAsync;
-    #onResolve = null;
-    #entryFnName = null;
-    #subtasks = [];
-    #completionPromise = null;
-    
-    cancelled = false;
-    requested = false;
-    alwaysTaskReturn = false;
-    
-    returnCalls =  0;
-    storage = [0, 0];
-    borrowedHandles = {};
-    
-    awaitableResume = null;
-    awaitableCancel = null;
-    
-    
-    constructor(opts) {
-      if (opts?.id === undefined) { throw new TypeError('missing task ID during task creation'); }
-      this.#id = opts.id;
-      if (opts?.componentIdx === undefined) {
-        throw new TypeError('missing component id during task creation');
-      }
-      this.#componentIdx = opts.componentIdx;
-      this.#state = AsyncTask.State.INITIAL;
-      this.#isAsync = opts?.isAsync ?? false;
-      this.#entryFnName = opts.entryFnName;
-      
-      const {
-        promise: completionPromise,
-        resolve: resolveCompletionPromise,
-        reject: rejectCompletionPromise,
-      } = Promise.withResolvers();
-      this.#completionPromise = completionPromise;
-      
-      this.#onResolve = (results) => {
-        // TODO: handle external facing cancellation (should likely be a rejection)
-        resolveCompletionPromise(results);
-      }
-    }
-    
-    taskState() { return this.#state.slice(); }
-    id() { return this.#id; }
-    componentIdx() { return this.#componentIdx; }
-    isAsync() { return this.#isAsync; }
-    entryFnName() { return this.#entryFnName; }
-    completionPromise() { return this.#completionPromise; }
-    
-    mayEnter(task) {
-      const cstate = getOrCreateAsyncState(this.#componentIdx);
-      if (!cstate.backpressure) {
-        _debugLog('[AsyncTask#mayEnter()] disallowed due to backpressure', { taskID: this.#id });
-        return false;
-      }
-      if (!cstate.callingSyncImport()) {
-        _debugLog('[AsyncTask#mayEnter()] disallowed due to sync import call', { taskID: this.#id });
-        return false;
-      }
-      const callingSyncExportWithSyncPending = cstate.callingSyncExport && !task.isAsync;
-      if (!callingSyncExportWithSyncPending) {
-        _debugLog('[AsyncTask#mayEnter()] disallowed due to sync export w/ sync pending', { taskID: this.#id });
-        return false;
-      }
-      return true;
-    }
-    
-    async enter() {
-      _debugLog('[AsyncTask#enter()] args', { taskID: this.#id });
-      
-      // TODO: assert scheduler locked
-      // TODO: trap if on the stack
-      
-      const cstate = getOrCreateAsyncState(this.#componentIdx);
-      
-      let mayNotEnter = !this.mayEnter(this);
-      const componentHasPendingTasks = cstate.pendingTasks > 0;
-      if (mayNotEnter || componentHasPendingTasks) {
-        throw new Error('in enter()'); // TODO: remove
-        cstate.pendingTasks.set(this.#id, new Awaitable(new Promise()));
-        
-        const blockResult = await this.onBlock(awaitable);
-        if (blockResult) {
-          // TODO: find this pending task in the component
-          const pendingTask = cstate.pendingTasks.get(this.#id);
-          if (!pendingTask) {
-            throw new Error('pending task [' + this.#id + '] not found for component instance');
-          }
-          cstate.pendingTasks.remove(this.#id);
-          this.#onResolve(new Error('failed enter'));
-          return false;
-        }
-        
-        mayNotEnter = !this.mayEnter(this);
-        if (!mayNotEnter || !cstate.startPendingTask) {
-          throw new Error('invalid component entrance/pending task resolution');
-        }
-        cstate.startPendingTask = false;
-      }
-      
-      if (!this.isAsync) { cstate.callingSyncExport = true; }
-      
-      return true;
-    }
-    
-    async waitForEvent(opts) {
-      const { waitableSetRep, isAsync } = opts;
-      _debugLog('[AsyncTask#waitForEvent()] args', { taskID: this.#id, waitableSetRep, isAsync });
-      
-      if (this.#isAsync !== isAsync) {
-        throw new Error('async waitForEvent called on non-async task');
-      }
-      
-      if (this.status === AsyncTask.State.CANCEL_PENDING) {
-        this.#state = AsyncTask.State.CANCEL_DELIVERED;
-        return {
-          code: ASYNC_EVENT_CODE.TASK_CANCELLED,
-        };
-      }
-      
-      const state = getOrCreateAsyncState(this.#componentIdx);
-      const waitableSet = state.waitableSets.get(waitableSetRep);
-      if (!waitableSet) { throw new Error('missing/invalid waitable set'); }
-      
-      waitableSet.numWaiting += 1;
-      let event = null;
-      
-      while (event == null) {
-        const awaitable = new Awaitable(waitableSet.getPendingEvent());
-        const waited = await this.blockOn({ awaitable, isAsync, isCancellable: true });
-        if (waited) {
-          if (this.#state !== AsyncTask.State.INITIAL) {
-            throw new Error('task should be in initial state found [' + this.#state + ']');
-          }
-          this.#state = AsyncTask.State.CANCELLED;
-          return {
-            code: ASYNC_EVENT_CODE.TASK_CANCELLED,
-          };
-        }
-        
-        event = waitableSet.poll();
-      }
-      
-      waitableSet.numWaiting -= 1;
-      return event;
+let wasm;
+
+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}`);
     }
-    
-    waitForEventSync(opts) {
-      throw new Error('AsyncTask#yieldSync() not implemented')
+}
+
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(state => state.dtor(state.a, state.b));
+
+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);
     }
-    
-    async pollForEvent(opts) {
-      const { waitableSetRep, isAsync } = opts;
-      _debugLog('[AsyncTask#pollForEvent()] args', { taskID: this.#id, waitableSetRep, isAsync });
-      
-      if (this.#isAsync !== isAsync) {
-        throw new Error('async pollForEvent called on non-async task');
-      }
-      
-      throw new Error('AsyncTask#pollForEvent() not implemented');
+    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);
     }
-    
-    pollForEventSync(opts) {
-      throw new Error('AsyncTask#yieldSync() not implemented')
+    return cachedUint8ArrayMemory0;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
     }
-    
-    async blockOn(opts) {
-      const { awaitable, isCancellable, forCallback } = opts;
-      _debugLog('[AsyncTask#blockOn()] args', { taskID: this.#id, awaitable, isCancellable, forCallback });
-      
-      if (awaitable.resolved() && !ASYNC_DETERMINISM && _coinFlip()) {
-        return AsyncTask.BlockResult.NOT_CANCELLED;
-      }
-      
-      const cstate = getOrCreateAsyncState(this.#componentIdx);
-      if (forCallback) { cstate.exclusiveRelease(); }
-      
-      let cancelled = await this.onBlock(awaitable);
-      if (cancelled === AsyncTask.BlockResult.CANCELLED && !isCancellable) {
-        const secondCancel = await this.onBlock(awaitable);
-        if (secondCancel !== AsyncTask.BlockResult.NOT_CANCELLED) {
-          throw new Error('uncancellable task was canceled despite second onBlock()');
-        }
-      }
-      
-      if (forCallback) {
-        const acquired = new Awaitable(cstate.exclusiveLock());
-        cancelled = await this.onBlock(acquired);
-        if (cancelled === AsyncTask.BlockResult.CANCELLED) {
-          const secondCancel = await this.onBlock(acquired);
-          if (secondCancel !== AsyncTask.BlockResult.NOT_CANCELLED) {
-            throw new Error('uncancellable callback task was canceled despite second onBlock()');
-          }
-        }
-      }
-      
-      if (cancelled === AsyncTask.BlockResult.CANCELLED) {
-        if (this.#state !== AsyncTask.State.INITIAL) {
-          throw new Error('cancelled task is not at initial state');
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function makeMutClosure(arg0, arg1, dtor, f) {
+    const state = { a: arg0, b: arg1, cnt: 1, dtor };
+    const real = (...args) => {
+
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            state.a = a;
+            real._wbg_cb_unref();
         }
-        if (isCancellable) {
-          this.#state = AsyncTask.State.CANCELLED;
-          return AsyncTask.BlockResult.CANCELLED;
-        } else {
-          this.#state = AsyncTask.State.CANCEL_PENDING;
-          return AsyncTask.BlockResult.NOT_CANCELLED;
+    };
+    real._wbg_cb_unref = () => {
+        if (--state.cnt === 0) {
+            state.dtor(state.a, state.b);
+            state.a = 0;
+            CLOSURE_DTORS.unregister(state);
         }
-      }
-      
-      return AsyncTask.BlockResult.NOT_CANCELLED;
-    }
-    
-    async onBlock(awaitable) {
-      _debugLog('[AsyncTask#onBlock()] args', { taskID: this.#id, awaitable });
-      if (!(awaitable instanceof Awaitable)) {
-        throw new Error('invalid awaitable during onBlock');
-      }
-      
-      // Build a promise that this task can await on which resolves when it is awoken
-      const { promise, resolve, reject } = Promise.withResolvers();
-      this.awaitableResume = () => {
-        _debugLog('[AsyncTask] resuming after onBlock', { taskID: this.#id });
-        resolve();
-      };
-      this.awaitableCancel = (err) => {
-        _debugLog('[AsyncTask] rejecting after onBlock', { taskID: this.#id, err });
-        reject(err);
-      };
-      
-      // Park this task/execution to be handled later
-      const state = getOrCreateAsyncState(this.#componentIdx);
-      state.parkTaskOnAwaitable({ awaitable, task: this });
-      
-      try {
-        await promise;
-        return AsyncTask.BlockResult.NOT_CANCELLED;
-      } catch (err) {
-        // rejection means task cancellation
-        return AsyncTask.BlockResult.CANCELLED;
-      }
+    };
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+
+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;
     }
-    
-    async asyncOnBlock(awaitable) {
-      _debugLog('[AsyncTask#asyncOnBlock()] args', { taskID: this.#id, awaitable });
-      if (!(awaitable instanceof Awaitable)) {
-        throw new Error('invalid awaitable during onBlock');
-      }
-      // TODO: watch for waitable AND cancellation
-      // TODO: if it WAS cancelled:
-      // - return true
-      // - only once per subtask
-      // - do not wait on the scheduler
-      // - control flow should go to the subtask (only once)
-      // - Once subtask blocks/resolves, reqlinquishControl() will tehn resolve request_cancel_end (without scheduler lock release)
-      // - control flow goes back to request_cancel
-      //
-      // Subtask cancellation should work similarly to an async import call -- runs sync up until
-      // the subtask blocks or resolves
-      //
-      throw new Error('AsyncTask#asyncOnBlock() not yet implemented');
+
+    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;
     }
-    
-    async yield(opts) {
-      const { isCancellable, forCallback } = opts;
-      _debugLog('[AsyncTask#yield()] args', { taskID: this.#id, isCancellable, forCallback });
-      
-      if (isCancellable && this.status === AsyncTask.State.CANCEL_PENDING) {
-        this.#state = AsyncTask.State.CANCELLED;
-        return {
-          code: ASYNC_EVENT_CODE.TASK_CANCELLED,
-          payload: [0, 0],
-        };
-      }
-      
-      // TODO: Awaitables need to *always* trigger the parking mechanism when they're done...?
-      // TODO: Component async state should remember which awaitables are done and work to clear tasks waiting
-      
-      const blockResult = await this.blockOn({
-        awaitable: new Awaitable(new Promise(resolve => setTimeout(resolve, 0))),
-        isCancellable,
-        forCallback,
-      });
-      
-      if (blockResult === AsyncTask.BlockResult.CANCELLED) {
-        if (this.#state !== AsyncTask.State.INITIAL) {
-          throw new Error('task should be in initial state found [' + this.#state + ']');
-        }
-        this.#state = AsyncTask.State.CANCELLED;
+
+    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 {
-          code: ASYNC_EVENT_CODE.TASK_CANCELLED,
-          payload: [0, 0],
+            read: arg.length,
+            written: buf.length
         };
-      }
-      
-      return {
-        code: ASYNC_EVENT_CODE.NONE,
-        payload: [0, 0],
-      };
-    }
-    
-    yieldSync(opts) {
-      throw new Error('AsyncTask#yieldSync() not implemented')
-    }
-    
-    cancel() {
-      _debugLog('[AsyncTask#cancel()] args', { });
-      if (!this.taskState() !== AsyncTask.State.CANCEL_DELIVERED) {
-        throw new Error('invalid task state for cancellation');
-      }
-      if (this.borrowedHandles.length > 0) { throw new Error('task still has borrow handles'); }
-      
-      this.#onResolve(new Error('cancelled'));
-      this.#state = AsyncTask.State.RESOLVED;
-    }
-    
-    resolve(results) {
-      _debugLog('[AsyncTask#resolve()] args', { results });
-      if (this.#state === AsyncTask.State.RESOLVED) {
-        throw new Error('task is already resolved');
-      }
-      if (this.borrowedHandles.length > 0) { throw new Error('task still has borrow handles'); }
-      this.#onResolve(results.length === 1 ? results[0] : results);
-      this.#state = AsyncTask.State.RESOLVED;
-    }
-    
-    exit() {
-      _debugLog('[AsyncTask#exit()] args', { });
-      
-      // TODO: ensure there is only one task at a time (scheduler.lock() functionality)
-      if (this.#state !== AsyncTask.State.RESOLVED) {
-        throw new Error('task exited without resolution');
-      }
-      if (this.borrowedHandles > 0) {
-        throw new Error('task exited without clearing borrowed handles');
-      }
-      
-      const state = getOrCreateAsyncState(this.#componentIdx);
-      if (!state) { throw new Error('missing async state for component [' + this.#componentIdx + ']'); }
-      if (!this.#isAsync && !state.inSyncExportCall) {
-        throw new Error('sync task must be run from components known to be in a sync export call');
-      }
-      state.inSyncExportCall = false;
-      
-      this.startPendingTask();
-    }
-    
-    startPendingTask(args) {
-      _debugLog('[AsyncTask#startPendingTask()] args', args);
-      throw new Error('AsyncTask#startPendingTask() not implemented');
-    }
-    
-    createSubtask(args) {
-      _debugLog('[AsyncTask#createSubtask()] args', args);
-      const newSubtask = new AsyncSubtask({
-        componentIdx: this.componentIdx(),
-        taskID: this.id(),
-        memoryIdx: args?.memoryIdx,
-      });
-      this.#subtasks.push(newSubtask);
-      return newSubtask;
-    }
-    
-    currentSubtask() {
-      _debugLog('[AsyncTask#currentSubtask()]');
-      if (this.#subtasks.length === 0) { throw new Error('no current subtask'); }
-      return this.#subtasks.at(-1);
-    }
-    
-    endCurrentSubtask() {
-      _debugLog('[AsyncTask#endCurrentSubtask()]');
-      if (this.#subtasks.length === 0) { throw new Error('cannot end current subtask: no current subtask'); }
-      const subtask = this.#subtasks.pop();
-      subtask.drop();
-      return subtask;
     }
-  }
-  
-  function unpackCallbackResult(result) {
-    _debugLog('[unpackCallbackResult()] args', { result });
-    if (!(_typeCheckValidI32(result))) { throw new Error('invalid callback return value [' + result + '], not a valid i32'); }
-    const eventCode = result & 0xF;
-    if (eventCode < 0 || eventCode > 3) {
-      throw new Error('invalid async return value [' + eventCode + '], outside callback code range');
-    }
-    if (result < 0 || result >= 2**32) { throw new Error('invalid callback result'); }
-    // TODO: table max length check?
-    const waitableSetIdx = result >> 4;
-    return [eventCode, waitableSetIdx];
-  }
-  const ASYNC_STATE = new Map();
-  
-  function getOrCreateAsyncState(componentIdx, init) {
-    if (!ASYNC_STATE.has(componentIdx)) {
-      ASYNC_STATE.set(componentIdx, new ComponentAsyncState());
-    }
-    return ASYNC_STATE.get(componentIdx);
-  }
-  
-  class ComponentAsyncState {
-    #callingAsyncImport = false;
-    #syncImportWait = Promise.withResolvers();
-    #lock = null;
-    
-    mayLeave = true;
-    waitableSets = new RepTable();
-    waitables = new RepTable();
-    
-    #parkedTasks = new Map();
-    
-    callingSyncImport(val) {
-      if (val === undefined) { return this.#callingAsyncImport; }
-      if (typeof val !== 'boolean') { throw new TypeError('invalid setting for async import'); }
-      const prev = this.#callingAsyncImport;
-      this.#callingAsyncImport = val;
-      if (prev === true && this.#callingAsyncImport === false) {
-        this.#notifySyncImportEnd();
-      }
-    }
-    
-    #notifySyncImportEnd() {
-      const existing = this.#syncImportWait;
-      this.#syncImportWait = Promise.withResolvers();
-      existing.resolve();
-    }
-    
-    async waitForSyncImportCallEnd() {
-      await this.#syncImportWait.promise;
-    }
-    
-    parkTaskOnAwaitable(args) {
-      if (!args.awaitable) { throw new TypeError('missing awaitable when trying to park'); }
-      if (!args.task) { throw new TypeError('missing task when trying to park'); }
-      const { awaitable, task } = args;
-      
-      let taskList = this.#parkedTasks.get(awaitable.id());
-      if (!taskList) {
-        taskList = [];
-        this.#parkedTasks.set(awaitable.id(), taskList);
-      }
-      taskList.push(task);
-      
-      this.wakeNextTaskForAwaitable(awaitable);
-    }
-    
-    wakeNextTaskForAwaitable(awaitable) {
-      if (!awaitable) { throw new TypeError('missing awaitable when waking next task'); }
-      const awaitableID = awaitable.id();
-      
-      const taskList = this.#parkedTasks.get(awaitableID);
-      if (!taskList || taskList.length === 0) {
-        _debugLog('[ComponentAsyncState] no tasks waiting for awaitable', { awaitableID: awaitable.id() });
-        return;
-      }
-      
-      let task = taskList.shift(); // todo(perf)
-      if (!task) { throw new Error('no task in parked list despite previous check'); }
-      
-      if (!task.awaitableResume) {
-        throw new Error('task ready due to awaitable is missing resume', { taskID: task.id(), awaitableID });
-      }
-      task.awaitableResume();
-    }
-    
-    async exclusiveLock() {  // TODO: use atomics
-    if (this.#lock === null) {
-      this.#lock = { ticket: 0n };
-    }
-    
-    // Take a ticket for the next valid usage
-    const ticket = ++this.#lock.ticket;
-    
-    _debugLog('[ComponentAsyncState#exclusiveLock()] locking', {
-      currentTicket: ticket - 1n,
-      ticket
-    });
-    
-    // If there is an active promise, then wait for it
-    let finishedTicket;
-    while (this.#lock.promise) {
-      finishedTicket = await this.#lock.promise;
-      if (finishedTicket === ticket - 1n) { break; }
-    }
-    
-    const { promise, resolve } = Promise.withResolvers();
-    this.#lock = {
-      ticket,
-      promise,
-      resolve,
-    };
-    
-    return this.#lock.promise;
-  }
-  
-  exclusiveRelease() {
-    _debugLog('[ComponentAsyncState#exclusiveRelease()] releasing', {
-      currentTicket: this.#lock === null ? 'none' : this.#lock.ticket,
-    });
-    
-    if (this.#lock === null) { return; }
-    
-    const existingLock = this.#lock;
-    this.#lock = null;
-    existingLock.resolve(existingLock.ticket);
-  }
-  
-  isExclusivelyLocked() { return this.#lock !== null; }
-  
 }
 
-function prepareCall(memoryIdx) {
-  _debugLog('[prepareCall()] args', { memoryIdx });
-  
-  const taskMeta = getCurrentTask(ASYNC_CURRENT_COMPONENT_IDXS.at(-1), ASYNC_CURRENT_TASK_IDS.at(-1));
-  if (!taskMeta) { throw new Error('invalid/missing current async task meta during prepare call'); }
-  
-  const task = taskMeta.task;
-  if (!task) { throw new Error('unexpectedly missing task in task meta during prepare call'); }
-  
-  const state = getOrCreateAsyncState(task.componentIdx());
-  if (!state) {
-    throw new Error('invalid/missing async state for component instance [' + componentInstanceID + ']');
-  }
-  
-  const subtask = task.createSubtask({
-    memoryIdx,
-  });
-  
+let WASM_VECTOR_LEN = 0;
+
+function wasm_bindgen__convert__closures_____invoke__hdf270ce0da308ff1(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__hdf270ce0da308ff1(arg0, arg1, arg2);
 }
 
-function asyncStartCall(callbackIdx, postReturnIdx) {
-  _debugLog('[asyncStartCall()] args', { callbackIdx, postReturnIdx });
-  
-  const taskMeta = getCurrentTask(ASYNC_CURRENT_COMPONENT_IDXS.at(-1), ASYNC_CURRENT_TASK_IDS.at(-1));
-  if (!taskMeta) { throw new Error('invalid/missing current async task meta during prepare call'); }
-  
-  const task = taskMeta.task;
-  if (!task) { throw new Error('unexpectedly missing task in task meta during prepare call'); }
-  
-  const subtask = task.currentSubtask();
-  if (!subtask) { throw new Error('invalid/missing subtask during async start call'); }
-  
-  return Number(subtask.waitableRep()) << 4 | subtask.getStateNumber();
+function wasm_bindgen__convert__closures_____invoke__h089a09d160a6520b(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h089a09d160a6520b(arg0, arg1, arg2, arg3);
 }
 
-function syncStartCall(callbackIdx) {
-  _debugLog('[syncStartCall()] args', { callbackIdx });
+const HighlightConfigFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_highlightconfig_free(ptr >>> 0, 1));
+
+/**
+ * Configuration for highlighting.
+ */
+export class HighlightConfig {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        HighlightConfigFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_highlightconfig_free(ptr, 0);
+    }
+    /**
+     * @param {number} depth
+     */
+    setMaxInjectionDepth(depth) {
+        wasm.highlightconfig_setMaxInjectionDepth(this.__wbg_ptr, depth);
+    }
+    constructor() {
+        const ret = wasm.highlightconfig_new();
+        this.__wbg_ptr = ret >>> 0;
+        HighlightConfigFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
 }
+if (Symbol.dispose) HighlightConfig.prototype[Symbol.dispose] = HighlightConfig.prototype.free;
 
-if (!Promise.withResolvers) {
-  Promise.withResolvers = () => {
-    let resolve;
-    let reject;
-    const promise = new Promise((res, rej) => {
-      resolve = res;
-      reject = rej;
-    });
-    return { promise, resolve, reject };
-  };
+/**
+ * Highlight source code, resolving injections recursively.
+ *
+ * This uses the shared `AsyncHighlighter` from `arborium_highlight`,
+ * ensuring the same injection handling logic as Rust native.
+ * @param {string} language
+ * @param {string} source
+ * @returns {Promise<string>}
+ */
+export function highlight(language, source) {
+    const ptr0 = passStringToWasm0(language, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.highlight(ptr0, len0, ptr1, len1);
+    return ret;
 }
 
-const _debugLog = (...args) => {
-  if (!globalThis?.process?.env?.JCO_DEBUG) { return; }
-  console.debug(...args);
+/**
+ * Highlight with custom configuration.
+ * @param {string} language
+ * @param {string} source
+ * @param {HighlightConfig} config
+ * @returns {Promise<string>}
+ */
+export function highlightWithConfig(language, source, config) {
+    const ptr0 = passStringToWasm0(language, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    _assertClass(config, HighlightConfig);
+    var ptr2 = config.__destroy_into_raw();
+    const ret = wasm.highlightWithConfig(ptr0, len0, ptr1, len1, ptr2);
+    return ret;
 }
-const ASYNC_DETERMINISM = 'random';
-const _coinFlip = () => { return Math.random() > 0.5; };
-const I32_MAX = 2_147_483_647;
-const I32_MIN = -2_147_483_648;
-const _typeCheckValidI32 = (n) => typeof n === 'number' && n >= I32_MIN && n <= I32_MAX;
 
-const isNode = typeof process !== 'undefined' && process.versions && process.versions.node;
-let _fs;
-async function fetchCompile (url) {
-  if (isNode) {
-    _fs = _fs || await import('node:fs/promises');
-    return WebAssembly.compile(await _fs.readFile(url));
-  }
-  return fetch(url).then(WebAssembly.compileStreaming);
+/**
+ * Check if a language is available for highlighting.
+ * @param {string} language
+ * @returns {boolean}
+ */
+export function isLanguageAvailable(language) {
+    const ptr0 = passStringToWasm0(language, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.isLanguageAvailable(ptr0, len0);
+    return ret !== 0;
 }
 
-const symbolCabiDispose = Symbol.for('cabiDispose');
+const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
 
-const symbolRscHandle = Symbol('handle');
+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);
 
-const symbolRscRep = Symbol.for('cabiRep');
+                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);
 
-const symbolDispose = Symbol.dispose || Symbol.for('dispose');
+                } else {
+                    throw e;
+                }
+            }
+        }
 
-const handleTables = [];
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
 
-function getErrorPayload(e) {
-  if (e && hasOwnProperty.call(e, 'payload')) return e.payload;
-  if (e instanceof Error) throw e;
-  return e;
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
 }
 
-class RepTable {
-  #data = [0, null];
-  
-  insert(val) {
-    _debugLog('[RepTable#insert()] args', { val });
-    const freeIdx = this.#data[0];
-    if (freeIdx === 0) {
-      this.#data.push(val);
-      this.#data.push(null);
-      return (this.#data.length >> 1) - 1;
-    }
-    this.#data[0] = this.#data[freeIdx << 1];
-    const placementIdx = freeIdx << 1;
-    this.#data[placementIdx] = val;
-    this.#data[placementIdx + 1] = null;
-    return freeIdx;
-  }
-  
-  get(rep) {
-    _debugLog('[RepTable#get()] args', { rep });
-    const baseIdx = rep << 1;
-    const val = this.#data[baseIdx];
-    return val;
-  }
-  
-  contains(rep) {
-    _debugLog('[RepTable#contains()] args', { rep });
-    const baseIdx = rep << 1;
-    return !!this.#data[baseIdx];
-  }
-  
-  remove(rep) {
-    _debugLog('[RepTable#remove()] args', { rep });
-    if (this.#data.length === 2) { throw new Error('invalid'); }
-    
-    const baseIdx = rep << 1;
-    const val = this.#data[baseIdx];
-    if (val === 0) { throw new Error('invalid resource rep (cannot be 0)'); }
-    
-    this.#data[baseIdx] = this.#data[0];
-    this.#data[0] = rep;
-    
-    return val;
-  }
-  
-  clear() {
-    _debugLog('[RepTable#clear()] args', { rep });
-    this.#data = [0, null];
-  }
+function __wbg_get_imports() {
+    const imports = {};
+    imports.wbg = {};
+    imports.wbg.__wbg___wbindgen_boolean_get_dea25b33882b895b = function(arg0) {
+        const v = arg0;
+        const ret = typeof(v) === 'boolean' ? v : undefined;
+        return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+    };
+    imports.wbg.__wbg___wbindgen_is_function_8d400b8b1af978cd = function(arg0) {
+        const ret = typeof(arg0) === 'function';
+        return ret;
+    };
+    imports.wbg.__wbg___wbindgen_is_null_dfda7d66506c95b5 = function(arg0) {
+        const ret = arg0 === null;
+        return ret;
+    };
+    imports.wbg.__wbg___wbindgen_is_undefined_f6b95eab589e0269 = function(arg0) {
+        const ret = arg0 === undefined;
+        return ret;
+    };
+    imports.wbg.__wbg___wbindgen_number_get_9619185a74197f95 = function(arg0, arg1) {
+        const obj = arg1;
+        const ret = typeof(obj) === 'number' ? obj : undefined;
+        getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+    };
+    imports.wbg.__wbg___wbindgen_string_get_a2a31e16edf96e42 = function(arg0, arg1) {
+        const obj = arg1;
+        const ret = typeof(obj) === 'string' ? obj : undefined;
+        var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbg__wbg_cb_unref_87dfb5aaa0cbcea7 = function(arg0) {
+        arg0._wbg_cb_unref();
+    };
+    imports.wbg.__wbg_call_3020136f7a2d6e44 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = arg0.call(arg1, arg2);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_call_abb4ff46ce38be40 = function() { return handleError(function (arg0, arg1) {
+        const ret = arg0.call(arg1);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_from_29a8414a7a7cd19d = function(arg0) {
+        const ret = Array.from(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_get_6b7bd52aca3f9671 = function(arg0, arg1) {
+        const ret = arg0[arg1 >>> 0];
+        return ret;
+    };
+    imports.wbg.__wbg_get_af9dab7e9603ea93 = function() { return handleError(function (arg0, arg1) {
+        const ret = Reflect.get(arg0, arg1);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_isLanguageAvailable_34dd470608352293 = function(arg0, arg1) {
+        const ret = arboriumHost.isLanguageAvailable(getStringFromWasm0(arg0, arg1));
+        return ret;
+    };
+    imports.wbg.__wbg_length_d45040a40c570362 = function(arg0) {
+        const ret = arg0.length;
+        return ret;
+    };
+    imports.wbg.__wbg_loadGrammar_3b1f0071cede0f25 = function() { return handleError(function (arg0, arg1) {
+        const ret = arboriumHost.loadGrammar(getStringFromWasm0(arg0, arg1));
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_new_ff12d2b041fb48f1 = function(arg0, arg1) {
+        try {
+            var state0 = {a: arg0, b: arg1};
+            var cb0 = (arg0, arg1) => {
+                const a = state0.a;
+                state0.a = 0;
+                try {
+                    return wasm_bindgen__convert__closures_____invoke__h089a09d160a6520b(a, state0.b, arg0, arg1);
+                } finally {
+                    state0.a = a;
+                }
+            };
+            const ret = new Promise(cb0);
+            return ret;
+        } finally {
+            state0.a = state0.b = 0;
+        }
+    };
+    imports.wbg.__wbg_new_no_args_cb138f77cf6151ee = function(arg0, arg1) {
+        const ret = new Function(getStringFromWasm0(arg0, arg1));
+        return ret;
+    };
+    imports.wbg.__wbg_parse_4dfd6e8a8b8e03d3 = function(arg0, arg1, arg2) {
+        const ret = arboriumHost.parse(arg0 >>> 0, getStringFromWasm0(arg1, arg2));
+        return ret;
+    };
+    imports.wbg.__wbg_queueMicrotask_9b549dfce8865860 = function(arg0) {
+        const ret = arg0.queueMicrotask;
+        return ret;
+    };
+    imports.wbg.__wbg_queueMicrotask_fca69f5bfad613a5 = function(arg0) {
+        queueMicrotask(arg0);
+    };
+    imports.wbg.__wbg_resolve_fd5bfbaa4ce36e1e = function(arg0) {
+        const ret = Promise.resolve(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_static_accessor_GLOBAL_769e6b65d6557335 = function() {
+        const ret = typeof global === 'undefined' ? null : global;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_static_accessor_GLOBAL_THIS_60cf02db4de8e1c1 = function() {
+        const ret = typeof globalThis === 'undefined' ? null : globalThis;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_static_accessor_SELF_08f5a74c69739274 = function() {
+        const ret = typeof self === 'undefined' ? null : self;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_static_accessor_WINDOW_a8924b26aa92d024 = function() {
+        const ret = typeof window === 'undefined' ? null : window;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_then_429f7caf1026411d = function(arg0, arg1, arg2) {
+        const ret = arg0.then(arg1, arg2);
+        return ret;
+    };
+    imports.wbg.__wbg_then_4f95312d68691235 = function(arg0, arg1) {
+        const ret = arg0.then(arg1);
+        return ret;
+    };
+    imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
+        // Cast intrinsic for `Ref(String) -> Externref`.
+        const ret = getStringFromWasm0(arg0, arg1);
+        return ret;
+    };
+    imports.wbg.__wbindgen_cast_3b1a32895b770b74 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 10, function: Function { arguments: [Externref], shim_idx: 11, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__hd7b7e163837b9c9e, wasm_bindgen__convert__closures_____invoke__hdf270ce0da308ff1);
+        return ret;
+    };
+    imports.wbg.__wbindgen_init_externref_table = function() {
+        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);
+    };
+
+    return imports;
 }
 
-const hasOwnProperty = Object.prototype.hasOwnProperty;
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    __wbg_init.__wbindgen_wasm_module = module;
+    cachedDataViewMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
 
 
-if (!getCoreModule) getCoreModule = (name) => fetchCompile(new URL(`./${name}`, import.meta.url));
-const module0 = getCoreModule('arborium_host.core.wasm');
-const module1 = getCoreModule('arborium_host.core2.wasm');
-const module2 = getCoreModule('arborium_host.core3.wasm');
-const module3 = getCoreModule('arborium_host.core4.wasm');
+    wasm.__wbindgen_start();
+    return wasm;
+}
 
-const { createPluginSession, freePluginSession, getInjectionLanguages, loadPlugin, pluginApplyEdit, pluginCancel, pluginParse, pluginSetText } = imports['arborium:host/plugin-provider'];
-const { getEnvironment } = imports['wasi:cli/environment'];
-const { exit } = imports['wasi:cli/exit'];
-const { getStderr } = imports['wasi:cli/stderr'];
-const { getStdin } = imports['wasi:cli/stdin'];
-const { getStdout } = imports['wasi:cli/stdout'];
-const { getDirectories } = imports['wasi:filesystem/preopens'];
-const { Descriptor, filesystemErrorCode } = imports['wasi:filesystem/types'];
-const { Error: Error$1 } = imports['wasi:io/error'];
-const { InputStream, OutputStream } = imports['wasi:io/streams'];
-let gen = (function* _initGenerator () {
-  let exports0;
-  
-  function trampoline0(arg0, arg1) {
-    _debugLog('[iface="arborium:host/plugin-provider@0.1.0", function="plugin-cancel"] [Instruction::CallInterface] (async? sync, @ enter)');
-    const _interface_call_currentTaskID = startCurrentTask(0, false, 'plugin-cancel');
-    pluginCancel(arg0 >>> 0, arg1 >>> 0);
-    _debugLog('[iface="arborium:host/plugin-provider@0.1.0", function="plugin-cancel"] [Instruction::CallInterface] (sync, @ post-call)');
-    endCurrentTask(0);
-    _debugLog('[iface="arborium:host/plugin-provider@0.1.0", function="plugin-cancel"][Instruction::Return]', {
-      funcName: 'plugin-cancel',
-      paramCount: 0,
-      async: false,
-      postReturn: false
-    });
-  }
-  
-  
-  function trampoline1(arg0, arg1) {
-    _debugLog('[iface="arborium:host/plugin-provider@0.1.0", function="free-plugin-session"] [Instruction::CallInterface] (async? sync, @ enter)');
-    const _interface_call_currentTaskID = startCurrentTask(0, false, 'free-plugin-session');
-    freePluginSession(arg0 >>> 0, arg1 >>> 0);
-    _debugLog('[iface="arborium:host/plugin-provider@0.1.0", function="free-plugin-session"] [Instruction::CallInterface] (sync, @ post-call)');
-    endCurrentTask(0);
-    _debugLog('[iface="arborium:host/plugin-provider@0.1.0", function="free-plugin-session"][Instruction::Return]', {
-      funcName: 'free-plugin-session',
-      paramCount: 0,
-      async: false,
-      postReturn: false
-    });
-  }
-  
-  
-  function trampoline2(arg0) {
-    _debugLog('[iface="arborium:host/plugin-provider@0.1.0", function="create-plugin-session"] [Instruction::CallInterface] (async? sync, @ enter)');
-    const _interface_call_currentTaskID = startCurrentTask(0, false, 'create-plugin-session');
-    const ret = createPluginSession(arg0 >>> 0);
-    _debugLog('[iface="arborium:host/plugin-provider@0.1.0", function="create-plugin-session"] [Instruction::CallInterface] (sync, @ post-call)');
-    endCurrentTask(0);
-    _debugLog('[iface="arborium:host/plugin-provider@0.1.0", function="create-plugin-session"][Instruction::Return]', {
-      funcName: 'create-plugin-session',
-      paramCount: 1,
-      async: false,
-      postReturn: false
-    });
-    return toUint32(ret);
-  }
-  
-  let exports1;
-  const handleTable1 = [T_FLAG, 0];
-  const captureTable1= new Map();
-  let captureCnt1 = 0;
-  handleTables[1] = handleTable1;
-  
-  function trampoline7() {
-    _debugLog('[iface="wasi:cli/stderr@0.2.3", function="get-stderr"] [Instruction::CallInterface] (async? sync, @ enter)');
-    const _interface_call_currentTaskID = startCurrentTask(0, false, 'get-stderr');
-    const ret = getStderr();
-    _debugLog('[iface="wasi:cli/stderr@0.2.3", function="get-stderr"] [Instruction::CallInterface] (sync, @ post-call)');
-    endCurrentTask(0);
-    if (!(ret instanceof OutputStream)) {
-      throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
-    }
-    var handle0 = ret[symbolRscHandle];
-    if (!handle0) {
-      const rep = ret[symbolRscRep] || ++captureCnt1;
-      captureTable1.set(rep, ret);
-      handle0 = rscTableCreateOwn(handleTable1, rep);
-    }
-    _debugLog('[iface="wasi:cli/stderr@0.2.3", function="get-stderr"][Instruction::Return]', {
-      funcName: 'get-stderr',
-      paramCount: 1,
-      async: false,
-      postReturn: false
-    });
-    return handle0;
-  }
-  
-  const handleTable2 = [T_FLAG, 0];
-  const captureTable2= new Map();
-  let captureCnt2 = 0;
-  handleTables[2] = handleTable2;
-  
-  function trampoline8() {
-    _debugLog('[iface="wasi:cli/stdin@0.2.3", function="get-stdin"] [Instruction::CallInterface] (async? sync, @ enter)');
-    const _interface_call_currentTaskID = startCurrentTask(0, false, 'get-stdin');
-    const ret = getStdin();
-    _debugLog('[iface="wasi:cli/stdin@0.2.3", function="get-stdin"] [Instruction::CallInterface] (sync, @ post-call)');
-    endCurrentTask(0);
-    if (!(ret instanceof InputStream)) {
-      throw new TypeError('Resource error: Not a valid "InputStream" resource.');
-    }
-    var handle0 = ret[symbolRscHandle];
-    if (!handle0) {
-      const rep = ret[symbolRscRep] || ++captureCnt2;
-      captureTable2.set(rep, ret);
-      handle0 = rscTableCreateOwn(handleTable2, rep);
-    }
-    _debugLog('[iface="wasi:cli/stdin@0.2.3", function="get-stdin"][Instruction::Return]', {
-      funcName: 'get-stdin',
-      paramCount: 1,
-      async: false,
-      postReturn: false
-    });
-    return handle0;
-  }
-  
-  
-  function trampoline9() {
-    _debugLog('[iface="wasi:cli/stdout@0.2.3", function="get-stdout"] [Instruction::CallInterface] (async? sync, @ enter)');
-    const _interface_call_currentTaskID = startCurrentTask(0, false, 'get-stdout');
-    const ret = getStdout();
-    _debugLog('[iface="wasi:cli/stdout@0.2.3", function="get-stdout"] [Instruction::CallInterface] (sync, @ post-call)');
-    endCurrentTask(0);
-    if (!(ret instanceof OutputStream)) {
-      throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
-    }
-    var handle0 = ret[symbolRscHandle];
-    if (!handle0) {
-      const rep = ret[symbolRscRep] || ++captureCnt1;
-      captureTable1.set(rep, ret);
-      handle0 = rscTableCreateOwn(handleTable1, rep);
-    }
-    _debugLog('[iface="wasi:cli/stdout@0.2.3", function="get-stdout"][Instruction::Return]', {
-      funcName: 'get-stdout',
-      paramCount: 1,
-      async: false,
-      postReturn: false
-    });
-    return handle0;
-  }
-  
-  
-  function trampoline10(arg0) {
-    let variant0;
-    switch (arg0) {
-      case 0: {
-        variant0= {
-          tag: 'ok',
-          val: undefined
-        };
-        break;
-      }
-      case 1: {
-        variant0= {
-          tag: 'err',
-          val: undefined
-        };
-        break;
-      }
-      default: {
-        throw new TypeError('invalid variant discriminant for expected');
-      }
-    }
-    _debugLog('[iface="wasi:cli/exit@0.2.3", function="exit"] [Instruction::CallInterface] (async? sync, @ enter)');
-    const _interface_call_currentTaskID = startCurrentTask(0, false, 'exit');
-    exit(variant0);
-    _debugLog('[iface="wasi:cli/exit@0.2.3", function="exit"] [Instruction::CallInterface] (sync, @ post-call)');
-    endCurrentTask(0);
-    _debugLog('[iface="wasi:cli/exit@0.2.3", function="exit"][Instruction::Return]', {
-      funcName: 'exit',
-      paramCount: 0,
-      async: false,
-      postReturn: false
-    });
-  }
-  
-  let exports2;
-  let memory0;
-  let realloc0;
-  let realloc1;
-  
-  function trampoline11(arg0, arg1, arg2) {
-    var ptr0 = arg0;
-    var len0 = arg1;
-    var result0 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr0, len0));
-    _debugLog('[iface="arborium:host/plugin-provider@0.1.0", function="load-plugin"] [Instruction::CallInterface] (async? sync, @ enter)');
-    const _interface_call_currentTaskID = startCurrentTask(0, false, 'load-plugin');
-    const ret = loadPlugin(result0);
-    _debugLog('[iface="arborium:host/plugin-provider@0.1.0", function="load-plugin"] [Instruction::CallInterface] (sync, @ post-call)');
-    endCurrentTask(0);
-    var variant1 = ret;
-    if (variant1 === null || variant1=== undefined) {
-      dataView(memory0).setInt8(arg2 + 0, 0, true);
-    } else {
-      const e = variant1;
-      dataView(memory0).setInt8(arg2 + 0, 1, true);
-      dataView(memory0).setInt32(arg2 + 4, toUint32(e), true);
-    }
-    _debugLog('[iface="arborium:host/plugin-provider@0.1.0", function="load-plugin"][Instruction::Return]', {
-      funcName: 'load-plugin',
-      paramCount: 0,
-      async: false,
-      postReturn: false
-    });
-  }
-  
-  
-  function trampoline12(arg0, arg1, arg2) {
-    _debugLog('[iface="arborium:host/plugin-provider@0.1.0", function="plugin-parse"] [Instruction::CallInterface] (async? sync, @ enter)');
-    const _interface_call_currentTaskID = startCurrentTask(0, false, 'plugin-parse');
-    let ret;
-    try {
-      ret = { tag: 'ok', val: pluginParse(arg0 >>> 0, arg1 >>> 0)};
-    } catch (e) {
-      ret = { tag: 'err', val: getErrorPayload(e) };
-    }
-    _debugLog('[iface="arborium:host/plugin-provider@0.1.0", function="plugin-parse"] [Instruction::CallInterface] (sync, @ post-call)');
-    endCurrentTask(0);
-    var variant9 = ret;
-    switch (variant9.tag) {
-      case 'ok': {
-        const e = variant9.val;
-        dataView(memory0).setInt8(arg2 + 0, 0, true);
-        var {spans: v0_0, injections: v0_1 } = e;
-        var vec3 = v0_0;
-        var len3 = vec3.length;
-        var result3 = realloc0(0, 0, 4, len3 * 16);
-        for (let i = 0; i < vec3.length; i++) {
-          const e = vec3[i];
-          const base = result3 + i * 16;var {start: v1_0, end: v1_1, capture: v1_2 } = e;
-          dataView(memory0).setInt32(base + 0, toUint32(v1_0), true);
-          dataView(memory0).setInt32(base + 4, toUint32(v1_1), true);
-          var ptr2 = utf8Encode(v1_2, realloc0, memory0);
-          var len2 = utf8EncodedLen;
-          dataView(memory0).setUint32(base + 12, len2, true);
-          dataView(memory0).setUint32(base + 8, ptr2, true);
-        }
-        dataView(memory0).setUint32(arg2 + 8, len3, true);
-        dataView(memory0).setUint32(arg2 + 4, result3, true);
-        var vec6 = v0_1;
-        var len6 = vec6.length;
-        var result6 = realloc0(0, 0, 4, len6 * 20);
-        for (let i = 0; i < vec6.length; i++) {
-          const e = vec6[i];
-          const base = result6 + i * 20;var {start: v4_0, end: v4_1, language: v4_2, includeChildren: v4_3 } = e;
-          dataView(memory0).setInt32(base + 0, toUint32(v4_0), true);
-          dataView(memory0).setInt32(base + 4, toUint32(v4_1), true);
-          var ptr5 = utf8Encode(v4_2, realloc0, memory0);
-          var len5 = utf8EncodedLen;
-          dataView(memory0).setUint32(base + 12, len5, true);
-          dataView(memory0).setUint32(base + 8, ptr5, true);
-          dataView(memory0).setInt8(base + 16, v4_3 ? 1 : 0, true);
-        }
-        dataView(memory0).setUint32(arg2 + 16, len6, true);
-        dataView(memory0).setUint32(arg2 + 12, result6, true);
-        break;
-      }
-      case 'err': {
-        const e = variant9.val;
-        dataView(memory0).setInt8(arg2 + 0, 1, true);
-        var {message: v7_0 } = e;
-        var ptr8 = utf8Encode(v7_0, realloc0, memory0);
-        var len8 = utf8EncodedLen;
-        dataView(memory0).setUint32(arg2 + 8, len8, true);
-        dataView(memory0).setUint32(arg2 + 4, ptr8, true);
-        break;
-      }
-      default: {
-        throw new TypeError('invalid variant specified for result');
-      }
-    }
-    _debugLog('[iface="arborium:host/plugin-provider@0.1.0", function="plugin-parse"][Instruction::Return]', {
-      funcName: 'plugin-parse',
-      paramCount: 0,
-      async: false,
-      postReturn: false
-    });
-  }
-  
-  
-  function trampoline13(arg0, arg1, arg2, arg3) {
-    var ptr0 = arg2;
-    var len0 = arg3;
-    var result0 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr0, len0));
-    _debugLog('[iface="arborium:host/plugin-provider@0.1.0", function="plugin-set-text"] [Instruction::CallInterface] (async? sync, @ enter)');
-    const _interface_call_currentTaskID = startCurrentTask(0, false, 'plugin-set-text');
-    pluginSetText(arg0 >>> 0, arg1 >>> 0, result0);
-    _debugLog('[iface="arborium:host/plugin-provider@0.1.0", function="plugin-set-text"] [Instruction::CallInterface] (sync, @ post-call)');
-    endCurrentTask(0);
-    _debugLog('[iface="arborium:host/plugin-provider@0.1.0", function="plugin-set-text"][Instruction::Return]', {
-      funcName: 'plugin-set-text',
-      paramCount: 0,
-      async: false,
-      postReturn: false
-    });
-  }
-  
-  
-  function trampoline14(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12) {
-    var ptr0 = arg2;
-    var len0 = arg3;
-    var result0 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr0, len0));
-    _debugLog('[iface="arborium:host/plugin-provider@0.1.0", function="plugin-apply-edit"] [Instruction::CallInterface] (async? sync, @ enter)');
-    const _interface_call_currentTaskID = startCurrentTask(0, false, 'plugin-apply-edit');
-    pluginApplyEdit(arg0 >>> 0, arg1 >>> 0, result0, {
-      startByte: arg4 >>> 0,
-      oldEndByte: arg5 >>> 0,
-      newEndByte: arg6 >>> 0,
-      startRow: arg7 >>> 0,
-      startCol: arg8 >>> 0,
-      oldEndRow: arg9 >>> 0,
-      oldEndCol: arg10 >>> 0,
-      newEndRow: arg11 >>> 0,
-      newEndCol: arg12 >>> 0,
-    });
-    _debugLog('[iface="arborium:host/plugin-provider@0.1.0", function="plugin-apply-edit"] [Instruction::CallInterface] (sync, @ post-call)');
-    endCurrentTask(0);
-    _debugLog('[iface="arborium:host/plugin-provider@0.1.0", function="plugin-apply-edit"][Instruction::Return]', {
-      funcName: 'plugin-apply-edit',
-      paramCount: 0,
-      async: false,
-      postReturn: false
-    });
-  }
-  
-  
-  function trampoline15(arg0, arg1) {
-    _debugLog('[iface="arborium:host/plugin-provider@0.1.0", function="get-injection-languages"] [Instruction::CallInterface] (async? sync, @ enter)');
-    const _interface_call_currentTaskID = startCurrentTask(0, false, 'get-injection-languages');
-    const ret = getInjectionLanguages(arg0 >>> 0);
-    _debugLog('[iface="arborium:host/plugin-provider@0.1.0", function="get-injection-languages"] [Instruction::CallInterface] (sync, @ post-call)');
-    endCurrentTask(0);
-    var vec1 = ret;
-    var len1 = vec1.length;
-    var result1 = realloc0(0, 0, 4, len1 * 8);
-    for (let i = 0; i < vec1.length; i++) {
-      const e = vec1[i];
-      const base = result1 + i * 8;var ptr0 = utf8Encode(e, realloc0, memory0);
-      var len0 = utf8EncodedLen;
-      dataView(memory0).setUint32(base + 4, len0, true);
-      dataView(memory0).setUint32(base + 0, ptr0, true);
-    }
-    dataView(memory0).setUint32(arg1 + 4, len1, true);
-    dataView(memory0).setUint32(arg1 + 0, result1, true);
-    _debugLog('[iface="arborium:host/plugin-provider@0.1.0", function="get-injection-languages"][Instruction::Return]', {
-      funcName: 'get-injection-languages',
-      paramCount: 0,
-      async: false,
-      postReturn: false
-    });
-  }
-  
-  
-  function trampoline16(arg0) {
-    _debugLog('[iface="wasi:cli/environment@0.2.3", function="get-environment"] [Instruction::CallInterface] (async? sync, @ enter)');
-    const _interface_call_currentTaskID = startCurrentTask(0, false, 'get-environment');
-    const ret = getEnvironment();
-    _debugLog('[iface="wasi:cli/environment@0.2.3", function="get-environment"] [Instruction::CallInterface] (sync, @ post-call)');
-    endCurrentTask(0);
-    var vec3 = ret;
-    var len3 = vec3.length;
-    var result3 = realloc1(0, 0, 4, len3 * 16);
-    for (let i = 0; i < vec3.length; i++) {
-      const e = vec3[i];
-      const base = result3 + i * 16;var [tuple0_0, tuple0_1] = e;
-      var ptr1 = utf8Encode(tuple0_0, realloc1, memory0);
-      var len1 = utf8EncodedLen;
-      dataView(memory0).setUint32(base + 4, len1, true);
-      dataView(memory0).setUint32(base + 0, ptr1, true);
-      var ptr2 = utf8Encode(tuple0_1, realloc1, memory0);
-      var len2 = utf8EncodedLen;
-      dataView(memory0).setUint32(base + 12, len2, true);
-      dataView(memory0).setUint32(base + 8, ptr2, true);
-    }
-    dataView(memory0).setUint32(arg0 + 4, len3, true);
-    dataView(memory0).setUint32(arg0 + 0, result3, true);
-    _debugLog('[iface="wasi:cli/environment@0.2.3", function="get-environment"][Instruction::Return]', {
-      funcName: 'get-environment',
-      paramCount: 0,
-      async: false,
-      postReturn: false
-    });
-  }
-  
-  const handleTable0 = [T_FLAG, 0];
-  const captureTable0= new Map();
-  let captureCnt0 = 0;
-  handleTables[0] = handleTable0;
-  
-  function trampoline17(arg0, arg1) {
-    var handle1 = arg0;
-    var rep2 = handleTable0[(handle1 << 1) + 1] & ~T_FLAG;
-    var rsc0 = captureTable0.get(rep2);
-    if (!rsc0) {
-      rsc0 = Object.create(Error$1.prototype);
-      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
-      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
-    }
-    curResourceBorrows.push(rsc0);
-    _debugLog('[iface="wasi:filesystem/types@0.2.3", function="filesystem-error-code"] [Instruction::CallInterface] (async? sync, @ enter)');
-    const _interface_call_currentTaskID = startCurrentTask(0, false, 'filesystem-error-code');
-    const ret = filesystemErrorCode(rsc0);
-    _debugLog('[iface="wasi:filesystem/types@0.2.3", function="filesystem-error-code"] [Instruction::CallInterface] (sync, @ post-call)');
-    for (const rsc of curResourceBorrows) {
-      rsc[symbolRscHandle] = undefined;
-    }
-    curResourceBorrows = [];
-    endCurrentTask(0);
-    var variant4 = ret;
-    if (variant4 === null || variant4=== undefined) {
-      dataView(memory0).setInt8(arg1 + 0, 0, true);
-    } else {
-      const e = variant4;
-      dataView(memory0).setInt8(arg1 + 0, 1, true);
-      var val3 = e;
-      let enum3;
-      switch (val3) {
-        case 'access': {
-          enum3 = 0;
-          break;
-        }
-        case 'would-block': {
-          enum3 = 1;
-          break;
-        }
-        case 'already': {
-          enum3 = 2;
-          break;
-        }
-        case 'bad-descriptor': {
-          enum3 = 3;
-          break;
-        }
-        case 'busy': {
-          enum3 = 4;
-          break;
-        }
-        case 'deadlock': {
-          enum3 = 5;
-          break;
-        }
-        case 'quota': {
-          enum3 = 6;
-          break;
-        }
-        case 'exist': {
-          enum3 = 7;
-          break;
-        }
-        case 'file-too-large': {
-          enum3 = 8;
-          break;
-        }
-        case 'illegal-byte-sequence': {
-          enum3 = 9;
-          break;
-        }
-        case 'in-progress': {
-          enum3 = 10;
-          break;
-        }
-        case 'interrupted': {
-          enum3 = 11;
-          break;
-        }
-        case 'invalid': {
-          enum3 = 12;
-          break;
-        }
-        case 'io': {
-          enum3 = 13;
-          break;
-        }
-        case 'is-directory': {
-          enum3 = 14;
-          break;
-        }
-        case 'loop': {
-          enum3 = 15;
-          break;
-        }
-        case 'too-many-links': {
-          enum3 = 16;
-          break;
-        }
-        case 'message-size': {
-          enum3 = 17;
-          break;
-        }
-        case 'name-too-long': {
-          enum3 = 18;
-          break;
-        }
-        case 'no-device': {
-          enum3 = 19;
-          break;
-        }
-        case 'no-entry': {
-          enum3 = 20;
-          break;
-        }
-        case 'no-lock': {
-          enum3 = 21;
-          break;
-        }
-        case 'insufficient-memory': {
-          enum3 = 22;
-          break;
-        }
-        case 'insufficient-space': {
-          enum3 = 23;
-          break;
-        }
-        case 'not-directory': {
-          enum3 = 24;
-          break;
-        }
-        case 'not-empty': {
-          enum3 = 25;
-          break;
-        }
-        case 'not-recoverable': {
-          enum3 = 26;
-          break;
-        }
-        case 'unsupported': {
-          enum3 = 27;
-          break;
-        }
-        case 'no-tty': {
-          enum3 = 28;
-          break;
-        }
-        case 'no-such-device': {
-          enum3 = 29;
-          break;
-        }
-        case 'overflow': {
-          enum3 = 30;
-          break;
-        }
-        case 'not-permitted': {
-          enum3 = 31;
-          break;
-        }
-        case 'pipe': {
-          enum3 = 32;
-          break;
-        }
-        case 'read-only': {
-          enum3 = 33;
-          break;
-        }
-        case 'invalid-seek': {
-          enum3 = 34;
-          break;
-        }
-        case 'text-file-busy': {
-          enum3 = 35;
-          break;
-        }
-        case 'cross-device': {
-          enum3 = 36;
-          break;
-        }
-        default: {
-          if ((e) instanceof Error) {
-            console.error(e);
-          }
-          
-          throw new TypeError(`"${val3}" is not one of the cases of error-code`);
-        }
-      }
-      dataView(memory0).setInt8(arg1 + 1, enum3, true);
-    }
-    _debugLog('[iface="wasi:filesystem/types@0.2.3", function="filesystem-error-code"][Instruction::Return]', {
-      funcName: 'filesystem-error-code',
-      paramCount: 0,
-      async: false,
-      postReturn: false
-    });
-  }
-  
-  const handleTable3 = [T_FLAG, 0];
-  const captureTable3= new Map();
-  let captureCnt3 = 0;
-  handleTables[3] = handleTable3;
-  
-  function trampoline18(arg0, arg1, arg2) {
-    var handle1 = arg0;
-    var rep2 = handleTable3[(handle1 << 1) + 1] & ~T_FLAG;
-    var rsc0 = captureTable3.get(rep2);
-    if (!rsc0) {
-      rsc0 = Object.create(Descriptor.prototype);
-      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
-      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
-    }
-    curResourceBorrows.push(rsc0);
-    _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.write-via-stream"] [Instruction::CallInterface] (async? sync, @ enter)');
-    const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]descriptor.write-via-stream');
-    let ret;
-    try {
-      ret = { tag: 'ok', val: rsc0.writeViaStream(BigInt.asUintN(64, arg1))};
-    } catch (e) {
-      ret = { tag: 'err', val: getErrorPayload(e) };
-    }
-    _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.write-via-stream"] [Instruction::CallInterface] (sync, @ post-call)');
-    for (const rsc of curResourceBorrows) {
-      rsc[symbolRscHandle] = undefined;
-    }
-    curResourceBorrows = [];
-    endCurrentTask(0);
-    var variant5 = ret;
-    switch (variant5.tag) {
-      case 'ok': {
-        const e = variant5.val;
-        dataView(memory0).setInt8(arg2 + 0, 0, true);
-        if (!(e instanceof OutputStream)) {
-          throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
-        }
-        var handle3 = e[symbolRscHandle];
-        if (!handle3) {
-          const rep = e[symbolRscRep] || ++captureCnt1;
-          captureTable1.set(rep, e);
-          handle3 = rscTableCreateOwn(handleTable1, rep);
-        }
-        dataView(memory0).setInt32(arg2 + 4, handle3, true);
-        break;
-      }
-      case 'err': {
-        const e = variant5.val;
-        dataView(memory0).setInt8(arg2 + 0, 1, true);
-        var val4 = e;
-        let enum4;
-        switch (val4) {
-          case 'access': {
-            enum4 = 0;
-            break;
-          }
-          case 'would-block': {
-            enum4 = 1;
-            break;
-          }
-          case 'already': {
-            enum4 = 2;
-            break;
-          }
-          case 'bad-descriptor': {
-            enum4 = 3;
-            break;
-          }
-          case 'busy': {
-            enum4 = 4;
-            break;
-          }
-          case 'deadlock': {
-            enum4 = 5;
-            break;
-          }
-          case 'quota': {
-            enum4 = 6;
-            break;
-          }
-          case 'exist': {
-            enum4 = 7;
-            break;
-          }
-          case 'file-too-large': {
-            enum4 = 8;
-            break;
-          }
-          case 'illegal-byte-sequence': {
-            enum4 = 9;
-            break;
-          }
-          case 'in-progress': {
-            enum4 = 10;
-            break;
-          }
-          case 'interrupted': {
-            enum4 = 11;
-            break;
-          }
-          case 'invalid': {
-            enum4 = 12;
-            break;
-          }
-          case 'io': {
-            enum4 = 13;
-            break;
-          }
-          case 'is-directory': {
-            enum4 = 14;
-            break;
-          }
-          case 'loop': {
-            enum4 = 15;
-            break;
-          }
-          case 'too-many-links': {
-            enum4 = 16;
-            break;
-          }
-          case 'message-size': {
-            enum4 = 17;
-            break;
-          }
-          case 'name-too-long': {
-            enum4 = 18;
-            break;
-          }
-          case 'no-device': {
-            enum4 = 19;
-            break;
-          }
-          case 'no-entry': {
-            enum4 = 20;
-            break;
-          }
-          case 'no-lock': {
-            enum4 = 21;
-            break;
-          }
-          case 'insufficient-memory': {
-            enum4 = 22;
-            break;
-          }
-          case 'insufficient-space': {
-            enum4 = 23;
-            break;
-          }
-          case 'not-directory': {
-            enum4 = 24;
-            break;
-          }
-          case 'not-empty': {
-            enum4 = 25;
-            break;
-          }
-          case 'not-recoverable': {
-            enum4 = 26;
-            break;
-          }
-          case 'unsupported': {
-            enum4 = 27;
-            break;
-          }
-          case 'no-tty': {
-            enum4 = 28;
-            break;
-          }
-          case 'no-such-device': {
-            enum4 = 29;
-            break;
-          }
-          case 'overflow': {
-            enum4 = 30;
-            break;
-          }
-          case 'not-permitted': {
-            enum4 = 31;
-            break;
-          }
-          case 'pipe': {
-            enum4 = 32;
-            break;
-          }
-          case 'read-only': {
-            enum4 = 33;
-            break;
-          }
-          case 'invalid-seek': {
-            enum4 = 34;
-            break;
-          }
-          case 'text-file-busy': {
-            enum4 = 35;
-            break;
-          }
-          case 'cross-device': {
-            enum4 = 36;
-            break;
-          }
-          default: {
-            if ((e) instanceof Error) {
-              console.error(e);
-            }
-            
-            throw new TypeError(`"${val4}" is not one of the cases of error-code`);
-          }
-        }
-        dataView(memory0).setInt8(arg2 + 4, enum4, true);
-        break;
-      }
-      default: {
-        throw new TypeError('invalid variant specified for result');
-      }
-    }
-    _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.write-via-stream"][Instruction::Return]', {
-      funcName: '[method]descriptor.write-via-stream',
-      paramCount: 0,
-      async: false,
-      postReturn: false
-    });
-  }
-  
-  
-  function trampoline19(arg0, arg1) {
-    var handle1 = arg0;
-    var rep2 = handleTable3[(handle1 << 1) + 1] & ~T_FLAG;
-    var rsc0 = captureTable3.get(rep2);
-    if (!rsc0) {
-      rsc0 = Object.create(Descriptor.prototype);
-      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
-      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
-    }
-    curResourceBorrows.push(rsc0);
-    _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.append-via-stream"] [Instruction::CallInterface] (async? sync, @ enter)');
-    const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]descriptor.append-via-stream');
-    let ret;
-    try {
-      ret = { tag: 'ok', val: rsc0.appendViaStream()};
-    } catch (e) {
-      ret = { tag: 'err', val: getErrorPayload(e) };
-    }
-    _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.append-via-stream"] [Instruction::CallInterface] (sync, @ post-call)');
-    for (const rsc of curResourceBorrows) {
-      rsc[symbolRscHandle] = undefined;
-    }
-    curResourceBorrows = [];
-    endCurrentTask(0);
-    var variant5 = ret;
-    switch (variant5.tag) {
-      case 'ok': {
-        const e = variant5.val;
-        dataView(memory0).setInt8(arg1 + 0, 0, true);
-        if (!(e instanceof OutputStream)) {
-          throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
-        }
-        var handle3 = e[symbolRscHandle];
-        if (!handle3) {
-          const rep = e[symbolRscRep] || ++captureCnt1;
-          captureTable1.set(rep, e);
-          handle3 = rscTableCreateOwn(handleTable1, rep);
-        }
-        dataView(memory0).setInt32(arg1 + 4, handle3, true);
-        break;
-      }
-      case 'err': {
-        const e = variant5.val;
-        dataView(memory0).setInt8(arg1 + 0, 1, true);
-        var val4 = e;
-        let enum4;
-        switch (val4) {
-          case 'access': {
-            enum4 = 0;
-            break;
-          }
-          case 'would-block': {
-            enum4 = 1;
-            break;
-          }
-          case 'already': {
-            enum4 = 2;
-            break;
-          }
-          case 'bad-descriptor': {
-            enum4 = 3;
-            break;
-          }
-          case 'busy': {
-            enum4 = 4;
-            break;
-          }
-          case 'deadlock': {
-            enum4 = 5;
-            break;
-          }
-          case 'quota': {
-            enum4 = 6;
-            break;
-          }
-          case 'exist': {
-            enum4 = 7;
-            break;
-          }
-          case 'file-too-large': {
-            enum4 = 8;
-            break;
-          }
-          case 'illegal-byte-sequence': {
-            enum4 = 9;
-            break;
-          }
-          case 'in-progress': {
-            enum4 = 10;
-            break;
-          }
-          case 'interrupted': {
-            enum4 = 11;
-            break;
-          }
-          case 'invalid': {
-            enum4 = 12;
-            break;
-          }
-          case 'io': {
-            enum4 = 13;
-            break;
-          }
-          case 'is-directory': {
-            enum4 = 14;
-            break;
-          }
-          case 'loop': {
-            enum4 = 15;
-            break;
-          }
-          case 'too-many-links': {
-            enum4 = 16;
-            break;
-          }
-          case 'message-size': {
-            enum4 = 17;
-            break;
-          }
-          case 'name-too-long': {
-            enum4 = 18;
-            break;
-          }
-          case 'no-device': {
-            enum4 = 19;
-            break;
-          }
-          case 'no-entry': {
-            enum4 = 20;
-            break;
-          }
-          case 'no-lock': {
-            enum4 = 21;
-            break;
-          }
-          case 'insufficient-memory': {
-            enum4 = 22;
-            break;
-          }
-          case 'insufficient-space': {
-            enum4 = 23;
-            break;
-          }
-          case 'not-directory': {
-            enum4 = 24;
-            break;
-          }
-          case 'not-empty': {
-            enum4 = 25;
-            break;
-          }
-          case 'not-recoverable': {
-            enum4 = 26;
-            break;
-          }
-          case 'unsupported': {
-            enum4 = 27;
-            break;
-          }
-          case 'no-tty': {
-            enum4 = 28;
-            break;
-          }
-          case 'no-such-device': {
-            enum4 = 29;
-            break;
-          }
-          case 'overflow': {
-            enum4 = 30;
-            break;
-          }
-          case 'not-permitted': {
-            enum4 = 31;
-            break;
-          }
-          case 'pipe': {
-            enum4 = 32;
-            break;
-          }
-          case 'read-only': {
-            enum4 = 33;
-            break;
-          }
-          case 'invalid-seek': {
-            enum4 = 34;
-            break;
-          }
-          case 'text-file-busy': {
-            enum4 = 35;
-            break;
-          }
-          case 'cross-device': {
-            enum4 = 36;
-            break;
-          }
-          default: {
-            if ((e) instanceof Error) {
-              console.error(e);
-            }
-            
-            throw new TypeError(`"${val4}" is not one of the cases of error-code`);
-          }
-        }
-        dataView(memory0).setInt8(arg1 + 4, enum4, true);
-        break;
-      }
-      default: {
-        throw new TypeError('invalid variant specified for result');
-      }
-    }
-    _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.append-via-stream"][Instruction::Return]', {
-      funcName: '[method]descriptor.append-via-stream',
-      paramCount: 0,
-      async: false,
-      postReturn: false
-    });
-  }
-  
-  
-  function trampoline20(arg0, arg1) {
-    var handle1 = arg0;
-    var rep2 = handleTable3[(handle1 << 1) + 1] & ~T_FLAG;
-    var rsc0 = captureTable3.get(rep2);
-    if (!rsc0) {
-      rsc0 = Object.create(Descriptor.prototype);
-      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
-      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
-    }
-    curResourceBorrows.push(rsc0);
-    _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.get-type"] [Instruction::CallInterface] (async? sync, @ enter)');
-    const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]descriptor.get-type');
-    let ret;
-    try {
-      ret = { tag: 'ok', val: rsc0.getType()};
-    } catch (e) {
-      ret = { tag: 'err', val: getErrorPayload(e) };
-    }
-    _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.get-type"] [Instruction::CallInterface] (sync, @ post-call)');
-    for (const rsc of curResourceBorrows) {
-      rsc[symbolRscHandle] = undefined;
-    }
-    curResourceBorrows = [];
-    endCurrentTask(0);
-    var variant5 = ret;
-    switch (variant5.tag) {
-      case 'ok': {
-        const e = variant5.val;
-        dataView(memory0).setInt8(arg1 + 0, 0, true);
-        var val3 = e;
-        let enum3;
-        switch (val3) {
-          case 'unknown': {
-            enum3 = 0;
-            break;
-          }
-          case 'block-device': {
-            enum3 = 1;
-            break;
-          }
-          case 'character-device': {
-            enum3 = 2;
-            break;
-          }
-          case 'directory': {
-            enum3 = 3;
-            break;
-          }
-          case 'fifo': {
-            enum3 = 4;
-            break;
-          }
-          case 'symbolic-link': {
-            enum3 = 5;
-            break;
-          }
-          case 'regular-file': {
-            enum3 = 6;
-            break;
-          }
-          case 'socket': {
-            enum3 = 7;
-            break;
-          }
-          default: {
-            if ((e) instanceof Error) {
-              console.error(e);
-            }
-            
-            throw new TypeError(`"${val3}" is not one of the cases of descriptor-type`);
-          }
-        }
-        dataView(memory0).setInt8(arg1 + 1, enum3, true);
-        break;
-      }
-      case 'err': {
-        const e = variant5.val;
-        dataView(memory0).setInt8(arg1 + 0, 1, true);
-        var val4 = e;
-        let enum4;
-        switch (val4) {
-          case 'access': {
-            enum4 = 0;
-            break;
-          }
-          case 'would-block': {
-            enum4 = 1;
-            break;
-          }
-          case 'already': {
-            enum4 = 2;
-            break;
-          }
-          case 'bad-descriptor': {
-            enum4 = 3;
-            break;
-          }
-          case 'busy': {
-            enum4 = 4;
-            break;
-          }
-          case 'deadlock': {
-            enum4 = 5;
-            break;
-          }
-          case 'quota': {
-            enum4 = 6;
-            break;
-          }
-          case 'exist': {
-            enum4 = 7;
-            break;
-          }
-          case 'file-too-large': {
-            enum4 = 8;
-            break;
-          }
-          case 'illegal-byte-sequence': {
-            enum4 = 9;
-            break;
-          }
-          case 'in-progress': {
-            enum4 = 10;
-            break;
-          }
-          case 'interrupted': {
-            enum4 = 11;
-            break;
-          }
-          case 'invalid': {
-            enum4 = 12;
-            break;
-          }
-          case 'io': {
-            enum4 = 13;
-            break;
-          }
-          case 'is-directory': {
-            enum4 = 14;
-            break;
-          }
-          case 'loop': {
-            enum4 = 15;
-            break;
-          }
-          case 'too-many-links': {
-            enum4 = 16;
-            break;
-          }
-          case 'message-size': {
-            enum4 = 17;
-            break;
-          }
-          case 'name-too-long': {
-            enum4 = 18;
-            break;
-          }
-          case 'no-device': {
-            enum4 = 19;
-            break;
-          }
-          case 'no-entry': {
-            enum4 = 20;
-            break;
-          }
-          case 'no-lock': {
-            enum4 = 21;
-            break;
-          }
-          case 'insufficient-memory': {
-            enum4 = 22;
-            break;
-          }
-          case 'insufficient-space': {
-            enum4 = 23;
-            break;
-          }
-          case 'not-directory': {
-            enum4 = 24;
-            break;
-          }
-          case 'not-empty': {
-            enum4 = 25;
-            break;
-          }
-          case 'not-recoverable': {
-            enum4 = 26;
-            break;
-          }
-          case 'unsupported': {
-            enum4 = 27;
-            break;
-          }
-          case 'no-tty': {
-            enum4 = 28;
-            break;
-          }
-          case 'no-such-device': {
-            enum4 = 29;
-            break;
-          }
-          case 'overflow': {
-            enum4 = 30;
-            break;
-          }
-          case 'not-permitted': {
-            enum4 = 31;
-            break;
-          }
-          case 'pipe': {
-            enum4 = 32;
-            break;
-          }
-          case 'read-only': {
-            enum4 = 33;
-            break;
-          }
-          case 'invalid-seek': {
-            enum4 = 34;
-            break;
-          }
-          case 'text-file-busy': {
-            enum4 = 35;
-            break;
-          }
-          case 'cross-device': {
-            enum4 = 36;
-            break;
-          }
-          default: {
-            if ((e) instanceof Error) {
-              console.error(e);
-            }
-            
-            throw new TypeError(`"${val4}" is not one of the cases of error-code`);
-          }
-        }
-        dataView(memory0).setInt8(arg1 + 1, enum4, true);
-        break;
-      }
-      default: {
-        throw new TypeError('invalid variant specified for result');
-      }
-    }
-    _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.get-type"][Instruction::Return]', {
-      funcName: '[method]descriptor.get-type',
-      paramCount: 0,
-      async: false,
-      postReturn: false
-    });
-  }
-  
-  
-  function trampoline21(arg0, arg1) {
-    var handle1 = arg0;
-    var rep2 = handleTable3[(handle1 << 1) + 1] & ~T_FLAG;
-    var rsc0 = captureTable3.get(rep2);
-    if (!rsc0) {
-      rsc0 = Object.create(Descriptor.prototype);
-      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
-      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
-    }
-    curResourceBorrows.push(rsc0);
-    _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.stat"] [Instruction::CallInterface] (async? sync, @ enter)');
-    const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]descriptor.stat');
-    let ret;
-    try {
-      ret = { tag: 'ok', val: rsc0.stat()};
-    } catch (e) {
-      ret = { tag: 'err', val: getErrorPayload(e) };
-    }
-    _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.stat"] [Instruction::CallInterface] (sync, @ post-call)');
-    for (const rsc of curResourceBorrows) {
-      rsc[symbolRscHandle] = undefined;
-    }
-    curResourceBorrows = [];
-    endCurrentTask(0);
-    var variant12 = ret;
-    switch (variant12.tag) {
-      case 'ok': {
-        const e = variant12.val;
-        dataView(memory0).setInt8(arg1 + 0, 0, true);
-        var {type: v3_0, linkCount: v3_1, size: v3_2, dataAccessTimestamp: v3_3, dataModificationTimestamp: v3_4, statusChangeTimestamp: v3_5 } = e;
-        var val4 = v3_0;
-        let enum4;
-        switch (val4) {
-          case 'unknown': {
-            enum4 = 0;
-            break;
-          }
-          case 'block-device': {
-            enum4 = 1;
-            break;
-          }
-          case 'character-device': {
-            enum4 = 2;
-            break;
-          }
-          case 'directory': {
-            enum4 = 3;
-            break;
-          }
-          case 'fifo': {
-            enum4 = 4;
-            break;
-          }
-          case 'symbolic-link': {
-            enum4 = 5;
-            break;
-          }
-          case 'regular-file': {
-            enum4 = 6;
-            break;
-          }
-          case 'socket': {
-            enum4 = 7;
-            break;
-          }
-          default: {
-            if ((v3_0) instanceof Error) {
-              console.error(v3_0);
-            }
-            
-            throw new TypeError(`"${val4}" is not one of the cases of descriptor-type`);
-          }
-        }
-        dataView(memory0).setInt8(arg1 + 8, enum4, true);
-        dataView(memory0).setBigInt64(arg1 + 16, toUint64(v3_1), true);
-        dataView(memory0).setBigInt64(arg1 + 24, toUint64(v3_2), true);
-        var variant6 = v3_3;
-        if (variant6 === null || variant6=== undefined) {
-          dataView(memory0).setInt8(arg1 + 32, 0, true);
-        } else {
-          const e = variant6;
-          dataView(memory0).setInt8(arg1 + 32, 1, true);
-          var {seconds: v5_0, nanoseconds: v5_1 } = e;
-          dataView(memory0).setBigInt64(arg1 + 40, toUint64(v5_0), true);
-          dataView(memory0).setInt32(arg1 + 48, toUint32(v5_1), true);
-        }
-        var variant8 = v3_4;
-        if (variant8 === null || variant8=== undefined) {
-          dataView(memory0).setInt8(arg1 + 56, 0, true);
-        } else {
-          const e = variant8;
-          dataView(memory0).setInt8(arg1 + 56, 1, true);
-          var {seconds: v7_0, nanoseconds: v7_1 } = e;
-          dataView(memory0).setBigInt64(arg1 + 64, toUint64(v7_0), true);
-          dataView(memory0).setInt32(arg1 + 72, toUint32(v7_1), true);
-        }
-        var variant10 = v3_5;
-        if (variant10 === null || variant10=== undefined) {
-          dataView(memory0).setInt8(arg1 + 80, 0, true);
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (typeof module !== 'undefined') {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
         } else {
-          const e = variant10;
-          dataView(memory0).setInt8(arg1 + 80, 1, true);
-          var {seconds: v9_0, nanoseconds: v9_1 } = e;
-          dataView(memory0).setBigInt64(arg1 + 88, toUint64(v9_0), true);
-          dataView(memory0).setInt32(arg1 + 96, toUint32(v9_1), true);
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
         }
-        break;
-      }
-      case 'err': {
-        const e = variant12.val;
-        dataView(memory0).setInt8(arg1 + 0, 1, true);
-        var val11 = e;
-        let enum11;
-        switch (val11) {
-          case 'access': {
-            enum11 = 0;
-            break;
-          }
-          case 'would-block': {
-            enum11 = 1;
-            break;
-          }
-          case 'already': {
-            enum11 = 2;
-            break;
-          }
-          case 'bad-descriptor': {
-            enum11 = 3;
-            break;
-          }
-          case 'busy': {
-            enum11 = 4;
-            break;
-          }
-          case 'deadlock': {
-            enum11 = 5;
-            break;
-          }
-          case 'quota': {
-            enum11 = 6;
-            break;
-          }
-          case 'exist': {
-            enum11 = 7;
-            break;
-          }
-          case 'file-too-large': {
-            enum11 = 8;
-            break;
-          }
-          case 'illegal-byte-sequence': {
-            enum11 = 9;
-            break;
-          }
-          case 'in-progress': {
-            enum11 = 10;
-            break;
-          }
-          case 'interrupted': {
-            enum11 = 11;
-            break;
-          }
-          case 'invalid': {
-            enum11 = 12;
-            break;
-          }
-          case 'io': {
-            enum11 = 13;
-            break;
-          }
-          case 'is-directory': {
-            enum11 = 14;
-            break;
-          }
-          case 'loop': {
-            enum11 = 15;
-            break;
-          }
-          case 'too-many-links': {
-            enum11 = 16;
-            break;
-          }
-          case 'message-size': {
-            enum11 = 17;
-            break;
-          }
-          case 'name-too-long': {
-            enum11 = 18;
-            break;
-          }
-          case 'no-device': {
-            enum11 = 19;
-            break;
-          }
-          case 'no-entry': {
-            enum11 = 20;
-            break;
-          }
-          case 'no-lock': {
-            enum11 = 21;
-            break;
-          }
-          case 'insufficient-memory': {
-            enum11 = 22;
-            break;
-          }
-          case 'insufficient-space': {
-            enum11 = 23;
-            break;
-          }
-          case 'not-directory': {
-            enum11 = 24;
-            break;
-          }
-          case 'not-empty': {
-            enum11 = 25;
-            break;
-          }
-          case 'not-recoverable': {
-            enum11 = 26;
-            break;
-          }
-          case 'unsupported': {
-            enum11 = 27;
-            break;
-          }
-          case 'no-tty': {
-            enum11 = 28;
-            break;
-          }
-          case 'no-such-device': {
-            enum11 = 29;
-            break;
-          }
-          case 'overflow': {
-            enum11 = 30;
-            break;
-          }
-          case 'not-permitted': {
-            enum11 = 31;
-            break;
-          }
-          case 'pipe': {
-            enum11 = 32;
-            break;
-          }
-          case 'read-only': {
-            enum11 = 33;
-            break;
-          }
-          case 'invalid-seek': {
-            enum11 = 34;
-            break;
-          }
-          case 'text-file-busy': {
-            enum11 = 35;
-            break;
-          }
-          case 'cross-device': {
-            enum11 = 36;
-            break;
-          }
-          default: {
-            if ((e) instanceof Error) {
-              console.error(e);
-            }
-            
-            throw new TypeError(`"${val11}" is not one of the cases of error-code`);
-          }
-        }
-        dataView(memory0).setInt8(arg1 + 8, enum11, true);
-        break;
-      }
-      default: {
-        throw new TypeError('invalid variant specified for result');
-      }
-    }
-    _debugLog('[iface="wasi:filesystem/types@0.2.3", function="[method]descriptor.stat"][Instruction::Return]', {
-      funcName: '[method]descriptor.stat',
-      paramCount: 0,
-      async: false,
-      postReturn: false
-    });
-  }
-  
-  
-  function trampoline22(arg0, arg1) {
-    var handle1 = arg0;
-    var rep2 = handleTable1[(handle1 << 1) + 1] & ~T_FLAG;
-    var rsc0 = captureTable1.get(rep2);
-    if (!rsc0) {
-      rsc0 = Object.create(OutputStream.prototype);
-      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
-      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
-    }
-    curResourceBorrows.push(rsc0);
-    _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.check-write"] [Instruction::CallInterface] (async? sync, @ enter)');
-    const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]output-stream.check-write');
-    let ret;
-    try {
-      ret = { tag: 'ok', val: rsc0.checkWrite()};
-    } catch (e) {
-      ret = { tag: 'err', val: getErrorPayload(e) };
-    }
-    _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.check-write"] [Instruction::CallInterface] (sync, @ post-call)');
-    for (const rsc of curResourceBorrows) {
-      rsc[symbolRscHandle] = undefined;
-    }
-    curResourceBorrows = [];
-    endCurrentTask(0);
-    var variant5 = ret;
-    switch (variant5.tag) {
-      case 'ok': {
-        const e = variant5.val;
-        dataView(memory0).setInt8(arg1 + 0, 0, true);
-        dataView(memory0).setBigInt64(arg1 + 8, toUint64(e), true);
-        break;
-      }
-      case 'err': {
-        const e = variant5.val;
-        dataView(memory0).setInt8(arg1 + 0, 1, true);
-        var variant4 = e;
-        switch (variant4.tag) {
-          case 'last-operation-failed': {
-            const e = variant4.val;
-            dataView(memory0).setInt8(arg1 + 8, 0, true);
-            if (!(e instanceof Error$1)) {
-              throw new TypeError('Resource error: Not a valid "Error" resource.');
-            }
-            var handle3 = e[symbolRscHandle];
-            if (!handle3) {
-              const rep = e[symbolRscRep] || ++captureCnt0;
-              captureTable0.set(rep, e);
-              handle3 = rscTableCreateOwn(handleTable0, rep);
-            }
-            dataView(memory0).setInt32(arg1 + 12, handle3, true);
-            break;
-          }
-          case 'closed': {
-            dataView(memory0).setInt8(arg1 + 8, 1, true);
-            break;
-          }
-          default: {
-            throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant4.tag)}\` (received \`${variant4}\`) specified for \`StreamError\``);
-          }
-        }
-        break;
-      }
-      default: {
-        throw new TypeError('invalid variant specified for result');
-      }
-    }
-    _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.check-write"][Instruction::Return]', {
-      funcName: '[method]output-stream.check-write',
-      paramCount: 0,
-      async: false,
-      postReturn: false
-    });
-  }
-  
-  
-  function trampoline23(arg0, arg1, arg2, arg3) {
-    var handle1 = arg0;
-    var rep2 = handleTable1[(handle1 << 1) + 1] & ~T_FLAG;
-    var rsc0 = captureTable1.get(rep2);
-    if (!rsc0) {
-      rsc0 = Object.create(OutputStream.prototype);
-      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
-      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
-    }
-    curResourceBorrows.push(rsc0);
-    var ptr3 = arg1;
-    var len3 = arg2;
-    var result3 = new Uint8Array(memory0.buffer.slice(ptr3, ptr3 + len3 * 1));
-    _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.write"] [Instruction::CallInterface] (async? sync, @ enter)');
-    const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]output-stream.write');
-    let ret;
-    try {
-      ret = { tag: 'ok', val: rsc0.write(result3)};
-    } catch (e) {
-      ret = { tag: 'err', val: getErrorPayload(e) };
-    }
-    _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.write"] [Instruction::CallInterface] (sync, @ post-call)');
-    for (const rsc of curResourceBorrows) {
-      rsc[symbolRscHandle] = undefined;
-    }
-    curResourceBorrows = [];
-    endCurrentTask(0);
-    var variant6 = ret;
-    switch (variant6.tag) {
-      case 'ok': {
-        const e = variant6.val;
-        dataView(memory0).setInt8(arg3 + 0, 0, true);
-        break;
-      }
-      case 'err': {
-        const e = variant6.val;
-        dataView(memory0).setInt8(arg3 + 0, 1, true);
-        var variant5 = e;
-        switch (variant5.tag) {
-          case 'last-operation-failed': {
-            const e = variant5.val;
-            dataView(memory0).setInt8(arg3 + 4, 0, true);
-            if (!(e instanceof Error$1)) {
-              throw new TypeError('Resource error: Not a valid "Error" resource.');
-            }
-            var handle4 = e[symbolRscHandle];
-            if (!handle4) {
-              const rep = e[symbolRscRep] || ++captureCnt0;
-              captureTable0.set(rep, e);
-              handle4 = rscTableCreateOwn(handleTable0, rep);
-            }
-            dataView(memory0).setInt32(arg3 + 8, handle4, true);
-            break;
-          }
-          case 'closed': {
-            dataView(memory0).setInt8(arg3 + 4, 1, true);
-            break;
-          }
-          default: {
-            throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant5.tag)}\` (received \`${variant5}\`) specified for \`StreamError\``);
-          }
-        }
-        break;
-      }
-      default: {
-        throw new TypeError('invalid variant specified for result');
-      }
-    }
-    _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.write"][Instruction::Return]', {
-      funcName: '[method]output-stream.write',
-      paramCount: 0,
-      async: false,
-      postReturn: false
-    });
-  }
-  
-  
-  function trampoline24(arg0, arg1) {
-    var handle1 = arg0;
-    var rep2 = handleTable1[(handle1 << 1) + 1] & ~T_FLAG;
-    var rsc0 = captureTable1.get(rep2);
-    if (!rsc0) {
-      rsc0 = Object.create(OutputStream.prototype);
-      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
-      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
     }
-    curResourceBorrows.push(rsc0);
-    _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.blocking-flush"] [Instruction::CallInterface] (async? sync, @ enter)');
-    const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]output-stream.blocking-flush');
-    let ret;
-    try {
-      ret = { tag: 'ok', val: rsc0.blockingFlush()};
-    } catch (e) {
-      ret = { tag: 'err', val: getErrorPayload(e) };
-    }
-    _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.blocking-flush"] [Instruction::CallInterface] (sync, @ post-call)');
-    for (const rsc of curResourceBorrows) {
-      rsc[symbolRscHandle] = undefined;
-    }
-    curResourceBorrows = [];
-    endCurrentTask(0);
-    var variant5 = ret;
-    switch (variant5.tag) {
-      case 'ok': {
-        const e = variant5.val;
-        dataView(memory0).setInt8(arg1 + 0, 0, true);
-        break;
-      }
-      case 'err': {
-        const e = variant5.val;
-        dataView(memory0).setInt8(arg1 + 0, 1, true);
-        var variant4 = e;
-        switch (variant4.tag) {
-          case 'last-operation-failed': {
-            const e = variant4.val;
-            dataView(memory0).setInt8(arg1 + 4, 0, true);
-            if (!(e instanceof Error$1)) {
-              throw new TypeError('Resource error: Not a valid "Error" resource.');
-            }
-            var handle3 = e[symbolRscHandle];
-            if (!handle3) {
-              const rep = e[symbolRscRep] || ++captureCnt0;
-              captureTable0.set(rep, e);
-              handle3 = rscTableCreateOwn(handleTable0, rep);
-            }
-            dataView(memory0).setInt32(arg1 + 8, handle3, true);
-            break;
-          }
-          case 'closed': {
-            dataView(memory0).setInt8(arg1 + 4, 1, true);
-            break;
-          }
-          default: {
-            throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant4.tag)}\` (received \`${variant4}\`) specified for \`StreamError\``);
-          }
-        }
-        break;
-      }
-      default: {
-        throw new TypeError('invalid variant specified for result');
-      }
-    }
-    _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.blocking-flush"][Instruction::Return]', {
-      funcName: '[method]output-stream.blocking-flush',
-      paramCount: 0,
-      async: false,
-      postReturn: false
-    });
-  }
-  
-  
-  function trampoline25(arg0, arg1, arg2, arg3) {
-    var handle1 = arg0;
-    var rep2 = handleTable1[(handle1 << 1) + 1] & ~T_FLAG;
-    var rsc0 = captureTable1.get(rep2);
-    if (!rsc0) {
-      rsc0 = Object.create(OutputStream.prototype);
-      Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
-      Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
-    }
-    curResourceBorrows.push(rsc0);
-    var ptr3 = arg1;
-    var len3 = arg2;
-    var result3 = new Uint8Array(memory0.buffer.slice(ptr3, ptr3 + len3 * 1));
-    _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.blocking-write-and-flush"] [Instruction::CallInterface] (async? sync, @ enter)');
-    const _interface_call_currentTaskID = startCurrentTask(0, false, '[method]output-stream.blocking-write-and-flush');
-    let ret;
-    try {
-      ret = { tag: 'ok', val: rsc0.blockingWriteAndFlush(result3)};
-    } catch (e) {
-      ret = { tag: 'err', val: getErrorPayload(e) };
-    }
-    _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.blocking-write-and-flush"] [Instruction::CallInterface] (sync, @ post-call)');
-    for (const rsc of curResourceBorrows) {
-      rsc[symbolRscHandle] = undefined;
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
     }
-    curResourceBorrows = [];
-    endCurrentTask(0);
-    var variant6 = ret;
-    switch (variant6.tag) {
-      case 'ok': {
-        const e = variant6.val;
-        dataView(memory0).setInt8(arg3 + 0, 0, true);
-        break;
-      }
-      case 'err': {
-        const e = variant6.val;
-        dataView(memory0).setInt8(arg3 + 0, 1, true);
-        var variant5 = e;
-        switch (variant5.tag) {
-          case 'last-operation-failed': {
-            const e = variant5.val;
-            dataView(memory0).setInt8(arg3 + 4, 0, true);
-            if (!(e instanceof Error$1)) {
-              throw new TypeError('Resource error: Not a valid "Error" resource.');
-            }
-            var handle4 = e[symbolRscHandle];
-            if (!handle4) {
-              const rep = e[symbolRscRep] || ++captureCnt0;
-              captureTable0.set(rep, e);
-              handle4 = rscTableCreateOwn(handleTable0, rep);
-            }
-            dataView(memory0).setInt32(arg3 + 8, handle4, true);
-            break;
-          }
-          case 'closed': {
-            dataView(memory0).setInt8(arg3 + 4, 1, true);
-            break;
-          }
-          default: {
-            throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant5.tag)}\` (received \`${variant5}\`) specified for \`StreamError\``);
-          }
+    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')
         }
-        break;
-      }
-      default: {
-        throw new TypeError('invalid variant specified for result');
-      }
-    }
-    _debugLog('[iface="wasi:io/streams@0.2.3", function="[method]output-stream.blocking-write-and-flush"][Instruction::Return]', {
-      funcName: '[method]output-stream.blocking-write-and-flush',
-      paramCount: 0,
-      async: false,
-      postReturn: false
-    });
-  }
-  
-  
-  function trampoline26(arg0) {
-    _debugLog('[iface="wasi:filesystem/preopens@0.2.3", function="get-directories"] [Instruction::CallInterface] (async? sync, @ enter)');
-    const _interface_call_currentTaskID = startCurrentTask(0, false, 'get-directories');
-    const ret = getDirectories();
-    _debugLog('[iface="wasi:filesystem/preopens@0.2.3", function="get-directories"] [Instruction::CallInterface] (sync, @ post-call)');
-    endCurrentTask(0);
-    var vec3 = ret;
-    var len3 = vec3.length;
-    var result3 = realloc1(0, 0, 4, len3 * 12);
-    for (let i = 0; i < vec3.length; i++) {
-      const e = vec3[i];
-      const base = result3 + i * 12;var [tuple0_0, tuple0_1] = e;
-      if (!(tuple0_0 instanceof Descriptor)) {
-        throw new TypeError('Resource error: Not a valid "Descriptor" resource.');
-      }
-      var handle1 = tuple0_0[symbolRscHandle];
-      if (!handle1) {
-        const rep = tuple0_0[symbolRscRep] || ++captureCnt3;
-        captureTable3.set(rep, tuple0_0);
-        handle1 = rscTableCreateOwn(handleTable3, rep);
-      }
-      dataView(memory0).setInt32(base + 0, handle1, true);
-      var ptr2 = utf8Encode(tuple0_1, realloc1, memory0);
-      var len2 = utf8EncodedLen;
-      dataView(memory0).setUint32(base + 8, len2, true);
-      dataView(memory0).setUint32(base + 4, ptr2, true);
-    }
-    dataView(memory0).setUint32(arg0 + 4, len3, true);
-    dataView(memory0).setUint32(arg0 + 0, result3, true);
-    _debugLog('[iface="wasi:filesystem/preopens@0.2.3", function="get-directories"][Instruction::Return]', {
-      funcName: 'get-directories',
-      paramCount: 0,
-      async: false,
-      postReturn: false
-    });
-  }
-  
-  let exports3;
-  let postReturn0;
-  let postReturn1;
-  function trampoline3(handle) {
-    const handleEntry = rscTableRemove(handleTable3, handle);
-    if (handleEntry.own) {
-      
-      const rsc = captureTable3.get(handleEntry.rep);
-      if (rsc) {
-        if (rsc[symbolDispose]) rsc[symbolDispose]();
-        captureTable3.delete(handleEntry.rep);
-      } else if (Descriptor[symbolCabiDispose]) {
-        Descriptor[symbolCabiDispose](handleEntry.rep);
-      }
-    }
-  }
-  function trampoline4(handle) {
-    const handleEntry = rscTableRemove(handleTable1, handle);
-    if (handleEntry.own) {
-      
-      const rsc = captureTable1.get(handleEntry.rep);
-      if (rsc) {
-        if (rsc[symbolDispose]) rsc[symbolDispose]();
-        captureTable1.delete(handleEntry.rep);
-      } else if (OutputStream[symbolCabiDispose]) {
-        OutputStream[symbolCabiDispose](handleEntry.rep);
-      }
-    }
-  }
-  function trampoline5(handle) {
-    const handleEntry = rscTableRemove(handleTable0, handle);
-    if (handleEntry.own) {
-      
-      const rsc = captureTable0.get(handleEntry.rep);
-      if (rsc) {
-        if (rsc[symbolDispose]) rsc[symbolDispose]();
-        captureTable0.delete(handleEntry.rep);
-      } else if (Error$1[symbolCabiDispose]) {
-        Error$1[symbolCabiDispose](handleEntry.rep);
-      }
-    }
-  }
-  function trampoline6(handle) {
-    const handleEntry = rscTableRemove(handleTable2, handle);
-    if (handleEntry.own) {
-      
-      const rsc = captureTable2.get(handleEntry.rep);
-      if (rsc) {
-        if (rsc[symbolDispose]) rsc[symbolDispose]();
-        captureTable2.delete(handleEntry.rep);
-      } else if (InputStream[symbolCabiDispose]) {
-        InputStream[symbolCabiDispose](handleEntry.rep);
-      }
-    }
-  }
-  Promise.all([module0, module1, module2, module3]).catch(() => {});
-  ({ exports: exports0 } = yield instantiateCore(yield module2));
-  ({ exports: exports1 } = yield instantiateCore(yield module0, {
-    'arborium:host/plugin-provider@0.1.0': {
-      'create-plugin-session': trampoline2,
-      'free-plugin-session': trampoline1,
-      'get-injection-languages': exports0['4'],
-      'load-plugin': exports0['0'],
-      'plugin-apply-edit': exports0['3'],
-      'plugin-cancel': trampoline0,
-      'plugin-parse': exports0['1'],
-      'plugin-set-text': exports0['2'],
-    },
-    wasi_snapshot_preview1: {
-      environ_get: exports0['6'],
-      environ_sizes_get: exports0['7'],
-      fd_write: exports0['5'],
-      proc_exit: exports0['8'],
-    },
-  }));
-  ({ exports: exports2 } = yield instantiateCore(yield module1, {
-    __main_module__: {
-      cabi_realloc: exports1.cabi_realloc,
-    },
-    env: {
-      memory: exports1.memory,
-    },
-    'wasi:cli/environment@0.2.3': {
-      'get-environment': exports0['9'],
-    },
-    'wasi:cli/exit@0.2.3': {
-      exit: trampoline10,
-    },
-    'wasi:cli/stderr@0.2.3': {
-      'get-stderr': trampoline7,
-    },
-    'wasi:cli/stdin@0.2.3': {
-      'get-stdin': trampoline8,
-    },
-    'wasi:cli/stdout@0.2.3': {
-      'get-stdout': trampoline9,
-    },
-    'wasi:filesystem/preopens@0.2.2': {
-      'get-directories': exports0['19'],
-    },
-    'wasi:filesystem/types@0.2.3': {
-      '[method]descriptor.append-via-stream': exports0['12'],
-      '[method]descriptor.get-type': exports0['13'],
-      '[method]descriptor.stat': exports0['14'],
-      '[method]descriptor.write-via-stream': exports0['11'],
-      '[resource-drop]descriptor': trampoline3,
-      'filesystem-error-code': exports0['10'],
-    },
-    'wasi:io/error@0.2.3': {
-      '[resource-drop]error': trampoline5,
-    },
-    'wasi:io/streams@0.2.3': {
-      '[method]output-stream.blocking-flush': exports0['17'],
-      '[method]output-stream.blocking-write-and-flush': exports0['18'],
-      '[method]output-stream.check-write': exports0['15'],
-      '[method]output-stream.write': exports0['16'],
-      '[resource-drop]input-stream': trampoline6,
-      '[resource-drop]output-stream': trampoline4,
-    },
-  }));
-  memory0 = exports1.memory;
-  realloc0 = exports1.cabi_realloc;
-  realloc1 = exports2.cabi_import_realloc;
-  ({ exports: exports3 } = yield instantiateCore(yield module3, {
-    '': {
-      $imports: exports0.$imports,
-      '0': trampoline11,
-      '1': trampoline12,
-      '10': trampoline17,
-      '11': trampoline18,
-      '12': trampoline19,
-      '13': trampoline20,
-      '14': trampoline21,
-      '15': trampoline22,
-      '16': trampoline23,
-      '17': trampoline24,
-      '18': trampoline25,
-      '19': trampoline26,
-      '2': trampoline13,
-      '3': trampoline14,
-      '4': trampoline15,
-      '5': exports2.fd_write,
-      '6': exports2.environ_get,
-      '7': exports2.environ_sizes_get,
-      '8': exports2.proc_exit,
-      '9': trampoline16,
-    },
-  }));
-  postReturn0 = exports1['cabi_post_arborium:host/host@0.1.0#highlight'];
-  postReturn1 = exports1['cabi_post_arborium:host/host@0.1.0#get-required-languages'];
-  let host010CreateDocument;
-  
-  function createDocument(arg0) {
-    var ptr0 = utf8Encode(arg0, realloc0, memory0);
-    var len0 = utf8EncodedLen;
-    _debugLog('[iface="arborium:host/host@0.1.0", function="create-document"][Instruction::CallWasm] enter', {
-      funcName: 'create-document',
-      paramCount: 2,
-      async: false,
-      postReturn: false,
-    });
-    const _wasm_call_currentTaskID = startCurrentTask(0, false, 'host010CreateDocument');
-    const ret = host010CreateDocument(ptr0, len0);
-    endCurrentTask(0);
-    let variant1;
-    switch (dataView(memory0).getUint8(ret + 0, true)) {
-      case 0: {
-        variant1 = undefined;
-        break;
-      }
-      case 1: {
-        variant1 = dataView(memory0).getInt32(ret + 4, true) >>> 0;
-        break;
-      }
-      default: {
-        throw new TypeError('invalid variant discriminant for option');
-      }
     }
-    _debugLog('[iface="arborium:host/host@0.1.0", function="create-document"][Instruction::Return]', {
-      funcName: 'create-document',
-      paramCount: 1,
-      async: false,
-      postReturn: false
-    });
-    return variant1;
-  }
-  let host010FreeDocument;
-  
-  function freeDocument(arg0) {
-    _debugLog('[iface="arborium:host/host@0.1.0", function="free-document"][Instruction::CallWasm] enter', {
-      funcName: 'free-document',
-      paramCount: 1,
-      async: false,
-      postReturn: false,
-    });
-    const _wasm_call_currentTaskID = startCurrentTask(0, false, 'host010FreeDocument');
-    host010FreeDocument(toUint32(arg0));
-    endCurrentTask(0);
-    _debugLog('[iface="arborium:host/host@0.1.0", function="free-document"][Instruction::Return]', {
-      funcName: 'free-document',
-      paramCount: 0,
-      async: false,
-      postReturn: false
-    });
-  }
-  let host010SetText;
-  
-  function setText(arg0, arg1) {
-    var ptr0 = utf8Encode(arg1, realloc0, memory0);
-    var len0 = utf8EncodedLen;
-    _debugLog('[iface="arborium:host/host@0.1.0", function="set-text"][Instruction::CallWasm] enter', {
-      funcName: 'set-text',
-      paramCount: 3,
-      async: false,
-      postReturn: false,
-    });
-    const _wasm_call_currentTaskID = startCurrentTask(0, false, 'host010SetText');
-    host010SetText(toUint32(arg0), ptr0, len0);
-    endCurrentTask(0);
-    _debugLog('[iface="arborium:host/host@0.1.0", function="set-text"][Instruction::Return]', {
-      funcName: 'set-text',
-      paramCount: 0,
-      async: false,
-      postReturn: false
-    });
-  }
-  let host010ApplyEdit;
-  
-  function applyEdit(arg0, arg1, arg2) {
-    var ptr0 = utf8Encode(arg1, realloc0, memory0);
-    var len0 = utf8EncodedLen;
-    var {startByte: v1_0, oldEndByte: v1_1, newEndByte: v1_2, startRow: v1_3, startCol: v1_4, oldEndRow: v1_5, oldEndCol: v1_6, newEndRow: v1_7, newEndCol: v1_8 } = arg2;
-    _debugLog('[iface="arborium:host/host@0.1.0", function="apply-edit"][Instruction::CallWasm] enter', {
-      funcName: 'apply-edit',
-      paramCount: 12,
-      async: false,
-      postReturn: false,
-    });
-    const _wasm_call_currentTaskID = startCurrentTask(0, false, 'host010ApplyEdit');
-    host010ApplyEdit(toUint32(arg0), ptr0, len0, toUint32(v1_0), toUint32(v1_1), toUint32(v1_2), toUint32(v1_3), toUint32(v1_4), toUint32(v1_5), toUint32(v1_6), toUint32(v1_7), toUint32(v1_8));
-    endCurrentTask(0);
-    _debugLog('[iface="arborium:host/host@0.1.0", function="apply-edit"][Instruction::Return]', {
-      funcName: 'apply-edit',
-      paramCount: 0,
-      async: false,
-      postReturn: false
-    });
-  }
-  let host010Highlight;
-  
-  function highlight(arg0, arg1) {
-    _debugLog('[iface="arborium:host/host@0.1.0", function="highlight"][Instruction::CallWasm] enter', {
-      funcName: 'highlight',
-      paramCount: 2,
-      async: false,
-      postReturn: true,
-    });
-    const _wasm_call_currentTaskID = startCurrentTask(0, false, 'host010Highlight');
-    const ret = host010Highlight(toUint32(arg0), toUint32(arg1));
-    endCurrentTask(0);
-    var len2 = dataView(memory0).getUint32(ret + 4, true);
-    var base2 = dataView(memory0).getUint32(ret + 0, true);
-    var result2 = [];
-    for (let i = 0; i < len2; i++) {
-      const base = base2 + i * 24;
-      var ptr0 = dataView(memory0).getUint32(base + 8, true);
-      var len0 = dataView(memory0).getUint32(base + 12, true);
-      var result0 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr0, len0));
-      var ptr1 = dataView(memory0).getUint32(base + 16, true);
-      var len1 = dataView(memory0).getUint32(base + 20, true);
-      var result1 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr1, len1));
-      result2.push({
-        start: dataView(memory0).getInt32(base + 0, true) >>> 0,
-        end: dataView(memory0).getInt32(base + 4, true) >>> 0,
-        capture: result0,
-        language: result1,
-      });
-    }
-    _debugLog('[iface="arborium:host/host@0.1.0", function="highlight"][Instruction::Return]', {
-      funcName: 'highlight',
-      paramCount: 1,
-      async: false,
-      postReturn: true
-    });
-    const retCopy = {
-      spans: result2,
-    };
-    
-    let cstate = getOrCreateAsyncState(0);
-    cstate.mayLeave = false;
-    postReturn0(ret);
-    cstate.mayLeave = true;
-    return retCopy;
-    
-  }
-  let host010Cancel;
-  
-  function cancel(arg0) {
-    _debugLog('[iface="arborium:host/host@0.1.0", function="cancel"][Instruction::CallWasm] enter', {
-      funcName: 'cancel',
-      paramCount: 1,
-      async: false,
-      postReturn: false,
-    });
-    const _wasm_call_currentTaskID = startCurrentTask(0, false, 'host010Cancel');
-    host010Cancel(toUint32(arg0));
-    endCurrentTask(0);
-    _debugLog('[iface="arborium:host/host@0.1.0", function="cancel"][Instruction::Return]', {
-      funcName: 'cancel',
-      paramCount: 0,
-      async: false,
-      postReturn: false
-    });
-  }
-  let host010GetRequiredLanguages;
-  
-  function getRequiredLanguages(arg0) {
-    _debugLog('[iface="arborium:host/host@0.1.0", function="get-required-languages"][Instruction::CallWasm] enter', {
-      funcName: 'get-required-languages',
-      paramCount: 1,
-      async: false,
-      postReturn: true,
-    });
-    const _wasm_call_currentTaskID = startCurrentTask(0, false, 'host010GetRequiredLanguages');
-    const ret = host010GetRequiredLanguages(toUint32(arg0));
-    endCurrentTask(0);
-    var len1 = dataView(memory0).getUint32(ret + 4, true);
-    var base1 = dataView(memory0).getUint32(ret + 0, true);
-    var result1 = [];
-    for (let i = 0; i < len1; i++) {
-      const base = base1 + i * 8;
-      var ptr0 = dataView(memory0).getUint32(base + 0, true);
-      var len0 = dataView(memory0).getUint32(base + 4, true);
-      var result0 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr0, len0));
-      result1.push(result0);
+
+    if (typeof module_or_path === 'undefined') {
+        module_or_path = new URL('arborium_host_bg.wasm', import.meta.url);
     }
-    _debugLog('[iface="arborium:host/host@0.1.0", function="get-required-languages"][Instruction::Return]', {
-      funcName: 'get-required-languages',
-      paramCount: 1,
-      async: false,
-      postReturn: true
-    });
-    const retCopy = result1;
-    
-    let cstate = getOrCreateAsyncState(0);
-    cstate.mayLeave = false;
-    postReturn1(ret);
-    cstate.mayLeave = true;
-    return retCopy;
-    
-  }
-  host010CreateDocument = exports1['arborium:host/host@0.1.0#create-document'];
-  host010FreeDocument = exports1['arborium:host/host@0.1.0#free-document'];
-  host010SetText = exports1['arborium:host/host@0.1.0#set-text'];
-  host010ApplyEdit = exports1['arborium:host/host@0.1.0#apply-edit'];
-  host010Highlight = exports1['arborium:host/host@0.1.0#highlight'];
-  host010Cancel = exports1['arborium:host/host@0.1.0#cancel'];
-  host010GetRequiredLanguages = exports1['arborium:host/host@0.1.0#get-required-languages'];
-  const host010 = {
-    applyEdit: applyEdit,
-    cancel: cancel,
-    createDocument: createDocument,
-    freeDocument: freeDocument,
-    getRequiredLanguages: getRequiredLanguages,
-    highlight: highlight,
-    setText: setText,
-    
-  };
-  
-  return { host: host010, 'arborium:host/host@0.1.0': host010,  };
-})();
-let promise, resolve, reject;
-function runNext (value) {
-  try {
-    let done;
-    do {
-      ({ value, done } = gen.next(value));
-    } while (!(value instanceof Promise) && !done);
-    if (done) {
-      if (resolve) return resolve(value);
-      else return value;
+    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);
     }
-    if (!promise) promise = new Promise((_resolve, _reject) => (resolve = _resolve, reject = _reject));
-    value.then(nextVal => done ? resolve() : runNext(nextVal), reject);
-  }
-  catch (e) {
-    if (reject) reject(e);
-    else throw e;
-  }
-}
-const maybeSyncReturn = runNext(null);
-return promise || maybeSyncReturn;
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
 }
+
+export { initSync };
+export default __wbg_init;