@agorapete/wllama 3.5.1-q2.0

package/esm/index.js

@@ -0,0 +1,3387 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
+
+// src/glue/messages.ts
+var GLUE_VERSION = 1;
+var GLUE_MESSAGE_PROTOTYPES = {
+  "erro_evt": {
+    "name": "erro_evt",
+    "structName": "glue_msg_error",
+    "className": "GlueMsgError",
+    "fields": [
+      {
+        "type": "str",
+        "name": "message",
+        "isNullable": false
+      }
+    ]
+  },
+  "load_req": {
+    "name": "load_req",
+    "structName": "glue_msg_load_req",
+    "className": "GlueMsgLoadReq",
+    "fields": [
+      {
+        "type": "arr_str",
+        "name": "model_paths",
+        "isNullable": false
+      },
+      {
+        "type": "str",
+        "name": "mmproj_path",
+        "isNullable": true
+      },
+      {
+        "type": "bool",
+        "name": "n_ctx_auto",
+        "isNullable": false
+      },
+      {
+        "type": "bool",
+        "name": "use_mmap",
+        "isNullable": false
+      },
+      {
+        "type": "bool",
+        "name": "use_mlock",
+        "isNullable": false
+      },
+      {
+        "type": "int",
+        "name": "n_gpu_layers",
+        "isNullable": false
+      },
+      {
+        "type": "int",
+        "name": "n_ctx",
+        "isNullable": false
+      },
+      {
+        "type": "int",
+        "name": "n_threads",
+        "isNullable": false
+      },
+      {
+        "type": "str",
+        "name": "model_alias",
+        "isNullable": true
+      },
+      {
+        "type": "int",
+        "name": "log_level",
+        "isNullable": true
+      },
+      {
+        "type": "bool",
+        "name": "embeddings",
+        "isNullable": true
+      },
+      {
+        "type": "bool",
+        "name": "offload_kqv",
+        "isNullable": true
+      },
+      {
+        "type": "int",
+        "name": "n_batch",
+        "isNullable": true
+      },
+      {
+        "type": "int",
+        "name": "n_ubatch",
+        "isNullable": true
+      },
+      {
+        "type": "int",
+        "name": "n_parallel",
+        "isNullable": true
+      },
+      {
+        "type": "str",
+        "name": "pooling_type",
+        "isNullable": true
+      },
+      {
+        "type": "str",
+        "name": "rope_scaling_type",
+        "isNullable": true
+      },
+      {
+        "type": "float",
+        "name": "rope_freq_base",
+        "isNullable": true
+      },
+      {
+        "type": "float",
+        "name": "rope_freq_scale",
+        "isNullable": true
+      },
+      {
+        "type": "float",
+        "name": "yarn_ext_factor",
+        "isNullable": true
+      },
+      {
+        "type": "float",
+        "name": "yarn_attn_factor",
+        "isNullable": true
+      },
+      {
+        "type": "float",
+        "name": "yarn_beta_fast",
+        "isNullable": true
+      },
+      {
+        "type": "float",
+        "name": "yarn_beta_slow",
+        "isNullable": true
+      },
+      {
+        "type": "int",
+        "name": "yarn_orig_ctx",
+        "isNullable": true
+      },
+      {
+        "type": "str",
+        "name": "cache_type_k",
+        "isNullable": true
+      },
+      {
+        "type": "str",
+        "name": "cache_type_v",
+        "isNullable": true
+      },
+      {
+        "type": "bool",
+        "name": "kv_unified",
+        "isNullable": true
+      },
+      {
+        "type": "bool",
+        "name": "flash_attn",
+        "isNullable": true
+      },
+      {
+        "type": "bool",
+        "name": "swa_full",
+        "isNullable": true
+      },
+      {
+        "type": "int",
+        "name": "n_ctx_checkpoints",
+        "isNullable": true
+      },
+      {
+        "type": "int",
+        "name": "checkpoint_min_step",
+        "isNullable": true
+      },
+      {
+        "type": "str",
+        "name": "chat_template",
+        "isNullable": true
+      },
+      {
+        "type": "bool",
+        "name": "jinja",
+        "isNullable": true
+      },
+      {
+        "type": "arr_str",
+        "name": "default_template_kwargs_keys",
+        "isNullable": true
+      },
+      {
+        "type": "arr_str",
+        "name": "default_template_kwargs_vals",
+        "isNullable": true
+      },
+      {
+        "type": "bool",
+        "name": "reasoning",
+        "isNullable": true
+      },
+      {
+        "type": "int",
+        "name": "image_min_tokens",
+        "isNullable": true
+      },
+      {
+        "type": "int",
+        "name": "image_max_tokens",
+        "isNullable": true
+      },
+      {
+        "type": "bool",
+        "name": "warmup",
+        "isNullable": true
+      },
+      {
+        "type": "bool",
+        "name": "no_kv_offload",
+        "isNullable": true
+      },
+      {
+        "type": "bool",
+        "name": "mmproj_offload",
+        "isNullable": true
+      },
+      {
+        "type": "bool",
+        "name": "cont_batching",
+        "isNullable": true
+      },
+      {
+        "type": "int",
+        "name": "n_keep",
+        "isNullable": true
+      },
+      {
+        "type": "bool",
+        "name": "ctx_shift",
+        "isNullable": true
+      },
+      {
+        "type": "bool",
+        "name": "cache_idle_slots",
+        "isNullable": true
+      },
+      {
+        "type": "int",
+        "name": "n_cache_reuse",
+        "isNullable": true
+      },
+      {
+        "type": "arr_str",
+        "name": "lora_paths",
+        "isNullable": true
+      },
+      {
+        "type": "arr_float",
+        "name": "lora_scales",
+        "isNullable": true
+      },
+      {
+        "type": "bool",
+        "name": "lora_init_without_apply",
+        "isNullable": true
+      },
+      {
+        "type": "str",
+        "name": "spec_draft_model",
+        "isNullable": true
+      },
+      {
+        "type": "int",
+        "name": "spec_draft_ngl",
+        "isNullable": true
+      },
+      {
+        "type": "int",
+        "name": "spec_draft_n_max",
+        "isNullable": true
+      },
+      {
+        "type": "int",
+        "name": "spec_draft_n_min",
+        "isNullable": true
+      },
+      {
+        "type": "float",
+        "name": "spec_draft_p_min",
+        "isNullable": true
+      },
+      {
+        "type": "int",
+        "name": "spec_draft_threads",
+        "isNullable": true
+      },
+      {
+        "type": "int",
+        "name": "spec_draft_threads_batch",
+        "isNullable": true
+      },
+      {
+        "type": "arr_str",
+        "name": "kv_overrides_keys",
+        "isNullable": true
+      },
+      {
+        "type": "arr_str",
+        "name": "kv_overrides_vals",
+        "isNullable": true
+      },
+      {
+        "type": "int",
+        "name": "reasoning_budget_tokens",
+        "isNullable": true
+      },
+      {
+        "type": "str",
+        "name": "reasoning_budget_message",
+        "isNullable": true
+      },
+      {
+        "type": "str",
+        "name": "reasoning_format",
+        "isNullable": true
+      },
+      {
+        "type": "bool",
+        "name": "skip_chat_parsing",
+        "isNullable": true
+      },
+      {
+        "type": "bool",
+        "name": "prefill_assistant",
+        "isNullable": true
+      }
+    ]
+  },
+  "load_res": {
+    "name": "load_res",
+    "structName": "glue_msg_load_res",
+    "className": "GlueMsgLoadRes",
+    "fields": [
+      {
+        "type": "bool",
+        "name": "success",
+        "isNullable": false
+      },
+      {
+        "type": "int",
+        "name": "n_ctx",
+        "isNullable": false
+      },
+      {
+        "type": "int",
+        "name": "n_batch",
+        "isNullable": false
+      },
+      {
+        "type": "int",
+        "name": "n_ubatch",
+        "isNullable": false
+      },
+      {
+        "type": "int",
+        "name": "n_vocab",
+        "isNullable": false
+      },
+      {
+        "type": "int",
+        "name": "n_ctx_train",
+        "isNullable": false
+      },
+      {
+        "type": "int",
+        "name": "n_embd",
+        "isNullable": false
+      },
+      {
+        "type": "int",
+        "name": "n_layer",
+        "isNullable": false
+      },
+      {
+        "type": "arr_str",
+        "name": "metadata_key",
+        "isNullable": false
+      },
+      {
+        "type": "arr_str",
+        "name": "metadata_val",
+        "isNullable": false
+      },
+      {
+        "type": "int",
+        "name": "token_bos",
+        "isNullable": false
+      },
+      {
+        "type": "int",
+        "name": "token_eos",
+        "isNullable": false
+      },
+      {
+        "type": "int",
+        "name": "token_eot",
+        "isNullable": false
+      },
+      {
+        "type": "arr_int",
+        "name": "list_tokens_eog",
+        "isNullable": false
+      },
+      {
+        "type": "bool",
+        "name": "add_bos_token",
+        "isNullable": false
+      },
+      {
+        "type": "bool",
+        "name": "add_eos_token",
+        "isNullable": false
+      },
+      {
+        "type": "bool",
+        "name": "has_encoder",
+        "isNullable": false
+      },
+      {
+        "type": "int",
+        "name": "token_decoder_start",
+        "isNullable": false
+      },
+      {
+        "type": "str",
+        "name": "media_marker",
+        "isNullable": false
+      },
+      {
+        "type": "bool",
+        "name": "has_image_input",
+        "isNullable": false
+      },
+      {
+        "type": "bool",
+        "name": "has_audio_input",
+        "isNullable": false
+      }
+    ]
+  },
+  "cmpl_req": {
+    "name": "cmpl_req",
+    "structName": "glue_msg_completion_req",
+    "className": "GlueMsgCompletionReq",
+    "fields": [
+      {
+        "type": "bool",
+        "name": "is_chat",
+        "isNullable": false
+      },
+      {
+        "type": "str",
+        "name": "data_json",
+        "isNullable": false
+      },
+      {
+        "type": "arr_raw",
+        "name": "files",
+        "isNullable": false
+      }
+    ]
+  },
+  "cmpl_res": {
+    "name": "cmpl_res",
+    "structName": "glue_msg_completion_res",
+    "className": "GlueMsgCompletionRes",
+    "fields": [
+      {
+        "type": "bool",
+        "name": "success",
+        "isNullable": false
+      }
+    ]
+  },
+  "embd_req": {
+    "name": "embd_req",
+    "structName": "glue_msg_embedding_req",
+    "className": "GlueMsgEmbeddingReq",
+    "fields": [
+      {
+        "type": "str",
+        "name": "data_json",
+        "isNullable": false
+      },
+      {
+        "type": "arr_raw",
+        "name": "files",
+        "isNullable": false
+      }
+    ]
+  },
+  "embd_res": {
+    "name": "embd_res",
+    "structName": "glue_msg_embedding_res",
+    "className": "GlueMsgEmbeddingRes",
+    "fields": [
+      {
+        "type": "bool",
+        "name": "success",
+        "isNullable": false
+      }
+    ]
+  },
+  "rrnk_req": {
+    "name": "rrnk_req",
+    "structName": "glue_msg_rerank_req",
+    "className": "GlueMsgRerankReq",
+    "fields": [
+      {
+        "type": "str",
+        "name": "data_json",
+        "isNullable": false
+      }
+    ]
+  },
+  "rrnk_res": {
+    "name": "rrnk_res",
+    "structName": "glue_msg_rerank_res",
+    "className": "GlueMsgRerankRes",
+    "fields": [
+      {
+        "type": "bool",
+        "name": "success",
+        "isNullable": false
+      }
+    ]
+  },
+  "gres_req": {
+    "name": "gres_req",
+    "structName": "glue_msg_get_result_req",
+    "className": "GlueMsgGetResultReq",
+    "fields": []
+  },
+  "gres_res": {
+    "name": "gres_res",
+    "structName": "glue_msg_get_result_res",
+    "className": "GlueMsgGetResultRes",
+    "fields": [
+      {
+        "type": "bool",
+        "name": "success",
+        "isNullable": false
+      },
+      {
+        "type": "bool",
+        "name": "has_more",
+        "isNullable": false
+      },
+      {
+        "type": "bool",
+        "name": "is_error",
+        "isNullable": false
+      },
+      {
+        "type": "str",
+        "name": "data_json",
+        "isNullable": false
+      }
+    ]
+  },
+  "tbop_req": {
+    "name": "tbop_req",
+    "structName": "glue_msg_test_backend_ops_req",
+    "className": "GlueMsgTestBackendOpsReq",
+    "fields": [
+      {
+        "type": "arr_str",
+        "name": "args",
+        "isNullable": false
+      }
+    ]
+  },
+  "tbop_res": {
+    "name": "tbop_res",
+    "structName": "glue_msg_test_backend_ops_res",
+    "className": "GlueMsgTestBackendOpsRes",
+    "fields": [
+      {
+        "type": "int",
+        "name": "retcode",
+        "isNullable": false
+      },
+      {
+        "type": "bool",
+        "name": "success",
+        "isNullable": false
+      }
+    ]
+  }
+};
+
+// src/glue/glue.ts
+var GLUE_MAGIC = new Uint8Array([71, 76, 85, 69]);
+var GLUE_DTYPE_NULL = 0;
+var GLUE_DTYPE_BOOL = 1;
+var GLUE_DTYPE_INT = 2;
+var GLUE_DTYPE_FLOAT = 3;
+var GLUE_DTYPE_STRING = 4;
+var GLUE_DTYPE_RAW = 5;
+var GLUE_DTYPE_ARRAY_BOOL = 6;
+var GLUE_DTYPE_ARRAY_INT = 7;
+var GLUE_DTYPE_ARRAY_FLOAT = 8;
+var GLUE_DTYPE_ARRAY_STRING = 9;
+var GLUE_DTYPE_ARRAY_RAW = 10;
+var TYPE_MAP = {
+  str: GLUE_DTYPE_STRING,
+  int: GLUE_DTYPE_INT,
+  float: GLUE_DTYPE_FLOAT,
+  bool: GLUE_DTYPE_BOOL,
+  raw: GLUE_DTYPE_RAW,
+  arr_str: GLUE_DTYPE_ARRAY_STRING,
+  arr_int: GLUE_DTYPE_ARRAY_INT,
+  arr_float: GLUE_DTYPE_ARRAY_FLOAT,
+  arr_bool: GLUE_DTYPE_ARRAY_BOOL,
+  arr_raw: GLUE_DTYPE_ARRAY_RAW,
+  null: GLUE_DTYPE_NULL
+};
+function glueDeserialize(buf) {
+  let offset = 0;
+  const view = new DataView(buf.buffer);
+  const readUint32 = () => {
+    const value = view.getUint32(offset, true);
+    offset += 4;
+    return value;
+  };
+  const readInt32 = () => {
+    const value = view.getInt32(offset, true);
+    offset += 4;
+    return value;
+  };
+  const readFloat = () => {
+    const value = view.getFloat32(offset, true);
+    offset += 4;
+    return value;
+  };
+  const readBool = () => {
+    return readUint32() !== 0;
+  };
+  const readString = (customLen) => {
+    const length = customLen != null ? customLen : readUint32();
+    const value = new TextDecoder().decode(buf.slice(offset, offset + length));
+    offset += length;
+    return value;
+  };
+  const readRaw = () => {
+    const length = readUint32();
+    const value = buf.slice(offset, offset + length);
+    offset += length;
+    return value;
+  };
+  const readArray = (readItem) => {
+    const length = readUint32();
+    const value = new Array(length);
+    for (let i = 0; i < length; i++) {
+      value[i] = readItem();
+    }
+    return value;
+  };
+  const readNull = () => null;
+  const readField = (field) => {
+    switch (field.type) {
+      case "str":
+        return readString();
+      case "int":
+        return readInt32();
+      case "float":
+        return readFloat();
+      case "bool":
+        return readBool();
+      case "raw":
+        return readRaw();
+      case "arr_str":
+        return readArray(readString);
+      case "arr_int":
+        return readArray(readInt32);
+      case "arr_float":
+        return readArray(readFloat);
+      case "arr_bool":
+        return readArray(readBool);
+      case "arr_raw":
+        return readArray(readRaw);
+      case "null":
+        return readNull();
+    }
+  };
+  const magicValid = buf[0] === GLUE_MAGIC[0] && buf[1] === GLUE_MAGIC[1] && buf[2] === GLUE_MAGIC[2] && buf[3] === GLUE_MAGIC[3];
+  offset += 4;
+  if (!magicValid) {
+    throw new Error("Invalid magic number");
+  }
+  const version = readUint32();
+  if (version !== GLUE_VERSION) {
+    throw new Error("Invalid version number");
+  }
+  const name = readString(8);
+  const msgProto = GLUE_MESSAGE_PROTOTYPES[name];
+  if (!msgProto) {
+    throw new Error(`Unknown message name: ${name}`);
+  }
+  const output = { _name: name };
+  for (const field of msgProto.fields) {
+    const readType = readUint32();
+    if (readType === GLUE_DTYPE_NULL) {
+      if (!field.isNullable) {
+        throw new Error(
+          `${name}: Expect field ${field.name} to be non-nullable`
+        );
+      }
+      output[field.name] = null;
+      continue;
+    }
+    if (readType !== TYPE_MAP[field.type]) {
+      throw new Error(
+        `${name}: Expect field ${field.name} to have type ${field.type}`
+      );
+    }
+    output[field.name] = readField(field);
+  }
+  return output;
+}
+function glueSerialize(msg) {
+  const msgProto = GLUE_MESSAGE_PROTOTYPES[msg._name];
+  if (!msgProto) {
+    throw new Error(`Unknown message name: ${msg._name}`);
+  }
+  const bufs = [];
+  const writeUint32 = (value) => {
+    const buf = new ArrayBuffer(4);
+    new DataView(buf).setUint32(0, value, true);
+    bufs.push(new Uint8Array(buf));
+  };
+  const writeInt32 = (value) => {
+    const buf = new ArrayBuffer(4);
+    new DataView(buf).setInt32(0, value, true);
+    bufs.push(new Uint8Array(buf));
+  };
+  const writeFloat = (value) => {
+    const buf = new ArrayBuffer(4);
+    new DataView(buf).setFloat32(0, value, true);
+    bufs.push(new Uint8Array(buf));
+  };
+  const writeBool = (value) => {
+    writeUint32(value ? 1 : 0);
+  };
+  const writeString = (value) => {
+    const utf8 = new TextEncoder().encode(value);
+    writeUint32(utf8.byteLength);
+    bufs.push(utf8);
+  };
+  const writeRaw = (value) => {
+    writeUint32(value.byteLength);
+    bufs.push(value);
+  };
+  const writeArray = (value, writeItem) => {
+    writeUint32(value.length);
+    for (const item of value) {
+      writeItem(item);
+    }
+  };
+  const writeNull = () => {
+  };
+  bufs.push(GLUE_MAGIC);
+  writeUint32(GLUE_VERSION);
+  {
+    const utf8 = new TextEncoder().encode(msg._name);
+    bufs.push(utf8);
+  }
+  for (const field of msgProto.fields) {
+    const val = msg[field.name];
+    if (!field.isNullable && (val === null || val === void 0)) {
+      throw new Error(
+        `${msg._name}: Expect field ${field.name} to be non-nullable`
+      );
+    }
+    if (val === null || val === void 0) {
+      writeUint32(GLUE_DTYPE_NULL);
+      continue;
+    }
+    writeUint32(TYPE_MAP[field.type]);
+    switch (field.type) {
+      case "str":
+        writeString(val);
+        break;
+      case "int":
+        writeInt32(val);
+        break;
+      case "float":
+        writeFloat(val);
+        break;
+      case "bool":
+        writeBool(val);
+        break;
+      case "raw":
+        writeRaw(val);
+        break;
+      case "arr_str":
+        writeArray(val, writeString);
+        break;
+      case "arr_int":
+        writeArray(val, writeInt32);
+        break;
+      case "arr_float":
+        writeArray(val, writeFloat);
+        break;
+      case "arr_bool":
+        writeArray(val, writeBool);
+        break;
+      case "arr_raw":
+        writeArray(val, writeRaw);
+        break;
+      case "null":
+        writeNull();
+        break;
+    }
+  }
+  const totalLength = bufs.reduce((acc, buf) => acc + buf.byteLength, 0);
+  const output = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const buf of bufs) {
+    output.set(buf, offset);
+    offset += buf.byteLength;
+  }
+  return output;
+}
+
+// src/wasm/source-map.ts
+var WASM_SOURCE_MAP = {
+  "default": "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",
+  "compat": "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"
+};
+
+// src/debug.ts
+var cache = /* @__PURE__ */ new Map();
+function loadMap(buildKey) {
+  return __async(this, null, function* () {
+    if (cache.has(buildKey)) return cache.get(buildKey);
+    const b64 = WASM_SOURCE_MAP[buildKey];
+    if (!b64) throw new Error(`No source map for build "${buildKey}"`);
+    const gzipped = Uint8Array.from(atob(b64), (c) => c.charCodeAt(0));
+    const ds = new DecompressionStream("gzip");
+    const writer = ds.writable.getWriter();
+    writer.write(gzipped);
+    writer.close();
+    const buf = yield new Response(ds.readable).arrayBuffer();
+    const dv = new DataView(buf);
+    const bytes = new Uint8Array(buf);
+    const firstId = dv.getUint32(0, true);
+    const funcCount = dv.getUint32(4, true);
+    const numNames = dv.getUint32(8, true);
+    const td = new TextDecoder();
+    const names = [];
+    let pos = 12;
+    for (let i = 0; i < numNames; i++) {
+      const len = bytes[pos++];
+      names.push(td.decode(bytes.subarray(pos, pos + len)));
+      pos += len;
+    }
+    const funcNames = [];
+    for (let i = 0; i < funcCount; i++) {
+      const idx = dv.getUint16(pos, true);
+      pos += 2;
+      funcNames.push(idx === 65535 ? null : names[idx]);
+    }
+    const entry = { firstId, funcNames };
+    cache.set(buildKey, entry);
+    return entry;
+  });
+}
+var Debug = {
+  /**
+   * Resolves a list of wasm function indices to their cleaned symbol names.
+   */
+  decodeFuncIds: (funcIds, isCompatBuild) => __async(void 0, null, function* () {
+    const buildKey = isCompatBuild ? "compat" : "default";
+    const { firstId, funcNames } = yield loadMap(buildKey);
+    return funcIds.map((funcId) => {
+      const i = funcId - firstId;
+      const name = i >= 0 && i < funcNames.length && funcNames[i] ? funcNames[i] : "(unknown)";
+      return { funcId, name };
+    });
+  }),
+  /**
+   * Annotates a wasm stack trace string with resolved function names.
+   *
+   * Example input from Chrome:
+   *   at http://localhost:8080/esm/wasm/wllama.wasm:wasm-function[775]:0x74251
+   *   at async blob:http://localhost:8080/53a863cc-7227-45cc-8594-ddbbf5257f20:317:28
+   *
+   * Example input from Firefox:
+   *   @http://localhost:8080/esm/wasm/wllama.wasm:wasm-function[796]:0x7dfe2
+   *       at wModuleInit/WebAssembly.promising/< (9b6a2acd-d909-44e2-b021-d42fb9087cfb:15:32) index.js:1433:45
+   *
+   * Example input from Safari:
+   *   2441@wasm-function[2441]
+   *       at wrapper (d746f19e-4523-4f36-ba06-d0969acc0b05:22:126009)
+   *
+   * Example output:
+   *   wasm-func[775] (server_response::send)
+   */
+  decodeStackTrace: (stack, isCompatBuild) => __async(void 0, null, function* () {
+    const re = /wasm-function\[(\d+)\]/g;
+    const funcIds = [
+      ...new Set([...stack.matchAll(re)].map((m) => parseInt(m[1])))
+    ];
+    if (funcIds.length === 0) return stack;
+    const resolved = yield Debug.decodeFuncIds(funcIds, isCompatBuild);
+    return resolved.map((r) => {
+      if (r.name === "(unknown)") {
+        return `    wasm-func[${r.funcId}] (unknown)`;
+      }
+      return `    wasm-func[${r.funcId}] (${r.name})`;
+    }).join("\n");
+  })
+};
+
+// src/utils.ts
+var textDecoder = new TextDecoder();
+var URL_PARTS_REGEX = /-(\d{5})-of-(\d{5})\.gguf(?:\?.*)?$/;
+var parseShardNumber = (fnameOrUrl) => {
+  const matches = fnameOrUrl.match(URL_PARTS_REGEX);
+  if (!matches) {
+    return {
+      baseURL: fnameOrUrl,
+      current: 1,
+      total: 1
+    };
+  } else {
+    return {
+      baseURL: fnameOrUrl.replace(URL_PARTS_REGEX, ""),
+      current: parseInt(matches[1]),
+      total: parseInt(matches[2])
+    };
+  }
+};
+var sortFileByShard = (blobs) => {
+  const isFiles = blobs.every((b) => !!b.name);
+  if (isFiles && blobs.length > 1) {
+    const files = blobs;
+    files.sort((a, b) => {
+      const infoA = parseShardNumber(a.name);
+      const infoB = parseShardNumber(b.name);
+      return infoA.current - infoB.current;
+    });
+  }
+};
+var isMmproj = (blob) => __async(void 0, null, function* () {
+  const META_NAME = "general.architecture";
+  const META_VAL = "clip";
+  const tmp = blob.slice(0, 128 * 1024);
+  const header = yield tmp.arrayBuffer();
+  const buf = new Uint8Array(header);
+  const nameBytes = new TextEncoder().encode(META_NAME);
+  const valBytes = new TextEncoder().encode(META_VAL);
+  let offset = -1;
+  outer: for (let i = 0; i <= buf.length - nameBytes.length; i++) {
+    for (let j = 0; j < nameBytes.length; j++) {
+      if (buf[i + j] !== nameBytes[j]) continue outer;
+    }
+    offset = i;
+    break;
+  }
+  if (offset === -1) return false;
+  if (offset + 8 * 4 + 4 > buf.length) return false;
+  const view = new DataView(header);
+  const valLen = view.getBigUint64(offset + 8 * 3, true);
+  if (valLen !== /* @__PURE__ */ BigInt("4")) return false;
+  for (let i = 0; i < valBytes.length; i++) {
+    if (buf[offset + 8 * 4 + i] !== valBytes[i]) return false;
+  }
+  return true;
+});
+var absoluteUrl = (relativePath) => new URL(relativePath, document.baseURI).href;
+var padDigits = (number, digits) => {
+  return Array(Math.max(digits - String(number).length + 1, 0)).join("0") + number;
+};
+var sumArr = (arr) => arr.reduce((prev, curr) => prev + curr, 0);
+var isString = (value) => !!(value == null ? void 0 : value.startsWith);
+var MMPROJ_FILE_NAME = "mmproj.gguf";
+var prepareBlobs = (blobsInp) => __async(void 0, null, function* () {
+  const blobs = [];
+  let blobMmproj = null;
+  for (const blob of blobsInp) {
+    if (yield isMmproj(blob)) {
+      blobMmproj = blob;
+    } else {
+      blobs.push(blob);
+    }
+  }
+  sortFileByShard(blobs);
+  const result = blobs.map((blob, i) => ({
+    blob,
+    name: `model-${padDigits(i + 1, 5)}-of-${padDigits(blobs.length, 5)}.gguf`
+  }));
+  if (blobMmproj) {
+    result.push({
+      blob: blobMmproj,
+      name: MMPROJ_FILE_NAME
+    });
+  }
+  return {
+    llm: result.filter((f) => f.name !== MMPROJ_FILE_NAME),
+    mmproj: blobMmproj ? { blob: blobMmproj, name: MMPROJ_FILE_NAME } : null,
+    all: result
+  };
+});
+var isSupportMultiThread = () => ((e) => __async(void 0, null, function* () {
+  try {
+    return "undefined" != typeof MessageChannel && new MessageChannel().port1.postMessage(new SharedArrayBuffer(1)), WebAssembly.validate(e);
+  } catch (e2) {
+    return false;
+  }
+}))(
+  new Uint8Array([
+    0,
+    97,
+    115,
+    109,
+    1,
+    0,
+    0,
+    0,
+    1,
+    4,
+    1,
+    96,
+    0,
+    0,
+    3,
+    2,
+    1,
+    0,
+    5,
+    4,
+    1,
+    3,
+    1,
+    1,
+    10,
+    11,
+    1,
+    9,
+    0,
+    65,
+    0,
+    254,
+    16,
+    2,
+    0,
+    26,
+    11
+  ])
+);
+var isSupportExceptions = () => __async(void 0, null, function* () {
+  return WebAssembly.validate(
+    new Uint8Array([
+      0,
+      97,
+      115,
+      109,
+      1,
+      0,
+      0,
+      0,
+      1,
+      4,
+      1,
+      96,
+      0,
+      0,
+      3,
+      2,
+      1,
+      0,
+      10,
+      8,
+      1,
+      6,
+      0,
+      6,
+      64,
+      25,
+      11,
+      11
+    ])
+  );
+});
+var isSupportSIMD = () => __async(void 0, null, function* () {
+  return WebAssembly.validate(
+    new Uint8Array([
+      0,
+      97,
+      115,
+      109,
+      1,
+      0,
+      0,
+      0,
+      1,
+      5,
+      1,
+      96,
+      0,
+      1,
+      123,
+      3,
+      2,
+      1,
+      0,
+      10,
+      10,
+      1,
+      8,
+      0,
+      65,
+      0,
+      253,
+      15,
+      253,
+      98,
+      11
+    ])
+  );
+});
+var isSupportJSPI = () => {
+  return !!WebAssembly.Suspending;
+};
+var isSupportWebGPU = () => {
+  return !!navigator.gpu;
+};
+var isSupportMem64 = () => {
+  try {
+    new WebAssembly.Memory({
+      address: "i64",
+      initial: /* @__PURE__ */ BigInt("1")
+      // 1 page (64 KiB)
+    });
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+var checkEnvironmentCompatible = () => __async(void 0, null, function* () {
+  if (!(yield isSupportExceptions())) {
+    throw new Error("WebAssembly runtime does not support exception handling");
+  }
+  if (!(yield isSupportSIMD())) {
+    throw new Error("WebAssembly runtime does not support SIMD");
+  }
+});
+var isFirefox = () => {
+  return !!navigator.userAgent.match(/Firefox\/([0-9\.]+)(?:\s|$)/);
+};
+var GGUF_FILE_REGEX = /^.*\.gguf(?:\?.*)?$/;
+var isValidGgufFile = (path) => {
+  return GGUF_FILE_REGEX.test(path);
+};
+var isSafariMobile = () => {
+  return !!navigator.userAgent.match(/Version\/([0-9\._]+).*Mobile.*Safari.*/);
+};
+var createWorker = (workerCode) => {
+  const workerURL = URL.createObjectURL(
+    isString(workerCode) ? new Blob([workerCode], { type: "text/javascript" }) : workerCode
+  );
+  return new Worker(workerURL, { type: "module" });
+};
+var cbToAsyncIter = (fn) => (...args) => {
+  let values = [];
+  let resolve;
+  let reject;
+  values.push(
+    new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    })
+  );
+  fn(...args, (val, done, err) => {
+    if (err) {
+      reject(err);
+      return;
+    }
+    resolve([val, done]);
+    values.push(
+      new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+      })
+    );
+  });
+  return function() {
+    return __asyncGenerator(this, null, function* () {
+      let val;
+      for (let i = 0, done = false; !done; i++) {
+        [val, done] = yield new __await(values[i]);
+        delete values[i];
+        if (val !== void 0) yield val;
+      }
+    });
+  }();
+};
+var canUseAsyncFileRead = (compat) => isSupportJSPI() || compat;
+var needCompat = () => !isSupportJSPI() || !isSupportMem64();
+
+// src/workers-code/generated.ts
+var LIBLLAMA_VERSION = "b9643-dd37ee8";
+var LLAMA_CPP_WORKER_CODE = "// Start the main llama.cpp\nlet wllamaMalloc;\nlet wllamaStart;\nlet wllamaAction;\nlet wllamaExit;\nlet wllamaDebug;\n\nlet Module = null;\nlet isCompat = false;\nlet lastStack = '';\nlet isAborted = false;\nlet hasMultithread = false;\n\n//////////////////////////////////////////////////////////////\n// UTILS\n//////////////////////////////////////////////////////////////\n\n// send message back to main thread\nconst msg = (data, transfer) => postMessage(data, transfer);\n\n// Convert CPP log into JS log\nconst cppLogToJSLog = (line) => {\n  const matched = line.match(/@@(DEBUG|INFO|WARN|ERROR)@@(.*)/);\n  return !!matched\n    ? {\n        level: (matched[1] === 'INFO' ? 'debug' : matched[1]).toLowerCase(),\n        text: matched[2],\n      }\n    : { level: 'log', text: line };\n};\n\nconst getHeapU8 = () => {\n  const buffer = Module.wasmMemory.buffer;\n  return new Uint8Array(buffer);\n};\n\nconst toSizeT = (num) => {\n  return isCompat ? Number(num) : BigInt(num);\n};\n\n// Get module config that forwards stdout/err to main thread\nconst getWModuleConfig = (_argMainScriptBlob) => {\n  var pathConfig = RUN_OPTIONS.pathConfig;\n  var pthreadPoolSize = RUN_OPTIONS.nbThread;\n  var argMainScriptBlob = _argMainScriptBlob;\n\n  isCompat = RUN_OPTIONS.compat;\n  hasMultithread = pthreadPoolSize > 1;\n\n  msg({\n    verb: 'console.debug',\n    args: [\n      `Multithread enabled: ${hasMultithread}, pthreadPoolSize: ${pthreadPoolSize}`,\n    ],\n  });\n\n  if (!pathConfig['wllama.wasm']) {\n    throw new Error('\"wllama.wasm\" is missing in pathConfig');\n  }\n  return {\n    noInitialRun: true,\n    print: function (text) {\n      if (arguments.length > 1)\n        text = Array.prototype.slice.call(arguments).join(' ');\n      msg({ verb: 'console.log', args: [text] });\n    },\n    printErr: function (text) {\n      if (arguments.length > 1)\n        text = Array.prototype.slice.call(arguments).join(' ');\n      if (text.startsWith('@@STACK@@')) {\n        lastStack = text.slice('@@STACK@@'.length);\n        return;\n      }\n      const logLine = cppLogToJSLog(text);\n      msg({ verb: 'console.' + logLine.level, args: [logLine.text] });\n    },\n    locateFile: function (filename, basePath) {\n      const p = pathConfig[filename];\n      const truncate = (str) =>\n        str.length > 128 ? `${str.substr(0, 128)}...` : str;\n      if (filename.match(/wllama\\.worker\\.js/)) {\n        msg({\n          verb: 'console.error',\n          args: [\n            '\"wllama.worker.js\" is removed from v2.2.1. Hint: make sure to clear browser\\'s cache.',\n          ],\n        });\n      } else {\n        msg({\n          verb: 'console.debug',\n          args: [`Loading \"${filename}\" from \"${truncate(p)}\"`],\n        });\n        return p;\n      }\n    },\n    mainScriptUrlOrBlob: hasMultithread\n      ? argMainScriptBlob\n      : 'throw new Error(\"Multithreading is not enabled\")',\n    pthreadPoolSize: hasMultithread ? pthreadPoolSize : 0,\n    wasmMemory: hasMultithread ? getWasmMemory() : null,\n    onAbort: function (message) {\n      isAborted = true;\n      msg({ verb: 'signal.abort', args: ['abort', message, lastStack, null] });\n    },\n    onExit: function (code) {\n      isAborted = true;\n      const callstack = new Error().stack.toString();\n      msg({\n        verb: 'signal.abort',\n        args: ['abort', 'exit(' + code + ')', callstack, null],\n      });\n    },\n  };\n};\n\n// Get the memory to be used by wasm. (Only used in multi-thread mode)\n// Because we have a weird OOM issue on iOS, we need to try some values\n// See: https://github.com/emscripten-core/emscripten/issues/19144\n//      https://github.com/godotengine/godot/issues/70621\nconst getWasmMemory = () => {\n  let minBytes = 128 * 1024 * 1024;\n  let maxBytes = 4096 * 1024 * 1024;\n  let stepBytes = 128 * 1024 * 1024;\n  while (maxBytes > minBytes) {\n    try {\n      const wasmMemory = new WebAssembly.Memory({\n        initial: toSizeT(minBytes / 65536),\n        maximum: toSizeT(maxBytes / 65536),\n        shared: true,\n        address: isCompat ? undefined : 'i64',\n      });\n      return wasmMemory;\n    } catch (e) {\n      maxBytes -= stepBytes;\n      continue; // retry\n    }\n  }\n  throw new Error('Cannot allocate WebAssembly.Memory');\n};\n\n//////////////////////////////////////////////////////////////\n// HEAPFS PATCH\n//////////////////////////////////////////////////////////////\n\n/**\n * By default, emscripten uses memfs. The way it works is by\n * allocating new Uint8Array in javascript heap. This is not good\n * because it requires files to be copied to wasm heap each time\n * a file is read.\n *\n * HeapFS is an alternative, which resolves this problem by\n * allocating space for file directly inside wasm heap. This\n * allows us to mmap without doing any copy.\n *\n * For llama.cpp, this is great because we use MAP_SHARED\n *\n * Ref: https://github.com/ngxson/wllama/pull/39\n * Ref: https://github.com/emscripten-core/emscripten/blob/main/src/library_memfs.js\n *\n * Note 29/05/2024 @ngxson\n * Due to ftell() being limited to MAX_LONG, we cannot load files bigger than 2^31 bytes (or 2GB)\n * Ref: https://github.com/emscripten-core/emscripten/blob/main/system/lib/libc/musl/src/stdio/ftell.c\n */\n\nconst fsNameToFile = {}; // map Name => File\nconst fsIdToFile = {}; // map ID => File\nlet currFileId = 0;\n\n// Patch and redirect memfs calls to wllama\nconst patchHeapFS = () => {\n  const m = Module;\n  // save functions\n  m.MEMFS.stream_ops._read = m.MEMFS.stream_ops.read;\n  m.MEMFS.stream_ops._write = m.MEMFS.stream_ops.write;\n  m.MEMFS.stream_ops._llseek = m.MEMFS.stream_ops.llseek;\n  m.MEMFS.stream_ops._allocate = m.MEMFS.stream_ops.allocate;\n  m.MEMFS.stream_ops._mmap = m.MEMFS.stream_ops.mmap;\n  m.MEMFS.stream_ops._msync = m.MEMFS.stream_ops.msync;\n\n  const patchStream = (stream) => {\n    const name = stream.node.name;\n    if (fsNameToFile[name]) {\n      const f = fsNameToFile[name];\n      const ptr = Number(f.ptr);\n      stream.node.contents = getHeapU8().subarray(ptr, ptr + f.size);\n      stream.node.usedBytes = f.size;\n    }\n  };\n\n  // replace \"read\" functions\n  m.MEMFS.stream_ops.read = function (\n    stream,\n    buffer,\n    offset,\n    length,\n    position\n  ) {\n    patchStream(stream);\n    return m.MEMFS.stream_ops._read(stream, buffer, offset, length, position);\n  };\n  m.MEMFS.ops_table.file.stream.read = m.MEMFS.stream_ops.read;\n\n  // replace \"llseek\" functions\n  m.MEMFS.stream_ops.llseek = function (stream, offset, whence) {\n    patchStream(stream);\n    return m.MEMFS.stream_ops._llseek(stream, offset, whence);\n  };\n  m.MEMFS.ops_table.file.stream.llseek = m.MEMFS.stream_ops.llseek;\n\n  // replace \"mmap\" functions\n  m.MEMFS.stream_ops.mmap = function (stream, length, position, prot, flags) {\n    patchStream(stream);\n    const name = stream.node.name;\n    if (fsNameToFile[name]) {\n      const f = fsNameToFile[name];\n      const mmapPtr = f.ptr + toSizeT(position);\n      return {\n        ptr: mmapPtr,\n        allocated: false,\n      };\n    } else {\n      return m.MEMFS.stream_ops._mmap(stream, length, position, prot, flags);\n    }\n  };\n  m.MEMFS.ops_table.file.stream.mmap = m.MEMFS.stream_ops.mmap;\n\n  // mount FS\n  m.FS.mkdir('/models');\n  m.FS.mount(m.MEMFS, { root: '.' }, '/models');\n};\n\n// Allocate a new file in wllama heapfs, returns file ID\nconst heapfsAlloc = (name, size, allocBuffer) => {\n  if (size < 1) {\n    throw new Error('File size must be bigger than 0');\n  }\n  const m = Module;\n  const ptr = toSizeT(allocBuffer ? m.mmapAlloc(size) : 0);\n  const file = {\n    ptr: ptr,\n    size: size,\n    id: currFileId++,\n  };\n  fsIdToFile[file.id] = file;\n  fsNameToFile[name] = file;\n  return file.id;\n};\n\n// Add new file to wllama heapfs, return number of written bytes\nconst heapfsWrite = (id, buffer, offset) => {\n  if (fsIdToFile[id]) {\n    const { ptr, size } = fsIdToFile[id];\n    const afterWriteByte = offset + buffer.byteLength;\n    if (afterWriteByte > size) {\n      throw new Error(\n        `File ID ${id} write out of bound, afterWriteByte = ${afterWriteByte} while size = ${size}`\n      );\n    }\n    getHeapU8().set(buffer, Number(ptr) + offset);\n    return buffer.byteLength;\n  } else {\n    throw new Error(`File ID ${id} not found in heapfs`);\n  }\n};\n\n//////////////////////////////////////////////////////////////\n// ASYNC FILE READ\n//////////////////////////////////////////////////////////////\n\nlet isAwaitReading = false;\nlet pendingReadPromise = null;\nlet pendingReadResolve = null;\nlet pendingReadReject = null;\n\nconst _stripModelsPrefix = (path) => path.replace(/^\\/?models\\//, '');\n\n// Called from EM_ASYNC_JS stub in wllama-fs.h (path is already a JS string)\nconst _wllama_js_file_read = async (path, offset, req_size, out_ptr) => {\n  const name = _stripModelsPrefix(path);\n\n  pendingReadPromise = new Promise((res, rej) => {\n    pendingReadResolve = res;\n    pendingReadReject = rej;\n  });\n  isAwaitReading = true;\n\n  postMessage({ verb: 'fs.read_req', args: [name, offset, req_size] });\n\n  let data;\n  try {\n    data = await pendingReadPromise;\n  } finally {\n    isAwaitReading = false;\n    pendingReadResolve = null;\n    pendingReadReject = null;\n  }\n\n  const bytes = new Uint8Array(data);\n  getHeapU8().set(bytes, out_ptr);\n  return toSizeT(bytes.length);\n};\n\n//////////////////////////////////////////////////////////////\n// MAIN CODE\n//////////////////////////////////////////////////////////////\n\nconst callWrapper = (name, ret, args, isAsync) => {\n  const fn = Module.cwrap(\n    name,\n    ret,\n    args,\n    isAsync ? { async: true } : undefined\n  );\n  return async (action, req) => {\n    // console.log(`Calling ${name} with action:`, action, 'and req:', req);\n    let result;\n    try {\n      if (args.length === 2) {\n        result = isAsync ? await fn(action, req) : fn(action, req);\n      } else {\n        result = fn();\n      }\n    } catch (ex) {\n      console.error(ex);\n      throw ex;\n    }\n    return result;\n  };\n};\n\nfunction handleError(err) {\n  // If WASM already aborted, onAbort already sent signal.abort; skip to avoid\n  // re-reporting the resulting WebAssembly.RuntimeError as a JS exception.\n  if (isAborted) return;\n\n  const message = err ? err.message || String(err) : 'Unknown error';\n  const stack = err ? err.stack || String(err) : '';\n  msg({\n    verb: 'signal.abort',\n    args: ['exception', message, stack, err],\n  });\n}\n\nonmessage = async (e) => {\n  if (!e.data) return;\n  const { verb, args, callbackId } = e.data;\n\n  // fs.read_res arrives while wasm is JSPI-suspended; resolve the pending promise.\n  if (verb === 'fs.read_res') {\n    if (pendingReadResolve) {\n      pendingReadResolve(args[0]);\n    }\n    return;\n  }\n\n  // Guard: while awaiting a file read, reject any other incoming task.\n  if (isAwaitReading) {\n    if (callbackId) {\n      msg({\n        callbackId,\n        err: 'Worker is suspended waiting for file data (JSPI)',\n      });\n    }\n    return;\n  }\n\n  if (!callbackId) {\n    msg({ verb: 'console.error', args: ['callbackId is required', e.data] });\n    return;\n  }\n\n  if (verb === 'module.init') {\n    const argMainScriptBlob = args[0];\n    const argUseAsyncFile = args[1];\n    try {\n      Module = getWModuleConfig(argMainScriptBlob);\n      Module.preRun = () => {\n        if (argUseAsyncFile) {\n          Module.ENV['USE_ASYNC_FILE'] = '1';\n        }\n      };\n      Module.onRuntimeInitialized = () => {\n        // async call once module is ready\n        // init FS\n        patchHeapFS();\n        // init cwrap\n        const pointer = isCompat ? 'number' : 'bigint';\n        // TODO: note sure why emscripten cannot bind if there is only 1 argument\n        wllamaMalloc = callWrapper('wllama_malloc', pointer, [\n          'number',\n          pointer,\n        ]);\n        wllamaStart = callWrapper('wllama_start', 'string', [], true);\n        wllamaAction = callWrapper(\n          'wllama_action',\n          pointer,\n          ['string', pointer],\n          true\n        );\n        wllamaExit = callWrapper('wllama_exit', 'string', []);\n        wllamaDebug = callWrapper('wllama_debug', 'string', []);\n        msg({ callbackId, result: null });\n      };\n      wModuleInit();\n    } catch (err) {\n      handleError(err);\n    }\n    return;\n  }\n\n  if (verb === 'fs.alloc') {\n    const argFilename = args[0];\n    const argSize = args[1];\n    const argAllocBuffer = args[2];\n    try {\n      // create blank file\n      const emptyBuffer = new ArrayBuffer(0);\n      Module['FS_createDataFile'](\n        '/models',\n        argFilename,\n        emptyBuffer,\n        true,\n        true,\n        true\n      );\n      // alloc data on heap\n      const fileId = heapfsAlloc(argFilename, argSize, argAllocBuffer);\n      msg({ callbackId, result: { fileId } });\n    } catch (err) {\n      handleError(err);\n    }\n    return;\n  }\n\n  if (verb === 'fs.write') {\n    const argFileId = args[0];\n    const argBuffer = args[1];\n    const argOffset = args[2];\n    try {\n      const writtenBytes = heapfsWrite(argFileId, argBuffer, argOffset);\n      msg({ callbackId, result: { writtenBytes } });\n    } catch (err) {\n      handleError(err);\n    }\n    return;\n  }\n\n  if (verb === 'wllama.start') {\n    try {\n      const result = await wllamaStart();\n      msg({ callbackId, result });\n    } catch (err) {\n      handleError(err);\n    }\n    return;\n  }\n\n  if (verb === 'wllama.action') {\n    const argAction = args[0];\n    const argEncodedMsg = args[1];\n    try {\n      const inputPtr = await wllamaMalloc(toSizeT(argEncodedMsg.byteLength), 0);\n      // copy data to wasm heap\n      const inputBuffer = new Uint8Array(\n        getHeapU8().buffer,\n        Number(inputPtr),\n        argEncodedMsg.byteLength\n      );\n      inputBuffer.set(argEncodedMsg, 0);\n      const outputPtr = await wllamaAction(argAction, inputPtr);\n      // length of output buffer is written at the first 4 bytes of input buffer\n      const outputLen = new Uint32Array(\n        getHeapU8().buffer,\n        Number(inputPtr),\n        1\n      )[0];\n      // copy the output buffer to JS heap\n      const outputBuffer = new Uint8Array(outputLen);\n      const outputSrcView = new Uint8Array(\n        getHeapU8().buffer,\n        Number(outputPtr),\n        outputLen\n      );\n      outputBuffer.set(outputSrcView, 0); // copy it\n      msg({ callbackId, result: outputBuffer }, [outputBuffer.buffer]);\n    } catch (err) {\n      handleError(err);\n    }\n    return;\n  }\n\n  if (verb === 'wllama.exit') {\n    try {\n      const result = await wllamaExit();\n      msg({ callbackId, result });\n    } catch (err) {\n      handleError(err);\n    }\n    return;\n  }\n\n  if (verb === 'wllama.debug') {\n    try {\n      const result = await wllamaDebug();\n      msg({ callbackId, result });\n    } catch (err) {\n      handleError(err);\n    }\n    return;\n  }\n};\n";
+var OPFS_UTILS_WORKER_CODE = "let accessHandle;\nlet abortController = new AbortController();\n\nasync function openFile(filename) {\n  const opfsRoot = await navigator.storage.getDirectory();\n  const cacheDir = await opfsRoot.getDirectoryHandle('cache', { create: true });\n  const fileHandler = await cacheDir.getFileHandle(filename, { create: true });\n  accessHandle = await fileHandler.createSyncAccessHandle();\n  accessHandle.truncate(0); // clear file content\n}\n\nasync function writeFile(buf) {\n  accessHandle.write(buf);\n}\n\nasync function closeFile() {\n  accessHandle.flush();\n  accessHandle.close();\n}\n\nasync function writeTextFile(filename, str) {\n  await openFile(filename);\n  await writeFile(new TextEncoder().encode(str));\n  await closeFile();\n}\n\nconst throttled = (func, delay) => {\n  let lastRun = 0;\n  return (...args) => {\n    const now = Date.now();\n    if (now - lastRun > delay) {\n      lastRun = now;\n      func.apply(null, args);\n    }\n  };\n};\n\nconst assertNonNull = (val) => {\n  if (val === null || val === undefined) {\n    throw new Error('OPFS Worker: Assertion failed');\n  }\n};\n\n// respond to main thread\nconst resOK = () => postMessage({ ok: true });\nconst resProgress = (loaded, total) =>\n  postMessage({ progress: { loaded, total } });\nconst resErr = (err) => postMessage({ err });\n\nonmessage = async (e) => {\n  try {\n    if (!e.data) return;\n\n    /**\n     * @param {Object} e.data\n     *\n     * Fine-control FS actions:\n     * - { action: 'open', filename: 'string' }\n     * - { action: 'write', buf: ArrayBuffer }\n     * - { action: 'close' }\n     *\n     * Simple write API:\n     * - { action: 'write-simple', filename: 'string', buf: ArrayBuffer }\n     *\n     * Download API:\n     * - { action: 'download', url: 'string', filename: 'string', options: Object, metadataFileName: 'string' }\n     * - { action: 'download-abort' }\n     */\n    const {\n      action,\n      filename,\n      buf,\n      url,\n      options,\n      metadataFileName,\n      metadataAdditional,\n    } = e.data;\n\n    if (action === 'open') {\n      assertNonNull(filename);\n      await openFile(filename);\n      return resOK();\n    } else if (action === 'write') {\n      assertNonNull(buf);\n      await writeFile(buf);\n      return resOK();\n    } else if (action === 'close') {\n      await closeFile();\n      return resOK();\n    } else if (action === 'write-simple') {\n      assertNonNull(filename);\n      assertNonNull(buf);\n      await openFile(filename);\n      await writeFile(buf);\n      await closeFile();\n      return resOK();\n    } else if (action === 'download') {\n      assertNonNull(url);\n      assertNonNull(filename);\n      assertNonNull(metadataFileName);\n      assertNonNull(options);\n      assertNonNull(options.aborted);\n      abortController = new AbortController();\n      if (options.aborted) abortController.abort();\n      const response = await fetch(url, {\n        ...options,\n        signal: abortController.signal,\n      });\n      const contentLength = response.headers.get('content-length');\n      const etag = (response.headers.get('etag') || '').replace(\n        /[^A-Za-z0-9]/g,\n        ''\n      );\n      const total = parseInt(contentLength, 10);\n      const reader = response.body.getReader();\n      await openFile(filename);\n      let loaded = 0;\n      const throttledProgress = throttled(resProgress, 100);\n      while (true) {\n        const { done, value } = await reader.read();\n        if (done) break;\n        loaded += value.byteLength;\n        await writeFile(value);\n        throttledProgress(loaded, total);\n      }\n      resProgress(total, total); // 100% done\n      await closeFile();\n      // make sure this is in-sync with CacheEntryMetadata\n      await writeTextFile(\n        metadataFileName,\n        JSON.stringify({\n          originalURL: url,\n          originalSize: total,\n          etag,\n          ...metadataAdditional,\n        })\n      );\n      return resOK();\n    } else if (action === 'download-abort') {\n      if (abortController) {\n        abortController.abort();\n      }\n      return;\n    }\n\n    throw new Error('OPFS Worker: Invalid action', e.data);\n  } catch (err) {\n    return resErr(err);\n  }\n};\n";
+var WLLAMA_EMSCRIPTEN_CODE = 'var Module=typeof Module!="undefined"?Module:{};var ENVIRONMENT_IS_WEB=!!globalThis.window;var ENVIRONMENT_IS_WORKER=!!globalThis.WorkerGlobalScope;var ENVIRONMENT_IS_NODE=globalThis.process?.versions?.node&&globalThis.process?.type!="renderer";var ENVIRONMENT_IS_PTHREAD=ENVIRONMENT_IS_WORKER&&self.name?.startsWith("em-pthread");if(ENVIRONMENT_IS_NODE){var worker_threads=require("worker_threads");global.Worker=worker_threads.Worker;ENVIRONMENT_IS_WORKER=!worker_threads.isMainThread;ENVIRONMENT_IS_PTHREAD=ENVIRONMENT_IS_WORKER&&worker_threads["workerData"]=="em-pthread"}var arguments_=[];var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};var _scriptName=globalThis.document?.currentScript?.src;if(typeof __filename!="undefined"){_scriptName=__filename}else if(ENVIRONMENT_IS_WORKER){_scriptName=self.location.href}var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var readAsync,readBinary;if(ENVIRONMENT_IS_NODE){var fs=require("fs");scriptDirectory=__dirname+"/";readBinary=filename=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename);return ret};readAsync=async(filename,binary=true)=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename,binary?undefined:"utf8");return ret};if(process.argv.length>1){thisProgram=process.argv[1].replace(/\\\\/g,"/")}arguments_=process.argv.slice(2);if(typeof module!="undefined"){module["exports"]=Module}quit_=(status,toThrow)=>{process.exitCode=status;throw toThrow}}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){try{scriptDirectory=new URL(".",_scriptName).href}catch{}if(!ENVIRONMENT_IS_NODE){if(ENVIRONMENT_IS_WORKER){readBinary=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}}readAsync=async url=>{if(isFileURI(url)){return new Promise((resolve,reject)=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,true);xhr.responseType="arraybuffer";xhr.onload=()=>{if(xhr.status==200||xhr.status==0&&xhr.response){resolve(xhr.response);return}reject(xhr.status)};xhr.onerror=reject;xhr.send(null)})}var response=await fetch(url,{credentials:"same-origin"});if(response.ok){return response.arrayBuffer()}throw new Error(response.status+" : "+response.url)}}}else{}var defaultPrint=console.log.bind(console);var defaultPrintErr=console.error.bind(console);if(ENVIRONMENT_IS_NODE){var utils=require("util");var stringify=a=>typeof a=="object"?utils.inspect(a):a;defaultPrint=(...args)=>fs.writeSync(1,args.map(stringify).join(" ")+"\\n");defaultPrintErr=(...args)=>fs.writeSync(2,args.map(stringify).join(" ")+"\\n")}var out=defaultPrint;var err=defaultPrintErr;var wasmBinary;var wasmModule;var ABORT=false;var EXITSTATUS;function assert(condition,text){if(!condition){abort(text)}}var isFileURI=filename=>filename.startsWith("file://");function growMemViews(){if(wasmMemory.buffer!=HEAP8.buffer){updateMemoryViews()}}if(ENVIRONMENT_IS_NODE&&ENVIRONMENT_IS_PTHREAD){var parentPort=worker_threads["parentPort"];parentPort.on("message",msg=>global.onmessage?.({data:msg}));Object.assign(globalThis,{self:global,postMessage:msg=>parentPort["postMessage"](msg)});process.on("uncaughtException",err=>{postMessage({cmd:"uncaughtException",error:err});process.exit(1)})}var startWorker;if(ENVIRONMENT_IS_PTHREAD){var initializedJS=false;self.onunhandledrejection=e=>{throw e.reason||e};async function handleMessage(e){try{var msgData=e["data"];var cmd=msgData.cmd;if(cmd==="load"){let messageQueue=[];self.onmessage=e=>messageQueue.push(e);startWorker=()=>{postMessage({cmd:"loaded"});for(let msg of messageQueue){handleMessage(msg)}self.onmessage=handleMessage};for(const handler of msgData.handlers){if(!Module[handler]||Module[handler].proxy){Module[handler]=(...args)=>{postMessage({cmd:"callHandler",handler,args})};if(handler=="print")out=Module[handler];if(handler=="printErr")err=Module[handler]}}wasmMemory=msgData.wasmMemory;updateMemoryViews();wasmModule=msgData.wasmModule;createWasm();run()}else if(cmd==="run"){establishStackSpace(msgData.pthread_ptr);__emscripten_thread_init(msgData.pthread_ptr,0,0,1,0,0);PThread.threadInitTLS();__emscripten_thread_mailbox_await(msgData.pthread_ptr);if(!initializedJS){initializedJS=true}try{await invokeEntryPoint(msgData.start_routine,msgData.arg)}catch(ex){if(ex!="unwind"){throw ex}}}else if(msgData.target==="setimmediate"){}else if(cmd==="checkMailbox"){if(initializedJS){checkMailbox()}}else if(cmd){err(`worker: received unknown command ${cmd}`);err(msgData)}}catch(ex){__emscripten_thread_crashed();throw ex}}self.onmessage=handleMessage}var HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;var HEAP64,HEAPU64;var runtimeInitialized=false;function updateMemoryViews(){var b=wasmMemory.buffer;HEAP8=new Int8Array(b);HEAP16=new Int16Array(b);Module["HEAPU8"]=HEAPU8=new Uint8Array(b);HEAPU16=new Uint16Array(b);HEAP32=new Int32Array(b);HEAPU32=new Uint32Array(b);HEAPF32=new Float32Array(b);HEAPF64=new Float64Array(b);HEAP64=new BigInt64Array(b);HEAPU64=new BigUint64Array(b)}function initMemory(){if(ENVIRONMENT_IS_PTHREAD){return}if(Module["wasmMemory"]){wasmMemory=Module["wasmMemory"]}else{var INITIAL_MEMORY=Module["INITIAL_MEMORY"]||134217728;wasmMemory=new WebAssembly.Memory({initial:BigInt(INITIAL_MEMORY/65536),maximum:65536n,shared:true,address:"i64"})}updateMemoryViews()}function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(onPreRuns)}function initRuntime(){runtimeInitialized=true;if(ENVIRONMENT_IS_PTHREAD)return startWorker();if(!Module["noFSInit"]&&!FS.initialized)FS.init();TTY.init();wasmExports["__wasm_call_ctors"]();FS.ignorePermissions=false}function preMain(){}function postRun(){if(ENVIRONMENT_IS_PTHREAD){return}if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(onPostRuns)}function abort(what){Module["onAbort"]?.(what);what="Aborted("+what+")";err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";if(runtimeInitialized){___trap()}var e=new WebAssembly.RuntimeError(what);throw e}var wasmBinaryFile;function findWasmBinary(){return locateFile("wllama.wasm")}function getBinarySync(file){if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}async function getWasmBinary(binaryFile){if(!wasmBinary){try{var response=await readAsync(binaryFile);return new Uint8Array(response)}catch{}}return getBinarySync(binaryFile)}async function instantiateArrayBuffer(binaryFile,imports){try{var binary=await getWasmBinary(binaryFile);var instance=await WebAssembly.instantiate(binary,imports);return instance}catch(reason){err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason)}}async function instantiateAsync(binary,binaryFile,imports){if(!binary&&!isFileURI(binaryFile)&&!ENVIRONMENT_IS_NODE){try{var response=fetch(binaryFile,{credentials:"same-origin"});var instantiationResult=await WebAssembly.instantiateStreaming(response,imports);return instantiationResult}catch(reason){err(`wasm streaming compile failed: ${reason}`);err("falling back to ArrayBuffer instantiation")}}return instantiateArrayBuffer(binaryFile,imports)}function getWasmImports(){assignWasmImports();if(!wasmImports.__instrumented){wasmImports.__instrumented=true;Asyncify.instrumentWasmImports(wasmImports)}var imports={env:wasmImports,wasi_snapshot_preview1:wasmImports};return imports}async function createWasm(){function receiveInstance(instance,module){wasmExports=instance.exports;wasmExports=Asyncify.instrumentWasmExports(wasmExports);wasmExports=applySignatureConversions(wasmExports);registerTLSInit(wasmExports["_emscripten_tls_init"]);assignWasmExports(wasmExports);wasmModule=module;removeRunDependency("wasm-instantiate");return wasmExports}addRunDependency("wasm-instantiate");function receiveInstantiationResult(result){return receiveInstance(result["instance"],result["module"])}var info=getWasmImports();if(Module["instantiateWasm"]){return new Promise((resolve,reject)=>{Module["instantiateWasm"](info,(inst,mod)=>{resolve(receiveInstance(inst,mod))})})}if(ENVIRONMENT_IS_PTHREAD){var instance=new WebAssembly.Instance(wasmModule,getWasmImports());return receiveInstance(instance,wasmModule)}wasmBinaryFile??=findWasmBinary();var result=await instantiateAsync(wasmBinary,wasmBinaryFile,info);var exports=receiveInstantiationResult(result);return exports}class ExitStatus{name="ExitStatus";constructor(status){this.message=`Program terminated with exit(${status})`;this.status=status}}var terminateWorker=worker=>{worker.terminate();worker.onmessage=e=>{}};var cleanupThread=pthread_ptr=>{var worker=PThread.pthreads[pthread_ptr];PThread.returnWorkerToPool(worker)};var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}};var onPreRuns=[];var addOnPreRun=cb=>onPreRuns.push(cb);var runDependencies=0;var dependenciesFulfilled=null;var removeRunDependency=id=>{runDependencies--;Module["monitorRunDependencies"]?.(runDependencies);if(runDependencies==0){if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback()}}};var addRunDependency=id=>{runDependencies++;Module["monitorRunDependencies"]?.(runDependencies)};var spawnThread=threadParams=>{var worker=PThread.getNewWorker();if(!worker){return 6}PThread.runningWorkers.push(worker);PThread.pthreads[threadParams.pthread_ptr]=worker;worker.pthread_ptr=threadParams.pthread_ptr;var msg={cmd:"run",start_routine:threadParams.startRoutine,arg:threadParams.arg,pthread_ptr:threadParams.pthread_ptr};if(ENVIRONMENT_IS_NODE){worker.unref()}worker.postMessage(msg,threadParams.transferList);return 0};var runtimeKeepaliveCounter=0;var keepRuntimeAlive=()=>noExitRuntime||runtimeKeepaliveCounter>0;var stackSave=()=>_emscripten_stack_get_current();var stackRestore=val=>__emscripten_stack_restore(val);var stackAlloc=sz=>__emscripten_stack_alloc(sz);var proxyToMainThread=(funcIndex,emAsmAddr,sync,...callArgs)=>{var serializedNumCallArgs=callArgs.length*2;var sp=stackSave();var args=stackAlloc(serializedNumCallArgs*8);var b=args/8;for(var i=0;i<callArgs.length;i++){var arg=callArgs[i];if(typeof arg=="bigint"){(growMemViews(),HEAP64)[b+2*i]=1n;(growMemViews(),HEAP64)[b+2*i+1]=arg}else{(growMemViews(),HEAP64)[b+2*i]=0n;(growMemViews(),HEAPF64)[b+2*i+1]=arg}}var rtn=__emscripten_run_js_on_main_thread(funcIndex,emAsmAddr,serializedNumCallArgs,args,sync);stackRestore(sp);return rtn};function _proc_exit(code){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(0,0,1,code);EXITSTATUS=code;if(!keepRuntimeAlive()){PThread.terminateAllThreads();Module["onExit"]?.(code);ABORT=true}quit_(code,new ExitStatus(code))}function exitOnMainThread(returnCode){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(1,0,0,returnCode);_exit(returnCode)}var exitJS=(status,implicit)=>{EXITSTATUS=status;if(ENVIRONMENT_IS_PTHREAD){exitOnMainThread(status);throw"unwind"}_proc_exit(status)};var _exit=exitJS;var PThread={unusedWorkers:[],runningWorkers:[],tlsInitFunctions:[],pthreads:{},init(){if(!ENVIRONMENT_IS_PTHREAD){PThread.initMainThread()}},initMainThread(){var pthreadPoolSize=Module["pthreadPoolSize"];while(pthreadPoolSize--){PThread.allocateUnusedWorker()}addOnPreRun(async()=>{var pthreadPoolReady=PThread.loadWasmModuleToAllWorkers();addRunDependency("loading-workers");await pthreadPoolReady;removeRunDependency("loading-workers")})},terminateAllThreads:()=>{for(var worker of PThread.runningWorkers){terminateWorker(worker)}for(var worker of PThread.unusedWorkers){terminateWorker(worker)}PThread.unusedWorkers=[];PThread.runningWorkers=[];PThread.pthreads={}},returnWorkerToPool:worker=>{var pthread_ptr=worker.pthread_ptr;delete PThread.pthreads[pthread_ptr];PThread.unusedWorkers.push(worker);PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(worker),1);worker.pthread_ptr=0;__emscripten_thread_free_data(pthread_ptr)},threadInitTLS(){PThread.tlsInitFunctions.forEach(f=>f())},loadWasmModuleToWorker:worker=>new Promise(onFinishedLoading=>{worker.onmessage=e=>{var d=e["data"];var cmd=d.cmd;if(d.targetThread&&d.targetThread!=_pthread_self()){var targetWorker=PThread.pthreads[d.targetThread];if(targetWorker){targetWorker.postMessage(d,d.transferList)}else{err(`Internal error! Worker sent a message "${cmd}" to target pthread ${d.targetThread}, but that thread no longer exists!`)}return}if(cmd==="checkMailbox"){checkMailbox()}else if(cmd==="spawnThread"){spawnThread(d)}else if(cmd==="cleanupThread"){callUserCallback(()=>cleanupThread(d.thread))}else if(cmd==="loaded"){worker.loaded=true;if(ENVIRONMENT_IS_NODE&&!worker.pthread_ptr){worker.unref()}onFinishedLoading(worker)}else if(d.target==="setimmediate"){worker.postMessage(d)}else if(cmd==="uncaughtException"){worker.onerror(d.error)}else if(cmd==="callHandler"){Module[d.handler](...d.args)}else if(cmd){err(`worker sent an unknown command ${cmd}`)}};worker.onerror=e=>{var message="worker sent an error!";err(`${message} ${e.filename}:${e.lineno}: ${e.message}`);throw e};if(ENVIRONMENT_IS_NODE){worker.on("message",data=>worker.onmessage({data}));worker.on("error",e=>worker.onerror(e))}var handlers=[];var knownHandlers=["onExit","onAbort","print","printErr"];for(var handler of knownHandlers){if(Module.propertyIsEnumerable(handler)){handlers.push(handler)}}worker.postMessage({cmd:"load",handlers,wasmMemory,wasmModule})}),async loadWasmModuleToAllWorkers(){if(ENVIRONMENT_IS_PTHREAD){return}let pthreadPoolReady=Promise.all(PThread.unusedWorkers.map(PThread.loadWasmModuleToWorker));return pthreadPoolReady},allocateUnusedWorker(){var worker;var pthreadMainJs=_scriptName;if(Module["mainScriptUrlOrBlob"]){pthreadMainJs=Module["mainScriptUrlOrBlob"];if(typeof pthreadMainJs!="string"){pthreadMainJs=URL.createObjectURL(pthreadMainJs)}}worker=new Worker(pthreadMainJs,{workerData:"em-pthread",name:"em-pthread"});PThread.unusedWorkers.push(worker)},getNewWorker(){if(PThread.unusedWorkers.length==0){PThread.allocateUnusedWorker();PThread.loadWasmModuleToWorker(PThread.unusedWorkers[0])}return PThread.unusedWorkers.pop()}};var onPostRuns=[];var addOnPostRun=cb=>onPostRuns.push(cb);function establishStackSpace(pthread_ptr){var stackHigh=Number((growMemViews(),HEAPU64)[(pthread_ptr+88)/8]);var stackSize=Number((growMemViews(),HEAPU64)[(pthread_ptr+96)/8]);var stackLow=stackHigh-stackSize;_emscripten_stack_set_limits(stackHigh,stackLow);stackRestore(stackHigh)}var wasmTableMirror=[];var getWasmTableEntry=funcPtr=>{funcPtr=Number(funcPtr);var func=wasmTableMirror[funcPtr];if(!func){wasmTableMirror[funcPtr]=func=wasmTable.get(BigInt(funcPtr));if(Asyncify.isAsyncExport(func)){wasmTableMirror[funcPtr]=func=Asyncify.makeAsyncFunction(func)}}return func};var invokeEntryPoint=async(ptr,arg)=>{runtimeKeepaliveCounter=0;noExitRuntime=0;var result=(a1=>WebAssembly.promising(getWasmTableEntry(ptr)).call(null,BigInt(a1)))(arg);function finish(result){if(keepRuntimeAlive()){EXITSTATUS=result;return}__emscripten_thread_exit(result)}result=await result;finish(result)};invokeEntryPoint.isAsync=true;var noExitRuntime=true;var registerTLSInit=tlsInitFunc=>PThread.tlsInitFunctions.push(tlsInitFunc);var wasmMemory;function pthreadCreateProxied(pthread_ptr,attr,startRoutine,arg){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(2,0,1,pthread_ptr,attr,startRoutine,arg);return ___pthread_create_js(pthread_ptr,attr,startRoutine,arg)}var _emscripten_has_threading_support=()=>!!globalThis.SharedArrayBuffer;var INT53_MAX=9007199254740992;var INT53_MIN=-9007199254740992;var bigintToI53Checked=num=>num<INT53_MIN||num>INT53_MAX?NaN:Number(num);function ___pthread_create_js(pthread_ptr,attr,startRoutine,arg){pthread_ptr=bigintToI53Checked(pthread_ptr);attr=bigintToI53Checked(attr);startRoutine=bigintToI53Checked(startRoutine);arg=bigintToI53Checked(arg);if(!_emscripten_has_threading_support()){return 6}var transferList=[];var error=0;if(ENVIRONMENT_IS_PTHREAD&&(transferList.length===0||error)){return pthreadCreateProxied(pthread_ptr,attr,startRoutine,arg)}if(error)return error;var threadParams={startRoutine,pthread_ptr,arg,transferList};if(ENVIRONMENT_IS_PTHREAD){threadParams.cmd="spawnThread";postMessage(threadParams,transferList);return 0}return spawnThread(threadParams)}var syscallGetVarargP=()=>{var ret=Number((growMemViews(),HEAPU64)[SYSCALLS.varargs/8]);SYSCALLS.varargs+=8;return ret};var syscallGetVarargI=()=>{var ret=(growMemViews(),HEAP32)[+SYSCALLS.varargs/4];SYSCALLS.varargs+=4;return ret};var PATH={isAbs:path=>path.charAt(0)==="/",splitPath:filename=>{var splitPathRe=/^(\\/?|)([\\s\\S]*?)((?:\\.{1,2}|[^\\/]+?|)(\\.[^.\\/]*|))(?:[\\/]*)$/;return splitPathRe.exec(filename).slice(1)},normalizeArray:(parts,allowAboveRoot)=>{var up=0;for(var i=parts.length-1;i>=0;i--){var last=parts[i];if(last==="."){parts.splice(i,1)}else if(last===".."){parts.splice(i,1);up++}else if(up){parts.splice(i,1);up--}}if(allowAboveRoot){for(;up;up--){parts.unshift("..")}}return parts},normalize:path=>{var isAbsolute=PATH.isAbs(path),trailingSlash=path.slice(-1)==="/";path=PATH.normalizeArray(path.split("/").filter(p=>!!p),!isAbsolute).join("/");if(!path&&!isAbsolute){path="."}if(path&&trailingSlash){path+="/"}return(isAbsolute?"/":"")+path},dirname:path=>{var result=PATH.splitPath(path),root=result[0],dir=result[1];if(!root&&!dir){return"."}if(dir){dir=dir.slice(0,-1)}return root+dir},basename:path=>path&&path.match(/([^\\/]+|\\/)\\/*$/)[1],join:(...paths)=>PATH.normalize(paths.join("/")),join2:(l,r)=>PATH.normalize(l+"/"+r)};var initRandomFill=()=>view=>view.set(crypto.getRandomValues(new Uint8Array(view.byteLength)));var randomFill=view=>{(randomFill=initRandomFill())(view)};var PATH_FS={resolve:(...args)=>{var resolvedPath="",resolvedAbsolute=false;for(var i=args.length-1;i>=-1&&!resolvedAbsolute;i--){var path=i>=0?args[i]:FS.cwd();if(typeof path!="string"){throw new TypeError("Arguments to path.resolve must be strings")}else if(!path){return""}resolvedPath=path+"/"+resolvedPath;resolvedAbsolute=PATH.isAbs(path)}resolvedPath=PATH.normalizeArray(resolvedPath.split("/").filter(p=>!!p),!resolvedAbsolute).join("/");return(resolvedAbsolute?"/":"")+resolvedPath||"."},relative:(from,to)=>{from=PATH_FS.resolve(from).slice(1);to=PATH_FS.resolve(to).slice(1);function trim(arr){var start=0;for(;start<arr.length;start++){if(arr[start]!=="")break}var end=arr.length-1;for(;end>=0;end--){if(arr[end]!=="")break}if(start>end)return[];return arr.slice(start,end-start+1)}var fromParts=trim(from.split("/"));var toParts=trim(to.split("/"));var length=Math.min(fromParts.length,toParts.length);var samePartsLength=length;for(var i=0;i<length;i++){if(fromParts[i]!==toParts[i]){samePartsLength=i;break}}var outputParts=[];for(var i=samePartsLength;i<fromParts.length;i++){outputParts.push("..")}outputParts=outputParts.concat(toParts.slice(samePartsLength));return outputParts.join("/")}};var UTF8Decoder=globalThis.TextDecoder&&new TextDecoder;var findStringEnd=(heapOrArray,idx,maxBytesToRead,ignoreNul)=>{var maxIdx=idx+maxBytesToRead;if(ignoreNul)return maxIdx;while(heapOrArray[idx]&&!(idx>=maxIdx))++idx;return idx};var UTF8ArrayToString=(heapOrArray,idx=0,maxBytesToRead,ignoreNul)=>{var endPtr=findStringEnd(heapOrArray,idx,maxBytesToRead,ignoreNul);if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.buffer instanceof ArrayBuffer?heapOrArray.subarray(idx,endPtr):heapOrArray.slice(idx,endPtr))}var str="";while(idx<endPtr){var u0=heapOrArray[idx++];if(!(u0&128)){str+=String.fromCharCode(u0);continue}var u1=heapOrArray[idx++]&63;if((u0&224)==192){str+=String.fromCharCode((u0&31)<<6|u1);continue}var u2=heapOrArray[idx++]&63;if((u0&240)==224){u0=(u0&15)<<12|u1<<6|u2}else{u0=(u0&7)<<18|u1<<12|u2<<6|heapOrArray[idx++]&63}if(u0<65536){str+=String.fromCharCode(u0)}else{var ch=u0-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}}return str};var FS_stdin_getChar_buffer=[];var lengthBytesUTF8=str=>{var len=0;for(var i=0;i<str.length;++i){var c=str.charCodeAt(i);if(c<=127){len++}else if(c<=2047){len+=2}else if(c>=55296&&c<=57343){len+=4;++i}else{len+=3}}return len};var stringToUTF8Array=(str,heap,outIdx,maxBytesToWrite)=>{if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i<str.length;++i){var u=str.codePointAt(i);if(u<=127){if(outIdx>=endIdx)break;heap[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63;i++}}heap[outIdx]=0;return outIdx-startIdx};var intArrayFromString=(stringy,dontAddNull,length)=>{var len=length>0?length:lengthBytesUTF8(stringy)+1;var u8array=new Array(len);var numBytesWritten=stringToUTF8Array(stringy,u8array,0,u8array.length);if(dontAddNull)u8array.length=numBytesWritten;return u8array};var FS_stdin_getChar=()=>{if(!FS_stdin_getChar_buffer.length){var result=null;if(ENVIRONMENT_IS_NODE){var BUFSIZE=256;var buf=Buffer.alloc(BUFSIZE);var bytesRead=0;var fd=process.stdin.fd;try{bytesRead=fs.readSync(fd,buf,0,BUFSIZE)}catch(e){if(e.toString().includes("EOF"))bytesRead=0;else throw e}if(bytesRead>0){result=buf.slice(0,bytesRead).toString("utf-8")}}else if(globalThis.window?.prompt){result=window.prompt("Input: ");if(result!==null){result+="\\n"}}else{}if(!result){return null}FS_stdin_getChar_buffer=intArrayFromString(result,true)}return FS_stdin_getChar_buffer.shift()};var TTY={ttys:[],init(){},shutdown(){},register(dev,ops){TTY.ttys[dev]={input:[],output:[],ops};FS.registerDevice(dev,TTY.stream_ops)},stream_ops:{open(stream){var tty=TTY.ttys[stream.node.rdev];if(!tty){throw new FS.ErrnoError(43)}stream.tty=tty;stream.seekable=false},close(stream){stream.tty.ops.fsync(stream.tty)},fsync(stream){stream.tty.ops.fsync(stream.tty)},read(stream,buffer,offset,length,pos){if(!stream.tty||!stream.tty.ops.get_char){throw new FS.ErrnoError(60)}var bytesRead=0;for(var i=0;i<length;i++){var result;try{result=stream.tty.ops.get_char(stream.tty)}catch(e){throw new FS.ErrnoError(29)}if(result===undefined&&bytesRead===0){throw new FS.ErrnoError(6)}if(result===null||result===undefined)break;bytesRead++;buffer[offset+i]=result}if(bytesRead){stream.node.atime=Date.now()}return bytesRead},write(stream,buffer,offset,length,pos){if(!stream.tty||!stream.tty.ops.put_char){throw new FS.ErrnoError(60)}try{for(var i=0;i<length;i++){stream.tty.ops.put_char(stream.tty,buffer[offset+i])}}catch(e){throw new FS.ErrnoError(29)}if(length){stream.node.mtime=stream.node.ctime=Date.now()}return i}},default_tty_ops:{get_char(tty){return FS_stdin_getChar()},put_char(tty,val){if(val===null||val===10){out(UTF8ArrayToString(tty.output));tty.output=[]}else{if(val!=0)tty.output.push(val)}},fsync(tty){if(tty.output?.length>0){out(UTF8ArrayToString(tty.output));tty.output=[]}},ioctl_tcgets(tty){return{c_iflag:25856,c_oflag:5,c_cflag:191,c_lflag:35387,c_cc:[3,28,127,21,4,0,1,0,17,19,26,0,18,15,23,22,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},ioctl_tcsets(tty,optional_actions,data){return 0},ioctl_tiocgwinsz(tty){return[24,80]}},default_tty1_ops:{put_char(tty,val){if(val===null||val===10){err(UTF8ArrayToString(tty.output));tty.output=[]}else{if(val!=0)tty.output.push(val)}},fsync(tty){if(tty.output?.length>0){err(UTF8ArrayToString(tty.output));tty.output=[]}}}};var zeroMemory=(ptr,size)=>(growMemViews(),HEAPU8).fill(0,ptr,ptr+size);var alignMemory=(size,alignment)=>Math.ceil(size/alignment)*alignment;var mmapAlloc=size=>{size=alignMemory(size,65536);var ptr=_emscripten_builtin_memalign(65536,size);if(ptr)zeroMemory(ptr,size);return ptr};var MEMFS={ops_table:null,mount(mount){return MEMFS.createNode(null,"/",16895,0)},createNode(parent,name,mode,dev){if(FS.isBlkdev(mode)||FS.isFIFO(mode)){throw new FS.ErrnoError(63)}MEMFS.ops_table||={dir:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr,lookup:MEMFS.node_ops.lookup,mknod:MEMFS.node_ops.mknod,rename:MEMFS.node_ops.rename,unlink:MEMFS.node_ops.unlink,rmdir:MEMFS.node_ops.rmdir,readdir:MEMFS.node_ops.readdir,symlink:MEMFS.node_ops.symlink},stream:{llseek:MEMFS.stream_ops.llseek}},file:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr},stream:{llseek:MEMFS.stream_ops.llseek,read:MEMFS.stream_ops.read,write:MEMFS.stream_ops.write,mmap:MEMFS.stream_ops.mmap,msync:MEMFS.stream_ops.msync}},link:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr,readlink:MEMFS.node_ops.readlink},stream:{}},chrdev:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr},stream:FS.chrdev_stream_ops}};var node=FS.createNode(parent,name,mode,dev);if(FS.isDir(node.mode)){node.node_ops=MEMFS.ops_table.dir.node;node.stream_ops=MEMFS.ops_table.dir.stream;node.contents={}}else if(FS.isFile(node.mode)){node.node_ops=MEMFS.ops_table.file.node;node.stream_ops=MEMFS.ops_table.file.stream;node.usedBytes=0;node.contents=null}else if(FS.isLink(node.mode)){node.node_ops=MEMFS.ops_table.link.node;node.stream_ops=MEMFS.ops_table.link.stream}else if(FS.isChrdev(node.mode)){node.node_ops=MEMFS.ops_table.chrdev.node;node.stream_ops=MEMFS.ops_table.chrdev.stream}node.atime=node.mtime=node.ctime=Date.now();if(parent){parent.contents[name]=node;parent.atime=parent.mtime=parent.ctime=node.atime}return node},getFileDataAsTypedArray(node){if(!node.contents)return new Uint8Array(0);if(node.contents.subarray)return node.contents.subarray(0,node.usedBytes);return new Uint8Array(node.contents)},expandFileStorage(node,newCapacity){var prevCapacity=node.contents?node.contents.length:0;if(prevCapacity>=newCapacity)return;var CAPACITY_DOUBLING_MAX=1024*1024;newCapacity=Math.max(newCapacity,prevCapacity*(prevCapacity<CAPACITY_DOUBLING_MAX?2:1.125)>>>0);if(prevCapacity!=0)newCapacity=Math.max(newCapacity,256);var oldContents=node.contents;node.contents=new Uint8Array(newCapacity);if(node.usedBytes>0)node.contents.set(oldContents.subarray(0,node.usedBytes),0)},resizeFileStorage(node,newSize){if(node.usedBytes==newSize)return;if(newSize==0){node.contents=null;node.usedBytes=0}else{var oldContents=node.contents;node.contents=new Uint8Array(newSize);if(oldContents){node.contents.set(oldContents.subarray(0,Math.min(newSize,node.usedBytes)))}node.usedBytes=newSize}},node_ops:{getattr(node){var attr={};attr.dev=FS.isChrdev(node.mode)?node.id:1;attr.ino=node.id;attr.mode=node.mode;attr.nlink=1;attr.uid=0;attr.gid=0;attr.rdev=node.rdev;if(FS.isDir(node.mode)){attr.size=4096}else if(FS.isFile(node.mode)){attr.size=node.usedBytes}else if(FS.isLink(node.mode)){attr.size=node.link.length}else{attr.size=0}attr.atime=new Date(node.atime);attr.mtime=new Date(node.mtime);attr.ctime=new Date(node.ctime);attr.blksize=4096;attr.blocks=Math.ceil(attr.size/attr.blksize);return attr},setattr(node,attr){for(const key of["mode","atime","mtime","ctime"]){if(attr[key]!=null){node[key]=attr[key]}}if(attr.size!==undefined){MEMFS.resizeFileStorage(node,attr.size)}},lookup(parent,name){if(!MEMFS.doesNotExistError){MEMFS.doesNotExistError=new FS.ErrnoError(44);MEMFS.doesNotExistError.stack="<generic error, no stack>"}throw MEMFS.doesNotExistError},mknod(parent,name,mode,dev){return MEMFS.createNode(parent,name,mode,dev)},rename(old_node,new_dir,new_name){var new_node;try{new_node=FS.lookupNode(new_dir,new_name)}catch(e){}if(new_node){if(FS.isDir(old_node.mode)){for(var i in new_node.contents){throw new FS.ErrnoError(55)}}FS.hashRemoveNode(new_node)}delete old_node.parent.contents[old_node.name];new_dir.contents[new_name]=old_node;old_node.name=new_name;new_dir.ctime=new_dir.mtime=old_node.parent.ctime=old_node.parent.mtime=Date.now()},unlink(parent,name){delete parent.contents[name];parent.ctime=parent.mtime=Date.now()},rmdir(parent,name){var node=FS.lookupNode(parent,name);for(var i in node.contents){throw new FS.ErrnoError(55)}delete parent.contents[name];parent.ctime=parent.mtime=Date.now()},readdir(node){return[".","..",...Object.keys(node.contents)]},symlink(parent,newname,oldpath){var node=MEMFS.createNode(parent,newname,511|40960,0);node.link=oldpath;return node},readlink(node){if(!FS.isLink(node.mode)){throw new FS.ErrnoError(28)}return node.link}},stream_ops:{read(stream,buffer,offset,length,position){var contents=stream.node.contents;if(position>=stream.node.usedBytes)return 0;var size=Math.min(stream.node.usedBytes-position,length);if(size>8&&contents.subarray){buffer.set(contents.subarray(position,position+size),offset)}else{for(var i=0;i<size;i++)buffer[offset+i]=contents[position+i]}return size},write(stream,buffer,offset,length,position,canOwn){if(buffer.buffer===(growMemViews(),HEAP8).buffer){canOwn=false}if(!length)return 0;var node=stream.node;node.mtime=node.ctime=Date.now();if(buffer.subarray&&(!node.contents||node.contents.subarray)){if(canOwn){node.contents=buffer.subarray(offset,offset+length);node.usedBytes=length;return length}else if(node.usedBytes===0&&position===0){node.contents=buffer.slice(offset,offset+length);node.usedBytes=length;return length}else if(position+length<=node.usedBytes){node.contents.set(buffer.subarray(offset,offset+length),position);return length}}MEMFS.expandFileStorage(node,position+length);if(node.contents.subarray&&buffer.subarray){node.contents.set(buffer.subarray(offset,offset+length),position)}else{for(var i=0;i<length;i++){node.contents[position+i]=buffer[offset+i]}}node.usedBytes=Math.max(node.usedBytes,position+length);return length},llseek(stream,offset,whence){var position=offset;if(whence===1){position+=stream.position}else if(whence===2){if(FS.isFile(stream.node.mode)){position+=stream.node.usedBytes}}if(position<0){throw new FS.ErrnoError(28)}return position},mmap(stream,length,position,prot,flags){if(!FS.isFile(stream.node.mode)){throw new FS.ErrnoError(43)}var ptr;var allocated;var contents=stream.node.contents;if(!(flags&2)&&contents&&contents.buffer===(growMemViews(),HEAP8).buffer){allocated=false;ptr=contents.byteOffset}else{allocated=true;ptr=mmapAlloc(length);if(!ptr){throw new FS.ErrnoError(48)}if(contents){if(position>0||position+length<contents.length){if(contents.subarray){contents=contents.subarray(position,position+length)}else{contents=Array.prototype.slice.call(contents,position,position+length)}}(growMemViews(),HEAP8).set(contents,ptr)}}return{ptr,allocated}},msync(stream,buffer,offset,length,mmapFlags){MEMFS.stream_ops.write(stream,buffer,0,length,offset,false);return 0}}};var FS_modeStringToFlags=str=>{var flagModes={r:0,"r+":2,w:512|64|1,"w+":512|64|2,a:1024|64|1,"a+":1024|64|2};var flags=flagModes[str];if(typeof flags=="undefined"){throw new Error(`Unknown file open mode: ${str}`)}return flags};var FS_getMode=(canRead,canWrite)=>{var mode=0;if(canRead)mode|=292|73;if(canWrite)mode|=146;return mode};var asyncLoad=async url=>{var arrayBuffer=await readAsync(url);return new Uint8Array(arrayBuffer)};var FS_createDataFile=(...args)=>FS.createDataFile(...args);var getUniqueRunDependency=id=>id;var preloadPlugins=[];var FS_handledByPreloadPlugin=async(byteArray,fullname)=>{if(typeof Browser!="undefined")Browser.init();for(var plugin of preloadPlugins){if(plugin["canHandle"](fullname)){return plugin["handle"](byteArray,fullname)}}return byteArray};var FS_preloadFile=async(parent,name,url,canRead,canWrite,dontCreateFile,canOwn,preFinish)=>{var fullname=name?PATH_FS.resolve(PATH.join2(parent,name)):parent;var dep=getUniqueRunDependency(`cp ${fullname}`);addRunDependency(dep);try{var byteArray=url;if(typeof url=="string"){byteArray=await asyncLoad(url)}byteArray=await FS_handledByPreloadPlugin(byteArray,fullname);preFinish?.();if(!dontCreateFile){FS_createDataFile(parent,name,byteArray,canRead,canWrite,canOwn)}}finally{removeRunDependency(dep)}};var FS_createPreloadedFile=(parent,name,url,canRead,canWrite,onload,onerror,dontCreateFile,canOwn,preFinish)=>{FS_preloadFile(parent,name,url,canRead,canWrite,dontCreateFile,canOwn,preFinish).then(onload).catch(onerror)};var FS={root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,filesystems:null,syncFSRequests:0,readFiles:{},ErrnoError:class{name="ErrnoError";constructor(errno){this.errno=errno}},FSStream:class{shared={};get object(){return this.node}set object(val){this.node=val}get isRead(){return(this.flags&2097155)!==1}get isWrite(){return(this.flags&2097155)!==0}get isAppend(){return this.flags&1024}get flags(){return this.shared.flags}set flags(val){this.shared.flags=val}get position(){return this.shared.position}set position(val){this.shared.position=val}},FSNode:class{node_ops={};stream_ops={};readMode=292|73;writeMode=146;mounted=null;constructor(parent,name,mode,rdev){if(!parent){parent=this}this.parent=parent;this.mount=parent.mount;this.id=FS.nextInode++;this.name=name;this.mode=mode;this.rdev=rdev;this.atime=this.mtime=this.ctime=Date.now()}get read(){return(this.mode&this.readMode)===this.readMode}set read(val){val?this.mode|=this.readMode:this.mode&=~this.readMode}get write(){return(this.mode&this.writeMode)===this.writeMode}set write(val){val?this.mode|=this.writeMode:this.mode&=~this.writeMode}get isFolder(){return FS.isDir(this.mode)}get isDevice(){return FS.isChrdev(this.mode)}},lookupPath(path,opts={}){if(!path){throw new FS.ErrnoError(44)}opts.follow_mount??=true;if(!PATH.isAbs(path)){path=FS.cwd()+"/"+path}linkloop:for(var nlinks=0;nlinks<40;nlinks++){var parts=path.split("/").filter(p=>!!p);var current=FS.root;var current_path="/";for(var i=0;i<parts.length;i++){var islast=i===parts.length-1;if(islast&&opts.parent){break}if(parts[i]==="."){continue}if(parts[i]===".."){current_path=PATH.dirname(current_path);if(FS.isRoot(current)){path=current_path+"/"+parts.slice(i+1).join("/");nlinks--;continue linkloop}else{current=current.parent}continue}current_path=PATH.join2(current_path,parts[i]);try{current=FS.lookupNode(current,parts[i])}catch(e){if(e?.errno===44&&islast&&opts.noent_okay){return{path:current_path}}throw e}if(FS.isMountpoint(current)&&(!islast||opts.follow_mount)){current=current.mounted.root}if(FS.isLink(current.mode)&&(!islast||opts.follow)){if(!current.node_ops.readlink){throw new FS.ErrnoError(52)}var link=current.node_ops.readlink(current);if(!PATH.isAbs(link)){link=PATH.dirname(current_path)+"/"+link}path=link+"/"+parts.slice(i+1).join("/");continue linkloop}}return{path:current_path,node:current}}throw new FS.ErrnoError(32)},getPath(node){var path;while(true){if(FS.isRoot(node)){var mount=node.mount.mountpoint;if(!path)return mount;return mount[mount.length-1]!=="/"?`${mount}/${path}`:mount+path}path=path?`${node.name}/${path}`:node.name;node=node.parent}},hashName(parentid,name){var hash=0;for(var i=0;i<name.length;i++){hash=(hash<<5)-hash+name.charCodeAt(i)|0}return(parentid+hash>>>0)%FS.nameTable.length},hashAddNode(node){var hash=FS.hashName(node.parent.id,node.name);node.name_next=FS.nameTable[hash];FS.nameTable[hash]=node},hashRemoveNode(node){var hash=FS.hashName(node.parent.id,node.name);if(FS.nameTable[hash]===node){FS.nameTable[hash]=node.name_next}else{var current=FS.nameTable[hash];while(current){if(current.name_next===node){current.name_next=node.name_next;break}current=current.name_next}}},lookupNode(parent,name){var errCode=FS.mayLookup(parent);if(errCode){throw new FS.ErrnoError(errCode)}var hash=FS.hashName(parent.id,name);for(var node=FS.nameTable[hash];node;node=node.name_next){var nodeName=node.name;if(node.parent.id===parent.id&&nodeName===name){return node}}return FS.lookup(parent,name)},createNode(parent,name,mode,rdev){var node=new FS.FSNode(parent,name,mode,rdev);FS.hashAddNode(node);return node},destroyNode(node){FS.hashRemoveNode(node)},isRoot(node){return node===node.parent},isMountpoint(node){return!!node.mounted},isFile(mode){return(mode&61440)===32768},isDir(mode){return(mode&61440)===16384},isLink(mode){return(mode&61440)===40960},isChrdev(mode){return(mode&61440)===8192},isBlkdev(mode){return(mode&61440)===24576},isFIFO(mode){return(mode&61440)===4096},isSocket(mode){return(mode&49152)===49152},flagsToPermissionString(flag){var perms=["r","w","rw"][flag&3];if(flag&512){perms+="w"}return perms},nodePermissions(node,perms){if(FS.ignorePermissions){return 0}if(perms.includes("r")&&!(node.mode&292)){return 2}else if(perms.includes("w")&&!(node.mode&146)){return 2}else if(perms.includes("x")&&!(node.mode&73)){return 2}return 0},mayLookup(dir){if(!FS.isDir(dir.mode))return 54;var errCode=FS.nodePermissions(dir,"x");if(errCode)return errCode;if(!dir.node_ops.lookup)return 2;return 0},mayCreate(dir,name){if(!FS.isDir(dir.mode)){return 54}try{var node=FS.lookupNode(dir,name);return 20}catch(e){}return FS.nodePermissions(dir,"wx")},mayDelete(dir,name,isdir){var node;try{node=FS.lookupNode(dir,name)}catch(e){return e.errno}var errCode=FS.nodePermissions(dir,"wx");if(errCode){return errCode}if(isdir){if(!FS.isDir(node.mode)){return 54}if(FS.isRoot(node)||FS.getPath(node)===FS.cwd()){return 10}}else{if(FS.isDir(node.mode)){return 31}}return 0},mayOpen(node,flags){if(!node){return 44}if(FS.isLink(node.mode)){return 32}else if(FS.isDir(node.mode)){if(FS.flagsToPermissionString(flags)!=="r"||flags&(512|64)){return 31}}return FS.nodePermissions(node,FS.flagsToPermissionString(flags))},checkOpExists(op,err){if(!op){throw new FS.ErrnoError(err)}return op},MAX_OPEN_FDS:4096,nextfd(){for(var fd=0;fd<=FS.MAX_OPEN_FDS;fd++){if(!FS.streams[fd]){return fd}}throw new FS.ErrnoError(33)},getStreamChecked(fd){var stream=FS.getStream(fd);if(!stream){throw new FS.ErrnoError(8)}return stream},getStream:fd=>FS.streams[fd],createStream(stream,fd=-1){stream=Object.assign(new FS.FSStream,stream);if(fd==-1){fd=FS.nextfd()}stream.fd=fd;FS.streams[fd]=stream;return stream},closeStream(fd){FS.streams[fd]=null},dupStream(origStream,fd=-1){var stream=FS.createStream(origStream,fd);stream.stream_ops?.dup?.(stream);return stream},doSetAttr(stream,node,attr){var setattr=stream?.stream_ops.setattr;var arg=setattr?stream:node;setattr??=node.node_ops.setattr;FS.checkOpExists(setattr,63);setattr(arg,attr)},chrdev_stream_ops:{open(stream){var device=FS.getDevice(stream.node.rdev);stream.stream_ops=device.stream_ops;stream.stream_ops.open?.(stream)},llseek(){throw new FS.ErrnoError(70)}},major:dev=>dev>>8,minor:dev=>dev&255,makedev:(ma,mi)=>ma<<8|mi,registerDevice(dev,ops){FS.devices[dev]={stream_ops:ops}},getDevice:dev=>FS.devices[dev],getMounts(mount){var mounts=[];var check=[mount];while(check.length){var m=check.pop();mounts.push(m);check.push(...m.mounts)}return mounts},syncfs(populate,callback){if(typeof populate=="function"){callback=populate;populate=false}FS.syncFSRequests++;if(FS.syncFSRequests>1){err(`warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`)}var mounts=FS.getMounts(FS.root.mount);var completed=0;function doCallback(errCode){FS.syncFSRequests--;return callback(errCode)}function done(errCode){if(errCode){if(!done.errored){done.errored=true;return doCallback(errCode)}return}if(++completed>=mounts.length){doCallback(null)}}for(var mount of mounts){if(mount.type.syncfs){mount.type.syncfs(mount,populate,done)}else{done(null)}}},mount(type,opts,mountpoint){var root=mountpoint==="/";var pseudo=!mountpoint;var node;if(root&&FS.root){throw new FS.ErrnoError(10)}else if(!root&&!pseudo){var lookup=FS.lookupPath(mountpoint,{follow_mount:false});mountpoint=lookup.path;node=lookup.node;if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}if(!FS.isDir(node.mode)){throw new FS.ErrnoError(54)}}var mount={type,opts,mountpoint,mounts:[]};var mountRoot=type.mount(mount);mountRoot.mount=mount;mount.root=mountRoot;if(root){FS.root=mountRoot}else if(node){node.mounted=mount;if(node.mount){node.mount.mounts.push(mount)}}return mountRoot},unmount(mountpoint){var lookup=FS.lookupPath(mountpoint,{follow_mount:false});if(!FS.isMountpoint(lookup.node)){throw new FS.ErrnoError(28)}var node=lookup.node;var mount=node.mounted;var mounts=FS.getMounts(mount);for(var[hash,current]of Object.entries(FS.nameTable)){while(current){var next=current.name_next;if(mounts.includes(current.mount)){FS.destroyNode(current)}current=next}}node.mounted=null;var idx=node.mount.mounts.indexOf(mount);node.mount.mounts.splice(idx,1)},lookup(parent,name){return parent.node_ops.lookup(parent,name)},mknod(path,mode,dev){var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;var name=PATH.basename(path);if(!name){throw new FS.ErrnoError(28)}if(name==="."||name===".."){throw new FS.ErrnoError(20)}var errCode=FS.mayCreate(parent,name);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.mknod){throw new FS.ErrnoError(63)}return parent.node_ops.mknod(parent,name,mode,dev)},statfs(path){return FS.statfsNode(FS.lookupPath(path,{follow:true}).node)},statfsStream(stream){return FS.statfsNode(stream.node)},statfsNode(node){var rtn={bsize:4096,frsize:4096,blocks:1e6,bfree:5e5,bavail:5e5,files:FS.nextInode,ffree:FS.nextInode-1,fsid:42,flags:2,namelen:255};if(node.node_ops.statfs){Object.assign(rtn,node.node_ops.statfs(node.mount.opts.root))}return rtn},create(path,mode=438){mode&=4095;mode|=32768;return FS.mknod(path,mode,0)},mkdir(path,mode=511){mode&=511|512;mode|=16384;return FS.mknod(path,mode,0)},mkdirTree(path,mode){var dirs=path.split("/");var d="";for(var dir of dirs){if(!dir)continue;if(d||PATH.isAbs(path))d+="/";d+=dir;try{FS.mkdir(d,mode)}catch(e){if(e.errno!=20)throw e}}},mkdev(path,mode,dev){if(typeof dev=="undefined"){dev=mode;mode=438}mode|=8192;return FS.mknod(path,mode,dev)},symlink(oldpath,newpath){if(!PATH_FS.resolve(oldpath)){throw new FS.ErrnoError(44)}var lookup=FS.lookupPath(newpath,{parent:true});var parent=lookup.node;if(!parent){throw new FS.ErrnoError(44)}var newname=PATH.basename(newpath);var errCode=FS.mayCreate(parent,newname);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.symlink){throw new FS.ErrnoError(63)}return parent.node_ops.symlink(parent,newname,oldpath)},rename(old_path,new_path){var old_dirname=PATH.dirname(old_path);var new_dirname=PATH.dirname(new_path);var old_name=PATH.basename(old_path);var new_name=PATH.basename(new_path);var lookup,old_dir,new_dir;lookup=FS.lookupPath(old_path,{parent:true});old_dir=lookup.node;lookup=FS.lookupPath(new_path,{parent:true});new_dir=lookup.node;if(!old_dir||!new_dir)throw new FS.ErrnoError(44);if(old_dir.mount!==new_dir.mount){throw new FS.ErrnoError(75)}var old_node=FS.lookupNode(old_dir,old_name);var relative=PATH_FS.relative(old_path,new_dirname);if(relative.charAt(0)!=="."){throw new FS.ErrnoError(28)}relative=PATH_FS.relative(new_path,old_dirname);if(relative.charAt(0)!=="."){throw new FS.ErrnoError(55)}var new_node;try{new_node=FS.lookupNode(new_dir,new_name)}catch(e){}if(old_node===new_node){return}var isdir=FS.isDir(old_node.mode);var errCode=FS.mayDelete(old_dir,old_name,isdir);if(errCode){throw new FS.ErrnoError(errCode)}errCode=new_node?FS.mayDelete(new_dir,new_name,isdir):FS.mayCreate(new_dir,new_name);if(errCode){throw new FS.ErrnoError(errCode)}if(!old_dir.node_ops.rename){throw new FS.ErrnoError(63)}if(FS.isMountpoint(old_node)||new_node&&FS.isMountpoint(new_node)){throw new FS.ErrnoError(10)}if(new_dir!==old_dir){errCode=FS.nodePermissions(old_dir,"w");if(errCode){throw new FS.ErrnoError(errCode)}}FS.hashRemoveNode(old_node);try{old_dir.node_ops.rename(old_node,new_dir,new_name);old_node.parent=new_dir}catch(e){throw e}finally{FS.hashAddNode(old_node)}},rmdir(path){var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;var name=PATH.basename(path);var node=FS.lookupNode(parent,name);var errCode=FS.mayDelete(parent,name,true);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.rmdir){throw new FS.ErrnoError(63)}if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}parent.node_ops.rmdir(parent,name);FS.destroyNode(node)},readdir(path){var lookup=FS.lookupPath(path,{follow:true});var node=lookup.node;var readdir=FS.checkOpExists(node.node_ops.readdir,54);return readdir(node)},unlink(path){var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;if(!parent){throw new FS.ErrnoError(44)}var name=PATH.basename(path);var node=FS.lookupNode(parent,name);var errCode=FS.mayDelete(parent,name,false);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.unlink){throw new FS.ErrnoError(63)}if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}parent.node_ops.unlink(parent,name);FS.destroyNode(node)},readlink(path){var lookup=FS.lookupPath(path);var link=lookup.node;if(!link){throw new FS.ErrnoError(44)}if(!link.node_ops.readlink){throw new FS.ErrnoError(28)}return link.node_ops.readlink(link)},stat(path,dontFollow){var lookup=FS.lookupPath(path,{follow:!dontFollow});var node=lookup.node;var getattr=FS.checkOpExists(node.node_ops.getattr,63);return getattr(node)},fstat(fd){var stream=FS.getStreamChecked(fd);var node=stream.node;var getattr=stream.stream_ops.getattr;var arg=getattr?stream:node;getattr??=node.node_ops.getattr;FS.checkOpExists(getattr,63);return getattr(arg)},lstat(path){return FS.stat(path,true)},doChmod(stream,node,mode,dontFollow){FS.doSetAttr(stream,node,{mode:mode&4095|node.mode&~4095,ctime:Date.now(),dontFollow})},chmod(path,mode,dontFollow){var node;if(typeof path=="string"){var lookup=FS.lookupPath(path,{follow:!dontFollow});node=lookup.node}else{node=path}FS.doChmod(null,node,mode,dontFollow)},lchmod(path,mode){FS.chmod(path,mode,true)},fchmod(fd,mode){var stream=FS.getStreamChecked(fd);FS.doChmod(stream,stream.node,mode,false)},doChown(stream,node,dontFollow){FS.doSetAttr(stream,node,{timestamp:Date.now(),dontFollow})},chown(path,uid,gid,dontFollow){var node;if(typeof path=="string"){var lookup=FS.lookupPath(path,{follow:!dontFollow});node=lookup.node}else{node=path}FS.doChown(null,node,dontFollow)},lchown(path,uid,gid){FS.chown(path,uid,gid,true)},fchown(fd,uid,gid){var stream=FS.getStreamChecked(fd);FS.doChown(stream,stream.node,false)},doTruncate(stream,node,len){if(FS.isDir(node.mode)){throw new FS.ErrnoError(31)}if(!FS.isFile(node.mode)){throw new FS.ErrnoError(28)}var errCode=FS.nodePermissions(node,"w");if(errCode){throw new FS.ErrnoError(errCode)}FS.doSetAttr(stream,node,{size:len,timestamp:Date.now()})},truncate(path,len){if(len<0){throw new FS.ErrnoError(28)}var node;if(typeof path=="string"){var lookup=FS.lookupPath(path,{follow:true});node=lookup.node}else{node=path}FS.doTruncate(null,node,len)},ftruncate(fd,len){var stream=FS.getStreamChecked(fd);if(len<0||(stream.flags&2097155)===0){throw new FS.ErrnoError(28)}FS.doTruncate(stream,stream.node,len)},utime(path,atime,mtime){var lookup=FS.lookupPath(path,{follow:true});var node=lookup.node;var setattr=FS.checkOpExists(node.node_ops.setattr,63);setattr(node,{atime,mtime})},open(path,flags,mode=438){if(path===""){throw new FS.ErrnoError(44)}flags=typeof flags=="string"?FS_modeStringToFlags(flags):flags;if(flags&64){mode=mode&4095|32768}else{mode=0}var node;var isDirPath;if(typeof path=="object"){node=path}else{isDirPath=path.endsWith("/");var lookup=FS.lookupPath(path,{follow:!(flags&131072),noent_okay:true});node=lookup.node;path=lookup.path}var created=false;if(flags&64){if(node){if(flags&128){throw new FS.ErrnoError(20)}}else if(isDirPath){throw new FS.ErrnoError(31)}else{node=FS.mknod(path,mode|511,0);created=true}}if(!node){throw new FS.ErrnoError(44)}if(FS.isChrdev(node.mode)){flags&=~512}if(flags&65536&&!FS.isDir(node.mode)){throw new FS.ErrnoError(54)}if(!created){var errCode=FS.mayOpen(node,flags);if(errCode){throw new FS.ErrnoError(errCode)}}if(flags&512&&!created){FS.truncate(node,0)}flags&=~(128|512|131072);var stream=FS.createStream({node,path:FS.getPath(node),flags,seekable:true,position:0,stream_ops:node.stream_ops,ungotten:[],error:false});if(stream.stream_ops.open){stream.stream_ops.open(stream)}if(created){FS.chmod(node,mode&511)}if(Module["logReadFiles"]&&!(flags&1)){if(!(path in FS.readFiles)){FS.readFiles[path]=1}}return stream},close(stream){if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if(stream.getdents)stream.getdents=null;try{if(stream.stream_ops.close){stream.stream_ops.close(stream)}}catch(e){throw e}finally{FS.closeStream(stream.fd)}stream.fd=null},isClosed(stream){return stream.fd===null},llseek(stream,offset,whence){if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if(!stream.seekable||!stream.stream_ops.llseek){throw new FS.ErrnoError(70)}if(whence!=0&&whence!=1&&whence!=2){throw new FS.ErrnoError(28)}stream.position=stream.stream_ops.llseek(stream,offset,whence);stream.ungotten=[];return stream.position},read(stream,buffer,offset,length,position){if(length<0||position<0){throw new FS.ErrnoError(28)}if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if((stream.flags&2097155)===1){throw new FS.ErrnoError(8)}if(FS.isDir(stream.node.mode)){throw new FS.ErrnoError(31)}if(!stream.stream_ops.read){throw new FS.ErrnoError(28)}var seeking=typeof position!="undefined";if(!seeking){position=stream.position}else if(!stream.seekable){throw new FS.ErrnoError(70)}var bytesRead=stream.stream_ops.read(stream,buffer,offset,length,position);if(!seeking)stream.position+=bytesRead;return bytesRead},write(stream,buffer,offset,length,position,canOwn){if(length<0||position<0){throw new FS.ErrnoError(28)}if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if((stream.flags&2097155)===0){throw new FS.ErrnoError(8)}if(FS.isDir(stream.node.mode)){throw new FS.ErrnoError(31)}if(!stream.stream_ops.write){throw new FS.ErrnoError(28)}if(stream.seekable&&stream.flags&1024){FS.llseek(stream,0,2)}var seeking=typeof position!="undefined";if(!seeking){position=stream.position}else if(!stream.seekable){throw new FS.ErrnoError(70)}var bytesWritten=stream.stream_ops.write(stream,buffer,offset,length,position,canOwn);if(!seeking)stream.position+=bytesWritten;return bytesWritten},mmap(stream,length,position,prot,flags){if((prot&2)!==0&&(flags&2)===0&&(stream.flags&2097155)!==2){throw new FS.ErrnoError(2)}if((stream.flags&2097155)===1){throw new FS.ErrnoError(2)}if(!stream.stream_ops.mmap){throw new FS.ErrnoError(43)}if(!length){throw new FS.ErrnoError(28)}return stream.stream_ops.mmap(stream,length,position,prot,flags)},msync(stream,buffer,offset,length,mmapFlags){if(!stream.stream_ops.msync){return 0}return stream.stream_ops.msync(stream,buffer,offset,length,mmapFlags)},ioctl(stream,cmd,arg){if(!stream.stream_ops.ioctl){throw new FS.ErrnoError(59)}return stream.stream_ops.ioctl(stream,cmd,arg)},readFile(path,opts={}){opts.flags=opts.flags||0;opts.encoding=opts.encoding||"binary";if(opts.encoding!=="utf8"&&opts.encoding!=="binary"){abort(`Invalid encoding type "${opts.encoding}"`)}var stream=FS.open(path,opts.flags);var stat=FS.stat(path);var length=stat.size;var buf=new Uint8Array(length);FS.read(stream,buf,0,length,0);if(opts.encoding==="utf8"){buf=UTF8ArrayToString(buf)}FS.close(stream);return buf},writeFile(path,data,opts={}){opts.flags=opts.flags||577;var stream=FS.open(path,opts.flags,opts.mode);if(typeof data=="string"){data=new Uint8Array(intArrayFromString(data,true))}if(ArrayBuffer.isView(data)){FS.write(stream,data,0,data.byteLength,undefined,opts.canOwn)}else{abort("Unsupported data type")}FS.close(stream)},cwd:()=>FS.currentPath,chdir(path){var lookup=FS.lookupPath(path,{follow:true});if(lookup.node===null){throw new FS.ErrnoError(44)}if(!FS.isDir(lookup.node.mode)){throw new FS.ErrnoError(54)}var errCode=FS.nodePermissions(lookup.node,"x");if(errCode){throw new FS.ErrnoError(errCode)}FS.currentPath=lookup.path},createDefaultDirectories(){FS.mkdir("/tmp");FS.mkdir("/home");FS.mkdir("/home/web_user")},createDefaultDevices(){FS.mkdir("/dev");FS.registerDevice(FS.makedev(1,3),{read:()=>0,write:(stream,buffer,offset,length,pos)=>length,llseek:()=>0});FS.mkdev("/dev/null",FS.makedev(1,3));TTY.register(FS.makedev(5,0),TTY.default_tty_ops);TTY.register(FS.makedev(6,0),TTY.default_tty1_ops);FS.mkdev("/dev/tty",FS.makedev(5,0));FS.mkdev("/dev/tty1",FS.makedev(6,0));var randomBuffer=new Uint8Array(1024),randomLeft=0;var randomByte=()=>{if(randomLeft===0){randomFill(randomBuffer);randomLeft=randomBuffer.byteLength}return randomBuffer[--randomLeft]};FS.createDevice("/dev","random",randomByte);FS.createDevice("/dev","urandom",randomByte);FS.mkdir("/dev/shm");FS.mkdir("/dev/shm/tmp")},createSpecialDirectories(){FS.mkdir("/proc");var proc_self=FS.mkdir("/proc/self");FS.mkdir("/proc/self/fd");FS.mount({mount(){var node=FS.createNode(proc_self,"fd",16895,73);node.stream_ops={llseek:MEMFS.stream_ops.llseek};node.node_ops={lookup(parent,name){var fd=+name;var stream=FS.getStreamChecked(fd);var ret={parent:null,mount:{mountpoint:"fake"},node_ops:{readlink:()=>stream.path},id:fd+1};ret.parent=ret;return ret},readdir(){return Array.from(FS.streams.entries()).filter(([k,v])=>v).map(([k,v])=>k.toString())}};return node}},{},"/proc/self/fd")},createStandardStreams(input,output,error){if(input){FS.createDevice("/dev","stdin",input)}else{FS.symlink("/dev/tty","/dev/stdin")}if(output){FS.createDevice("/dev","stdout",null,output)}else{FS.symlink("/dev/tty","/dev/stdout")}if(error){FS.createDevice("/dev","stderr",null,error)}else{FS.symlink("/dev/tty1","/dev/stderr")}var stdin=FS.open("/dev/stdin",0);var stdout=FS.open("/dev/stdout",1);var stderr=FS.open("/dev/stderr",1)},staticInit(){FS.nameTable=new Array(4096);FS.mount(MEMFS,{},"/");FS.createDefaultDirectories();FS.createDefaultDevices();FS.createSpecialDirectories();FS.filesystems={MEMFS}},init(input,output,error){FS.initialized=true;input??=Module["stdin"];output??=Module["stdout"];error??=Module["stderr"];FS.createStandardStreams(input,output,error)},quit(){FS.initialized=false;for(var stream of FS.streams){if(stream){FS.close(stream)}}},findObject(path,dontResolveLastLink){var ret=FS.analyzePath(path,dontResolveLastLink);if(!ret.exists){return null}return ret.object},analyzePath(path,dontResolveLastLink){try{var lookup=FS.lookupPath(path,{follow:!dontResolveLastLink});path=lookup.path}catch(e){}var ret={isRoot:false,exists:false,error:0,name:null,path:null,object:null,parentExists:false,parentPath:null,parentObject:null};try{var lookup=FS.lookupPath(path,{parent:true});ret.parentExists=true;ret.parentPath=lookup.path;ret.parentObject=lookup.node;ret.name=PATH.basename(path);lookup=FS.lookupPath(path,{follow:!dontResolveLastLink});ret.exists=true;ret.path=lookup.path;ret.object=lookup.node;ret.name=lookup.node.name;ret.isRoot=lookup.path==="/"}catch(e){ret.error=e.errno}return ret},createPath(parent,path,canRead,canWrite){parent=typeof parent=="string"?parent:FS.getPath(parent);var parts=path.split("/").reverse();while(parts.length){var part=parts.pop();if(!part)continue;var current=PATH.join2(parent,part);try{FS.mkdir(current)}catch(e){if(e.errno!=20)throw e}parent=current}return current},createFile(parent,name,properties,canRead,canWrite){var path=PATH.join2(typeof parent=="string"?parent:FS.getPath(parent),name);var mode=FS_getMode(canRead,canWrite);return FS.create(path,mode)},createDataFile(parent,name,data,canRead,canWrite,canOwn){var path=name;if(parent){parent=typeof parent=="string"?parent:FS.getPath(parent);path=name?PATH.join2(parent,name):parent}var mode=FS_getMode(canRead,canWrite);var node=FS.create(path,mode);if(data){if(typeof data=="string"){var arr=new Array(data.length);for(var i=0,len=data.length;i<len;++i)arr[i]=data.charCodeAt(i);data=arr}FS.chmod(node,mode|146);var stream=FS.open(node,577);FS.write(stream,data,0,data.length,0,canOwn);FS.close(stream);FS.chmod(node,mode)}},createDevice(parent,name,input,output){var path=PATH.join2(typeof parent=="string"?parent:FS.getPath(parent),name);var mode=FS_getMode(!!input,!!output);FS.createDevice.major??=64;var dev=FS.makedev(FS.createDevice.major++,0);FS.registerDevice(dev,{open(stream){stream.seekable=false},close(stream){if(output?.buffer?.length){output(10)}},read(stream,buffer,offset,length,pos){var bytesRead=0;for(var i=0;i<length;i++){var result;try{result=input()}catch(e){throw new FS.ErrnoError(29)}if(result===undefined&&bytesRead===0){throw new FS.ErrnoError(6)}if(result===null||result===undefined)break;bytesRead++;buffer[offset+i]=result}if(bytesRead){stream.node.atime=Date.now()}return bytesRead},write(stream,buffer,offset,length,pos){for(var i=0;i<length;i++){try{output(buffer[offset+i])}catch(e){throw new FS.ErrnoError(29)}}if(length){stream.node.mtime=stream.node.ctime=Date.now()}return i}});return FS.mkdev(path,mode,dev)},forceLoadFile(obj){if(obj.isDevice||obj.isFolder||obj.link||obj.contents)return true;if(globalThis.XMLHttpRequest){abort("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.")}else{try{obj.contents=readBinary(obj.url)}catch(e){throw new FS.ErrnoError(29)}}},createLazyFile(parent,name,url,canRead,canWrite){class LazyUint8Array{lengthKnown=false;chunks=[];get(idx){if(idx>this.length-1||idx<0){return undefined}var chunkOffset=idx%this.chunkSize;var chunkNum=idx/this.chunkSize|0;return this.getter(chunkNum)[chunkOffset]}setDataGetter(getter){this.getter=getter}cacheLength(){var xhr=new XMLHttpRequest;xhr.open("HEAD",url,false);xhr.send(null);if(!(xhr.status>=200&&xhr.status<300||xhr.status===304))abort("Couldn\'t load "+url+". Status: "+xhr.status);var datalength=Number(xhr.getResponseHeader("Content-length"));var header;var hasByteServing=(header=xhr.getResponseHeader("Accept-Ranges"))&&header==="bytes";var usesGzip=(header=xhr.getResponseHeader("Content-Encoding"))&&header==="gzip";var chunkSize=1024*1024;if(!hasByteServing)chunkSize=datalength;var doXHR=(from,to)=>{if(from>to)abort("invalid range ("+from+", "+to+") or no bytes requested!");if(to>datalength-1)abort("only "+datalength+" bytes available! programmer error!");var xhr=new XMLHttpRequest;xhr.open("GET",url,false);if(datalength!==chunkSize)xhr.setRequestHeader("Range","bytes="+from+"-"+to);xhr.responseType="arraybuffer";if(xhr.overrideMimeType){xhr.overrideMimeType("text/plain; charset=x-user-defined")}xhr.send(null);if(!(xhr.status>=200&&xhr.status<300||xhr.status===304))abort("Couldn\'t load "+url+". Status: "+xhr.status);if(xhr.response!==undefined){return new Uint8Array(xhr.response||[])}return intArrayFromString(xhr.responseText||"",true)};var lazyArray=this;lazyArray.setDataGetter(chunkNum=>{var start=chunkNum*chunkSize;var end=(chunkNum+1)*chunkSize-1;end=Math.min(end,datalength-1);if(typeof lazyArray.chunks[chunkNum]=="undefined"){lazyArray.chunks[chunkNum]=doXHR(start,end)}if(typeof lazyArray.chunks[chunkNum]=="undefined")abort("doXHR failed!");return lazyArray.chunks[chunkNum]});if(usesGzip||!datalength){chunkSize=datalength=1;datalength=this.getter(0).length;chunkSize=datalength;out("LazyFiles on gzip forces download of the whole file when length is accessed")}this._length=datalength;this._chunkSize=chunkSize;this.lengthKnown=true}get length(){if(!this.lengthKnown){this.cacheLength()}return this._length}get chunkSize(){if(!this.lengthKnown){this.cacheLength()}return this._chunkSize}}if(globalThis.XMLHttpRequest){if(!ENVIRONMENT_IS_WORKER)abort("Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc");var lazyArray=new LazyUint8Array;var properties={isDevice:false,contents:lazyArray}}else{var properties={isDevice:false,url}}var node=FS.createFile(parent,name,properties,canRead,canWrite);if(properties.contents){node.contents=properties.contents}else if(properties.url){node.contents=null;node.url=properties.url}Object.defineProperties(node,{usedBytes:{get:function(){return this.contents.length}}});var stream_ops={};for(const[key,fn]of Object.entries(node.stream_ops)){stream_ops[key]=(...args)=>{FS.forceLoadFile(node);return fn(...args)}}function writeChunks(stream,buffer,offset,length,position){var contents=stream.node.contents;if(position>=contents.length)return 0;var size=Math.min(contents.length-position,length);if(contents.slice){for(var i=0;i<size;i++){buffer[offset+i]=contents[position+i]}}else{for(var i=0;i<size;i++){buffer[offset+i]=contents.get(position+i)}}return size}stream_ops.read=(stream,buffer,offset,length,position)=>{FS.forceLoadFile(node);return writeChunks(stream,buffer,offset,length,position)};stream_ops.mmap=(stream,length,position,prot,flags)=>{FS.forceLoadFile(node);var ptr=mmapAlloc(length);if(!ptr){throw new FS.ErrnoError(48)}writeChunks(stream,(growMemViews(),HEAP8),ptr,length,position);return{ptr,allocated:true}};node.stream_ops=stream_ops;return node}};var UTF8ToString=(ptr,maxBytesToRead,ignoreNul)=>ptr?UTF8ArrayToString((growMemViews(),HEAPU8),ptr,maxBytesToRead,ignoreNul):"";var SYSCALLS={DEFAULT_POLLMASK:5,calculateAt(dirfd,path,allowEmpty){if(PATH.isAbs(path)){return path}var dir;if(dirfd===-100){dir=FS.cwd()}else{var dirstream=SYSCALLS.getStreamFromFD(dirfd);dir=dirstream.path}if(path.length==0){if(!allowEmpty){throw new FS.ErrnoError(44)}return dir}return dir+"/"+path},writeStat(buf,stat){(growMemViews(),HEAPU32)[buf/4]=stat.dev;(growMemViews(),HEAPU32)[(buf+4)/4]=stat.mode;(growMemViews(),HEAPU64)[(buf+8)/8]=BigInt(stat.nlink);(growMemViews(),HEAPU32)[(buf+16)/4]=stat.uid;(growMemViews(),HEAPU32)[(buf+20)/4]=stat.gid;(growMemViews(),HEAPU32)[(buf+24)/4]=stat.rdev;(growMemViews(),HEAP64)[(buf+32)/8]=BigInt(stat.size);(growMemViews(),HEAP32)[(buf+40)/4]=4096;(growMemViews(),HEAP32)[(buf+44)/4]=stat.blocks;var atime=stat.atime.getTime();var mtime=stat.mtime.getTime();var ctime=stat.ctime.getTime();(growMemViews(),HEAP64)[(buf+48)/8]=BigInt(Math.floor(atime/1e3));(growMemViews(),HEAPU64)[(buf+56)/8]=BigInt(atime%1e3*1e3*1e3);(growMemViews(),HEAP64)[(buf+64)/8]=BigInt(Math.floor(mtime/1e3));(growMemViews(),HEAPU64)[(buf+72)/8]=BigInt(mtime%1e3*1e3*1e3);(growMemViews(),HEAP64)[(buf+80)/8]=BigInt(Math.floor(ctime/1e3));(growMemViews(),HEAPU64)[(buf+88)/8]=BigInt(ctime%1e3*1e3*1e3);(growMemViews(),HEAP64)[(buf+96)/8]=BigInt(stat.ino);return 0},writeStatFs(buf,stats){(growMemViews(),HEAPU32)[(buf+8)/4]=stats.bsize;(growMemViews(),HEAPU32)[(buf+72)/4]=stats.bsize;(growMemViews(),HEAP64)[(buf+16)/8]=BigInt(stats.blocks);(growMemViews(),HEAP64)[(buf+24)/8]=BigInt(stats.bfree);(growMemViews(),HEAP64)[(buf+32)/8]=BigInt(stats.bavail);(growMemViews(),HEAP64)[(buf+40)/8]=BigInt(stats.files);(growMemViews(),HEAP64)[(buf+48)/8]=BigInt(stats.ffree);(growMemViews(),HEAPU32)[(buf+56)/4]=stats.fsid;(growMemViews(),HEAPU32)[(buf+80)/4]=stats.flags;(growMemViews(),HEAPU32)[(buf+64)/4]=stats.namelen},doMsync(addr,stream,len,flags,offset){if(!FS.isFile(stream.node.mode)){throw new FS.ErrnoError(43)}if(flags&2){return 0}var buffer=(growMemViews(),HEAPU8).slice(addr,addr+len);FS.msync(stream,buffer,offset,len,flags)},getStreamFromFD(fd){var stream=FS.getStreamChecked(fd);return stream},varargs:undefined,getStr(ptr){var ret=UTF8ToString(ptr);return ret}};function ___syscall_fcntl64(fd,cmd,varargs){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(3,0,1,fd,cmd,varargs);varargs=bigintToI53Checked(varargs);SYSCALLS.varargs=varargs;try{var stream=SYSCALLS.getStreamFromFD(fd);switch(cmd){case 0:{var arg=syscallGetVarargI();if(arg<0){return-28}while(FS.streams[arg]){arg++}var newStream;newStream=FS.dupStream(stream,arg);return newStream.fd}case 1:case 2:return 0;case 3:return stream.flags;case 4:{var arg=syscallGetVarargI();stream.flags|=arg;return 0}case 5:{var arg=syscallGetVarargP();var offset=0;(growMemViews(),HEAP16)[(arg+offset)/2]=2;return 0}case 6:case 7:return 0}return-28}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_fstat64(fd,buf){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(4,0,1,fd,buf);buf=bigintToI53Checked(buf);try{return SYSCALLS.writeStat(buf,FS.fstat(fd))}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var stringToUTF8=(str,outPtr,maxBytesToWrite)=>stringToUTF8Array(str,(growMemViews(),HEAPU8),outPtr,maxBytesToWrite);function ___syscall_getcwd(buf,size){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(5,0,1,buf,size);buf=bigintToI53Checked(buf);size=bigintToI53Checked(size);try{if(size===0)return-28;var cwd=FS.cwd();var cwdLengthInBytes=lengthBytesUTF8(cwd)+1;if(size<cwdLengthInBytes)return-68;stringToUTF8(cwd,buf,size);return cwdLengthInBytes}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_getdents64(fd,dirp,count){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(6,0,1,fd,dirp,count);dirp=bigintToI53Checked(dirp);count=bigintToI53Checked(count);try{var stream=SYSCALLS.getStreamFromFD(fd);stream.getdents||=FS.readdir(stream.path);var struct_size=280;var pos=0;var off=FS.llseek(stream,0,1);var startIdx=Math.floor(off/struct_size);var endIdx=Math.min(stream.getdents.length,startIdx+Math.floor(count/struct_size));for(var idx=startIdx;idx<endIdx;idx++){var id;var type;var name=stream.getdents[idx];if(name==="."){id=stream.node.id;type=4}else if(name===".."){var lookup=FS.lookupPath(stream.path,{parent:true});id=lookup.node.id;type=4}else{var child;try{child=FS.lookupNode(stream.node,name)}catch(e){if(e?.errno===28){continue}throw e}id=child.id;type=FS.isChrdev(child.mode)?2:FS.isDir(child.mode)?4:FS.isLink(child.mode)?10:8}(growMemViews(),HEAP64)[(dirp+pos)/8]=BigInt(id);(growMemViews(),HEAP64)[(dirp+pos+8)/8]=BigInt((idx+1)*struct_size);(growMemViews(),HEAP16)[(dirp+pos+16)/2]=280;(growMemViews(),HEAP8)[dirp+pos+18]=type;stringToUTF8(name,dirp+pos+19,256);pos+=struct_size}FS.llseek(stream,idx*struct_size,0);return pos}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_ioctl(fd,op,varargs){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(7,0,1,fd,op,varargs);varargs=bigintToI53Checked(varargs);SYSCALLS.varargs=varargs;try{var stream=SYSCALLS.getStreamFromFD(fd);switch(op){case 21509:{if(!stream.tty)return-59;return 0}case 21505:{if(!stream.tty)return-59;if(stream.tty.ops.ioctl_tcgets){var termios=stream.tty.ops.ioctl_tcgets(stream);var argp=syscallGetVarargP();(growMemViews(),HEAP32)[argp/4]=termios.c_iflag||0;(growMemViews(),HEAP32)[(argp+4)/4]=termios.c_oflag||0;(growMemViews(),HEAP32)[(argp+8)/4]=termios.c_cflag||0;(growMemViews(),HEAP32)[(argp+12)/4]=termios.c_lflag||0;for(var i=0;i<32;i++){(growMemViews(),HEAP8)[argp+i+17]=termios.c_cc[i]||0}return 0}return 0}case 21510:case 21511:case 21512:{if(!stream.tty)return-59;return 0}case 21506:case 21507:case 21508:{if(!stream.tty)return-59;if(stream.tty.ops.ioctl_tcsets){var argp=syscallGetVarargP();var c_iflag=(growMemViews(),HEAP32)[argp/4];var c_oflag=(growMemViews(),HEAP32)[(argp+4)/4];var c_cflag=(growMemViews(),HEAP32)[(argp+8)/4];var c_lflag=(growMemViews(),HEAP32)[(argp+12)/4];var c_cc=[];for(var i=0;i<32;i++){c_cc.push((growMemViews(),HEAP8)[argp+i+17])}return stream.tty.ops.ioctl_tcsets(stream.tty,op,{c_iflag,c_oflag,c_cflag,c_lflag,c_cc})}return 0}case 21519:{if(!stream.tty)return-59;var argp=syscallGetVarargP();(growMemViews(),HEAP32)[argp/4]=0;return 0}case 21520:{if(!stream.tty)return-59;return-28}case 21537:case 21531:{var argp=syscallGetVarargP();return FS.ioctl(stream,op,argp)}case 21523:{if(!stream.tty)return-59;if(stream.tty.ops.ioctl_tiocgwinsz){var winsize=stream.tty.ops.ioctl_tiocgwinsz(stream.tty);var argp=syscallGetVarargP();(growMemViews(),HEAP16)[argp/2]=winsize[0];(growMemViews(),HEAP16)[(argp+2)/2]=winsize[1]}return 0}case 21524:{if(!stream.tty)return-59;return 0}case 21515:{if(!stream.tty)return-59;return 0}default:return-28}}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_lstat64(path,buf){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(8,0,1,path,buf);path=bigintToI53Checked(path);buf=bigintToI53Checked(buf);try{path=SYSCALLS.getStr(path);return SYSCALLS.writeStat(buf,FS.lstat(path))}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_newfstatat(dirfd,path,buf,flags){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(9,0,1,dirfd,path,buf,flags);path=bigintToI53Checked(path);buf=bigintToI53Checked(buf);try{path=SYSCALLS.getStr(path);var nofollow=flags&256;var allowEmpty=flags&4096;flags=flags&~6400;path=SYSCALLS.calculateAt(dirfd,path,allowEmpty);return SYSCALLS.writeStat(buf,nofollow?FS.lstat(path):FS.stat(path))}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_openat(dirfd,path,flags,varargs){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(10,0,1,dirfd,path,flags,varargs);path=bigintToI53Checked(path);varargs=bigintToI53Checked(varargs);SYSCALLS.varargs=varargs;try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);var mode=varargs?syscallGetVarargI():0;return FS.open(path,flags,mode).fd}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_stat64(path,buf){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(11,0,1,path,buf);path=bigintToI53Checked(path);buf=bigintToI53Checked(buf);try{path=SYSCALLS.getStr(path);return SYSCALLS.writeStat(buf,FS.stat(path))}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var __abort_js=()=>abort("");function __emscripten_init_main_thread_js(tb){tb=bigintToI53Checked(tb);__emscripten_thread_init(tb,!ENVIRONMENT_IS_WORKER,1,!ENVIRONMENT_IS_WEB,5242880,false);PThread.threadInitTLS()}var handleException=e=>{if(e instanceof ExitStatus||e=="unwind"){return EXITSTATUS}quit_(1,e)};var maybeExit=()=>{if(!keepRuntimeAlive()){try{if(ENVIRONMENT_IS_PTHREAD){if(_pthread_self())__emscripten_thread_exit(EXITSTATUS);return}_exit(EXITSTATUS)}catch(e){handleException(e)}}};var callUserCallback=func=>{if(ABORT){return}try{func();maybeExit()}catch(e){handleException(e)}};function __emscripten_thread_mailbox_await(pthread_ptr){pthread_ptr=bigintToI53Checked(pthread_ptr);if(Atomics.waitAsync){var wait=Atomics.waitAsync((growMemViews(),HEAP32),pthread_ptr/4,pthread_ptr);wait.value.then(checkMailbox);var waitingAsync=pthread_ptr+228;Atomics.store((growMemViews(),HEAP32),waitingAsync/4,1)}}var checkMailbox=()=>callUserCallback(()=>{var pthread_ptr=_pthread_self();if(pthread_ptr){__emscripten_thread_mailbox_await(pthread_ptr);__emscripten_check_mailbox()}});function __emscripten_notify_mailbox_postmessage(targetThread,currThreadId){targetThread=bigintToI53Checked(targetThread);currThreadId=bigintToI53Checked(currThreadId);if(targetThread==currThreadId){setTimeout(checkMailbox)}else if(ENVIRONMENT_IS_PTHREAD){postMessage({targetThread,cmd:"checkMailbox"})}else{var worker=PThread.pthreads[targetThread];if(!worker){return}worker.postMessage({cmd:"checkMailbox"})}}var proxiedJSCallArgs=[];function __emscripten_receive_on_main_thread_js(funcIndex,emAsmAddr,callingThread,numCallArgs,args){emAsmAddr=bigintToI53Checked(emAsmAddr);callingThread=bigintToI53Checked(callingThread);args=bigintToI53Checked(args);numCallArgs/=2;proxiedJSCallArgs.length=numCallArgs;var b=args/8;for(var i=0;i<numCallArgs;i++){if((growMemViews(),HEAP64)[b+2*i]){proxiedJSCallArgs[i]=(growMemViews(),HEAP64)[b+2*i+1]}else{proxiedJSCallArgs[i]=(growMemViews(),HEAPF64)[b+2*i+1]}}var func=proxiedFunctionTable[funcIndex];PThread.currentProxiedOperationCallerThread=callingThread;var rtn=func(...proxiedJSCallArgs);PThread.currentProxiedOperationCallerThread=0;if(typeof rtn=="bigint"){rtn=bigintToI53Checked(rtn)}return rtn}function __emscripten_thread_cleanup(thread){thread=bigintToI53Checked(thread);if(!ENVIRONMENT_IS_PTHREAD)cleanupThread(thread);else postMessage({cmd:"cleanupThread",thread})}function __emscripten_thread_set_strongref(thread){thread=bigintToI53Checked(thread);if(ENVIRONMENT_IS_NODE){PThread.pthreads[thread].ref()}}var isLeapYear=year=>year%4===0&&(year%100!==0||year%400===0);var MONTH_DAYS_LEAP_CUMULATIVE=[0,31,60,91,121,152,182,213,244,274,305,335];var MONTH_DAYS_REGULAR_CUMULATIVE=[0,31,59,90,120,151,181,212,243,273,304,334];var ydayFromDate=date=>{var leap=isLeapYear(date.getFullYear());var monthDaysCumulative=leap?MONTH_DAYS_LEAP_CUMULATIVE:MONTH_DAYS_REGULAR_CUMULATIVE;var yday=monthDaysCumulative[date.getMonth()]+date.getDate()-1;return yday};function __localtime_js(time,tmPtr){time=bigintToI53Checked(time);tmPtr=bigintToI53Checked(tmPtr);var date=new Date(time*1e3);(growMemViews(),HEAP32)[tmPtr/4]=date.getSeconds();(growMemViews(),HEAP32)[(tmPtr+4)/4]=date.getMinutes();(growMemViews(),HEAP32)[(tmPtr+8)/4]=date.getHours();(growMemViews(),HEAP32)[(tmPtr+12)/4]=date.getDate();(growMemViews(),HEAP32)[(tmPtr+16)/4]=date.getMonth();(growMemViews(),HEAP32)[(tmPtr+20)/4]=date.getFullYear()-1900;(growMemViews(),HEAP32)[(tmPtr+24)/4]=date.getDay();var yday=ydayFromDate(date)|0;(growMemViews(),HEAP32)[(tmPtr+28)/4]=yday;(growMemViews(),HEAP64)[(tmPtr+40)/8]=BigInt(-(date.getTimezoneOffset()*60));var start=new Date(date.getFullYear(),0,1);var summerOffset=new Date(date.getFullYear(),6,1).getTimezoneOffset();var winterOffset=start.getTimezoneOffset();var dst=(summerOffset!=winterOffset&&date.getTimezoneOffset()==Math.min(winterOffset,summerOffset))|0;(growMemViews(),HEAP32)[(tmPtr+32)/4]=dst}function __mmap_js(len,prot,flags,fd,offset,allocated,addr){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(12,0,1,len,prot,flags,fd,offset,allocated,addr);len=bigintToI53Checked(len);offset=bigintToI53Checked(offset);allocated=bigintToI53Checked(allocated);addr=bigintToI53Checked(addr);try{var stream=SYSCALLS.getStreamFromFD(fd);var res=FS.mmap(stream,len,offset,prot,flags);var ptr=res.ptr;(growMemViews(),HEAP32)[allocated/4]=res.allocated;(growMemViews(),HEAPU64)[addr/8]=BigInt(ptr);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function __munmap_js(addr,len,prot,flags,fd,offset){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(13,0,1,addr,len,prot,flags,fd,offset);addr=bigintToI53Checked(addr);len=bigintToI53Checked(len);offset=bigintToI53Checked(offset);try{var stream=SYSCALLS.getStreamFromFD(fd);if(prot&2){SYSCALLS.doMsync(addr,stream,len,flags,offset)}}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var __tzset_js=function(timezone,daylight,std_name,dst_name){timezone=bigintToI53Checked(timezone);daylight=bigintToI53Checked(daylight);std_name=bigintToI53Checked(std_name);dst_name=bigintToI53Checked(dst_name);var currentYear=(new Date).getFullYear();var winter=new Date(currentYear,0,1);var summer=new Date(currentYear,6,1);var winterOffset=winter.getTimezoneOffset();var summerOffset=summer.getTimezoneOffset();var stdTimezoneOffset=Math.max(winterOffset,summerOffset);(growMemViews(),HEAPU64)[timezone/8]=BigInt(stdTimezoneOffset*60);(growMemViews(),HEAP32)[daylight/4]=Number(winterOffset!=summerOffset);var extractZone=timezoneOffset=>{var sign=timezoneOffset>=0?"-":"+";var absOffset=Math.abs(timezoneOffset);var hours=String(Math.floor(absOffset/60)).padStart(2,"0");var minutes=String(absOffset%60).padStart(2,"0");return`UTC${sign}${hours}${minutes}`};var winterName=extractZone(winterOffset);var summerName=extractZone(summerOffset);if(summerOffset<winterOffset){stringToUTF8(winterName,std_name,17);stringToUTF8(summerName,dst_name,17)}else{stringToUTF8(winterName,dst_name,17);stringToUTF8(summerName,std_name,17)}};var _emscripten_get_now=()=>performance.timeOrigin+performance.now();var _emscripten_date_now=()=>Date.now();var nowIsMonotonic=1;var checkWasiClock=clock_id=>clock_id>=0&&clock_id<=3;function _clock_time_get(clk_id,ignored_precision,ptime){ignored_precision=bigintToI53Checked(ignored_precision);ptime=bigintToI53Checked(ptime);if(!checkWasiClock(clk_id)){return 28}var now;if(clk_id===0){now=_emscripten_date_now()}else if(nowIsMonotonic){now=_emscripten_get_now()}else{return 52}var nsec=Math.round(now*1e3*1e3);(growMemViews(),HEAP64)[ptime/8]=BigInt(nsec);return 0}var _emscripten_check_blocking_allowed=()=>{};var runtimeKeepalivePush=()=>{runtimeKeepaliveCounter+=1};var _emscripten_exit_with_live_runtime=()=>{runtimeKeepalivePush();throw"unwind"};var jsStackTrace=()=>(new Error).stack.toString();var getCallstack=flags=>{var callstack=jsStackTrace();var lines=callstack.split("\\n");callstack="";var firefoxRe=new RegExp("\\\\s*(.*?)@(.*?):([0-9]+):([0-9]+)");var chromeRe=new RegExp("\\\\s*at (.*?) \\\\((.*):(.*):(.*)\\\\)");for(var line of lines){var symbolName="";var file="";var lineno=0;var column=0;var parts=chromeRe.exec(line);if(parts?.length==5){symbolName=parts[1];file=parts[2];lineno=parts[3];column=parts[4]}else{parts=firefoxRe.exec(line);if(parts?.length>=4){symbolName=parts[1];file=parts[2];lineno=parts[3];column=parts[4]|0}else{callstack+=line+"\\n";continue}}if(symbolName=="_emscripten_log"||symbolName=="_emscripten_get_callstack"){callstack="";continue}if(flags&24){if(flags&64){file=file.substring(file.replace(/\\\\/g,"/").lastIndexOf("/")+1)}callstack+=`    at ${symbolName} (${file}:${lineno}:${column})\\n`}}callstack=callstack.replace(/\\s+$/,"");return callstack};function _emscripten_get_callstack(flags,str,maxbytes){str=bigintToI53Checked(str);var callstack=getCallstack(flags);if(!str||maxbytes<=0){return lengthBytesUTF8(callstack)+1}var bytesWrittenExcludingNull=stringToUTF8(callstack,str,maxbytes);return bytesWrittenExcludingNull+1}var getHeapMax=()=>4294967296;var _emscripten_get_heap_max=()=>BigInt(getHeapMax());var _emscripten_has_asyncify=()=>2;var _emscripten_num_logical_cores=()=>ENVIRONMENT_IS_NODE?require("os").cpus().length:navigator["hardwareConcurrency"];var growMemory=size=>{var oldHeapSize=wasmMemory.buffer.byteLength;var pages=(size-oldHeapSize+65535)/65536|0;try{wasmMemory.grow(BigInt(pages));updateMemoryViews();return 1}catch(e){}};function _emscripten_resize_heap(requestedSize){requestedSize=bigintToI53Checked(requestedSize);var oldSize=(growMemViews(),HEAPU8).length;if(requestedSize<=oldSize){return false}var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignMemory(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false}var stringToUTF8OnStack=str=>{var size=lengthBytesUTF8(str)+1;var ret=stackAlloc(size);stringToUTF8(str,ret,size);return ret};var writeI53ToI64=(ptr,num)=>{(growMemViews(),HEAPU32)[ptr/4]=num;var lower=(growMemViews(),HEAPU32)[ptr/4];(growMemViews(),HEAPU32)[(ptr+4)/4]=(num-lower)/4294967296};var stringToNewUTF8=str=>{var size=lengthBytesUTF8(str)+1;var ret=_malloc(size);if(ret)stringToUTF8(str,ret,size);return ret};var readI53FromI64=ptr=>(growMemViews(),HEAPU32)[ptr/4]+(growMemViews(),HEAP32)[(ptr+4)/4]*4294967296;var WebGPU={Internals:{jsObjects:[],jsObjectInsert:(ptr,jsObject)=>{WebGPU.Internals.jsObjects[ptr]=jsObject},bufferOnUnmaps:[],futures:[],futureInsert:(futureId,promise)=>{WebGPU.Internals.futures[futureId]=new Promise(resolve=>promise.finally(()=>resolve(futureId)))}},getJsObject:ptr=>{if(!ptr)return undefined;return WebGPU.Internals.jsObjects[ptr]},importJsAdapter:(obj,parentPtr=0)=>{var ptr=_emwgpuCreateAdapter(parentPtr);WebGPU.Internals.jsObjects[ptr]=obj;return ptr},importJsBindGroup:(obj,parentPtr=0)=>{var ptr=_emwgpuCreateBindGroup(parentPtr);WebGPU.Internals.jsObjects[ptr]=obj;return ptr},importJsBindGroupLayout:(obj,parentPtr=0)=>{var ptr=_emwgpuCreateBindGroupLayout(parentPtr);WebGPU.Internals.jsObjects[ptr]=obj;return ptr},importJsBuffer:(buffer,parentPtr=0)=>{assert(buffer.mapState==="unmapped");var bufferPtr=_emwgpuCreateBuffer(parentPtr);WebGPU.Internals.jsObjectInsert(bufferPtr,buffer);return bufferPtr},importJsCommandBuffer:(obj,parentPtr=0)=>{var ptr=_emwgpuCreateCommandBuffer(parentPtr);WebGPU.Internals.jsObjects[ptr]=obj;return ptr},importJsCommandEncoder:(obj,parentPtr=0)=>{var ptr=_emwgpuCreateCommandEncoder(parentPtr);WebGPU.Internals.jsObjects[ptr]=obj;return ptr},importJsComputePassEncoder:(obj,parentPtr=0)=>{var ptr=_emwgpuCreateComputePassEncoder(parentPtr);WebGPU.Internals.jsObjects[ptr]=obj;return ptr},importJsComputePipeline:(obj,parentPtr=0)=>{var ptr=_emwgpuCreateComputePipeline(parentPtr);WebGPU.Internals.jsObjects[ptr]=obj;return ptr},importJsDevice:(device,parentPtr=0)=>{var queuePtr=_emwgpuCreateQueue(parentPtr);var devicePtr=_emwgpuCreateDevice(parentPtr,queuePtr);WebGPU.Internals.jsObjectInsert(queuePtr,device.queue);WebGPU.Internals.jsObjectInsert(devicePtr,device);return devicePtr},importJsExternalTexture:(obj,parentPtr=0)=>{var ptr=_emwgpuCreateExternalTexture(parentPtr);WebGPU.Internals.jsObjects[ptr]=obj;return ptr},importJsPipelineLayout:(obj,parentPtr=0)=>{var ptr=_emwgpuCreatePipelineLayout(parentPtr);WebGPU.Internals.jsObjects[ptr]=obj;return ptr},importJsQuerySet:(obj,parentPtr=0)=>{var ptr=_emwgpuCreateQuerySet(parentPtr);WebGPU.Internals.jsObjects[ptr]=obj;return ptr},importJsQueue:(obj,parentPtr=0)=>{var ptr=_emwgpuCreateQueue(parentPtr);WebGPU.Internals.jsObjects[ptr]=obj;return ptr},importJsRenderBundle:(obj,parentPtr=0)=>{var ptr=_emwgpuCreateRenderBundle(parentPtr);WebGPU.Internals.jsObjects[ptr]=obj;return ptr},importJsRenderBundleEncoder:(obj,parentPtr=0)=>{var ptr=_emwgpuCreateRenderBundleEncoder(parentPtr);WebGPU.Internals.jsObjects[ptr]=obj;return ptr},importJsRenderPassEncoder:(obj,parentPtr=0)=>{var ptr=_emwgpuCreateRenderPassEncoder(parentPtr);WebGPU.Internals.jsObjects[ptr]=obj;return ptr},importJsRenderPipeline:(obj,parentPtr=0)=>{var ptr=_emwgpuCreateRenderPipeline(parentPtr);WebGPU.Internals.jsObjects[ptr]=obj;return ptr},importJsSampler:(obj,parentPtr=0)=>{var ptr=_emwgpuCreateSampler(parentPtr);WebGPU.Internals.jsObjects[ptr]=obj;return ptr},importJsShaderModule:(obj,parentPtr=0)=>{var ptr=_emwgpuCreateShaderModule(parentPtr);WebGPU.Internals.jsObjects[ptr]=obj;return ptr},importJsSurface:(obj,parentPtr=0)=>{var ptr=_emwgpuCreateSurface(parentPtr);WebGPU.Internals.jsObjects[ptr]=obj;return ptr},importJsTexture:(obj,parentPtr=0)=>{var ptr=_emwgpuCreateTexture(parentPtr);WebGPU.Internals.jsObjects[ptr]=obj;return ptr},importJsTextureView:(obj,parentPtr=0)=>{var ptr=_emwgpuCreateTextureView(parentPtr);WebGPU.Internals.jsObjects[ptr]=obj;return ptr},errorCallback:(callback,type,message,userdata)=>{var sp=stackSave();var messagePtr=stringToUTF8OnStack(message);((a1,a2,a3)=>getWasmTableEntry(callback).call(null,a1,BigInt(a2),BigInt(a3)))(type,BigInt(messagePtr),userdata);stackRestore(sp)},iterateExtensions:(root,handlers)=>{for(var ptr=Number((growMemViews(),HEAPU64)[root/8]);ptr;ptr=Number((growMemViews(),HEAPU64)[ptr/8])){var sType=(growMemViews(),HEAP32)[(ptr+8)/4];var handler=handlers[sType](ptr)}},setStringView:(ptr,data,length)=>{(growMemViews(),HEAPU64)[ptr/8]=BigInt(data);(growMemViews(),HEAPU64)[(ptr+8)/8]=BigInt(length)},makeStringFromStringView:stringViewPtr=>{var ptr=Number((growMemViews(),HEAPU64)[stringViewPtr/8]);var length=Number((growMemViews(),HEAPU64)[(stringViewPtr+8)/8]);return UTF8ToString(ptr,length)},makeStringFromOptionalStringView:stringViewPtr=>{var ptr=Number((growMemViews(),HEAPU64)[stringViewPtr/8]);var length=Number((growMemViews(),HEAPU64)[(stringViewPtr+8)/8]);if(!ptr){if(length===0){return""}return undefined}return UTF8ToString(ptr,length)},makeColor:ptr=>({r:(growMemViews(),HEAPF64)[ptr/8],g:(growMemViews(),HEAPF64)[(ptr+8)/8],b:(growMemViews(),HEAPF64)[(ptr+16)/8],a:(growMemViews(),HEAPF64)[(ptr+24)/8]}),makeExtent3D:ptr=>({width:(growMemViews(),HEAPU32)[ptr/4],height:(growMemViews(),HEAPU32)[(ptr+4)/4],depthOrArrayLayers:(growMemViews(),HEAPU32)[(ptr+8)/4]}),makeOrigin3D:ptr=>({x:(growMemViews(),HEAPU32)[ptr/4],y:(growMemViews(),HEAPU32)[(ptr+4)/4],z:(growMemViews(),HEAPU32)[(ptr+8)/4]}),makeTexelCopyTextureInfo:ptr=>({texture:WebGPU.getJsObject(Number((growMemViews(),HEAPU64)[ptr/8])),mipLevel:(growMemViews(),HEAPU32)[(ptr+8)/4],origin:WebGPU.makeOrigin3D(ptr+12),aspect:WebGPU.TextureAspect[(growMemViews(),HEAP32)[(ptr+24)/4]]}),makeTexelCopyBufferLayout:ptr=>{var bytesPerRow=(growMemViews(),HEAPU32)[(ptr+8)/4];var rowsPerImage=(growMemViews(),HEAPU32)[(ptr+12)/4];return{offset:readI53FromI64(ptr),bytesPerRow:bytesPerRow===4294967295?undefined:bytesPerRow,rowsPerImage:rowsPerImage===4294967295?undefined:rowsPerImage}},makeTexelCopyBufferInfo:ptr=>{var layoutPtr=ptr+0;var bufferCopyView=WebGPU.makeTexelCopyBufferLayout(layoutPtr);bufferCopyView["buffer"]=WebGPU.getJsObject(Number((growMemViews(),HEAPU64)[(ptr+16)/8]));return bufferCopyView},makePassTimestampWrites:ptr=>{if(ptr===0)return undefined;return{querySet:WebGPU.getJsObject(Number((growMemViews(),HEAPU64)[(ptr+8)/8])),beginningOfPassWriteIndex:(growMemViews(),HEAPU32)[(ptr+16)/4],endOfPassWriteIndex:(growMemViews(),HEAPU32)[(ptr+20)/4]}},makePipelineConstants:(constantCount,constantsPtr)=>{if(!constantCount)return;var constants={};for(var i=0;i<constantCount;++i){var entryPtr=constantsPtr+32*i;var key=WebGPU.makeStringFromStringView(entryPtr+8);constants[key]=(growMemViews(),HEAPF64)[(entryPtr+24)/8]}return constants},makePipelineLayout:layoutPtr=>{if(!layoutPtr)return"auto";return WebGPU.getJsObject(layoutPtr)},makeComputeState:ptr=>{if(!ptr)return undefined;var desc={module:WebGPU.getJsObject(Number((growMemViews(),HEAPU64)[(ptr+8)/8])),constants:WebGPU.makePipelineConstants(Number((growMemViews(),HEAPU64)[(ptr+32)/8]),Number((growMemViews(),HEAPU64)[(ptr+40)/8])),entryPoint:WebGPU.makeStringFromOptionalStringView(ptr+16)};return desc},makeComputePipelineDesc:descriptor=>{var desc={label:WebGPU.makeStringFromOptionalStringView(descriptor+8),layout:WebGPU.makePipelineLayout(Number((growMemViews(),HEAPU64)[(descriptor+24)/8])),compute:WebGPU.makeComputeState(descriptor+32)};return desc},makeRenderPipelineDesc:descriptor=>{function makePrimitiveState(psPtr){if(!psPtr)return undefined;return{topology:WebGPU.PrimitiveTopology[(growMemViews(),HEAP32)[(psPtr+8)/4]],stripIndexFormat:WebGPU.IndexFormat[(growMemViews(),HEAP32)[(psPtr+12)/4]],frontFace:WebGPU.FrontFace[(growMemViews(),HEAP32)[(psPtr+16)/4]],cullMode:WebGPU.CullMode[(growMemViews(),HEAP32)[(psPtr+20)/4]],unclippedDepth:!!(growMemViews(),HEAPU32)[(psPtr+24)/4]}}function makeBlendComponent(bdPtr){if(!bdPtr)return undefined;return{operation:WebGPU.BlendOperation[(growMemViews(),HEAP32)[bdPtr/4]],srcFactor:WebGPU.BlendFactor[(growMemViews(),HEAP32)[(bdPtr+4)/4]],dstFactor:WebGPU.BlendFactor[(growMemViews(),HEAP32)[(bdPtr+8)/4]]}}function makeBlendState(bsPtr){if(!bsPtr)return undefined;return{alpha:makeBlendComponent(bsPtr+12),color:makeBlendComponent(bsPtr+0)}}function makeColorState(csPtr){var format=WebGPU.TextureFormat[(growMemViews(),HEAP32)[(csPtr+8)/4]];return format?{format,blend:makeBlendState(Number((growMemViews(),HEAPU64)[(csPtr+16)/8])),writeMask:(growMemViews(),HEAPU32)[(csPtr+24)/4]}:undefined}function makeColorStates(count,csArrayPtr){var states=[];for(var i=0;i<count;++i){states.push(makeColorState(csArrayPtr+32*i))}return states}function makeStencilStateFace(ssfPtr){return{compare:WebGPU.CompareFunction[(growMemViews(),HEAP32)[ssfPtr/4]],failOp:WebGPU.StencilOperation[(growMemViews(),HEAP32)[(ssfPtr+4)/4]],depthFailOp:WebGPU.StencilOperation[(growMemViews(),HEAP32)[(ssfPtr+8)/4]],passOp:WebGPU.StencilOperation[(growMemViews(),HEAP32)[(ssfPtr+12)/4]]}}function makeDepthStencilState(dssPtr){if(!dssPtr)return undefined;return{format:WebGPU.TextureFormat[(growMemViews(),HEAP32)[(dssPtr+8)/4]],depthWriteEnabled:!!(growMemViews(),HEAPU32)[(dssPtr+12)/4],depthCompare:WebGPU.CompareFunction[(growMemViews(),HEAP32)[(dssPtr+16)/4]],stencilFront:makeStencilStateFace(dssPtr+20),stencilBack:makeStencilStateFace(dssPtr+36),stencilReadMask:(growMemViews(),HEAPU32)[(dssPtr+52)/4],stencilWriteMask:(growMemViews(),HEAPU32)[(dssPtr+56)/4],depthBias:(growMemViews(),HEAP32)[(dssPtr+60)/4],depthBiasSlopeScale:(growMemViews(),HEAPF32)[(dssPtr+64)/4],depthBiasClamp:(growMemViews(),HEAPF32)[(dssPtr+68)/4]}}function makeVertexAttribute(vaPtr){return{format:WebGPU.VertexFormat[(growMemViews(),HEAP32)[(vaPtr+8)/4]],offset:readI53FromI64(vaPtr+16),shaderLocation:(growMemViews(),HEAPU32)[(vaPtr+24)/4]}}function makeVertexAttributes(count,vaArrayPtr){var vas=[];for(var i=0;i<count;++i){vas.push(makeVertexAttribute(vaArrayPtr+i*32))}return vas}function makeVertexBuffer(vbPtr){if(!vbPtr)return undefined;var stepMode=WebGPU.VertexStepMode[(growMemViews(),HEAP32)[(vbPtr+8)/4]];var attributeCount=Number((growMemViews(),HEAPU64)[(vbPtr+24)/8]);if(!stepMode&&!attributeCount){return null}return{arrayStride:readI53FromI64(vbPtr+16),stepMode,attributes:makeVertexAttributes(attributeCount,Number((growMemViews(),HEAPU64)[(vbPtr+32)/8]))}}function makeVertexBuffers(count,vbArrayPtr){if(!count)return undefined;var vbs=[];for(var i=0;i<count;++i){vbs.push(makeVertexBuffer(vbArrayPtr+i*40))}return vbs}function makeVertexState(viPtr){if(!viPtr)return undefined;var desc={module:WebGPU.getJsObject(Number((growMemViews(),HEAPU64)[(viPtr+8)/8])),constants:WebGPU.makePipelineConstants(Number((growMemViews(),HEAPU64)[(viPtr+32)/8]),Number((growMemViews(),HEAPU64)[(viPtr+40)/8])),buffers:makeVertexBuffers(Number((growMemViews(),HEAPU64)[(viPtr+48)/8]),Number((growMemViews(),HEAPU64)[(viPtr+56)/8])),entryPoint:WebGPU.makeStringFromOptionalStringView(viPtr+16)};return desc}function makeMultisampleState(msPtr){if(!msPtr)return undefined;return{count:(growMemViews(),HEAPU32)[(msPtr+8)/4],mask:(growMemViews(),HEAPU32)[(msPtr+12)/4],alphaToCoverageEnabled:!!(growMemViews(),HEAPU32)[(msPtr+16)/4]}}function makeFragmentState(fsPtr){if(!fsPtr)return undefined;var desc={module:WebGPU.getJsObject(Number((growMemViews(),HEAPU64)[(fsPtr+8)/8])),constants:WebGPU.makePipelineConstants(Number((growMemViews(),HEAPU64)[(fsPtr+32)/8]),Number((growMemViews(),HEAPU64)[(fsPtr+40)/8])),targets:makeColorStates(Number((growMemViews(),HEAPU64)[(fsPtr+48)/8]),Number((growMemViews(),HEAPU64)[(fsPtr+56)/8])),entryPoint:WebGPU.makeStringFromOptionalStringView(fsPtr+16)};return desc}var desc={label:WebGPU.makeStringFromOptionalStringView(descriptor+8),layout:WebGPU.makePipelineLayout(Number((growMemViews(),HEAPU64)[(descriptor+24)/8])),vertex:makeVertexState(descriptor+32),primitive:makePrimitiveState(descriptor+96),depthStencil:makeDepthStencilState(Number((growMemViews(),HEAPU64)[(descriptor+128)/8])),multisample:makeMultisampleState(descriptor+136),fragment:makeFragmentState(Number((growMemViews(),HEAPU64)[(descriptor+160)/8]))};return desc},fillLimitStruct:(limits,limitsOutPtr)=>{var nextInChainPtr=Number((growMemViews(),HEAPU64)[limitsOutPtr/8]);function setLimitValueU32(name,basePtr,limitOffset,fallbackValue=0){var limitValue=limits[name]??fallbackValue;(growMemViews(),HEAPU32)[(basePtr+limitOffset)/4]=limitValue}function setLimitValueU64(name,basePtr,limitOffset,fallbackValue=0){var limitValue=limits[name]??fallbackValue;writeI53ToI64(basePtr+limitOffset,limitValue)}setLimitValueU32("maxTextureDimension1D",limitsOutPtr,8);setLimitValueU32("maxTextureDimension2D",limitsOutPtr,12);setLimitValueU32("maxTextureDimension3D",limitsOutPtr,16);setLimitValueU32("maxTextureArrayLayers",limitsOutPtr,20);setLimitValueU32("maxBindGroups",limitsOutPtr,24);setLimitValueU32("maxBindGroupsPlusVertexBuffers",limitsOutPtr,28);setLimitValueU32("maxBindingsPerBindGroup",limitsOutPtr,32);setLimitValueU32("maxDynamicUniformBuffersPerPipelineLayout",limitsOutPtr,36);setLimitValueU32("maxDynamicStorageBuffersPerPipelineLayout",limitsOutPtr,40);setLimitValueU32("maxSampledTexturesPerShaderStage",limitsOutPtr,44);setLimitValueU32("maxSamplersPerShaderStage",limitsOutPtr,48);setLimitValueU32("maxStorageBuffersPerShaderStage",limitsOutPtr,52);setLimitValueU32("maxStorageTexturesPerShaderStage",limitsOutPtr,56);setLimitValueU32("maxUniformBuffersPerShaderStage",limitsOutPtr,60);setLimitValueU32("minUniformBufferOffsetAlignment",limitsOutPtr,80);setLimitValueU32("minStorageBufferOffsetAlignment",limitsOutPtr,84);setLimitValueU64("maxUniformBufferBindingSize",limitsOutPtr,64);setLimitValueU64("maxStorageBufferBindingSize",limitsOutPtr,72);setLimitValueU32("maxVertexBuffers",limitsOutPtr,88);setLimitValueU64("maxBufferSize",limitsOutPtr,96);setLimitValueU32("maxVertexAttributes",limitsOutPtr,104);setLimitValueU32("maxVertexBufferArrayStride",limitsOutPtr,108);setLimitValueU32("maxInterStageShaderVariables",limitsOutPtr,112);setLimitValueU32("maxColorAttachments",limitsOutPtr,116);setLimitValueU32("maxColorAttachmentBytesPerSample",limitsOutPtr,120);setLimitValueU32("maxComputeWorkgroupStorageSize",limitsOutPtr,124);setLimitValueU32("maxComputeInvocationsPerWorkgroup",limitsOutPtr,128);setLimitValueU32("maxComputeWorkgroupSizeX",limitsOutPtr,132);setLimitValueU32("maxComputeWorkgroupSizeY",limitsOutPtr,136);setLimitValueU32("maxComputeWorkgroupSizeZ",limitsOutPtr,140);setLimitValueU32("maxComputeWorkgroupsPerDimension",limitsOutPtr,144);setLimitValueU32("maxImmediateSize",limitsOutPtr,148);if(nextInChainPtr!==0){var sType=(growMemViews(),HEAP32)[(nextInChainPtr+8)/4];var compatibilityModeLimitsPtr=nextInChainPtr;setLimitValueU32("maxStorageBuffersInVertexStage",compatibilityModeLimitsPtr,16,limits.maxStorageBuffersPerShaderStage);setLimitValueU32("maxStorageBuffersInFragmentStage",compatibilityModeLimitsPtr,24,limits.maxStorageBuffersPerShaderStage);setLimitValueU32("maxStorageTexturesInVertexStage",compatibilityModeLimitsPtr,20,limits.maxStorageTexturesPerShaderStage);setLimitValueU32("maxStorageTexturesInFragmentStage",compatibilityModeLimitsPtr,28,limits.maxStorageTexturesPerShaderStage)}},fillAdapterInfoStruct:(info,infoStruct)=>{(growMemViews(),HEAPU32)[(infoStruct+88)/4]=info.subgroupMinSize;(growMemViews(),HEAPU32)[(infoStruct+92)/4]=info.subgroupMaxSize;var strs=info.vendor+info.architecture+info.device+info.description;var strPtr=stringToNewUTF8(strs);var vendorLen=lengthBytesUTF8(info.vendor);WebGPU.setStringView(infoStruct+8,strPtr,vendorLen);strPtr+=vendorLen;var architectureLen=lengthBytesUTF8(info.architecture);WebGPU.setStringView(infoStruct+24,strPtr,architectureLen);strPtr+=architectureLen;var deviceLen=lengthBytesUTF8(info.device);WebGPU.setStringView(infoStruct+40,strPtr,deviceLen);strPtr+=deviceLen;var descriptionLen=lengthBytesUTF8(info.description);WebGPU.setStringView(infoStruct+56,strPtr,descriptionLen);strPtr+=descriptionLen;(growMemViews(),HEAP32)[(infoStruct+72)/4]=2;var adapterType=info.isFallbackAdapter?3:4;(growMemViews(),HEAP32)[(infoStruct+76)/4]=adapterType;(growMemViews(),HEAPU32)[(infoStruct+80)/4]=0;(growMemViews(),HEAPU32)[(infoStruct+84)/4]=0},AddressMode:[,"clamp-to-edge","repeat","mirror-repeat"],BlendFactor:[,"zero","one","src","one-minus-src","src-alpha","one-minus-src-alpha","dst","one-minus-dst","dst-alpha","one-minus-dst-alpha","src-alpha-saturated","constant","one-minus-constant","src1","one-minus-src1","src1-alpha","one-minus-src1-alpha"],BlendOperation:[,"add","subtract","reverse-subtract","min","max"],BufferBindingType:[,,"uniform","storage","read-only-storage"],BufferMapState:[,"unmapped","pending","mapped"],CompareFunction:[,"never","less","equal","less-equal","greater","not-equal","greater-equal","always"],CompilationInfoRequestStatus:[,"success","callback-cancelled"],ComponentSwizzle:[,"0","1","r","g","b","a"],CompositeAlphaMode:[,"opaque","premultiplied","unpremultiplied","inherit"],CullMode:[,"none","front","back"],ErrorFilter:[,"validation","out-of-memory","internal"],FeatureLevel:[,"compatibility","core"],FeatureName:{1:"core-features-and-limits",2:"depth-clip-control",3:"depth32float-stencil8",4:"texture-compression-bc",5:"texture-compression-bc-sliced-3d",6:"texture-compression-etc2",7:"texture-compression-astc",8:"texture-compression-astc-sliced-3d",9:"timestamp-query",10:"indirect-first-instance",11:"shader-f16",12:"rg11b10ufloat-renderable",13:"bgra8unorm-storage",14:"float32-filterable",15:"float32-blendable",16:"clip-distances",17:"dual-source-blending",18:"subgroups",19:"texture-formats-tier1",20:"texture-formats-tier2",21:"primitive-index",22:"texture-component-swizzle",327692:"chromium-experimental-unorm16-texture-formats",327729:"chromium-experimental-multi-draw-indirect"},FilterMode:[,"nearest","linear"],FrontFace:[,"ccw","cw"],IndexFormat:[,"uint16","uint32"],InstanceFeatureName:[,"timed-wait-any","shader-source-spirv","multiple-devices-per-adapter"],LoadOp:[,"load","clear"],MipmapFilterMode:[,"nearest","linear"],OptionalBool:["false","true"],PowerPreference:[,"low-power","high-performance"],PredefinedColorSpace:[,"srgb","display-p3"],PrimitiveTopology:[,"point-list","line-list","line-strip","triangle-list","triangle-strip"],QueryType:[,"occlusion","timestamp"],SamplerBindingType:[,,"filtering","non-filtering","comparison"],Status:[,"success","error"],StencilOperation:[,"keep","zero","replace","invert","increment-clamp","decrement-clamp","increment-wrap","decrement-wrap"],StorageTextureAccess:[,,"write-only","read-only","read-write"],StoreOp:[,"store","discard"],SurfaceGetCurrentTextureStatus:[,"success-optimal","success-suboptimal","timeout","outdated","lost","error"],TextureAspect:[,"all","stencil-only","depth-only"],TextureDimension:[,"1d","2d","3d"],TextureFormat:[,"r8unorm","r8snorm","r8uint","r8sint","r16unorm","r16snorm","r16uint","r16sint","r16float","rg8unorm","rg8snorm","rg8uint","rg8sint","r32float","r32uint","r32sint","rg16unorm","rg16snorm","rg16uint","rg16sint","rg16float","rgba8unorm","rgba8unorm-srgb","rgba8snorm","rgba8uint","rgba8sint","bgra8unorm","bgra8unorm-srgb","rgb10a2uint","rgb10a2unorm","rg11b10ufloat","rgb9e5ufloat","rg32float","rg32uint","rg32sint","rgba16unorm","rgba16snorm","rgba16uint","rgba16sint","rgba16float","rgba32float","rgba32uint","rgba32sint","stencil8","depth16unorm","depth24plus","depth24plus-stencil8","depth32float","depth32float-stencil8","bc1-rgba-unorm","bc1-rgba-unorm-srgb","bc2-rgba-unorm","bc2-rgba-unorm-srgb","bc3-rgba-unorm","bc3-rgba-unorm-srgb","bc4-r-unorm","bc4-r-snorm","bc5-rg-unorm","bc5-rg-snorm","bc6h-rgb-ufloat","bc6h-rgb-float","bc7-rgba-unorm","bc7-rgba-unorm-srgb","etc2-rgb8unorm","etc2-rgb8unorm-srgb","etc2-rgb8a1unorm","etc2-rgb8a1unorm-srgb","etc2-rgba8unorm","etc2-rgba8unorm-srgb","eac-r11unorm","eac-r11snorm","eac-rg11unorm","eac-rg11snorm","astc-4x4-unorm","astc-4x4-unorm-srgb","astc-5x4-unorm","astc-5x4-unorm-srgb","astc-5x5-unorm","astc-5x5-unorm-srgb","astc-6x5-unorm","astc-6x5-unorm-srgb","astc-6x6-unorm","astc-6x6-unorm-srgb","astc-8x5-unorm","astc-8x5-unorm-srgb","astc-8x6-unorm","astc-8x6-unorm-srgb","astc-8x8-unorm","astc-8x8-unorm-srgb","astc-10x5-unorm","astc-10x5-unorm-srgb","astc-10x6-unorm","astc-10x6-unorm-srgb","astc-10x8-unorm","astc-10x8-unorm-srgb","astc-10x10-unorm","astc-10x10-unorm-srgb","astc-12x10-unorm","astc-12x10-unorm-srgb","astc-12x12-unorm","astc-12x12-unorm-srgb"],TextureSampleType:[,,"float","unfilterable-float","depth","sint","uint"],TextureViewDimension:[,"1d","2d","2d-array","cube","cube-array","3d"],ToneMappingMode:[,"standard","extended"],VertexFormat:[,"uint8","uint8x2","uint8x4","sint8","sint8x2","sint8x4","unorm8","unorm8x2","unorm8x4","snorm8","snorm8x2","snorm8x4","uint16","uint16x2","uint16x4","sint16","sint16x2","sint16x4","unorm16","unorm16x2","unorm16x4","snorm16","snorm16x2","snorm16x4","float16","float16x2","float16x4","float32","float32x2","float32x3","float32x4","uint32","uint32x2","uint32x3","uint32x4","sint32","sint32x2","sint32x3","sint32x4","unorm10-10-10-2","unorm8x4-bgra"],VertexStepMode:[,"vertex","instance"],WGSLLanguageFeatureName:[,"readonly_and_readwrite_storage_textures","packed_4x8_integer_dot_product","unrestricted_pointer_parameters","pointer_composite_access","uniform_buffer_standard_layout","subgroup_id","texture_and_sampler_let","subgroup_uniformity","texture_formats_tier1"]};var emwgpuStringToInt_DeviceLostReason={undefined:1,unknown:1,destroyed:2};var runtimeKeepalivePop=()=>{runtimeKeepaliveCounter-=1};function _emwgpuAdapterRequestDevice(adapterPtr,futureId,deviceLostFutureId,devicePtr,queuePtr,descriptor){adapterPtr=bigintToI53Checked(adapterPtr);futureId=bigintToI53Checked(futureId);deviceLostFutureId=bigintToI53Checked(deviceLostFutureId);devicePtr=bigintToI53Checked(devicePtr);queuePtr=bigintToI53Checked(queuePtr);descriptor=bigintToI53Checked(descriptor);var adapter=WebGPU.getJsObject(adapterPtr);var desc={};if(descriptor){var requiredFeatureCount=Number((growMemViews(),HEAPU64)[(descriptor+24)/8]);if(requiredFeatureCount){var requiredFeaturesPtr=Number((growMemViews(),HEAPU64)[(descriptor+32)/8]);desc["requiredFeatures"]=Array.from((growMemViews(),HEAPU32).subarray(requiredFeaturesPtr/4,(requiredFeaturesPtr+requiredFeatureCount*4)/4),feature=>WebGPU.FeatureName[feature])}var limitsPtr=Number((growMemViews(),HEAPU64)[(descriptor+40)/8]);if(limitsPtr){var nextInChainPtr=Number((growMemViews(),HEAPU64)[limitsPtr/8]);var requiredLimits={};function setLimitU32IfDefined(name,basePtr,limitOffset,ignoreIfZero=false){var ptr=basePtr+limitOffset;var value=(growMemViews(),HEAPU32)[ptr/4];if(value!=4294967295&&(!ignoreIfZero||value!=0)){requiredLimits[name]=value}}function setLimitU64IfDefined(name,basePtr,limitOffset){var ptr=basePtr+limitOffset;var limitPart1=(growMemViews(),HEAPU32)[ptr/4];var limitPart2=(growMemViews(),HEAPU32)[(ptr+4)/4];if(limitPart1!=4294967295||limitPart2!=4294967295){requiredLimits[name]=readI53FromI64(ptr)}}setLimitU32IfDefined("maxTextureDimension1D",limitsPtr,8);setLimitU32IfDefined("maxTextureDimension2D",limitsPtr,12);setLimitU32IfDefined("maxTextureDimension3D",limitsPtr,16);setLimitU32IfDefined("maxTextureArrayLayers",limitsPtr,20);setLimitU32IfDefined("maxBindGroups",limitsPtr,24);setLimitU32IfDefined("maxBindGroupsPlusVertexBuffers",limitsPtr,28);setLimitU32IfDefined("maxBindingsPerBindGroup",limitsPtr,32);setLimitU32IfDefined("maxDynamicUniformBuffersPerPipelineLayout",limitsPtr,36);setLimitU32IfDefined("maxDynamicStorageBuffersPerPipelineLayout",limitsPtr,40);setLimitU32IfDefined("maxSampledTexturesPerShaderStage",limitsPtr,44);setLimitU32IfDefined("maxSamplersPerShaderStage",limitsPtr,48);setLimitU32IfDefined("maxStorageBuffersPerShaderStage",limitsPtr,52);setLimitU32IfDefined("maxStorageTexturesPerShaderStage",limitsPtr,56);setLimitU32IfDefined("maxUniformBuffersPerShaderStage",limitsPtr,60);setLimitU32IfDefined("minUniformBufferOffsetAlignment",limitsPtr,80);setLimitU32IfDefined("minStorageBufferOffsetAlignment",limitsPtr,84);setLimitU64IfDefined("maxUniformBufferBindingSize",limitsPtr,64);setLimitU64IfDefined("maxStorageBufferBindingSize",limitsPtr,72);setLimitU32IfDefined("maxVertexBuffers",limitsPtr,88);setLimitU64IfDefined("maxBufferSize",limitsPtr,96);setLimitU32IfDefined("maxVertexAttributes",limitsPtr,104);setLimitU32IfDefined("maxVertexBufferArrayStride",limitsPtr,108);setLimitU32IfDefined("maxInterStageShaderVariables",limitsPtr,112);setLimitU32IfDefined("maxColorAttachments",limitsPtr,116);setLimitU32IfDefined("maxColorAttachmentBytesPerSample",limitsPtr,120);setLimitU32IfDefined("maxComputeWorkgroupStorageSize",limitsPtr,124);setLimitU32IfDefined("maxComputeInvocationsPerWorkgroup",limitsPtr,128);setLimitU32IfDefined("maxComputeWorkgroupSizeX",limitsPtr,132);setLimitU32IfDefined("maxComputeWorkgroupSizeY",limitsPtr,136);setLimitU32IfDefined("maxComputeWorkgroupSizeZ",limitsPtr,140);setLimitU32IfDefined("maxComputeWorkgroupsPerDimension",limitsPtr,144);setLimitU32IfDefined("maxImmediateSize",limitsPtr,148,true);if(nextInChainPtr!==0){var sType=(growMemViews(),HEAP32)[(nextInChainPtr+8)/4];var compatibilityModeLimitsPtr=nextInChainPtr;if("maxStorageBuffersInVertexStage"in GPUSupportedLimits.prototype){setLimitU32IfDefined("maxStorageBuffersInVertexStage",compatibilityModeLimitsPtr,16);setLimitU32IfDefined("maxStorageTexturesInVertexStage",compatibilityModeLimitsPtr,20);setLimitU32IfDefined("maxStorageBuffersInFragmentStage",compatibilityModeLimitsPtr,24);setLimitU32IfDefined("maxStorageTexturesInFragmentStage",compatibilityModeLimitsPtr,28)}}desc["requiredLimits"]=requiredLimits}var defaultQueuePtr=Number((growMemViews(),HEAPU64)[(descriptor+48)/8]);if(defaultQueuePtr){var defaultQueueDesc={label:WebGPU.makeStringFromOptionalStringView(defaultQueuePtr+8)};desc["defaultQueue"]=defaultQueueDesc}desc["label"]=WebGPU.makeStringFromOptionalStringView(descriptor+8)}runtimeKeepalivePush();WebGPU.Internals.futureInsert(futureId,adapter.requestDevice(desc).then(device=>{runtimeKeepalivePop();callUserCallback(()=>{WebGPU.Internals.jsObjectInsert(queuePtr,device.queue);WebGPU.Internals.jsObjectInsert(devicePtr,device);devicePtr=BigInt(devicePtr);WebGPU.Internals.futureInsert(deviceLostFutureId,device.lost.then(info=>{callUserCallback(()=>{device.onuncapturederror=ev=>{};var sp=stackSave();var messagePtr=stringToUTF8OnStack(info.message);_emwgpuOnDeviceLostCompleted(deviceLostFutureId,emwgpuStringToInt_DeviceLostReason[info.reason],BigInt(messagePtr));stackRestore(sp)})}));device.onuncapturederror=ev=>{var type=5;if(ev.error instanceof GPUValidationError)type=2;else if(ev.error instanceof GPUOutOfMemoryError)type=3;else if(ev.error instanceof GPUInternalError)type=4;var sp=stackSave();var messagePtr=stringToUTF8OnStack(ev.error.message);_emwgpuOnUncapturedError(BigInt(devicePtr),type,BigInt(messagePtr));stackRestore(sp)};_emwgpuOnRequestDeviceCompleted(futureId,1,BigInt(devicePtr),0n)})},ex=>{runtimeKeepalivePop();callUserCallback(()=>{var sp=stackSave();var messagePtr=stringToUTF8OnStack(ex.message);_emwgpuOnRequestDeviceCompleted(futureId,3,BigInt(devicePtr),BigInt(messagePtr));if(deviceLostFutureId){_emwgpuOnDeviceLostCompleted(deviceLostFutureId,4,BigInt(messagePtr))}stackRestore(sp)})}))}function _emwgpuBufferDestroy(bufferPtr){bufferPtr=bigintToI53Checked(bufferPtr);var buffer=WebGPU.getJsObject(bufferPtr);var onUnmap=WebGPU.Internals.bufferOnUnmaps[bufferPtr];if(onUnmap){for(var i=0;i<onUnmap.length;++i){onUnmap[i]()}delete WebGPU.Internals.bufferOnUnmaps[bufferPtr]}buffer.destroy()}var warnOnce=text=>{warnOnce.shown||={};if(!warnOnce.shown[text]){warnOnce.shown[text]=1;if(ENVIRONMENT_IS_NODE)text="warning: "+text;err(text)}};var _emwgpuBufferGetConstMappedRange=function(bufferPtr,offset,size){bufferPtr=bigintToI53Checked(bufferPtr);offset=bigintToI53Checked(offset);size=bigintToI53Checked(size);var ret=(()=>{var buffer=WebGPU.getJsObject(bufferPtr);if(size==-1)size=undefined;var mapped;try{mapped=buffer.getMappedRange(offset,size)}catch(ex){return 0n}var data=_memalign(16,mapped.byteLength);(growMemViews(),HEAPU8).set(new Uint8Array(mapped),data);WebGPU.Internals.bufferOnUnmaps[bufferPtr].push(()=>_free(data));return data})();return BigInt(ret)};var _emwgpuBufferMapAsync=function(bufferPtr,futureId,mode,offset,size){bufferPtr=bigintToI53Checked(bufferPtr);futureId=bigintToI53Checked(futureId);mode=bigintToI53Checked(mode);offset=bigintToI53Checked(offset);size=bigintToI53Checked(size);var buffer=WebGPU.getJsObject(bufferPtr);WebGPU.Internals.bufferOnUnmaps[bufferPtr]=[];if(size==-1)size=undefined;runtimeKeepalivePush();WebGPU.Internals.futureInsert(futureId,buffer.mapAsync(mode,offset,size).then(()=>{runtimeKeepalivePop();callUserCallback(()=>{_emwgpuOnMapAsyncCompleted(futureId,1,0n)})},ex=>{runtimeKeepalivePop();callUserCallback(()=>{var sp=stackSave();var messagePtr=stringToUTF8OnStack(ex.message);var status=ex.name==="AbortError"?4:ex.name==="OperationError"?3:0;_emwgpuOnMapAsyncCompleted(futureId,status,BigInt(messagePtr));delete WebGPU.Internals.bufferOnUnmaps[bufferPtr]})}))};function _emwgpuBufferUnmap(bufferPtr){bufferPtr=bigintToI53Checked(bufferPtr);var buffer=WebGPU.getJsObject(bufferPtr);var onUnmap=WebGPU.Internals.bufferOnUnmaps[bufferPtr];if(!onUnmap){return}for(var i=0;i<onUnmap.length;++i){onUnmap[i]()}delete WebGPU.Internals.bufferOnUnmaps[bufferPtr];buffer.unmap()}function _emwgpuDelete(ptr){ptr=bigintToI53Checked(ptr);delete WebGPU.Internals.jsObjects[ptr]}function _emwgpuDeviceCreateBuffer(devicePtr,descriptor,bufferPtr){devicePtr=bigintToI53Checked(devicePtr);descriptor=bigintToI53Checked(descriptor);bufferPtr=bigintToI53Checked(bufferPtr);var mappedAtCreation=!!(growMemViews(),HEAPU32)[(descriptor+40)/4];var desc={label:WebGPU.makeStringFromOptionalStringView(descriptor+8),usage:(growMemViews(),HEAPU32)[(descriptor+24)/4],size:readI53FromI64(descriptor+32),mappedAtCreation};var device=WebGPU.getJsObject(devicePtr);var buffer;try{buffer=device.createBuffer(desc)}catch(ex){return false}WebGPU.Internals.jsObjectInsert(bufferPtr,buffer);if(mappedAtCreation){WebGPU.Internals.bufferOnUnmaps[bufferPtr]=[]}return true}function _emwgpuDeviceCreateShaderModule(devicePtr,descriptor,shaderModulePtr){devicePtr=bigintToI53Checked(devicePtr);descriptor=bigintToI53Checked(descriptor);shaderModulePtr=bigintToI53Checked(shaderModulePtr);var nextInChainPtr=Number((growMemViews(),HEAPU64)[descriptor/8]);var sType=(growMemViews(),HEAP32)[(nextInChainPtr+8)/4];var desc={label:WebGPU.makeStringFromOptionalStringView(descriptor+8),code:""};switch(sType){case 2:{desc["code"]=WebGPU.makeStringFromStringView(nextInChainPtr+16);break}}var device=WebGPU.getJsObject(devicePtr);WebGPU.Internals.jsObjectInsert(shaderModulePtr,device.createShaderModule(desc))}var _emwgpuDeviceDestroy=devicePtr=>{const device=WebGPU.getJsObject(devicePtr);device.onuncapturederror=null;device.destroy()};function _emwgpuInstanceRequestAdapter(instancePtr,futureId,options,adapterPtr){instancePtr=bigintToI53Checked(instancePtr);futureId=bigintToI53Checked(futureId);options=bigintToI53Checked(options);adapterPtr=bigintToI53Checked(adapterPtr);var opts;if(options){opts={featureLevel:WebGPU.FeatureLevel[(growMemViews(),HEAP32)[(options+8)/4]],powerPreference:WebGPU.PowerPreference[(growMemViews(),HEAP32)[(options+12)/4]],forceFallbackAdapter:!!(growMemViews(),HEAPU32)[(options+16)/4]};var nextInChainPtr=Number((growMemViews(),HEAPU64)[options/8]);if(nextInChainPtr!==0){var sType=(growMemViews(),HEAP32)[(nextInChainPtr+8)/4];var webxrOptions=nextInChainPtr;opts.xrCompatible=!!(growMemViews(),HEAPU32)[(webxrOptions+16)/4]}}if(!("gpu"in navigator)){var sp=stackSave();var messagePtr=stringToUTF8OnStack("WebGPU not available on this browser (navigator.gpu is not available)");_emwgpuOnRequestAdapterCompleted(futureId,3,BigInt(adapterPtr),BigInt(messagePtr));stackRestore(sp);return}runtimeKeepalivePush();WebGPU.Internals.futureInsert(futureId,navigator.gpu.requestAdapter(opts).then(adapter=>{runtimeKeepalivePop();callUserCallback(()=>{if(adapter){WebGPU.Internals.jsObjectInsert(adapterPtr,adapter);_emwgpuOnRequestAdapterCompleted(futureId,1,BigInt(adapterPtr),0n)}else{var sp=stackSave();var messagePtr=stringToUTF8OnStack("WebGPU not available on this browser (requestAdapter returned null)");_emwgpuOnRequestAdapterCompleted(futureId,3,BigInt(adapterPtr),BigInt(messagePtr));stackRestore(sp)}})},ex=>{runtimeKeepalivePop();callUserCallback(()=>{var sp=stackSave();var messagePtr=stringToUTF8OnStack(ex.message);_emwgpuOnRequestAdapterCompleted(futureId,4,BigInt(adapterPtr),BigInt(messagePtr));stackRestore(sp)})}))}var _emwgpuQueueOnSubmittedWorkDone=function(queuePtr,futureId){queuePtr=bigintToI53Checked(queuePtr);futureId=bigintToI53Checked(futureId);var queue=WebGPU.getJsObject(queuePtr);runtimeKeepalivePush();WebGPU.Internals.futureInsert(futureId,queue.onSubmittedWorkDone().then(()=>{runtimeKeepalivePop();callUserCallback(()=>{_emwgpuOnWorkDoneCompleted(futureId,1)})}))};var _emwgpuWaitAny=function(futurePtr,futureCount,timeoutMSPtr){futurePtr=bigintToI53Checked(futurePtr);futureCount=bigintToI53Checked(futureCount);timeoutMSPtr=bigintToI53Checked(timeoutMSPtr);return Asyncify.handleAsync(async()=>{var promises=[];if(timeoutMSPtr){var timeoutMS=(growMemViews(),HEAP32)[timeoutMSPtr/4];promises.length=futureCount+1;promises[futureCount]=new Promise(resolve=>setTimeout(resolve,timeoutMS,0))}else{promises.length=futureCount}for(var i=0;i<futureCount;++i){var futureId=readI53FromI64(futurePtr+i*8);if(!(futureId in WebGPU.Internals.futures)){return futureId}promises[i]=WebGPU.Internals.futures[futureId]}const firstResolvedFuture=await Promise.race(promises);delete WebGPU.Internals.futures[firstResolvedFuture];return firstResolvedFuture})};_emwgpuWaitAny.isAsync=true;var ENV={};var getExecutableName=()=>thisProgram||"./this.program";var getEnvStrings=()=>{if(!getEnvStrings.strings){var lang=(typeof navigator=="object"&&navigator.language||"C").replace("-","_")+".UTF-8";var env={USER:"web_user",LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:lang,_:getExecutableName()};for(var x in ENV){if(ENV[x]===undefined)delete env[x];else env[x]=ENV[x]}var strings=[];for(var x in env){strings.push(`${x}=${env[x]}`)}getEnvStrings.strings=strings}return getEnvStrings.strings};function _environ_get(__environ,environ_buf){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(14,0,1,__environ,environ_buf);__environ=bigintToI53Checked(__environ);environ_buf=bigintToI53Checked(environ_buf);var bufSize=0;var envp=0;for(var string of getEnvStrings()){var ptr=environ_buf+bufSize;(growMemViews(),HEAPU64)[(__environ+envp)/8]=BigInt(ptr);bufSize+=stringToUTF8(string,ptr,Infinity)+1;envp+=8}return 0}function _environ_sizes_get(penviron_count,penviron_buf_size){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(15,0,1,penviron_count,penviron_buf_size);penviron_count=bigintToI53Checked(penviron_count);penviron_buf_size=bigintToI53Checked(penviron_buf_size);var strings=getEnvStrings();(growMemViews(),HEAPU64)[penviron_count/8]=BigInt(strings.length);var bufSize=0;for(var string of strings){bufSize+=lengthBytesUTF8(string)+1}(growMemViews(),HEAPU64)[penviron_buf_size/8]=BigInt(bufSize);return 0}function _fd_close(fd){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(16,0,1,fd);try{var stream=SYSCALLS.getStreamFromFD(fd);FS.close(stream);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}var doReadv=(stream,iov,iovcnt,offset)=>{var ret=0;for(var i=0;i<iovcnt;i++){var ptr=Number((growMemViews(),HEAPU64)[iov/8]);var len=Number((growMemViews(),HEAPU64)[(iov+8)/8]);iov+=16;var curr=FS.read(stream,(growMemViews(),HEAP8),ptr,len,offset);if(curr<0)return-1;ret+=curr;if(curr<len)break;if(typeof offset!="undefined"){offset+=curr}}return ret};function _fd_read(fd,iov,iovcnt,pnum){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(17,0,1,fd,iov,iovcnt,pnum);iov=bigintToI53Checked(iov);iovcnt=bigintToI53Checked(iovcnt);pnum=bigintToI53Checked(pnum);try{var stream=SYSCALLS.getStreamFromFD(fd);var num=doReadv(stream,iov,iovcnt);(growMemViews(),HEAPU64)[pnum/8]=BigInt(num);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}function _fd_seek(fd,offset,whence,newOffset){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(18,0,1,fd,offset,whence,newOffset);offset=bigintToI53Checked(offset);newOffset=bigintToI53Checked(newOffset);try{if(isNaN(offset))return 61;var stream=SYSCALLS.getStreamFromFD(fd);FS.llseek(stream,offset,whence);(growMemViews(),HEAP64)[newOffset/8]=BigInt(stream.position);if(stream.getdents&&offset===0&&whence===0)stream.getdents=null;return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}var doWritev=(stream,iov,iovcnt,offset)=>{var ret=0;for(var i=0;i<iovcnt;i++){var ptr=Number((growMemViews(),HEAPU64)[iov/8]);var len=Number((growMemViews(),HEAPU64)[(iov+8)/8]);iov+=16;var curr=FS.write(stream,(growMemViews(),HEAP8),ptr,len,offset);if(curr<0)return-1;ret+=curr;if(curr<len){break}if(typeof offset!="undefined"){offset+=curr}}return ret};function _fd_write(fd,iov,iovcnt,pnum){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(19,0,1,fd,iov,iovcnt,pnum);iov=bigintToI53Checked(iov);iovcnt=bigintToI53Checked(iovcnt);pnum=bigintToI53Checked(pnum);try{var stream=SYSCALLS.getStreamFromFD(fd);var num=doWritev(stream,iov,iovcnt);(growMemViews(),HEAPU64)[pnum/8]=BigInt(num);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}function _random_get(buffer,size){buffer=bigintToI53Checked(buffer);size=bigintToI53Checked(size);try{randomFill((growMemViews(),HEAPU8).subarray(buffer,buffer+size));return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}function _wgpuAdapterGetInfo(adapterPtr,info){adapterPtr=bigintToI53Checked(adapterPtr);info=bigintToI53Checked(info);var adapter=WebGPU.getJsObject(adapterPtr);WebGPU.fillAdapterInfoStruct(adapter.info,info);return 1}function _wgpuAdapterGetLimits(adapterPtr,limitsOutPtr){adapterPtr=bigintToI53Checked(adapterPtr);limitsOutPtr=bigintToI53Checked(limitsOutPtr);var adapter=WebGPU.getJsObject(adapterPtr);WebGPU.fillLimitStruct(adapter.limits,limitsOutPtr);return 1}function _wgpuAdapterHasFeature(adapterPtr,featureEnumValue){adapterPtr=bigintToI53Checked(adapterPtr);var adapter=WebGPU.getJsObject(adapterPtr);return adapter.features.has(WebGPU.FeatureName[featureEnumValue])}var _wgpuBufferGetSize=function(bufferPtr){bufferPtr=bigintToI53Checked(bufferPtr);var ret=(()=>{var buffer=WebGPU.getJsObject(bufferPtr);return buffer.size})();return BigInt(ret)};var _wgpuCommandEncoderBeginComputePass=function(encoderPtr,descriptor){encoderPtr=bigintToI53Checked(encoderPtr);descriptor=bigintToI53Checked(descriptor);var ret=(()=>{var desc;if(descriptor){desc={label:WebGPU.makeStringFromOptionalStringView(descriptor+8),timestampWrites:WebGPU.makePassTimestampWrites(Number((growMemViews(),HEAPU64)[(descriptor+24)/8]))}}var commandEncoder=WebGPU.getJsObject(encoderPtr);var ptr=_emwgpuCreateComputePassEncoder(0n);WebGPU.Internals.jsObjectInsert(ptr,commandEncoder.beginComputePass(desc));return ptr})();return BigInt(ret)};function _wgpuCommandEncoderCopyBufferToBuffer(encoderPtr,srcPtr,srcOffset,dstPtr,dstOffset,size){encoderPtr=bigintToI53Checked(encoderPtr);srcPtr=bigintToI53Checked(srcPtr);srcOffset=bigintToI53Checked(srcOffset);dstPtr=bigintToI53Checked(dstPtr);dstOffset=bigintToI53Checked(dstOffset);size=bigintToI53Checked(size);var commandEncoder=WebGPU.getJsObject(encoderPtr);var src=WebGPU.getJsObject(srcPtr);var dst=WebGPU.getJsObject(dstPtr);commandEncoder.copyBufferToBuffer(src,srcOffset,dst,dstOffset,size)}var _wgpuCommandEncoderFinish=function(encoderPtr,descriptor){encoderPtr=bigintToI53Checked(encoderPtr);descriptor=bigintToI53Checked(descriptor);var ret=(()=>{var commandEncoder=WebGPU.getJsObject(encoderPtr);var ptr=_emwgpuCreateCommandBuffer(0n);WebGPU.Internals.jsObjectInsert(ptr,commandEncoder.finish());return ptr})();return BigInt(ret)};function _wgpuComputePassEncoderDispatchWorkgroups(passPtr,x,y,z){passPtr=bigintToI53Checked(passPtr);var pass=WebGPU.getJsObject(passPtr);pass.dispatchWorkgroups(x,y,z)}function _wgpuComputePassEncoderEnd(passPtr){passPtr=bigintToI53Checked(passPtr);var pass=WebGPU.getJsObject(passPtr);pass.end()}function _wgpuComputePassEncoderSetBindGroup(passPtr,groupIndex,groupPtr,dynamicOffsetCount,dynamicOffsetsPtr){passPtr=bigintToI53Checked(passPtr);groupPtr=bigintToI53Checked(groupPtr);dynamicOffsetCount=bigintToI53Checked(dynamicOffsetCount);dynamicOffsetsPtr=bigintToI53Checked(dynamicOffsetsPtr);var pass=WebGPU.getJsObject(passPtr);var group=WebGPU.getJsObject(groupPtr);if(dynamicOffsetCount==0){pass.setBindGroup(groupIndex,group)}else{pass.setBindGroup(groupIndex,group,(growMemViews(),HEAPU32),dynamicOffsetsPtr/4,dynamicOffsetCount)}}function _wgpuComputePassEncoderSetPipeline(passPtr,pipelinePtr){passPtr=bigintToI53Checked(passPtr);pipelinePtr=bigintToI53Checked(pipelinePtr);var pass=WebGPU.getJsObject(passPtr);var pipeline=WebGPU.getJsObject(pipelinePtr);pass.setPipeline(pipeline)}var _wgpuComputePipelineGetBindGroupLayout=function(pipelinePtr,groupIndex){pipelinePtr=bigintToI53Checked(pipelinePtr);var ret=(()=>{var pipeline=WebGPU.getJsObject(pipelinePtr);var ptr=_emwgpuCreateBindGroupLayout(0n);WebGPU.Internals.jsObjectInsert(ptr,pipeline.getBindGroupLayout(groupIndex));return ptr})();return BigInt(ret)};var _wgpuDeviceCreateBindGroup=function(devicePtr,descriptor){devicePtr=bigintToI53Checked(devicePtr);descriptor=bigintToI53Checked(descriptor);var ret=(()=>{function makeEntry(entryPtr){var bufferPtr=Number((growMemViews(),HEAPU64)[(entryPtr+16)/8]);var samplerPtr=Number((growMemViews(),HEAPU64)[(entryPtr+40)/8]);var textureViewPtr=Number((growMemViews(),HEAPU64)[(entryPtr+48)/8]);var externalTexturePtr=0;WebGPU.iterateExtensions(entryPtr,{327681:ptr=>{externalTexturePtr=Number((growMemViews(),HEAPU64)[(ptr+16)/8])}});var resource;if(bufferPtr){var size=readI53FromI64(entryPtr+32);if(size==-1)size=undefined;resource={buffer:WebGPU.getJsObject(bufferPtr),offset:readI53FromI64(entryPtr+24),size}}else{resource=WebGPU.getJsObject(samplerPtr||textureViewPtr||externalTexturePtr)}return{binding:(growMemViews(),HEAPU32)[(entryPtr+8)/4],resource}}function makeEntries(count,entriesPtrs){var entries=[];for(var i=0;i<count;++i){entries.push(makeEntry(entriesPtrs+56*i))}return entries}var desc={label:WebGPU.makeStringFromOptionalStringView(descriptor+8),layout:WebGPU.getJsObject(Number((growMemViews(),HEAPU64)[(descriptor+24)/8])),entries:makeEntries(Number((growMemViews(),HEAPU64)[(descriptor+32)/8]),Number((growMemViews(),HEAPU64)[(descriptor+40)/8]))};var device=WebGPU.getJsObject(devicePtr);var ptr=_emwgpuCreateBindGroup(0n);WebGPU.Internals.jsObjectInsert(ptr,device.createBindGroup(desc));return ptr})();return BigInt(ret)};var _wgpuDeviceCreateCommandEncoder=function(devicePtr,descriptor){devicePtr=bigintToI53Checked(devicePtr);descriptor=bigintToI53Checked(descriptor);var ret=(()=>{var desc;if(descriptor){desc={label:WebGPU.makeStringFromOptionalStringView(descriptor+8)}}var device=WebGPU.getJsObject(devicePtr);var ptr=_emwgpuCreateCommandEncoder(0n);WebGPU.Internals.jsObjectInsert(ptr,device.createCommandEncoder(desc));return ptr})();return BigInt(ret)};var _wgpuDeviceCreateComputePipeline=function(devicePtr,descriptor){devicePtr=bigintToI53Checked(devicePtr);descriptor=bigintToI53Checked(descriptor);var ret=(()=>{var desc=WebGPU.makeComputePipelineDesc(descriptor);var device=WebGPU.getJsObject(devicePtr);var ptr=_emwgpuCreateComputePipeline(0n);WebGPU.Internals.jsObjectInsert(ptr,device.createComputePipeline(desc));return ptr})();return BigInt(ret)};function _wgpuInstanceHasWGSLLanguageFeature(instance,featureEnumValue){instance=bigintToI53Checked(instance);if(!("wgslLanguageFeatures"in navigator.gpu)){return false}return navigator.gpu.wgslLanguageFeatures.has(WebGPU.WGSLLanguageFeatureName[featureEnumValue])}var _wgpuQueueSubmit=function(queuePtr,commandCount,commands){queuePtr=bigintToI53Checked(queuePtr);commandCount=bigintToI53Checked(commandCount);commands=bigintToI53Checked(commands);var queue=WebGPU.getJsObject(queuePtr);var cmds=Array.from((growMemViews(),HEAP64).subarray(commands/8,(commands+commandCount*8)/8),id=>WebGPU.getJsObject(id));queue.submit(cmds)};function _wgpuQueueWriteBuffer(queuePtr,bufferPtr,bufferOffset,data,size){queuePtr=bigintToI53Checked(queuePtr);bufferPtr=bigintToI53Checked(bufferPtr);bufferOffset=bigintToI53Checked(bufferOffset);data=bigintToI53Checked(data);size=bigintToI53Checked(size);var queue=WebGPU.getJsObject(queuePtr);var buffer=WebGPU.getJsObject(bufferPtr);var subarray=(growMemViews(),HEAPU8).subarray(data,data+size);queue.writeBuffer(buffer,bufferOffset,subarray,0,size)}var Asyncify={instrumentWasmImports(imports){var importPattern=/^(invoke_.*|__asyncjs__.*)$/;for(let[x,original]of Object.entries(imports)){if(typeof original=="function"){let isAsyncifyImport=original.isAsync||importPattern.test(x);if(isAsyncifyImport){imports[x]=original=new WebAssembly.Suspending(original)}}}},instrumentFunction(original){var wrapper=(...args)=>original(...args);return wrapper},instrumentWasmExports(exports){var exportPattern=/^(wllama_start|wllama_action|main|__main_argc_argv)$/;Asyncify.asyncExports=new Set;var ret={};for(let[x,original]of Object.entries(exports)){if(typeof original=="function"){let isAsyncifyExport=exportPattern.test(x);if(isAsyncifyExport){Asyncify.asyncExports.add(original);original=Asyncify.makeAsyncFunction(original)}var wrapper=Asyncify.instrumentFunction(original);ret[x]=wrapper}else{ret[x]=original}}return ret},asyncExports:null,isAsyncExport(func){return Asyncify.asyncExports?.has(func)},handleAsync:async startAsync=>{runtimeKeepalivePush();try{return await startAsync()}finally{runtimeKeepalivePop()}},handleSleep:startAsync=>Asyncify.handleAsync(()=>new Promise(startAsync)),makeAsyncFunction(original){return WebAssembly.promising(original)}};var getCFunc=ident=>{var func=Module["_"+ident];return func};var writeArrayToMemory=(array,buffer)=>{(growMemViews(),HEAP8).set(array,buffer)};var ccall=(ident,returnType,argTypes,args,opts)=>{var toC={pointer:p=>BigInt(p),string:str=>{var ret=0;if(str!==null&&str!==undefined&&str!==0){ret=stringToUTF8OnStack(str)}return BigInt(ret)},array:arr=>{var ret=stackAlloc(arr.length);writeArrayToMemory(arr,ret);return BigInt(ret)}};function convertReturnValue(ret){if(returnType==="string"){return UTF8ToString(Number(ret))}if(returnType==="pointer")return Number(ret);if(returnType==="boolean")return Boolean(ret);return ret}var func=getCFunc(ident);var cArgs=[];var stack=0;if(args){for(var i=0;i<args.length;i++){var converter=toC[argTypes[i]];if(converter){if(stack===0)stack=stackSave();cArgs[i]=converter(args[i])}else{cArgs[i]=args[i]}}}var ret=func(...cArgs);function onDone(ret){if(stack!==0)stackRestore(stack);return convertReturnValue(ret)}var asyncMode=opts?.async;if(asyncMode)return ret.then(onDone);ret=onDone(ret);return ret};var cwrap=(ident,returnType,argTypes,opts)=>{var numericArgs=!argTypes||argTypes.every(type=>type==="number"||type==="boolean");var numericRet=returnType!=="string";if(numericRet&&numericArgs&&!opts){return getCFunc(ident)}return(...args)=>ccall(ident,returnType,argTypes,args,opts)};var FS_createPath=(...args)=>FS.createPath(...args);var FS_unlink=(...args)=>FS.unlink(...args);var FS_createLazyFile=(...args)=>FS.createLazyFile(...args);var FS_createDevice=(...args)=>FS.createDevice(...args);PThread.init();FS.createPreloadedFile=FS_createPreloadedFile;FS.preloadFile=FS_preloadFile;FS.staticInit();{initMemory();if(Module["noExitRuntime"])noExitRuntime=Module["noExitRuntime"];if(Module["preloadPlugins"])preloadPlugins=Module["preloadPlugins"];if(Module["print"])out=Module["print"];if(Module["printErr"])err=Module["printErr"];if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];if(Module["arguments"])arguments_=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].shift()()}}}Module["ENV"]=ENV;Module["mmapAlloc"]=mmapAlloc;Module["wasmMemory"]=wasmMemory;Module["addRunDependency"]=addRunDependency;Module["removeRunDependency"]=removeRunDependency;Module["ccall"]=ccall;Module["cwrap"]=cwrap;Module["FS_preloadFile"]=FS_preloadFile;Module["FS_unlink"]=FS_unlink;Module["FS_createPath"]=FS_createPath;Module["FS_createDevice"]=FS_createDevice;Module["FS"]=FS;Module["FS_createDataFile"]=FS_createDataFile;Module["FS_createLazyFile"]=FS_createLazyFile;Module["MEMFS"]=MEMFS;var proxiedFunctionTable=[_proc_exit,exitOnMainThread,pthreadCreateProxied,___syscall_fcntl64,___syscall_fstat64,___syscall_getcwd,___syscall_getdents64,___syscall_ioctl,___syscall_lstat64,___syscall_newfstatat,___syscall_openat,___syscall_stat64,__mmap_js,__munmap_js,_environ_get,_environ_sizes_get,_fd_close,_fd_read,_fd_seek,_fd_write];function __asyncjs__js_file_read(path_ptr,offset,req_size,out_ptr){return Asyncify.handleAsync(async()=>await _wllama_js_file_read(UTF8ToString(Number(path_ptr)),Number(offset),Number(req_size),Number(out_ptr)))}__asyncjs__js_file_read.sig="jjjjj";var _malloc,_free,_wllama_malloc,_wllama_start,_wllama_action,_wllama_exit,_wllama_debug,_main,_emwgpuCreateBindGroup,_emwgpuCreateBindGroupLayout,_emwgpuCreateCommandBuffer,_emwgpuCreateCommandEncoder,_emwgpuCreateComputePassEncoder,_emwgpuCreateComputePipeline,_emwgpuCreateExternalTexture,_emwgpuCreatePipelineLayout,_emwgpuCreateQuerySet,_emwgpuCreateRenderBundle,_emwgpuCreateRenderBundleEncoder,_emwgpuCreateRenderPassEncoder,_emwgpuCreateRenderPipeline,_emwgpuCreateSampler,_emwgpuCreateSurface,_emwgpuCreateTexture,_emwgpuCreateTextureView,_emwgpuCreateAdapter,_emwgpuCreateBuffer,_emwgpuCreateDevice,_emwgpuCreateQueue,_emwgpuCreateShaderModule,_emwgpuOnDeviceLostCompleted,_emwgpuOnMapAsyncCompleted,_emwgpuOnRequestAdapterCompleted,_emwgpuOnRequestDeviceCompleted,_emwgpuOnWorkDoneCompleted,_emwgpuOnUncapturedError,__emscripten_tls_init,_pthread_self,_emscripten_builtin_memalign,__emscripten_thread_init,__emscripten_thread_crashed,__emscripten_run_js_on_main_thread,__emscripten_thread_free_data,__emscripten_thread_exit,__emscripten_check_mailbox,_memalign,___trap,_emscripten_stack_set_limits,__emscripten_stack_restore,__emscripten_stack_alloc,_emscripten_stack_get_current,__indirect_function_table,wasmTable;function assignWasmExports(wasmExports){_malloc=wasmExports["malloc"];_free=wasmExports["free"];_wllama_malloc=Module["_wllama_malloc"]=wasmExports["wllama_malloc"];_wllama_start=Module["_wllama_start"]=wasmExports["wllama_start"];_wllama_action=Module["_wllama_action"]=wasmExports["wllama_action"];_wllama_exit=Module["_wllama_exit"]=wasmExports["wllama_exit"];_wllama_debug=Module["_wllama_debug"]=wasmExports["wllama_debug"];_main=Module["_main"]=wasmExports["main"];_emwgpuCreateBindGroup=wasmExports["emwgpuCreateBindGroup"];_emwgpuCreateBindGroupLayout=wasmExports["emwgpuCreateBindGroupLayout"];_emwgpuCreateCommandBuffer=wasmExports["emwgpuCreateCommandBuffer"];_emwgpuCreateCommandEncoder=wasmExports["emwgpuCreateCommandEncoder"];_emwgpuCreateComputePassEncoder=wasmExports["emwgpuCreateComputePassEncoder"];_emwgpuCreateComputePipeline=wasmExports["emwgpuCreateComputePipeline"];_emwgpuCreateExternalTexture=wasmExports["emwgpuCreateExternalTexture"];_emwgpuCreatePipelineLayout=wasmExports["emwgpuCreatePipelineLayout"];_emwgpuCreateQuerySet=wasmExports["emwgpuCreateQuerySet"];_emwgpuCreateRenderBundle=wasmExports["emwgpuCreateRenderBundle"];_emwgpuCreateRenderBundleEncoder=wasmExports["emwgpuCreateRenderBundleEncoder"];_emwgpuCreateRenderPassEncoder=wasmExports["emwgpuCreateRenderPassEncoder"];_emwgpuCreateRenderPipeline=wasmExports["emwgpuCreateRenderPipeline"];_emwgpuCreateSampler=wasmExports["emwgpuCreateSampler"];_emwgpuCreateSurface=wasmExports["emwgpuCreateSurface"];_emwgpuCreateTexture=wasmExports["emwgpuCreateTexture"];_emwgpuCreateTextureView=wasmExports["emwgpuCreateTextureView"];_emwgpuCreateAdapter=wasmExports["emwgpuCreateAdapter"];_emwgpuCreateBuffer=wasmExports["emwgpuCreateBuffer"];_emwgpuCreateDevice=wasmExports["emwgpuCreateDevice"];_emwgpuCreateQueue=wasmExports["emwgpuCreateQueue"];_emwgpuCreateShaderModule=wasmExports["emwgpuCreateShaderModule"];_emwgpuOnDeviceLostCompleted=wasmExports["emwgpuOnDeviceLostCompleted"];_emwgpuOnMapAsyncCompleted=wasmExports["emwgpuOnMapAsyncCompleted"];_emwgpuOnRequestAdapterCompleted=wasmExports["emwgpuOnRequestAdapterCompleted"];_emwgpuOnRequestDeviceCompleted=wasmExports["emwgpuOnRequestDeviceCompleted"];_emwgpuOnWorkDoneCompleted=wasmExports["emwgpuOnWorkDoneCompleted"];_emwgpuOnUncapturedError=wasmExports["emwgpuOnUncapturedError"];__emscripten_tls_init=wasmExports["_emscripten_tls_init"];_pthread_self=wasmExports["pthread_self"];_emscripten_builtin_memalign=wasmExports["emscripten_builtin_memalign"];__emscripten_thread_init=wasmExports["_emscripten_thread_init"];__emscripten_thread_crashed=wasmExports["_emscripten_thread_crashed"];__emscripten_run_js_on_main_thread=wasmExports["_emscripten_run_js_on_main_thread"];__emscripten_thread_free_data=wasmExports["_emscripten_thread_free_data"];__emscripten_thread_exit=wasmExports["_emscripten_thread_exit"];__emscripten_check_mailbox=wasmExports["_emscripten_check_mailbox"];_memalign=wasmExports["memalign"];___trap=wasmExports["__trap"];_emscripten_stack_set_limits=wasmExports["emscripten_stack_set_limits"];__emscripten_stack_restore=wasmExports["_emscripten_stack_restore"];__emscripten_stack_alloc=wasmExports["_emscripten_stack_alloc"];_emscripten_stack_get_current=wasmExports["emscripten_stack_get_current"];__indirect_function_table=wasmTable=wasmExports["__indirect_function_table"]}var wasmImports;function assignWasmImports(){wasmImports={__asyncjs__js_file_read,__pthread_create_js:___pthread_create_js,__syscall_fcntl64:___syscall_fcntl64,__syscall_getcwd:___syscall_getcwd,__syscall_getdents64:___syscall_getdents64,__syscall_ioctl:___syscall_ioctl,__syscall_openat:___syscall_openat,__syscall_stat64:___syscall_stat64,_abort_js:__abort_js,_emscripten_init_main_thread_js:__emscripten_init_main_thread_js,_emscripten_notify_mailbox_postmessage:__emscripten_notify_mailbox_postmessage,_emscripten_receive_on_main_thread_js:__emscripten_receive_on_main_thread_js,_emscripten_thread_cleanup:__emscripten_thread_cleanup,_emscripten_thread_mailbox_await:__emscripten_thread_mailbox_await,_emscripten_thread_set_strongref:__emscripten_thread_set_strongref,_localtime_js:__localtime_js,_mmap_js:__mmap_js,_munmap_js:__munmap_js,_tzset_js:__tzset_js,clock_time_get:_clock_time_get,emscripten_check_blocking_allowed:_emscripten_check_blocking_allowed,emscripten_date_now:_emscripten_date_now,emscripten_exit_with_live_runtime:_emscripten_exit_with_live_runtime,emscripten_get_callstack:_emscripten_get_callstack,emscripten_get_heap_max:_emscripten_get_heap_max,emscripten_get_now:_emscripten_get_now,emscripten_has_asyncify:_emscripten_has_asyncify,emscripten_num_logical_cores:_emscripten_num_logical_cores,emscripten_resize_heap:_emscripten_resize_heap,emwgpuAdapterRequestDevice:_emwgpuAdapterRequestDevice,emwgpuBufferDestroy:_emwgpuBufferDestroy,emwgpuBufferGetConstMappedRange:_emwgpuBufferGetConstMappedRange,emwgpuBufferMapAsync:_emwgpuBufferMapAsync,emwgpuBufferUnmap:_emwgpuBufferUnmap,emwgpuDelete:_emwgpuDelete,emwgpuDeviceCreateBuffer:_emwgpuDeviceCreateBuffer,emwgpuDeviceCreateShaderModule:_emwgpuDeviceCreateShaderModule,emwgpuDeviceDestroy:_emwgpuDeviceDestroy,emwgpuInstanceRequestAdapter:_emwgpuInstanceRequestAdapter,emwgpuQueueOnSubmittedWorkDone:_emwgpuQueueOnSubmittedWorkDone,emwgpuWaitAny:_emwgpuWaitAny,environ_get:_environ_get,environ_sizes_get:_environ_sizes_get,exit:_exit,fd_close:_fd_close,fd_read:_fd_read,fd_seek:_fd_seek,fd_write:_fd_write,memory:wasmMemory,random_get:_random_get,wgpuAdapterGetInfo:_wgpuAdapterGetInfo,wgpuAdapterGetLimits:_wgpuAdapterGetLimits,wgpuAdapterHasFeature:_wgpuAdapterHasFeature,wgpuBufferGetSize:_wgpuBufferGetSize,wgpuCommandEncoderBeginComputePass:_wgpuCommandEncoderBeginComputePass,wgpuCommandEncoderCopyBufferToBuffer:_wgpuCommandEncoderCopyBufferToBuffer,wgpuCommandEncoderFinish:_wgpuCommandEncoderFinish,wgpuComputePassEncoderDispatchWorkgroups:_wgpuComputePassEncoderDispatchWorkgroups,wgpuComputePassEncoderEnd:_wgpuComputePassEncoderEnd,wgpuComputePassEncoderSetBindGroup:_wgpuComputePassEncoderSetBindGroup,wgpuComputePassEncoderSetPipeline:_wgpuComputePassEncoderSetPipeline,wgpuComputePipelineGetBindGroupLayout:_wgpuComputePipelineGetBindGroupLayout,wgpuDeviceCreateBindGroup:_wgpuDeviceCreateBindGroup,wgpuDeviceCreateCommandEncoder:_wgpuDeviceCreateCommandEncoder,wgpuDeviceCreateComputePipeline:_wgpuDeviceCreateComputePipeline,wgpuInstanceHasWGSLLanguageFeature:_wgpuInstanceHasWGSLLanguageFeature,wgpuQueueSubmit:_wgpuQueueSubmit,wgpuQueueWriteBuffer:_wgpuQueueWriteBuffer}}function applySignatureConversions(wasmExports){wasmExports=Object.assign({},wasmExports);var makeWrapper_pp=f=>a0=>Number(f(BigInt(a0)));var makeWrapper__p=f=>a0=>f(BigInt(a0));var makeWrapper___PP=f=>(a0,a1,a2)=>f(a0,BigInt(a1?a1:0),BigInt(a2?a2:0));var makeWrapper_p=f=>()=>Number(f());var makeWrapper_ppp=f=>(a0,a1)=>Number(f(BigInt(a0),BigInt(a1)));var makeWrapper__p_____=f=>(a0,a1,a2,a3,a4,a5)=>f(BigInt(a0),a1,a2,a3,a4,a5);var makeWrapper___p_p_=f=>(a0,a1,a2,a3,a4)=>f(a0,BigInt(a1),a2,BigInt(a3),a4);var makeWrapper__pp=f=>(a0,a1)=>f(BigInt(a0),BigInt(a1));wasmExports["malloc"]=makeWrapper_pp(wasmExports["malloc"]);wasmExports["free"]=makeWrapper__p(wasmExports["free"]);wasmExports["main"]=makeWrapper___PP(wasmExports["main"]);wasmExports["pthread_self"]=makeWrapper_p(wasmExports["pthread_self"]);wasmExports["emscripten_builtin_memalign"]=makeWrapper_ppp(wasmExports["emscripten_builtin_memalign"]);wasmExports["_emscripten_thread_init"]=makeWrapper__p_____(wasmExports["_emscripten_thread_init"]);wasmExports["_emscripten_run_js_on_main_thread"]=makeWrapper___p_p_(wasmExports["_emscripten_run_js_on_main_thread"]);wasmExports["_emscripten_thread_free_data"]=makeWrapper__p(wasmExports["_emscripten_thread_free_data"]);wasmExports["_emscripten_thread_exit"]=makeWrapper__p(wasmExports["_emscripten_thread_exit"]);wasmExports["memalign"]=makeWrapper_ppp(wasmExports["memalign"]);wasmExports["emscripten_stack_set_limits"]=makeWrapper__pp(wasmExports["emscripten_stack_set_limits"]);wasmExports["_emscripten_stack_restore"]=makeWrapper__p(wasmExports["_emscripten_stack_restore"]);wasmExports["_emscripten_stack_alloc"]=makeWrapper_pp(wasmExports["_emscripten_stack_alloc"]);wasmExports["emscripten_stack_get_current"]=makeWrapper_p(wasmExports["emscripten_stack_get_current"]);return wasmExports}async function callMain(){var entryFunction=_main;var argc=0;var argv=0;try{var ret=entryFunction(argc,BigInt(argv));ret=await ret;exitJS(ret,true);return ret}catch(e){return handleException(e)}}function run(){if(runDependencies>0){dependenciesFulfilled=run;return}if(ENVIRONMENT_IS_PTHREAD){initRuntime();return}preRun();if(runDependencies>0){dependenciesFulfilled=run;return}async function doRun(){Module["calledRun"]=true;if(ABORT)return;initRuntime();preMain();Module["onRuntimeInitialized"]?.();var noInitialRun=Module["noInitialRun"]||false;if(!noInitialRun)await callMain();postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(()=>{setTimeout(()=>Module["setStatus"](""),1);doRun()},1)}else{doRun()}}var wasmExports;if(!ENVIRONMENT_IS_PTHREAD){createWasm();run()}\n';
+
+// src/worker.ts
+var FILE_READ_REQ_EVENT = "fs.read_req";
+var JSPI_STUB = `
+if (!WebAssembly.Suspending) {
+  // JSPI not available - stubs that keep the import/export tables valid.
+  // Suspending wraps imports: identity is fine since async imports won't be called.
+  WebAssembly.Suspending = function (fn) {
+    // console.log(fn.toString());
+    return fn;
+  };
+  // promising wraps exports: must return a Promise so ccall's ret.then() works.
+  WebAssembly.promising = function (fn) {
+    return function (...args) {
+      try {
+        return Promise.resolve(fn(...args));
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+  };
+}
+`;
+var ProxyToWorker = class {
+  // filename -> Blob for async reads
+  constructor(resources, nbThread, suppressNativeLog, logger) {
+    __publicField(this, "resources");
+    __publicField(this, "logger");
+    __publicField(this, "suppressNativeLog");
+    __publicField(this, "taskQueue", []);
+    __publicField(this, "taskId", 1);
+    __publicField(this, "resultQueue", []);
+    __publicField(this, "busy", false);
+    // is the work loop is running?
+    __publicField(this, "worker");
+    __publicField(this, "multiThread");
+    __publicField(this, "nbThread");
+    __publicField(this, "useAsyncFile");
+    __publicField(this, "fileBlobs", /* @__PURE__ */ new Map());
+    this.resources = resources;
+    this.nbThread = nbThread;
+    this.multiThread = nbThread > 0;
+    this.logger = logger;
+    this.suppressNativeLog = suppressNativeLog;
+    this.useAsyncFile = canUseAsyncFileRead(resources.compat);
+  }
+  getModuleCode() {
+    return __async(this, null, function* () {
+      if (!this.resources.jsPath) {
+        if (this.resources.compat) {
+          throw new Error(
+            "compat mode is enabled but no jsPath was provided. Pass a worker JS via setCompat() or install @wllama/wllama-compat."
+          );
+        }
+        return WLLAMA_EMSCRIPTEN_CODE;
+      } else if (this.resources.jsPath.code) {
+        return this.resources.jsPath.code;
+      } else if (isString(this.resources.jsPath)) {
+        const response = yield fetch(this.resources.jsPath);
+        if (!response.ok) {
+          throw new Error(
+            `Failed to fetch worker code from ${this.resources.jsPath}`
+          );
+        }
+        return yield response.text();
+      } else {
+        throw new Error("No JS code provided for worker");
+      }
+    });
+  }
+  moduleInit(ggufFiles) {
+    return __async(this, null, function* () {
+      let moduleCode = JSPI_STUB + (yield this.getModuleCode());
+      let mainModuleCode = moduleCode.replace("var Module", "var ___Module");
+      const runOptions = {
+        pathConfig: {
+          "wllama.wasm": this.resources.wasmPath
+        },
+        nbThread: this.nbThread,
+        compat: this.resources.compat
+      };
+      const completeCode = [
+        `const RUN_OPTIONS = ${JSON.stringify(runOptions)};`,
+        `function wModuleInit() { ${mainModuleCode}; return Module; }`,
+        LLAMA_CPP_WORKER_CODE
+      ].join(";\n\n");
+      this.worker = createWorker(completeCode);
+      this.worker.onmessage = this.onRecvMsg.bind(this);
+      this.worker.onerror = this.logger.error;
+      const res = yield this.pushTask({
+        verb: "module.init",
+        args: [
+          new Blob([moduleCode], { type: "text/javascript" }),
+          this.useAsyncFile
+        ],
+        callbackId: this.taskId++
+      });
+      const nativeFiles = [];
+      for (const file of ggufFiles) {
+        const needAllocBuffer = !this.useAsyncFile;
+        const id = yield this.fileAlloc(
+          file.name,
+          file.blob.size,
+          needAllocBuffer
+        );
+        nativeFiles.push(__spreadValues({ id }, file));
+        if (this.useAsyncFile) {
+          this.fileBlobs.set(file.name, file.blob);
+        }
+      }
+      if (!this.useAsyncFile) {
+        yield Promise.all(
+          nativeFiles.map((file) => {
+            return this.fileWrite(file.id, file.blob);
+          })
+        );
+      }
+      return res;
+    });
+  }
+  wllamaStart() {
+    return __async(this, null, function* () {
+      const result = yield this.pushTask({
+        verb: "wllama.start",
+        args: [],
+        callbackId: this.taskId++
+      });
+      const parsedResult = this.parseResult(result);
+      return parsedResult;
+    });
+  }
+  wllamaAction(name, body) {
+    return __async(this, null, function* () {
+      const encodedMsg = glueSerialize(body);
+      const result = yield this.pushTask({
+        verb: "wllama.action",
+        args: [name, encodedMsg],
+        callbackId: this.taskId++
+      });
+      const parsedResult = glueDeserialize(result);
+      return parsedResult;
+    });
+  }
+  wllamaExit() {
+    return __async(this, null, function* () {
+      if (this.worker) {
+        this.worker.terminate();
+      }
+    });
+  }
+  wllamaDebug() {
+    return __async(this, null, function* () {
+      const result = yield this.pushTask({
+        verb: "wllama.debug",
+        args: [],
+        callbackId: this.taskId++
+      });
+      return JSON.parse(result);
+    });
+  }
+  ///////////////////////////////////////
+  /**
+   * Allocate a new file in heapfs
+   * @returns fileId, to be used by fileWrite()
+   */
+  fileAlloc(fileName, size, allocBuffer) {
+    return __async(this, null, function* () {
+      const result = yield this.pushTask({
+        verb: "fs.alloc",
+        args: [fileName, size, allocBuffer],
+        callbackId: this.taskId++
+      });
+      return result.fileId;
+    });
+  }
+  /**
+   * Write a Blob to heapfs
+   */
+  fileWrite(fileId, blob) {
+    return __async(this, null, function* () {
+      const reader = blob.stream().getReader();
+      let offset = 0;
+      while (true) {
+        const { done, value } = yield reader.read();
+        if (done) break;
+        const size = value.byteLength;
+        yield this.pushTask(
+          {
+            verb: "fs.write",
+            args: [fileId, value, offset],
+            callbackId: this.taskId++
+          },
+          // @ts-ignore Type 'ArrayBufferLike' is not assignable to type 'ArrayBuffer'
+          [value.buffer]
+        );
+        offset += size;
+      }
+    });
+  }
+  fileReadResponse(name, offset, size) {
+    return __async(this, null, function* () {
+      var _a;
+      try {
+        const blob = this.fileBlobs.get(name);
+        if (!blob) {
+          throw new Error(`blob not found for name="${name}"`);
+        }
+        const chunk = blob.slice(offset, offset + size);
+        const buffer = yield chunk.arrayBuffer();
+        this.worker.postMessage(
+          { verb: "fs.read_res", args: [buffer] },
+          { transfer: [buffer] }
+        );
+      } catch (err) {
+        this.logger.error("fileReadResponse failed, terminating worker:", err);
+        (_a = this.worker) == null ? void 0 : _a.terminate();
+        this.worker = void 0;
+        this.abort(`File read failed: ${err}`, err.stack || "");
+      }
+    });
+  }
+  /**
+   * Parse JSON result returned by cpp code.
+   * Throw new Error if "__exception" is present in the response
+   *
+   * TODO: get rid of this function once everything is migrated to Glue
+   */
+  parseResult(result) {
+    const parsedResult = JSON.parse(result);
+    if (parsedResult && parsedResult["error"]) {
+      throw new WllamaRuntimeError("Unknown error, please see console.log", "");
+    }
+    return parsedResult;
+  }
+  /**
+   * Push a new task to taskQueue
+   */
+  pushTask(param, buffers) {
+    return new Promise((resolve, reject) => {
+      this.taskQueue.push({ resolve, reject, param, buffers });
+      this.runTaskLoop();
+    });
+  }
+  /**
+   * Main loop for processing tasks
+   */
+  runTaskLoop() {
+    return __async(this, null, function* () {
+      var _a;
+      if (this.busy) {
+        return;
+      }
+      this.busy = true;
+      while (true) {
+        const task = this.taskQueue.shift();
+        if (!task) break;
+        this.resultQueue.push(task);
+        this.worker.postMessage(
+          task.param,
+          isSafariMobile() ? void 0 : {
+            transfer: (_a = task.buffers) != null ? _a : []
+          }
+        );
+      }
+      this.busy = false;
+    });
+  }
+  /**
+   * Handle messages from worker
+   */
+  onRecvMsg(e) {
+    if (!e.data) return;
+    const { verb, args } = e.data;
+    const isCompatBuild = this.resources.compat;
+    if (verb && verb.startsWith("console.")) {
+      if (this.suppressNativeLog) {
+        return;
+      }
+      if (verb.endsWith("debug")) this.logger.debug(...args);
+      if (verb.endsWith("log")) this.logger.log(...args);
+      if (verb.endsWith("warn")) this.logger.warn(...args);
+      if (verb.endsWith("error")) this.logger.error(...args);
+      return;
+    } else if (verb === "signal.abort") {
+      const [signalType, message, rawStack, originalErr] = args;
+      if (originalErr) {
+        this.logger.error(originalErr);
+      }
+      (() => __async(this, null, function* () {
+        let stack = "";
+        let newMsg = message.replace(
+          "Build with -sASSERTIONS for more info.",
+          ""
+        );
+        if (signalType === "abort") {
+          newMsg = `(ABORT) ${newMsg}`;
+          stack = rawStack.replace(/\|/g, "\n");
+        } else if (signalType === "exception") {
+          stack = rawStack;
+        }
+        const decoded = yield Debug.decodeStackTrace(stack, isCompatBuild);
+        this.logger.error(`Stack trace (${signalType}):
+` + decoded);
+        this.abort(newMsg, decoded);
+      }))();
+      return;
+    }
+    if (verb === FILE_READ_REQ_EVENT) {
+      const [name, offset, size] = args;
+      this.fileReadResponse(name, offset, size).catch(() => {
+      });
+      return;
+    }
+    const { callbackId, result, err } = e.data;
+    if (callbackId) {
+      const idx = this.resultQueue.findIndex(
+        (t) => t.param.callbackId === callbackId
+      );
+      if (idx !== -1) {
+        const waitingTask = this.resultQueue.splice(idx, 1)[0];
+        if (err) waitingTask.reject(err);
+        else waitingTask.resolve(result);
+      } else {
+        this.logger.error(
+          `Cannot find waiting task with callbackId = ${callbackId}`
+        );
+      }
+    }
+  }
+  abort(text, stack) {
+    const error = new WllamaRuntimeError(
+      text.length == 0 ? "(unknown error)" : text,
+      stack
+    );
+    while (this.resultQueue.length > 0) {
+      const waitingTask = this.resultQueue.pop();
+      if (!waitingTask) break;
+      waitingTask.reject(error);
+    }
+    while (this.taskQueue.length > 0) {
+      const pendingTask = this.taskQueue.pop();
+      if (!pendingTask) break;
+      pendingTask.reject(error);
+    }
+  }
+};
+
+// src/huggingface.ts
+var HF_BASE = "https://huggingface.co";
+var DEFAULT_QUANTS = ["Q4_K_M", "Q8_0"];
+function fetchRepoFiles(repo, token) {
+  return __async(this, null, function* () {
+    var _a;
+    const url = `${HF_BASE}/api/models/${repo}/tree/main?recursive=true`;
+    const headers = { Accept: "application/json" };
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    const res = yield fetch(url, { headers });
+    if (!res.ok) {
+      let msg = res.statusText;
+      try {
+        msg = (_a = (yield res.json()).error) != null ? _a : msg;
+      } catch (e) {
+      }
+      throw new Error(`HF API error (${res.status}): ${msg}`);
+    }
+    return res.json();
+  });
+}
+function firstShardPath(files, path) {
+  const m = path.match(/^(.+)-(\d{5})-of-(\d{5})\.gguf$/i);
+  if (!m) return path;
+  const first = `${m[1]}-00001-of-${m[3]}.gguf`;
+  return files.some((f) => f.path === first) ? first : path;
+}
+function selectFile(files, quant, mmprojOnly) {
+  const candidates = files.filter((f) => {
+    if (f.type !== "file" || !f.path.toLowerCase().endsWith(".gguf"))
+      return false;
+    const ismmproj = f.path.toLowerCase().includes("mmproj");
+    return mmprojOnly ? ismmproj : !ismmproj;
+  });
+  if (candidates.length === 0) return null;
+  if (quant) {
+    const upper = quant.toUpperCase();
+    const match = candidates.find((f) => f.path.toUpperCase().includes(upper));
+    if (match) return firstShardPath(candidates, match.path);
+    return null;
+  }
+  for (const q of DEFAULT_QUANTS) {
+    const match = candidates.find((f) => f.path.toUpperCase().includes(q));
+    if (match) return firstShardPath(candidates, match.path);
+  }
+  return firstShardPath(candidates, candidates[0].path);
+}
+function getHFModelSource(config) {
+  return __async(this, null, function* () {
+    const { repo, file, quant, mmprojFile, mmprojQuant, hfToken } = config;
+    const files = yield fetchRepoFiles(repo, hfToken);
+    const modelPath = file != null ? file : selectFile(files, quant, false);
+    if (!modelPath) {
+      throw new Error(`No GGUF file found in repo "${repo}"`);
+    }
+    const source = {
+      url: `${HF_BASE}/${repo}/resolve/main/${modelPath}`
+    };
+    if (mmprojFile || mmprojQuant !== void 0) {
+      const mmpath = mmprojFile != null ? mmprojFile : selectFile(files, mmprojQuant, true);
+      if (mmpath) {
+        source.mmprojUrl = `${HF_BASE}/${repo}/resolve/main/${mmpath}`;
+      }
+    }
+    if (hfToken) {
+      const params = new URLSearchParams({ token: hfToken });
+      source.url += `?${params}`;
+      if (source.mmprojUrl) {
+        source.mmprojUrl += `?${params}`;
+      }
+    }
+    return source;
+  });
+}
+function getHFFileSHA256(url, headers) {
+  return __async(this, null, function* () {
+    if (!url.includes("/resolve/")) return void 0;
+    const rawUrl = url.replace("/resolve/", "/raw/");
+    try {
+      const text = yield fetch(rawUrl, { headers }).then((r) => r.text());
+      const match = text.match(/^oid sha256:([0-9a-f]{64})$/m);
+      return match ? match[1] : void 0;
+    } catch (e) {
+      return void 0;
+    }
+  });
+}
+
+// src/storage/opfs.ts
+var OPFSBackend = class {
+  isSupported() {
+    var _a;
+    return typeof navigator !== "undefined" && "storage" in navigator && !!((_a = navigator.storage) == null ? void 0 : _a.getDirectory);
+  }
+  read(key) {
+    return __async(this, null, function* () {
+      try {
+        const cacheDir = yield getCacheDir();
+        const fileHandle = yield cacheDir.getFileHandle(key);
+        return yield fileHandle.getFile();
+      } catch (e) {
+        return null;
+      }
+    });
+  }
+  write(key, stream) {
+    return __async(this, null, function* () {
+      const writable = yield openWritable(key);
+      yield writable.truncate(0);
+      const reader = stream.getReader();
+      try {
+        while (true) {
+          const { done, value } = yield reader.read();
+          if (done) break;
+          yield writable.write(value);
+        }
+      } finally {
+        yield writable.close();
+      }
+    });
+  }
+  getSize(key) {
+    return __async(this, null, function* () {
+      try {
+        const cacheDir = yield getCacheDir();
+        const fileHandle = yield cacheDir.getFileHandle(key);
+        const file = yield fileHandle.getFile();
+        return file.size;
+      } catch (e) {
+        return -1;
+      }
+    });
+  }
+  list() {
+    return __async(this, null, function* () {
+      const cacheDir = yield getCacheDir();
+      const result = [];
+      try {
+        for (var iter = __forAwait(cacheDir.entries()), more, temp, error; more = !(temp = yield iter.next()).done; more = false) {
+          const [name, handle] = temp.value;
+          if (handle.kind === "file") {
+            const file = yield handle.getFile();
+            result.push({ key: name, size: file.size });
+          }
+        }
+      } catch (temp) {
+        error = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && (yield temp.call(iter));
+        } finally {
+          if (error)
+            throw error[0];
+        }
+      }
+      return result;
+    });
+  }
+  delete(key) {
+    return __async(this, null, function* () {
+      try {
+        const cacheDir = yield getCacheDir();
+        yield cacheDir.removeEntry(key);
+      } catch (e) {
+        if ((e == null ? void 0 : e.name) !== "NotFoundError") throw e;
+      }
+    });
+  }
+};
+function getCacheDir() {
+  return __async(this, null, function* () {
+    const opfsRoot = yield navigator.storage.getDirectory();
+    return opfsRoot.getDirectoryHandle("cache", { create: true });
+  });
+}
+function openWritable(fileName) {
+  return __async(this, null, function* () {
+    const worker = createWorker(OPFS_UTILS_WORKER_CODE);
+    let pResolve;
+    let pReject;
+    worker.onmessage = (e) => {
+      if (e.data.ok) pResolve(null);
+      else if (e.data.err) pReject(e.data.err);
+    };
+    worker.onerror = (e) => {
+      var _a;
+      return pReject == null ? void 0 : pReject((_a = e.message) != null ? _a : e);
+    };
+    const workerExec = (data) => new Promise((resolve, reject) => {
+      pResolve = resolve;
+      pReject = reject;
+      worker.postMessage(
+        data,
+        isSafariMobile() ? void 0 : { transfer: "buf" in data && data.buf ? [data.buf.buffer] : [] }
+      );
+    });
+    yield workerExec({ action: "open", filename: fileName });
+    return {
+      truncate: () => __async(this, null, function* () {
+      }),
+      write: (value) => workerExec({ action: "write", buf: value }),
+      close: () => __async(this, null, function* () {
+        yield workerExec({ action: "close" });
+        worker.terminate();
+      })
+    };
+  });
+}
+
+// src/storage/cos.ts
+function makeHash(key) {
+  return { algorithm: "SHA-256", value: key };
+}
+var COSInternalBackend = class {
+  isSupported() {
+    return typeof navigator !== "undefined" && "crossOriginStorage" in navigator;
+  }
+  // IMPORTANT: key must be SHA-256 hash of the data
+  read(key) {
+    return __async(this, null, function* () {
+      try {
+        const handle = yield navigator.crossOriginStorage.requestFileHandle(
+          makeHash(key)
+        );
+        return handle.getFile();
+      } catch (e) {
+        return null;
+      }
+    });
+  }
+  // IMPORTANT: key must be SHA-256 hash of the data
+  write(key, stream) {
+    return __async(this, null, function* () {
+      const handle = yield navigator.crossOriginStorage.requestFileHandle(
+        makeHash(key),
+        { create: true }
+      );
+      const writable = yield handle.createWritable();
+      const reader = stream.getReader();
+      try {
+        while (true) {
+          const { done, value } = yield reader.read();
+          if (done) break;
+          yield writable.write(value);
+        }
+      } finally {
+        yield writable.close();
+      }
+    });
+  }
+  // IMPORTANT: key must be SHA-256 hash of the data
+  getSize(key) {
+    return __async(this, null, function* () {
+      try {
+        const handle = yield navigator.crossOriginStorage.requestFileHandle(
+          makeHash(key)
+        );
+        const file = yield handle.getFile();
+        return file.size;
+      } catch (e) {
+        return -1;
+      }
+    });
+  }
+  list() {
+    return __async(this, null, function* () {
+      throw new Error("not implemented");
+    });
+  }
+  delete(_key) {
+    return __async(this, null, function* () {
+      throw new Error("not implemented");
+    });
+  }
+};
+var COSBackend = class {
+  constructor() {
+    __publicField(this, "cos", new COSInternalBackend());
+    __publicField(this, "priv", new OPFSBackend());
+  }
+  isSupported() {
+    return this.priv.isSupported();
+  }
+  read(key, hint) {
+    return __async(this, null, function* () {
+      if ((hint == null ? void 0 : hint.sha256) && this.cos.isSupported()) {
+        const blob = yield this.cos.read(hint.sha256);
+        if (blob) return blob;
+      }
+      return this.priv.read(key);
+    });
+  }
+  write(key, stream, hint) {
+    return __async(this, null, function* () {
+      if ((hint == null ? void 0 : hint.sha256) && this.cos.isSupported()) {
+        yield this.cos.write(hint.sha256, stream);
+      } else {
+        yield this.priv.write(key, stream);
+      }
+    });
+  }
+  getSize(key, hint) {
+    return __async(this, null, function* () {
+      if ((hint == null ? void 0 : hint.sha256) && this.cos.isSupported()) {
+        const size = yield this.cos.getSize(hint.sha256);
+        if (size !== -1) return size;
+      }
+      return this.priv.getSize(key);
+    });
+  }
+  list() {
+    return __async(this, null, function* () {
+      return this.priv.list();
+    });
+  }
+  delete(key) {
+    return __async(this, null, function* () {
+      return this.priv.delete(key);
+    });
+  }
+};
+
+// src/cache-manager.ts
+var PREFIX_METADATA = "__metadata__";
+var POLYFILL_ETAG = "polyfill_for_older_version";
+function hintFromMetadata(metadata) {
+  if (!metadata) return void 0;
+  if (metadata.sha256) return { sha256: metadata.sha256 };
+  return void 0;
+}
+var CacheManager = class {
+  /**
+   * @param backends Array of storage backends to use, in order of preference ; if first is available, use it, otherwise try the next one.
+   */
+  constructor(backends = [new COSBackend()]) {
+    __publicField(this, "sb");
+    for (const backend of backends) {
+      if (backend.isSupported()) {
+        this.sb = backend;
+        return;
+      }
+    }
+    throw new Error("No supported storage backend found");
+  }
+  /**
+   * Convert a given URL into a storage key.
+   *
+   * Format: `${hashSHA1(fullURL)}_${fileName}`
+   */
+  getNameFromURL(url) {
+    return __async(this, null, function* () {
+      return urlToFileName(url, "");
+    });
+  }
+  /**
+   * @deprecated Use `download()` instead
+   *
+   * Write a new file to cache. This will overwrite existing file.
+   *
+   * @param name The file name returned by `getNameFromURL()` or `list()`
+   */
+  write(name, stream, metadata) {
+    return __async(this, null, function* () {
+      yield this.sb.write(name, stream);
+      yield this.writeMetadata(name, metadata);
+    });
+  }
+  download(_0) {
+    return __async(this, arguments, function* (url, options = {}) {
+      var _a, _b, _c;
+      const fileKey = yield urlToFileName(url, "");
+      const sha256 = yield getHFFileSHA256(url, (_a = options.headers) != null ? _a : {});
+      const hint = sha256 ? { sha256 } : void 0;
+      if (hint && (yield this.sb.getSize(fileKey, hint)) !== -1) {
+        if (!(yield this.getMetadata(fileKey))) {
+          const head = yield fetch(url, __spreadValues({
+            method: "HEAD"
+          }, options.headers ? { headers: options.headers } : {}));
+          const contentLength2 = head.headers.get("content-length");
+          const etag2 = (head.headers.get("etag") || "").replace(
+            /[^A-Za-z0-9]/g,
+            ""
+          );
+          yield this.writeMetadata(fileKey, __spreadValues({
+            originalURL: url,
+            originalSize: parseInt(contentLength2 != null ? contentLength2 : "0", 10),
+            etag: etag2,
+            sha256
+          }, (_b = options.metadataAdditional) != null ? _b : {}));
+        }
+        return;
+      }
+      const response = yield fetch(url, __spreadValues(__spreadValues({}, options.headers ? { headers: options.headers } : {}), options.signal ? { signal: options.signal } : {}));
+      if (!response.ok || !response.body) {
+        throw new Error(`Failed to fetch ${url}: HTTP ${response.status}`);
+      }
+      const contentLength = response.headers.get("content-length");
+      const etag = (response.headers.get("etag") || "").replace(
+        /[^A-Za-z0-9]/g,
+        ""
+      );
+      const total = parseInt(contentLength != null ? contentLength : "0", 10);
+      const progressCallback = options.progressCallback;
+      let loaded = 0;
+      let lastProgressAt = 0;
+      const progressStream = new TransformStream({
+        transform(chunk, controller) {
+          loaded += chunk.byteLength;
+          if (progressCallback) {
+            const now = Date.now();
+            if (now - lastProgressAt > 100) {
+              lastProgressAt = now;
+              progressCallback({ loaded, total });
+            }
+          }
+          controller.enqueue(chunk);
+        },
+        flush() {
+          progressCallback == null ? void 0 : progressCallback({ loaded, total: total || loaded });
+        }
+      });
+      const metadata = __spreadValues({
+        originalURL: url,
+        originalSize: total,
+        etag
+      }, (_c = options.metadataAdditional) != null ? _c : {});
+      if (sha256) {
+        metadata.sha256 = sha256;
+      }
+      yield this.sb.write(
+        fileKey,
+        response.body.pipeThrough(progressStream),
+        hint
+      );
+      yield this.writeMetadata(fileKey, metadata);
+    });
+  }
+  /**
+   * Open a file in cache for reading
+   *
+   * @param nameOrURL The file name returned by `getNameFromURL()` or `list()`, or the original URL of the remote file
+   * @returns Blob, or null if file does not exist
+   */
+  open(nameOrURL) {
+    return __async(this, null, function* () {
+      const hint1 = hintFromMetadata(yield this.getMetadata(nameOrURL));
+      const direct = yield this.sb.read(nameOrURL, hint1);
+      if (direct) return direct;
+      const key = yield urlToFileName(nameOrURL, "");
+      const hint2 = hintFromMetadata(yield this.getMetadata(key));
+      return this.sb.read(key, hint2);
+    });
+  }
+  /**
+   * Get the size of a file in stored cache
+   *
+   * NOTE: in case the download is stopped mid-way (i.e. user close browser tab), the file maybe corrupted, size maybe different from `metadata.originalSize`
+   *
+   * @param name The file name returned by `getNameFromURL()` or `list()`
+   * @returns number of bytes, or -1 if file does not exist
+   */
+  getSize(name) {
+    return __async(this, null, function* () {
+      const hint = hintFromMetadata(yield this.getMetadata(name));
+      return this.sb.getSize(name, hint);
+    });
+  }
+  /**
+   * Get metadata of a cached file
+   */
+  getMetadata(name) {
+    return __async(this, null, function* () {
+      const blob = yield this.sb.read(`${PREFIX_METADATA}${name}`);
+      const cachedSize = yield this.sb.getSize(name);
+      if (!blob) {
+        return cachedSize > 0 ? (
+          // files created by older version of wllama don't have metadata; polyfill it
+          {
+            etag: POLYFILL_ETAG,
+            originalSize: cachedSize,
+            originalURL: ""
+          }
+        ) : (
+          // cached file not found
+          null
+        );
+      }
+      try {
+        return yield new Response(blob).json();
+      } catch (e) {
+        return null;
+      }
+    });
+  }
+  /**
+   * List all files currently in cache
+   */
+  list() {
+    return __async(this, null, function* () {
+      const all = yield this.sb.list();
+      const metadataMap = {};
+      for (const { key } of all) {
+        if (key.startsWith(PREFIX_METADATA)) {
+          const blob = yield this.sb.read(key);
+          if (blob) {
+            const meta = yield new Response(blob).json().catch(() => null);
+            metadataMap[key.slice(PREFIX_METADATA.length)] = meta;
+          }
+        }
+      }
+      const result = [];
+      for (const { key, size } of all) {
+        if (!key.startsWith(PREFIX_METADATA)) {
+          result.push({
+            name: key,
+            size,
+            metadata: metadataMap[key] || {
+              originalSize: size,
+              originalURL: "",
+              etag: ""
+            }
+          });
+        }
+      }
+      return result;
+    });
+  }
+  /**
+   * Clear all files currently in cache
+   */
+  clear() {
+    return __async(this, null, function* () {
+      yield this.deleteMany(() => true);
+    });
+  }
+  /**
+   * Delete a single file in cache
+   *
+   * @param nameOrURL Can be either an URL or a name returned by `getNameFromURL()` or `list()`
+   */
+  delete(nameOrURL) {
+    return __async(this, null, function* () {
+      const name2 = yield this.getNameFromURL(nameOrURL);
+      yield this.deleteMany(
+        (entry) => entry.name === nameOrURL || entry.name === name2
+      );
+    });
+  }
+  /**
+   * Delete multiple files in cache.
+   *
+   * @param predicate A predicate like `array.filter(item => boolean)`
+   */
+  deleteMany(predicate) {
+    return __async(this, null, function* () {
+      const list = yield this.list();
+      for (const item of list) {
+        if (predicate(item)) {
+          yield this.sb.delete(item.name);
+          yield this.sb.delete(`${PREFIX_METADATA}${item.name}`);
+        }
+      }
+    });
+  }
+  /**
+   * Write the metadata of the file to disk.
+   */
+  writeMetadata(name, metadata) {
+    return __async(this, null, function* () {
+      const blob = new Blob([JSON.stringify(metadata)], { type: "text/plain" });
+      yield this.sb.write(`${PREFIX_METADATA}${name}`, blob.stream());
+    });
+  }
+};
+var cache_manager_default = CacheManager;
+function urlToFileName(url, prefix) {
+  return __async(this, null, function* () {
+    const hashBuffer = yield crypto.subtle.digest(
+      "SHA-1",
+      new TextEncoder().encode(url)
+    );
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+    return `${prefix}${hashHex}_${url.split("/").pop()}`;
+  });
+}
+
+// src/model-manager.ts
+var DEFAULT_PARALLEL_DOWNLOADS = 3;
+var ModelValidationStatus = /* @__PURE__ */ ((ModelValidationStatus2) => {
+  ModelValidationStatus2["VALID"] = "valid";
+  ModelValidationStatus2["INVALID"] = "invalid";
+  ModelValidationStatus2["DELETED"] = "deleted";
+  return ModelValidationStatus2;
+})(ModelValidationStatus || {});
+var Model = class {
+  constructor(modelManager, url, mmprojUrl, savedFiles) {
+    __publicField(this, "modelManager");
+    /**
+     * URL to the GGUF file (in case it contains multiple shards, the URL should point to the first shard)
+     *
+     * This URL will be used to identify the model in the cache. There can't be 2 models with the same URL.
+     */
+    __publicField(this, "url");
+    /**
+     * URL to mmproj file, if exists
+     */
+    __publicField(this, "mmprojUrl");
+    /**
+     * Size in bytes (total size of all shards).
+     *
+     * A value of -1 means the model is deleted from the cache. You must call `ModelManager.downloadModel` to re-download the model.
+     */
+    __publicField(this, "size");
+    /**
+     * List of all shards in the cache, sorted by original URL (ascending order)
+     */
+    __publicField(this, "files");
+    this.modelManager = modelManager;
+    this.url = url;
+    this.mmprojUrl = mmprojUrl;
+    if (savedFiles) {
+      this.files = this.getAllFiles(savedFiles);
+      this.size = sumArr(this.files.map((f) => f.metadata.originalSize));
+    } else {
+      this.files = [];
+      this.size = 0;
+    }
+  }
+  /**
+   * Open and get a list of all shards as Blobs
+   */
+  open() {
+    return __async(this, null, function* () {
+      if (this.size === -1) {
+        throw new WllamaError(
+          `Model is deleted from the cache; Call ModelManager.downloadModel to re-download the model`,
+          "load_error"
+        );
+      }
+      const blobs = [];
+      for (const file of this.files) {
+        const blob = yield this.modelManager.cacheManager.open(file.name);
+        if (!blob) {
+          throw new Error(
+            `Failed to open file ${file.name}; Hint: the model may be invalid, please refresh it`
+          );
+        }
+        blobs.push(blob);
+      }
+      return blobs;
+    });
+  }
+  /**
+   * Validate the model files.
+   *
+   * If the model is invalid, the model manager will not be able to use it. You must call `refresh` to re-download the model.
+   *
+   * Cases that model is invalid:
+   * - The model is deleted from the cache
+   * - The model files are missing (or the download is interrupted)
+   */
+  validate() {
+    let nbShards = ModelManager.parseModelUrl(this.url).length;
+    if (this.mmprojUrl) {
+      nbShards += 1;
+    }
+    if (this.size === -1) {
+      return "deleted" /* DELETED */;
+    }
+    if (this.size < 16 || this.files.length !== nbShards) {
+      return "invalid" /* INVALID */;
+    }
+    for (const file of this.files) {
+      if (!file.metadata || file.metadata.originalSize !== file.size) {
+        return "invalid" /* INVALID */;
+      }
+    }
+    return "valid" /* VALID */;
+  }
+  /**
+   * In case the model is invalid, call this function to re-download the model
+   */
+  refresh() {
+    return __async(this, arguments, function* (options = {}) {
+      var _a;
+      const urls = ModelManager.parseModelUrl(this.url);
+      if (this.mmprojUrl) {
+        urls.push(this.mmprojUrl);
+      }
+      const works = urls.map((url, index) => ({
+        url,
+        index
+      }));
+      this.modelManager.logger.debug("Downloading model files:", urls);
+      const nParallel = (_a = this.modelManager.params.parallelDownloads) != null ? _a : DEFAULT_PARALLEL_DOWNLOADS;
+      const totalSize = yield this.getTotalDownloadSize(urls);
+      const loadedSize = [];
+      const worker = () => __async(this, null, function* () {
+        while (works.length > 0) {
+          const w = works.shift();
+          if (!w) break;
+          yield this.modelManager.cacheManager.download(w.url, __spreadProps(__spreadValues({}, options), {
+            metadataAdditional: {
+              originalURL: w.url,
+              mmprojURL: this.mmprojUrl
+            },
+            progressCallback: ({ loaded }) => {
+              var _a2;
+              loadedSize[w.index] = loaded;
+              (_a2 = options.progressCallback) == null ? void 0 : _a2.call(options, {
+                loaded: sumArr(loadedSize),
+                total: totalSize
+              });
+            }
+          }));
+        }
+      });
+      const promises = [];
+      for (let i = 0; i < nParallel; i++) {
+        promises.push(worker());
+        loadedSize.push(0);
+      }
+      yield Promise.all(promises);
+      this.files = this.getAllFiles(yield this.modelManager.cacheManager.list());
+      this.size = this.files.reduce((acc, f) => acc + f.metadata.originalSize, 0);
+    });
+  }
+  /**
+   * Remove the model from the cache
+   */
+  remove() {
+    return __async(this, null, function* () {
+      this.files = this.getAllFiles(yield this.modelManager.cacheManager.list());
+      yield this.modelManager.cacheManager.deleteMany(
+        (f) => !!this.files.find((file) => file.name === f.name)
+      );
+      this.size = -1;
+    });
+  }
+  getAllFiles(savedFiles) {
+    const allUrls = new Set(ModelManager.parseModelUrl(this.url));
+    if (this.mmprojUrl) {
+      allUrls.add(this.mmprojUrl);
+    }
+    const allFiles = [];
+    for (const url of allUrls) {
+      const file = savedFiles.find((f) => f.metadata.originalURL === url);
+      if (!file) {
+        throw new Error(`Model file not found: ${url}`);
+      }
+      allFiles.push(file);
+    }
+    allFiles.sort(
+      (a, b) => a.metadata.originalURL.localeCompare(b.metadata.originalURL)
+    );
+    return allFiles;
+  }
+  getTotalDownloadSize(urls) {
+    return __async(this, null, function* () {
+      const responses = yield Promise.all(
+        urls.map((url) => fetch(url, { method: "HEAD" }))
+      );
+      const sizes = responses.map(
+        (res) => Number(res.headers.get("content-length") || "0")
+      );
+      return sumArr(sizes);
+    });
+  }
+};
+var ModelManager = class _ModelManager {
+  constructor(params = {}) {
+    // The CacheManager singleton, can be accessed by user
+    __publicField(this, "cacheManager");
+    __publicField(this, "params");
+    __publicField(this, "logger");
+    this.cacheManager = params.cacheManager || new cache_manager_default();
+    this.params = params;
+    this.logger = params.logger || console;
+  }
+  /**
+   * Parses a model URL and returns an array of URLs based on the following patterns:
+   * - If the input URL is an array, it returns the array itself.
+   * - If the input URL is a string in the `gguf-split` format, it returns an array containing the URL of each shard in ascending order.
+   * - Otherwise, it returns an array containing the input URL as a single element array.
+   * @param modelUrl URL or list of URLs
+   */
+  static parseModelUrl(modelUrl) {
+    var _a;
+    if (Array.isArray(modelUrl)) {
+      return modelUrl;
+    }
+    const urlPartsRegex = /-(\d{5})-of-(\d{5})\.gguf(?:\?.*)?$/;
+    const queryMatch = modelUrl.match(/\.gguf(\?.*)?$/);
+    const queryParams = (_a = queryMatch == null ? void 0 : queryMatch[1]) != null ? _a : "";
+    const matches = modelUrl.match(urlPartsRegex);
+    if (!matches) {
+      return [modelUrl];
+    }
+    const baseURL = modelUrl.replace(urlPartsRegex, "");
+    const total = matches[2];
+    const paddedShardIds = Array.from(
+      { length: Number(total) },
+      (_, index) => (index + 1).toString().padStart(5, "0")
+    );
+    return paddedShardIds.map(
+      (current) => `${baseURL}-${current}-of-${total}.gguf${queryParams}`
+    );
+  }
+  /**
+   * Get all models in the cache
+   */
+  getModels() {
+    return __async(this, arguments, function* (opts = {}) {
+      const cachedFiles = yield this.cacheManager.list();
+      let models = [];
+      for (const file of cachedFiles) {
+        const shards = _ModelManager.parseModelUrl(file.metadata.originalURL);
+        const mmprojUrl = file.metadata.mmprojURL;
+        const isFirstShard = shards.length === 1 || shards[0] === file.metadata.originalURL;
+        if (isFirstShard) {
+          models.push(
+            new Model(this, file.metadata.originalURL, mmprojUrl, cachedFiles)
+          );
+        }
+      }
+      if (!opts.includeInvalid) {
+        models = models.filter(
+          (m) => m.validate() === "valid" /* VALID */
+        );
+      }
+      return models;
+    });
+  }
+  /**
+   * Download a model from the given URL.
+   *
+   * The URL must end with `.gguf`
+   */
+  downloadModel(_0) {
+    return __async(this, arguments, function* (sourceOrURL, options = {}) {
+      const source = isString(sourceOrURL) ? { url: sourceOrURL } : sourceOrURL;
+      if (!isValidGgufFile(source.url)) {
+        throw new WllamaError(
+          `Invalid model URL: ${source.url}; URL must ends with ".gguf"`,
+          "download_error"
+        );
+      }
+      const model = new Model(this, source.url, source.mmprojUrl);
+      const validity = model.validate();
+      if (validity !== "valid" /* VALID */) {
+        yield model.refresh(options);
+      }
+      return model;
+    });
+  }
+  /**
+   * Get a model from the cache or download it if it's not available.
+   */
+  getModelOrDownload(_0) {
+    return __async(this, arguments, function* (source, options = {}) {
+      var _a;
+      const models = yield this.getModels();
+      const model = models.find((m) => m.url === source.url);
+      if (model) {
+        (_a = options.progressCallback) == null ? void 0 : _a.call(options, { loaded: model.size, total: model.size });
+        return model;
+      }
+      return this.downloadModel(source, options);
+    });
+  }
+  /**
+   * Remove all models from the cache
+   */
+  clear() {
+    return __async(this, null, function* () {
+      yield this.cacheManager.clear();
+    });
+  }
+};
+
+// src/types/types.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 1] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 2] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 3] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 4] = "ERROR";
+  return LogLevel2;
+})(LogLevel || {});
+
+// src/wasm-from-cdn.ts
+var WasmCompatFromCDN = {
+  worker: "https://cdn.jsdelivr.net/npm/@wllama/wllama-compat@3.5.1-q2.0/wasm/wllama.js",
+  wasm: "https://cdn.jsdelivr.net/npm/@wllama/wllama-compat@3.5.1-q2.0/wasm/wllama.wasm"
+};
+
+// src/wllama.ts
+var LoggerWithoutDebug = __spreadProps(__spreadValues({}, console), {
+  debug: () => {
+  }
+});
+var WllamaError = class extends Error {
+  constructor(message, type = "unknown_error") {
+    super(message);
+    __publicField(this, "type");
+    this.type = type;
+  }
+};
+var WllamaAbortError = class extends Error {
+  constructor() {
+    super("Operation aborted");
+    __publicField(this, "name", "AbortError");
+  }
+};
+var WllamaRuntimeError = class extends Error {
+  constructor(message, stack) {
+    super(message);
+    __publicField(this, "name", "RuntimeError");
+    __publicField(this, "stack");
+    this.stack = stack;
+  }
+};
+var Wllama = class {
+  constructor(pathConfig, wllamaConfig = {}) {
+    // The CacheManager and ModelManager are singleton, can be accessed by user
+    __publicField(this, "cacheManager");
+    __publicField(this, "modelManager");
+    __publicField(this, "compat", null);
+    __publicField(this, "proxy", null);
+    __publicField(this, "config");
+    __publicField(this, "pathConfig");
+    __publicField(this, "useMultiThread", false);
+    __publicField(this, "nbThreads", 1);
+    __publicField(this, "useEmbeddings", false);
+    __publicField(this, "useRerank", false);
+    // available when loaded
+    __publicField(this, "loadedContextInfo", null);
+    __publicField(this, "seed");
+    __publicField(this, "bosToken", -1);
+    __publicField(this, "eosToken", -1);
+    __publicField(this, "eotToken", -1);
+    __publicField(this, "eogTokens", /* @__PURE__ */ new Set());
+    __publicField(this, "addBosToken", false);
+    __publicField(this, "addEosToken", false);
+    __publicField(this, "mediaMarker");
+    __publicField(this, "chatTemplate");
+    __publicField(this, "metadata");
+    __publicField(this, "hasEncoder", false);
+    __publicField(this, "decoderStartToken", -1);
+    // note: we overlay instead of using llama-server default_template_kwargs, because we cannot transfer complex data structure via GLUE
+    // overlay allow mixed data type or nested structure for kwargs
+    __publicField(this, "chatTemplateKwargs", {});
+    var _a, _b, _c;
+    checkEnvironmentCompatible();
+    if (!pathConfig) throw new WllamaError("AssetsPathConfig is required");
+    this.pathConfig = pathConfig;
+    this.config = wllamaConfig;
+    this.cacheManager = (_a = wllamaConfig.cacheManager) != null ? _a : new cache_manager_default();
+    this.modelManager = (_c = wllamaConfig.modelManager) != null ? _c : new ModelManager({
+      cacheManager: this.cacheManager,
+      logger: (_b = wllamaConfig.logger) != null ? _b : console,
+      parallelDownloads: wllamaConfig.parallelDownloads,
+      allowOffline: wllamaConfig.allowOffline
+    });
+    this.setCompat("default");
+  }
+  logger() {
+    var _a;
+    return (_a = this.config.logger) != null ? _a : console;
+  }
+  checkModelLoaded() {
+    if (!this.isModelLoaded()) {
+      throw new WllamaError(
+        "loadModel() is not yet called",
+        "model_not_loaded"
+      );
+    }
+  }
+  /**
+   * Get the libllama version string, e.g. "b6327-4d74393".
+   *
+   * @returns version string embedded at build time.
+   */
+  static getLibllamaVersion() {
+    return LIBLLAMA_VERSION;
+  }
+  /**
+   * Set compatibility options for Wllama.
+   * @param compat Set to null to disable compatibility, or 'default' to use the default compat resources from CDN.
+   * @param mode 'safari' by default; If set to 'firefox_safari', the compat mode will **also** be enabled on Firefox, which will significantly degrade the performance but allow using WebGPU on Firefox.
+   */
+  setCompat(compat, mode = "safari") {
+    if (mode === "safari") {
+      if (isFirefox()) {
+        this.compat = null;
+        return;
+      }
+    }
+    this.compat = compat === "default" ? WasmCompatFromCDN : compat;
+  }
+  /**
+   * Check if the model is loaded via `loadModel()`
+   */
+  isModelLoaded() {
+    return !!this.proxy && !!this.metadata;
+  }
+  /**
+   * Get token ID associated to BOS (begin of sentence) token.
+   *
+   * NOTE: This can only being used after `loadModel` is called.
+   *
+   * @returns -1 if the model is not loaded.
+   */
+  getBOS() {
+    return this.bosToken;
+  }
+  /**
+   * Get token ID associated to EOS (end of sentence) token.
+   *
+   * NOTE: This can only being used after `loadModel` is called.
+   *
+   * @returns -1 if the model is not loaded.
+   */
+  getEOS() {
+    return this.eosToken;
+  }
+  /**
+   * Get token ID associated to EOT (end of turn) token.
+   *
+   * NOTE: This can only being used after `loadModel` is called.
+   *
+   * @returns -1 if the model is not loaded.
+   */
+  getEOT() {
+    return this.eotToken;
+  }
+  /**
+   * Check if a given token is end-of-generation token (e.g. EOS, EOT, etc.)
+   *
+   * @param token the token ID to be checked
+   * @returns true if the token is EOS, EOT, or any other end-of-generation tokens
+   */
+  isTokenEOG(token) {
+    return token === this.eosToken || token === this.eotToken || this.eogTokens.has(token);
+  }
+  /**
+   * Get token ID associated to token used by decoder, to start generating output sequence(only usable for encoder-decoder architecture). In other words, encoder uses normal BOS and decoder uses this token.
+   *
+   * NOTE: This can only being used after `loadModel` is called.
+   *
+   * @returns -1 if the model is not loaded.
+   */
+  getDecoderStartToken() {
+    return this.decoderStartToken;
+  }
+  /**
+   * Get model hyper-parameters and metadata
+   *
+   * NOTE: This can only being used after `loadModel` is called.
+   *
+   * @returns ModelMetadata
+   */
+  getModelMetadata() {
+    this.checkModelLoaded();
+    return this.metadata;
+  }
+  /**
+   * Check if we're currently using multi-thread build.
+   *
+   * NOTE: This can only being used after `loadModel` is called.
+   *
+   * @returns true if multi-thread is used.
+   */
+  isMultithread() {
+    this.checkModelLoaded();
+    return this.useMultiThread;
+  }
+  /**
+   * Get number of threads used in the current context.
+   *
+   * NOTE: This can only being used after `loadModel` is called.
+   *
+   * @returns number of threads
+   */
+  getNumThreads() {
+    this.checkModelLoaded();
+    return this.useMultiThread ? this.nbThreads : 1;
+  }
+  /**
+   * Check if the current model uses encoder-decoder architecture
+   *
+   * NOTE: This can only being used after `loadModel` is called.
+   *
+   * @returns true if multi-thread is used.
+   */
+  isEncoderDecoderArchitecture() {
+    this.checkModelLoaded();
+    return this.hasEncoder;
+  }
+  /**
+   * Must we add BOS token to the tokenized sequence?
+   *
+   * NOTE: This can only being used after `loadModel` is called.
+   *
+   * @returns true if BOS token must be added to the sequence
+   */
+  mustAddBosToken() {
+    this.checkModelLoaded();
+    return this.addBosToken;
+  }
+  /**
+   * Must we add EOS token to the tokenized sequence?
+   *
+   * NOTE: This can only being used after `loadModel` is called.
+   *
+   * @returns true if EOS token must be added to the sequence
+   */
+  mustAddEosToken() {
+    this.checkModelLoaded();
+    return this.addEosToken;
+  }
+  /**
+   * Get the jinja chat template comes with the model. It only available if the original model (before converting to gguf) has the template in `tokenizer_config.json`
+   *
+   * NOTE: This can only being used after `loadModel` is called.
+   *
+   * @returns the jinja template. null if there is no template in gguf
+   */
+  getChatTemplate() {
+    var _a;
+    this.checkModelLoaded();
+    return (_a = this.chatTemplate) != null ? _a : null;
+  }
+  /**
+   * Check if WebGPU is supported by the current environment.
+   * @returns true if WebGPU is supported
+   */
+  isSupportWebGPU() {
+    return isSupportWebGPU();
+  }
+  /**
+   * Load model from a given URL (or a list of URLs, in case the model is splitted into smaller files)
+   * - If the model already been downloaded (via `downloadModel()`), then we will use the cached model
+   * - Else, we download the model from internet
+   * @param modelSourceOrURL
+   * @param params
+   */
+  loadModelFromUrl(_0) {
+    return __async(this, arguments, function* (modelSourceOrURL, params = {}) {
+      var _a;
+      const source = isString(modelSourceOrURL) ? { url: modelSourceOrURL } : modelSourceOrURL;
+      const useCache = (_a = params.useCache) != null ? _a : true;
+      const model = useCache ? yield this.modelManager.getModelOrDownload(source, params) : yield this.modelManager.downloadModel(source, params);
+      const blobs = yield model.open();
+      return yield this.loadModel(blobs, params);
+    });
+  }
+  /**
+   * Load model from a given Hugging Face model ID and file path.
+   *
+   * @param hfOptions
+   * @param params
+   */
+  loadModelFromHF(_0) {
+    return __async(this, arguments, function* (hfOptions, params = {}) {
+      const source = yield getHFModelSource(hfOptions);
+      return yield this.loadModelFromUrl(source, params);
+    });
+  }
+  /**
+   * Load model from a given list of Blob.
+   *
+   * You can pass multiple buffers into the function (in case the model contains multiple shards).
+   *
+   * @param ggufBlobsOrModel Can be either list of Blobs (in case you use local file), or a Model object (in case you use ModelManager)
+   * @param params LoadModelParams
+   */
+  loadModel(_0) {
+    return __async(this, arguments, function* (ggufBlobsOrModel, params = {}) {
+      var _a, _b, _c, _d, _e, _f, _g, _h;
+      const blobs = ggufBlobsOrModel instanceof Model ? yield ggufBlobsOrModel.open() : [...ggufBlobsOrModel];
+      if (blobs.some((b) => b.size === 0)) {
+        throw new WllamaError(
+          "Input model (or splits) must be non-empty Blob or File",
+          "load_error"
+        );
+      }
+      if (!this.pathConfig["default"]) {
+        throw new WllamaError(
+          '"default" is missing from pathConfig',
+          "load_error"
+        );
+      }
+      if (this.proxy) {
+        throw new WllamaError("Module is already initialized", "load_error");
+      }
+      const supportMultiThread = yield isSupportMultiThread();
+      const hwConccurency = Math.floor((navigator.hardwareConcurrency || 1) / 2);
+      const nbThreads = (_a = params.n_threads) != null ? _a : hwConccurency;
+      this.nbThreads = nbThreads;
+      this.useMultiThread = supportMultiThread && nbThreads > 1;
+      const workerResources = this.getWorkerResources();
+      this.proxy = new ProxyToWorker(
+        workerResources,
+        this.useMultiThread ? nbThreads : 0,
+        // 0 means disable pthread
+        (_b = this.config.suppressNativeLog) != null ? _b : false,
+        this.logger()
+      );
+      let logLevel = (_c = params.log_level) != null ? _c : 2 /* INFO */;
+      if (this.config.suppressNativeLog) {
+        logLevel = 9999;
+      }
+      const modelFiles = yield prepareBlobs(blobs);
+      yield this.proxy.moduleInit(modelFiles.all);
+      this.logger().debug("Calling wllamaStart...");
+      const startResult = yield this.proxy.wllamaStart();
+      if (!startResult.success) {
+        throw new WllamaError(
+          `Error while calling start function, result = ${startResult}`
+        );
+      }
+      this.logger().debug("Loading model...");
+      const loadResult = yield this.proxy.wllamaAction("load", {
+        _name: "load_req",
+        log_level: logLevel,
+        // if async read is not supported, use mmap; refer to README-dev.md for more details
+        use_mmap: !canUseAsyncFileRead(workerResources.compat),
+        use_mlock: false,
+        n_gpu_layers: (_d = params.n_gpu_layers) != null ? _d : 99999,
+        n_ctx: (_e = params.n_ctx) != null ? _e : 1024,
+        n_threads: this.useMultiThread ? nbThreads : 1,
+        n_ctx_auto: false,
+        // not supported for now
+        mmproj_path: modelFiles.mmproj ? `/models/${MMPROJ_FILE_NAME}` : void 0,
+        model_paths: modelFiles.llm.map((f) => `models/${f.name}`),
+        embeddings: params.embeddings,
+        offload_kqv: params.offload_kqv,
+        n_batch: params.n_batch,
+        pooling_type: params.pooling_type,
+        rope_scaling_type: params.rope_scaling_type,
+        rope_freq_base: params.rope_freq_base,
+        rope_freq_scale: params.rope_freq_scale,
+        yarn_ext_factor: params.yarn_ext_factor,
+        yarn_attn_factor: params.yarn_attn_factor,
+        yarn_beta_fast: params.yarn_beta_fast,
+        yarn_beta_slow: params.yarn_beta_slow,
+        yarn_orig_ctx: params.yarn_orig_ctx,
+        cache_type_k: params.cache_type_k,
+        cache_type_v: params.cache_type_v,
+        n_parallel: 1,
+        // only support single sequence for now
+        kv_unified: false,
+        // TODO: support kv unified cache
+        flash_attn: params.flash_attn,
+        swa_full: params.swa_full,
+        chat_template: params.chat_template,
+        jinja: params.jinja,
+        reasoning: params.reasoning,
+        image_min_tokens: params.image_min_tokens,
+        image_max_tokens: params.image_max_tokens,
+        warmup: params.warmup,
+        no_kv_offload: params.no_kv_offload,
+        mmproj_offload: params.mmproj_offload,
+        cont_batching: params.cont_batching,
+        n_keep: params.n_keep,
+        ctx_shift: params.ctx_shift,
+        cache_idle_slots: params.cache_idle_slots,
+        n_cache_reuse: params.n_cache_reuse,
+        lora_paths: (_f = params.lora_adapters) == null ? void 0 : _f.map((a) => a.path),
+        lora_scales: (_g = params.lora_adapters) == null ? void 0 : _g.map((a) => {
+          var _a2;
+          return (_a2 = a.scale) != null ? _a2 : 1;
+        }),
+        lora_init_without_apply: params.lora_init_without_apply,
+        spec_draft_model: params.spec_draft_model,
+        spec_draft_ngl: params.spec_draft_ngl,
+        spec_draft_n_max: params.spec_draft_n_max,
+        spec_draft_n_min: params.spec_draft_n_min,
+        spec_draft_p_min: params.spec_draft_p_min,
+        spec_draft_threads: params.spec_draft_threads,
+        spec_draft_threads_batch: params.spec_draft_threads_batch,
+        kv_overrides_keys: params.kv_overrides ? Object.keys(params.kv_overrides) : void 0,
+        kv_overrides_vals: params.kv_overrides ? Object.values(params.kv_overrides) : void 0,
+        reasoning_budget_tokens: params.reasoning_budget_tokens,
+        reasoning_budget_message: params.reasoning_budget_message,
+        reasoning_format: params.reasoning_format,
+        skip_chat_parsing: params.skip_chat_parsing,
+        prefill_assistant: params.prefill_assistant
+      });
+      const loadedCtxInfo = __spreadProps(__spreadValues({}, loadResult), {
+        metadata: {}
+      });
+      for (let i = 0; i < loadResult.metadata_key.length; i++) {
+        loadedCtxInfo.metadata[loadResult.metadata_key[i]] = loadResult.metadata_val[i];
+      }
+      this.seed = params.seed;
+      this.bosToken = loadedCtxInfo.token_bos;
+      this.eosToken = loadedCtxInfo.token_eos;
+      this.eotToken = loadedCtxInfo.token_eot;
+      this.useEmbeddings = !!params.embeddings;
+      this.useRerank = params.pooling_type == "rank";
+      this.metadata = {
+        hparams: {
+          nVocab: loadedCtxInfo.n_vocab,
+          nCtxTrain: loadedCtxInfo.n_ctx_train,
+          nEmbd: loadedCtxInfo.n_embd,
+          nLayer: loadedCtxInfo.n_layer
+        },
+        meta: loadedCtxInfo.metadata
+      };
+      this.hasEncoder = !!loadedCtxInfo.has_encoder;
+      this.decoderStartToken = loadedCtxInfo.token_decoder_start;
+      this.addBosToken = loadedCtxInfo.add_bos_token;
+      this.addEosToken = loadedCtxInfo.add_eos_token;
+      this.chatTemplate = loadedCtxInfo.metadata["tokenizer.chat_template"];
+      this.loadedContextInfo = loadedCtxInfo;
+      this.eogTokens = new Set(loadedCtxInfo.list_tokens_eog);
+      this.mediaMarker = loadedCtxInfo.media_marker;
+      this.chatTemplateKwargs = (_h = params.default_template_kwargs) != null ? _h : {};
+      this.logger().debug({ loadedCtxInfo });
+    });
+  }
+  getLoadedContextInfo() {
+    this.checkModelLoaded();
+    if (!this.loadedContextInfo) {
+      throw new WllamaError("Loaded context info is not available");
+    }
+    return __spreadValues({}, this.loadedContextInfo);
+  }
+  //////////////////////////////////////////////
+  // High level API
+  /**
+   * Calculate embedding vector for a given text.
+   * By default, BOS and EOS tokens will be added automatically. You can use the "skipBOS" and "skipEOS" option to disable it.
+   * @param options OAI-compatible embedding creation options
+   * @returns OAI-compatible embedding response
+   */
+  createEmbedding(options) {
+    return __async(this, null, function* () {
+      this.checkModelLoaded();
+      if (!this.useEmbeddings) {
+        throw new WllamaError(
+          "Embeddings is not enabled. Please set it via LoadModelParams.embeddings"
+        );
+      }
+      const result = yield this.proxy.wllamaAction(
+        "embedding",
+        {
+          _name: "embd_req",
+          data_json: JSON.stringify(options),
+          files: []
+          // TODO: support file input
+        }
+      );
+      if (!result.success) {
+        throw new WllamaError(
+          "Model failed to start inference",
+          "inference_error"
+        );
+      }
+      return yield this.getResponse(options, false);
+    });
+  }
+  /**
+   * Rerank a list of documents against a query.
+   * Requires the model to be loaded with embeddings: true and pooling_type: 'rank'.
+   * @param options Reranking options (query, documents, top_n)
+   * @returns Reranking response with relevance scores sorted highest first
+   */
+  createRerank(options) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      this.checkModelLoaded();
+      if (!this.useEmbeddings || !this.useRerank) {
+        throw new WllamaError(
+          "Rerank is not enabled. Please set it via LoadModelParams: embeddings = true and pooling_type = rank"
+        );
+      }
+      const top_n = (_a = options.top_n) != null ? _a : options.documents.length;
+      let totalTokens = 0;
+      const rawResults = [];
+      for (let i = 0; i < options.documents.length; i++) {
+        const result = yield this.proxy.wllamaAction("rerank", {
+          _name: "rrnk_req",
+          data_json: JSON.stringify({
+            query: options.query,
+            document: options.documents[i]
+          })
+        });
+        if (!result.success) {
+          throw new WllamaError(
+            "Model failed to start reranking",
+            "inference_error"
+          );
+        }
+        const { score, tokens_evaluated } = yield this.getRerankResult();
+        totalTokens += tokens_evaluated;
+        rawResults.push({ index: i, score });
+      }
+      rawResults.sort((a, b) => b.score - a.score);
+      return {
+        model: (_b = this.getModelMetadata().meta["general.name"]) != null ? _b : "",
+        object: "list",
+        usage: { prompt_tokens: totalTokens, total_tokens: totalTokens },
+        results: rawResults.slice(0, top_n).map(({ index, score }) => ({
+          index,
+          relevance_score: score
+        }))
+      };
+    });
+  }
+  createChatCompletion(options) {
+    return __async(this, null, function* () {
+      var _a;
+      if (Object.keys(this.chatTemplateKwargs).length > 0) {
+        options = __spreadProps(__spreadValues({}, options), {
+          chat_template_kwargs: __spreadValues(__spreadValues({}, this.chatTemplateKwargs), (_a = options.chat_template_kwargs) != null ? _a : {})
+        });
+      }
+      if (options.stream && options.onData) {
+        yield this.createCompletionImpl(options);
+      } else if (options.stream) {
+        return yield this.createCompletionGenerator(options);
+      } else {
+        return yield this.createCompletionImpl(__spreadProps(__spreadValues({}, options), { stream: false }));
+      }
+    });
+  }
+  createCompletion(options) {
+    return __async(this, null, function* () {
+      if (options.stream && options.onData) {
+        yield this.createCompletionImpl(options);
+      } else if (options.stream) {
+        return yield this.createCompletionGenerator(options);
+      } else {
+        return yield this.createCompletionImpl(__spreadProps(__spreadValues({}, options), { stream: false }));
+      }
+    });
+  }
+  /**
+   * Private implementation of createCompletion
+   */
+  createCompletionImpl(options) {
+    return __async(this, null, function* () {
+      this.checkModelLoaded();
+      const isStream = !!options.stream;
+      const isChat = !!options.messages;
+      const customOpt = {};
+      if (this.seed !== void 0) {
+        customOpt.seed = this.seed;
+      }
+      let files = [];
+      if (isChat) {
+        const tmp = this.prepareMultimodalInput(
+          options
+        );
+        options = tmp.params;
+        files = tmp.files;
+      }
+      const result = yield this.proxy.wllamaAction(
+        "completion",
+        {
+          _name: "cmpl_req",
+          is_chat: isChat,
+          data_json: JSON.stringify(__spreadValues(__spreadValues({}, options), customOpt)),
+          files: files.map((f) => new Uint8Array(f))
+        }
+      );
+      if (!result.success) {
+        throw new WllamaError(
+          "Model failed to start inference",
+          "inference_error"
+        );
+      }
+      return yield this.getResponse(
+        options,
+        isStream
+      );
+    });
+  }
+  /**
+   * Same with `createCompletion`, but returns an async iterator instead.
+   * Only called when stream=true and no onData is provided.
+   */
+  createCompletionGenerator(options) {
+    return new Promise((resolve) => {
+      const createGenerator = cbToAsyncIter(
+        (callback) => {
+          this.createCompletionImpl(__spreadProps(__spreadValues({}, options), {
+            onData: (chunk) => callback(chunk)
+          })).then(() => callback(void 0, true)).catch((err) => callback(void 0, false, err));
+        }
+      );
+      resolve(createGenerator());
+    });
+  }
+  /**
+   * Whether the currently loaded model supports a specific input modality (e.g. image or audio).
+   * @param modality
+   * @returns
+   */
+  supportInputModality(modality) {
+    this.checkModelLoaded();
+    if (modality === "image") {
+      return !!this.loadedContextInfo.has_image_input;
+    } else if (modality === "audio") {
+      return !!this.loadedContextInfo.has_audio_input;
+    } else {
+      throw new WllamaError(
+        "Unsupported modality: " + modality,
+        "unknown_error"
+      );
+    }
+  }
+  /**
+   * Unload the model and free all memory.
+   *
+   * Note: This function will NOT crash if model is not yet loaded
+   */
+  exit() {
+    return __async(this, null, function* () {
+      var _a;
+      yield (_a = this.proxy) == null ? void 0 : _a.wllamaExit();
+      this.proxy = null;
+    });
+  }
+  /**
+   * [FOR DEBUGGING ONLY] Run ggml backend ops tests without loading any model.
+   *
+   * Initializes the wasm runtime, executes `test-backend-ops` with the given args, then shuts down.
+   *
+   * For more info, please refer to guides/debug.md
+   *
+   * @param args Arguments forwarded to test-backend-ops (e.g. ["-o", "ADD"])
+   * @returns retcode (0 = all tests passed) and success flag
+   */
+  testBackendOps() {
+    return __async(this, arguments, function* (args = []) {
+      var _a;
+      if (!this.pathConfig["default"]) {
+        throw new WllamaError(
+          '"default" is missing from pathConfig',
+          "load_error"
+        );
+      }
+      if (!(yield isSupportMultiThread())) {
+        throw new WllamaError(
+          "Multi-threading is required to run backend ops tests, but it is not supported in the current environment."
+        );
+      }
+      const tmpProxy = new ProxyToWorker(
+        this.getWorkerResources(),
+        0,
+        // single-thread; no model needed
+        (_a = this.config.suppressNativeLog) != null ? _a : false,
+        this.logger()
+      );
+      try {
+        yield tmpProxy.moduleInit([]);
+        const startResult = yield tmpProxy.wllamaStart();
+        if (!startResult.success) {
+          throw new WllamaError(
+            `Error while calling start function, result = ${startResult}`
+          );
+        }
+        const result = yield tmpProxy.wllamaAction(
+          "test_backend_ops",
+          { _name: "tbop_req", args: ["test-backend-ops", ...args] }
+        );
+        return { retcode: result.retcode, success: result.success };
+      } finally {
+        yield tmpProxy.wllamaExit();
+      }
+    });
+  }
+  //////////////////////////////////////////////
+  // Low level API
+  // TODO: add back
+  /**
+   * get debug info
+   */
+  _getDebugInfo() {
+    return __async(this, null, function* () {
+      this.checkModelLoaded();
+      return yield this.proxy.wllamaDebug();
+    });
+  }
+  //////////////////////////////////////////////
+  // Utils
+  jsonDecode(data_json) {
+    try {
+      return JSON.parse(data_json);
+    } catch (e) {
+      this.logger().error("Failed to parse JSON:", data_json);
+      throw new WllamaError("Failed to parse model output", "inference_error");
+    }
+  }
+  prepareMultimodalInput(params) {
+    const msg = params.messages;
+    const msgNew = [];
+    const files = [];
+    for (const m of msg) {
+      if (Array.isArray(m.content)) {
+        const newContent = [];
+        for (const c of m.content) {
+          if (c.type === "text") {
+            newContent.push(c);
+          } else {
+            if (!this.mediaMarker) {
+              throw new WllamaError(
+                "Media marker is undefined",
+                "inference_error"
+              );
+            }
+            files.push(c.data);
+            newContent.push({
+              type: "text",
+              text: this.mediaMarker
+            });
+          }
+        }
+        msgNew.push(__spreadProps(__spreadValues({}, m), {
+          content: newContent
+        }));
+      } else {
+        msgNew.push(m);
+      }
+    }
+    return {
+      params: __spreadProps(__spreadValues({}, params), {
+        messages: msgNew
+      }),
+      files
+    };
+  }
+  getRerankResult() {
+    return __async(this, null, function* () {
+      while (true) {
+        const chunk = yield this.proxy.wllamaAction(
+          "get_result",
+          { _name: "gres_req" }
+        );
+        const jsonString = chunk.data_json;
+        if (jsonString && jsonString.length > 0) {
+          if (chunk.is_error) {
+            const jsonData = this.jsonDecode(jsonString);
+            throw new WllamaError(
+              jsonData.message || "Unknown reranking error",
+              "inference_error"
+            );
+          }
+          return this.jsonDecode(jsonString);
+        }
+        if (!chunk.has_more) break;
+      }
+      throw new WllamaError("No reranking result received", "inference_error");
+    });
+  }
+  getResponse(options, isStream) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      let finalResult = null;
+      while (true) {
+        if ((_a = options.abortSignal) == null ? void 0 : _a.aborted) {
+          throw new WllamaAbortError();
+        }
+        const result_chunk = yield this.proxy.wllamaAction(
+          "get_result",
+          {
+            _name: "gres_req"
+          }
+        );
+        const jsonString = result_chunk.data_json;
+        if (!jsonString || jsonString.length === 0) {
+          if (!result_chunk.has_more) {
+            break;
+          } else {
+            continue;
+          }
+        }
+        if (jsonString == "null") {
+          continue;
+        }
+        let jsonData = this.jsonDecode(jsonString);
+        finalResult = jsonData;
+        if (result_chunk.is_error) {
+          this.logger().error("Model returned an error:", jsonData);
+          throw new WllamaError(
+            jsonData.message || "Unknown inference error",
+            "inference_error"
+          );
+        }
+        if (isStream) {
+          if (!Array.isArray(jsonData)) {
+            jsonData = [jsonData];
+          }
+          for (const chunk of jsonData) {
+            (_b = options.onData) == null ? void 0 : _b.call(options, chunk);
+            finalResult = chunk;
+          }
+        }
+        if (!result_chunk.has_more) {
+          break;
+        }
+      }
+      return finalResult;
+    });
+  }
+  getWorkerResources() {
+    const workerResources = {
+      wasmPath: absoluteUrl(this.pathConfig["default"]),
+      compat: false
+    };
+    if (needCompat()) {
+      if (!this.compat) {
+        this.logger().warn(
+          "Not using compat mode" + (isFirefox() ? " (expected on Firefox - WebGPU will be disabled)" : "")
+        );
+      } else {
+        const isUsingDefault = this.compat.worker === WasmCompatFromCDN.worker && this.compat.wasm === WasmCompatFromCDN.wasm;
+        if (isUsingDefault) {
+          this.logger().warn(
+            "Compatibility mode is activated, using resources from CDN. To use local resources, please refer to @wllama/wllama-compat package."
+          );
+          this.logger().warn(
+            "IMPORTANT: Performance will be significantly degraded in compatibility mode."
+          );
+        }
+        workerResources.wasmPath = absoluteUrl(this.compat.wasm);
+        workerResources.jsPath = this.compat.worker;
+        workerResources.compat = true;
+      }
+    }
+    if (isFirefox()) {
+      if (workerResources.compat) {
+        this.logger().warn(
+          'Using compat mode on Firefox, performance will be significantly degraded; Consider enabling "javascript.options.wasm_js_promise_integration" in "about:config".'
+        );
+      } else if (!isSupportJSPI()) {
+        this.logger().warn(
+          'WebGPU is disabled on Firefox due to missing JSPI support. Please consider enabling compat mode, or enabling "javascript.options.wasm_js_promise_integration" in "about:config".'
+        );
+      }
+    }
+    return workerResources;
+  }
+};
+export {
+  CacheManager,
+  LogLevel,
+  LoggerWithoutDebug,
+  Model,
+  ModelManager,
+  ModelValidationStatus,
+  POLYFILL_ETAG,
+  Wllama,
+  WllamaAbortError,
+  WllamaError,
+  WllamaRuntimeError,
+  getHFFileSHA256,
+  getHFModelSource,
+  isValidGgufFile
+};