@extend-ai/react-xlsx 0.18.1 → 0.19.0

package/dist/xlsx-worker.js

@@ -1,5 +1,2860 @@
-// src/xlsx-worker.ts
-import { strFromU8 as strFromU83, unzipSync as unzipSync2 } from "fflate";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../../node_modules/.pnpm/@dukelib+sheets-wasm@0.1.23/node_modules/@dukelib/sheets-wasm/duke_sheets_wasm.js
+var duke_sheets_wasm_exports = {};
+__export(duke_sheets_wasm_exports, {
+  CellValue: () => CellValue,
+  Workbook: () => Workbook,
+  Worksheet: () => Worksheet,
+  default: () => __wbg_init,
+  init: () => init,
+  initSync: () => initSync
+});
+function init() {
+  wasm.init();
+}
+function __wbg_get_imports() {
+  const import0 = {
+    __proto__: null,
+    __wbg_Error_8c4e43fe74559d73: function(arg0, arg1) {
+      const ret = Error(getStringFromWasm0(arg0, arg1));
+      return ret;
+    },
+    __wbg_Number_04624de7d0e8332d: function(arg0) {
+      const ret = Number(arg0);
+      return ret;
+    },
+    __wbg_String_8f0eb39a4a4c2f66: function(arg0, arg1) {
+      const ret = String(arg1);
+      const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len1 = WASM_VECTOR_LEN;
+      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    },
+    __wbg___wbindgen_bigint_get_as_i64_8fcf4ce7f1ca72a2: function(arg0, arg1) {
+      const v = arg1;
+      const ret = typeof v === "bigint" ? v : void 0;
+      getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+    },
+    __wbg___wbindgen_boolean_get_bbbb1c18aa2f5e25: function(arg0) {
+      const v = arg0;
+      const ret = typeof v === "boolean" ? v : void 0;
+      return isLikeNone(ret) ? 16777215 : ret ? 1 : 0;
+    },
+    __wbg___wbindgen_debug_string_0bc8482c6e3508ae: function(arg0, arg1) {
+      const ret = debugString(arg1);
+      const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len1 = WASM_VECTOR_LEN;
+      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    },
+    __wbg___wbindgen_in_47fa6863be6f2f25: function(arg0, arg1) {
+      const ret = arg0 in arg1;
+      return ret;
+    },
+    __wbg___wbindgen_is_bigint_31b12575b56f32fc: function(arg0) {
+      const ret = typeof arg0 === "bigint";
+      return ret;
+    },
+    __wbg___wbindgen_is_function_0095a73b8b156f76: function(arg0) {
+      const ret = typeof arg0 === "function";
+      return ret;
+    },
+    __wbg___wbindgen_is_null_ac34f5003991759a: function(arg0) {
+      const ret = arg0 === null;
+      return ret;
+    },
+    __wbg___wbindgen_is_object_5ae8e5880f2c1fbd: function(arg0) {
+      const val = arg0;
+      const ret = typeof val === "object" && val !== null;
+      return ret;
+    },
+    __wbg___wbindgen_is_string_cd444516edc5b180: function(arg0) {
+      const ret = typeof arg0 === "string";
+      return ret;
+    },
+    __wbg___wbindgen_is_undefined_9e4d92534c42d778: function(arg0) {
+      const ret = arg0 === void 0;
+      return ret;
+    },
+    __wbg___wbindgen_jsval_eq_11888390b0186270: function(arg0, arg1) {
+      const ret = arg0 === arg1;
+      return ret;
+    },
+    __wbg___wbindgen_jsval_loose_eq_9dd77d8cd6671811: function(arg0, arg1) {
+      const ret = arg0 == arg1;
+      return ret;
+    },
+    __wbg___wbindgen_number_get_8ff4255516ccad3e: function(arg0, arg1) {
+      const obj = arg1;
+      const ret = typeof obj === "number" ? obj : void 0;
+      getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+    },
+    __wbg___wbindgen_string_get_72fb696202c56729: function(arg0, arg1) {
+      const obj = arg1;
+      const ret = typeof obj === "string" ? obj : void 0;
+      var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      var len1 = WASM_VECTOR_LEN;
+      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    },
+    __wbg___wbindgen_throw_be289d5034ed271b: function(arg0, arg1) {
+      throw new Error(getStringFromWasm0(arg0, arg1));
+    },
+    __wbg_call_389efe28435a9388: function() {
+      return handleError(function(arg0, arg1) {
+        const ret = arg0.call(arg1);
+        return ret;
+      }, arguments);
+    },
+    __wbg_call_4708e0c13bdc8e95: function() {
+      return handleError(function(arg0, arg1, arg2) {
+        const ret = arg0.call(arg1, arg2);
+        return ret;
+      }, arguments);
+    },
+    __wbg_call_812d25f1510c13c8: function() {
+      return handleError(function(arg0, arg1, arg2, arg3) {
+        const ret = arg0.call(arg1, arg2, arg3);
+        return ret;
+      }, arguments);
+    },
+    __wbg_call_e8c868596c950cf6: function() {
+      return handleError(function(arg0, arg1, arg2, arg3, arg4) {
+        const ret = arg0.call(arg1, arg2, arg3, arg4);
+        return ret;
+      }, arguments);
+    },
+    __wbg_crypto_86f2631e91b51511: function(arg0) {
+      const ret = arg0.crypto;
+      return ret;
+    },
+    __wbg_done_57b39ecd9addfe81: function(arg0) {
+      const ret = arg0.done;
+      return ret;
+    },
+    __wbg_entries_58c7934c745daac7: function(arg0) {
+      const ret = Object.entries(arg0);
+      return ret;
+    },
+    __wbg_getRandomValues_1c61fac11405ffdc: function() {
+      return handleError(function(arg0, arg1) {
+        globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+      }, arguments);
+    },
+    __wbg_getRandomValues_b3f15fcbfabb0f8b: function() {
+      return handleError(function(arg0, arg1) {
+        arg0.getRandomValues(arg1);
+      }, arguments);
+    },
+    __wbg_getTime_1e3cd1391c5c3995: function(arg0) {
+      const ret = arg0.getTime();
+      return ret;
+    },
+    __wbg_getTimezoneOffset_81776d10a4ec18a8: function(arg0) {
+      const ret = arg0.getTimezoneOffset();
+      return ret;
+    },
+    __wbg_get_9b94d73e6221f75c: function(arg0, arg1) {
+      const ret = arg0[arg1 >>> 0];
+      return ret;
+    },
+    __wbg_get_b3ed3ad4be2bc8ac: function() {
+      return handleError(function(arg0, arg1) {
+        const ret = Reflect.get(arg0, arg1);
+        return ret;
+      }, arguments);
+    },
+    __wbg_get_with_ref_key_1dc361bd10053bfe: function(arg0, arg1) {
+      const ret = arg0[arg1];
+      return ret;
+    },
+    __wbg_instanceof_ArrayBuffer_c367199e2fa2aa04: function(arg0) {
+      let result;
+      try {
+        result = arg0 instanceof ArrayBuffer;
+      } catch (_) {
+        result = false;
+      }
+      const ret = result;
+      return ret;
+    },
+    __wbg_instanceof_Map_53af74335dec57f4: function(arg0) {
+      let result;
+      try {
+        result = arg0 instanceof Map;
+      } catch (_) {
+        result = false;
+      }
+      const ret = result;
+      return ret;
+    },
+    __wbg_instanceof_Uint8Array_9b9075935c74707c: function(arg0) {
+      let result;
+      try {
+        result = arg0 instanceof Uint8Array;
+      } catch (_) {
+        result = false;
+      }
+      const ret = result;
+      return ret;
+    },
+    __wbg_isArray_d314bb98fcf08331: function(arg0) {
+      const ret = Array.isArray(arg0);
+      return ret;
+    },
+    __wbg_isSafeInteger_bfbc7332a9768d2a: function(arg0) {
+      const ret = Number.isSafeInteger(arg0);
+      return ret;
+    },
+    __wbg_iterator_6ff6560ca1568e55: function() {
+      const ret = Symbol.iterator;
+      return ret;
+    },
+    __wbg_length_32ed9a279acd054c: function(arg0) {
+      const ret = arg0.length;
+      return ret;
+    },
+    __wbg_length_35a7bace40f36eac: function(arg0) {
+      const ret = arg0.length;
+      return ret;
+    },
+    __wbg_msCrypto_d562bbe83e0d4b91: function(arg0) {
+      const ret = arg0.msCrypto;
+      return ret;
+    },
+    __wbg_new_0_73afc35eb544e539: function() {
+      const ret = /* @__PURE__ */ new Date();
+      return ret;
+    },
+    __wbg_new_245cd5c49157e602: function(arg0) {
+      const ret = new Date(arg0);
+      return ret;
+    },
+    __wbg_new_361308b2356cecd0: function() {
+      const ret = new Object();
+      return ret;
+    },
+    __wbg_new_3eb36ae241fe6f44: function() {
+      const ret = new Array();
+      return ret;
+    },
+    __wbg_new_dca287b076112a51: function() {
+      const ret = /* @__PURE__ */ new Map();
+      return ret;
+    },
+    __wbg_new_dd2b680c8bf6ae29: function(arg0) {
+      const ret = new Uint8Array(arg0);
+      return ret;
+    },
+    __wbg_new_no_args_1c7c842f08d00ebb: function(arg0, arg1) {
+      const ret = new Function(getStringFromWasm0(arg0, arg1));
+      return ret;
+    },
+    __wbg_new_with_length_a2c39cbe88fd8ff1: function(arg0) {
+      const ret = new Uint8Array(arg0 >>> 0);
+      return ret;
+    },
+    __wbg_next_3482f54c49e8af19: function() {
+      return handleError(function(arg0) {
+        const ret = arg0.next();
+        return ret;
+      }, arguments);
+    },
+    __wbg_next_418f80d8f5303233: function(arg0) {
+      const ret = arg0.next;
+      return ret;
+    },
+    __wbg_node_e1f24f89a7336c2e: function(arg0) {
+      const ret = arg0.node;
+      return ret;
+    },
+    __wbg_process_3975fd6c72f520aa: function(arg0) {
+      const ret = arg0.process;
+      return ret;
+    },
+    __wbg_prototypesetcall_bdcdcc5842e4d77d: function(arg0, arg1, arg2) {
+      Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+    },
+    __wbg_push_8ffdcb2063340ba5: function(arg0, arg1) {
+      const ret = arg0.push(arg1);
+      return ret;
+    },
+    __wbg_randomFillSync_f8c153b79f285817: function() {
+      return handleError(function(arg0, arg1) {
+        arg0.randomFillSync(arg1);
+      }, arguments);
+    },
+    __wbg_require_b74f47fc2d022fd6: function() {
+      return handleError(function() {
+        const ret = module.require;
+        return ret;
+      }, arguments);
+    },
+    __wbg_set_1eb0999cf5d27fc8: function(arg0, arg1, arg2) {
+      const ret = arg0.set(arg1, arg2);
+      return ret;
+    },
+    __wbg_set_3f1d0b984ed272ed: function(arg0, arg1, arg2) {
+      arg0[arg1] = arg2;
+    },
+    __wbg_set_f43e577aea94465b: function(arg0, arg1, arg2) {
+      arg0[arg1 >>> 0] = arg2;
+    },
+    __wbg_static_accessor_GLOBAL_12837167ad935116: function() {
+      const ret = typeof global === "undefined" ? null : global;
+      return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    },
+    __wbg_static_accessor_GLOBAL_THIS_e628e89ab3b1c95f: function() {
+      const ret = typeof globalThis === "undefined" ? null : globalThis;
+      return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    },
+    __wbg_static_accessor_SELF_a621d3dfbb60d0ce: function() {
+      const ret = typeof self === "undefined" ? null : self;
+      return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    },
+    __wbg_static_accessor_WINDOW_f8727f0cf888e0bd: function() {
+      const ret = typeof window === "undefined" ? null : window;
+      return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    },
+    __wbg_subarray_a96e1fef17ed23cb: function(arg0, arg1, arg2) {
+      const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+      return ret;
+    },
+    __wbg_value_0546255b415e96c1: function(arg0) {
+      const ret = arg0.value;
+      return ret;
+    },
+    __wbg_versions_4e31226f5e8dc909: function(arg0) {
+      const ret = arg0.versions;
+      return ret;
+    },
+    __wbindgen_cast_0000000000000001: function(arg0) {
+      const ret = arg0;
+      return ret;
+    },
+    __wbindgen_cast_0000000000000002: function(arg0) {
+      const ret = arg0;
+      return ret;
+    },
+    __wbindgen_cast_0000000000000003: function(arg0, arg1) {
+      const ret = getArrayU8FromWasm0(arg0, arg1);
+      return ret;
+    },
+    __wbindgen_cast_0000000000000004: function(arg0, arg1) {
+      const ret = getStringFromWasm0(arg0, arg1);
+      return ret;
+    },
+    __wbindgen_cast_0000000000000005: function(arg0) {
+      const ret = BigInt.asUintN(64, arg0);
+      return ret;
+    },
+    __wbindgen_init_externref_table: function() {
+      const table = wasm.__wbindgen_externrefs;
+      const offset = table.grow(4);
+      table.set(0, void 0);
+      table.set(offset + 0, void 0);
+      table.set(offset + 1, null);
+      table.set(offset + 2, true);
+      table.set(offset + 3, false);
+    },
+    __wbindgen_object_is_undefined: function(arg0) {
+      const ret = arg0 === void 0;
+      return ret;
+    }
+  };
+  return {
+    __proto__: null,
+    "./duke_sheets_wasm_bg.js": import0
+  };
+}
+function addToExternrefTable0(obj) {
+  const idx = wasm.__externref_table_alloc();
+  wasm.__wbindgen_externrefs.set(idx, obj);
+  return idx;
+}
+function debugString(val) {
+  const type = typeof val;
+  if (type == "number" || type == "boolean" || val == null) {
+    return `${val}`;
+  }
+  if (type == "string") {
+    return `"${val}"`;
+  }
+  if (type == "symbol") {
+    const description = val.description;
+    if (description == null) {
+      return "Symbol";
+    } else {
+      return `Symbol(${description})`;
+    }
+  }
+  if (type == "function") {
+    const name = val.name;
+    if (typeof name == "string" && name.length > 0) {
+      return `Function(${name})`;
+    } else {
+      return "Function";
+    }
+  }
+  if (Array.isArray(val)) {
+    const length = val.length;
+    let debug = "[";
+    if (length > 0) {
+      debug += debugString(val[0]);
+    }
+    for (let i = 1; i < length; i++) {
+      debug += ", " + debugString(val[i]);
+    }
+    debug += "]";
+    return debug;
+  }
+  const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+  let className;
+  if (builtInMatches && builtInMatches.length > 1) {
+    className = builtInMatches[1];
+  } else {
+    return toString.call(val);
+  }
+  if (className == "Object") {
+    try {
+      return "Object(" + JSON.stringify(val) + ")";
+    } catch (_) {
+      return "Object";
+    }
+  }
+  if (val instanceof Error) {
+    return `${val.name}: ${val.message}
+${val.stack}`;
+  }
+  return className;
+}
+function getArrayJsValueFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  const mem = getDataViewMemory0();
+  const result = [];
+  for (let i = ptr; i < ptr + 4 * len; i += 4) {
+    result.push(wasm.__wbindgen_externrefs.get(mem.getUint32(i, true)));
+  }
+  wasm.__externref_drop_slice(ptr, len);
+  return result;
+}
+function getArrayU32FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+function getArrayU8FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+function getDataViewMemory0() {
+  if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
+    cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+  }
+  return cachedDataViewMemory0;
+}
+function getStringFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return decodeText(ptr, len);
+}
+function getUint32ArrayMemory0() {
+  if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+    cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+  }
+  return cachedUint32ArrayMemory0;
+}
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+function handleError(f, args) {
+  try {
+    return f.apply(this, args);
+  } catch (e) {
+    const idx = addToExternrefTable0(e);
+    wasm.__wbindgen_exn_store(idx);
+  }
+}
+function isLikeNone(x) {
+  return x === void 0 || x === null;
+}
+function passArray8ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 1, 1) >>> 0;
+  getUint8ArrayMemory0().set(arg, ptr / 1);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
+function passStringToWasm0(arg, malloc, realloc) {
+  if (realloc === void 0) {
+    const buf = cachedTextEncoder.encode(arg);
+    const ptr2 = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+    WASM_VECTOR_LEN = buf.length;
+    return ptr2;
+  }
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
+  const mem = getUint8ArrayMemory0();
+  let offset = 0;
+  for (; offset < len; offset++) {
+    const code = arg.charCodeAt(offset);
+    if (code > 127) break;
+    mem[ptr + offset] = code;
+  }
+  if (offset !== len) {
+    if (offset !== 0) {
+      arg = arg.slice(offset);
+    }
+    ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+    const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+    const ret = cachedTextEncoder.encodeInto(arg, view);
+    offset += ret.written;
+    ptr = realloc(ptr, len, offset, 1) >>> 0;
+  }
+  WASM_VECTOR_LEN = offset;
+  return ptr;
+}
+function takeFromExternrefTable0(idx) {
+  const value = wasm.__wbindgen_externrefs.get(idx);
+  wasm.__externref_table_dealloc(idx);
+  return value;
+}
+function decodeText(ptr, len) {
+  numBytesDecoded += len;
+  if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+    cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    numBytesDecoded = len;
+  }
+  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+function __wbg_finalize_init(instance, module2) {
+  wasm = instance.exports;
+  wasmModule = module2;
+  cachedDataViewMemory0 = null;
+  cachedUint32ArrayMemory0 = null;
+  cachedUint8ArrayMemory0 = null;
+  wasm.__wbindgen_start();
+  return wasm;
+}
+async function __wbg_load(module2, imports) {
+  if (typeof Response === "function" && module2 instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === "function") {
+      try {
+        return await WebAssembly.instantiateStreaming(module2, imports);
+      } catch (e) {
+        const validResponse = module2.ok && expectedResponseType(module2.type);
+        if (validResponse && module2.headers.get("Content-Type") !== "application/wasm") {
+          console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+        } else {
+          throw e;
+        }
+      }
+    }
+    const bytes = await module2.arrayBuffer();
+    return await WebAssembly.instantiate(bytes, imports);
+  } else {
+    const instance = await WebAssembly.instantiate(module2, imports);
+    if (instance instanceof WebAssembly.Instance) {
+      return { instance, module: module2 };
+    } else {
+      return instance;
+    }
+  }
+  function expectedResponseType(type) {
+    switch (type) {
+      case "basic":
+      case "cors":
+      case "default":
+        return true;
+    }
+    return false;
+  }
+}
+function initSync(module2) {
+  if (wasm !== void 0) return wasm;
+  if (module2 !== void 0) {
+    if (Object.getPrototypeOf(module2) === Object.prototype) {
+      ({ module: module2 } = module2);
+    } else {
+      console.warn("using deprecated parameters for `initSync()`; pass a single object instead");
+    }
+  }
+  const imports = __wbg_get_imports();
+  if (!(module2 instanceof WebAssembly.Module)) {
+    module2 = new WebAssembly.Module(module2);
+  }
+  const instance = new WebAssembly.Instance(module2, imports);
+  return __wbg_finalize_init(instance, module2);
+}
+async function __wbg_init(module_or_path) {
+  if (wasm !== void 0) return wasm;
+  if (module_or_path !== void 0) {
+    if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+      ({ module_or_path } = module_or_path);
+    } else {
+      console.warn("using deprecated parameters for the initialization function; pass a single object instead");
+    }
+  }
+  if (module_or_path === void 0) {
+    module_or_path = new URL("duke_sheets_wasm_bg.wasm", import.meta.url);
+  }
+  const imports = __wbg_get_imports();
+  if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) {
+    module_or_path = fetch(module_or_path);
+  }
+  const { instance, module: module2 } = await __wbg_load(await module_or_path, imports);
+  return __wbg_finalize_init(instance, module2);
+}
+var CellValue, Workbook, Worksheet, CellValueFinalization, WorkbookFinalization, WorksheetFinalization, cachedDataViewMemory0, cachedUint32ArrayMemory0, cachedUint8ArrayMemory0, cachedTextDecoder, MAX_SAFARI_DECODE_BYTES, numBytesDecoded, cachedTextEncoder, WASM_VECTOR_LEN, wasmModule, wasm;
+var init_duke_sheets_wasm = __esm({
+  "../../node_modules/.pnpm/@dukelib+sheets-wasm@0.1.23/node_modules/@dukelib/sheets-wasm/duke_sheets_wasm.js"() {
+    "use strict";
+    CellValue = class _CellValue {
+      static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(_CellValue.prototype);
+        obj.__wbg_ptr = ptr;
+        CellValueFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+      }
+      __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CellValueFinalization.unregister(this);
+        return ptr;
+      }
+      free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_cellvalue_free(ptr, 0);
+      }
+      /**
+       * @returns {boolean | undefined}
+       */
+      asBoolean() {
+        const ret = wasm.cellvalue_asBoolean(this.__wbg_ptr);
+        return ret === 16777215 ? void 0 : ret !== 0;
+      }
+      /**
+       * @returns {string | undefined}
+       */
+      asError() {
+        const ret = wasm.cellvalue_asError(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+          v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+          wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+      }
+      /**
+       * @returns {number | undefined}
+       */
+      asNumber() {
+        const ret = wasm.cellvalue_asNumber(this.__wbg_ptr);
+        return ret[0] === 0 ? void 0 : ret[1];
+      }
+      /**
+       * @returns {string | undefined}
+       */
+      asText() {
+        const ret = wasm.cellvalue_asText(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+          v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+          wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+      }
+      /**
+       * @returns {boolean}
+       */
+      get is_boolean() {
+        const ret = wasm.cellvalue_is_boolean(this.__wbg_ptr);
+        return ret !== 0;
+      }
+      /**
+       * @returns {boolean}
+       */
+      get is_empty() {
+        const ret = wasm.cellvalue_is_empty(this.__wbg_ptr);
+        return ret !== 0;
+      }
+      /**
+       * @returns {boolean}
+       */
+      get is_error() {
+        const ret = wasm.cellvalue_is_error(this.__wbg_ptr);
+        return ret !== 0;
+      }
+      /**
+       * @returns {boolean}
+       */
+      get is_number() {
+        const ret = wasm.cellvalue_is_number(this.__wbg_ptr);
+        return ret !== 0;
+      }
+      /**
+       * @returns {boolean}
+       */
+      get is_text() {
+        const ret = wasm.cellvalue_is_text(this.__wbg_ptr);
+        return ret !== 0;
+      }
+      /**
+       * @returns {any}
+       */
+      toJs() {
+        const ret = wasm.cellvalue_toJs(this.__wbg_ptr);
+        return ret;
+      }
+      /**
+       * @returns {string}
+       */
+      toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+          const ret = wasm.cellvalue_toString(this.__wbg_ptr);
+          deferred1_0 = ret[0];
+          deferred1_1 = ret[1];
+          return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+          wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+      }
+    };
+    if (Symbol.dispose) CellValue.prototype[Symbol.dispose] = CellValue.prototype.free;
+    Workbook = class _Workbook {
+      static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(_Workbook.prototype);
+        obj.__wbg_ptr = ptr;
+        WorkbookFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+      }
+      __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WorkbookFinalization.unregister(this);
+        return ptr;
+      }
+      free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_workbook_free(ptr, 0);
+      }
+      /**
+       * @returns {number}
+       */
+      get activeSheet() {
+        const ret = wasm.workbook_activeSheet(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+      }
+      /**
+       * @param {string} name
+       * @returns {number}
+       */
+      addSheet(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.workbook_addSheet(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+      }
+      /**
+       * @param {any | null} [options]
+       * @returns {any}
+       */
+      calculate(options) {
+        const ret = wasm.workbook_calculate(this.__wbg_ptr, isLikeNone(options) ? 0 : addToExternrefTable0(options));
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @returns {number}
+       */
+      get chartsheetCount() {
+        const ret = wasm.workbook_chartsheetCount(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+      }
+      /**
+       * @returns {any}
+       */
+      get chartsheets() {
+        const ret = wasm.workbook_chartsheets(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @param {string} name
+       * @param {string} refers_to
+       */
+      defineName(name, refers_to) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(refers_to, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.workbook_defineName(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+          throw takeFromExternrefTable0(ret[0]);
+        }
+      }
+      /**
+       * Load a workbook from bytes, auto-detecting the format (XLSX or XLS).
+       * @param {Uint8Array} data
+       * @returns {Workbook}
+       */
+      static fromBytes(data) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.workbook_fromBytes(ptr0, len0);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return _Workbook.__wrap(ret[0]);
+      }
+      /**
+       * Load a password-protected workbook from bytes, auto-detecting
+       * the format (XLSX or XLS). `skipIntegrityCheck` skips the HMAC
+       * integrity check on Agile-encrypted files (matches Office
+       * behaviour); defaults to false.
+       * @param {Uint8Array} data
+       * @param {string} password
+       * @param {boolean | null} [skip_integrity_check]
+       * @returns {Workbook}
+       */
+      static fromBytesWithPassword(data, password, skip_integrity_check) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.workbook_fromBytesWithPassword(ptr0, len0, ptr1, len1, isLikeNone(skip_integrity_check) ? 16777215 : skip_integrity_check ? 1 : 0);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return _Workbook.__wrap(ret[0]);
+      }
+      /**
+       * @param {string} csv
+       * @returns {Workbook}
+       */
+      static fromCsvString(csv) {
+        const ptr0 = passStringToWasm0(csv, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.workbook_fromCsvString(ptr0, len0);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return _Workbook.__wrap(ret[0]);
+      }
+      /**
+       * @param {string} name
+       * @returns {string | undefined}
+       */
+      getNamedRange(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.workbook_getNamedRange(this.__wbg_ptr, ptr0, len0);
+        if (ret[3]) {
+          throw takeFromExternrefTable0(ret[2]);
+        }
+        let v2;
+        if (ret[0] !== 0) {
+          v2 = getStringFromWasm0(ret[0], ret[1]).slice();
+          wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v2;
+      }
+      /**
+       * @param {number} index
+       * @returns {Worksheet}
+       */
+      getSheet(index) {
+        const ret = wasm.workbook_getSheet(this.__wbg_ptr, index);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return Worksheet.__wrap(ret[0]);
+      }
+      /**
+       * @param {string} name
+       * @returns {Worksheet}
+       */
+      getSheetByName(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.workbook_getSheetByName(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return Worksheet.__wrap(ret[0]);
+      }
+      /**
+       * @returns {boolean}
+       */
+      get isEmpty() {
+        const ret = wasm.workbook_isEmpty(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+      }
+      /**
+       * @param {string} csv
+       * @returns {Workbook}
+       */
+      static loadCsvString(csv) {
+        const ptr0 = passStringToWasm0(csv, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.workbook_loadCsvString(ptr0, len0);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return _Workbook.__wrap(ret[0]);
+      }
+      /**
+       * @returns {any}
+       */
+      get namedRanges() {
+        const ret = wasm.workbook_namedRanges(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      constructor() {
+        const ret = wasm.workbook_new();
+        this.__wbg_ptr = ret >>> 0;
+        WorkbookFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+      }
+      /**
+       * @param {number} index
+       */
+      removeSheet(index) {
+        const ret = wasm.workbook_removeSheet(this.__wbg_ptr, index);
+        if (ret[1]) {
+          throw takeFromExternrefTable0(ret[0]);
+        }
+      }
+      /**
+       * Resolve a drawing color to display RGB (`RRGGBB` hex) against
+       * this workbook's theme palette. `auto` has no fixed RGB and
+       * resolves to `null`.
+       * @param {any} color
+       * @returns {string | undefined}
+       */
+      resolveColor(color) {
+        const ret = wasm.workbook_resolveColor(this.__wbg_ptr, color);
+        if (ret[3]) {
+          throw takeFromExternrefTable0(ret[2]);
+        }
+        let v1;
+        if (ret[0] !== 0) {
+          v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+          wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+      }
+      /**
+       * Save the first sheet as a CSV string, with form-control state
+       * synchronized into linked cells in the output.
+       * @returns {string}
+       */
+      saveCsvString() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+          const ret = wasm.workbook_saveCsvString(this.__wbg_ptr);
+          var ptr1 = ret[0];
+          var len1 = ret[1];
+          if (ret[3]) {
+            ptr1 = 0;
+            len1 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+          }
+          deferred2_0 = ptr1;
+          deferred2_1 = len1;
+          return getStringFromWasm0(ptr1, len1);
+        } finally {
+          wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+      }
+      /**
+       * Save the workbook as encrypted XLS bytes after synchronizing
+       * form-control state into linked cells. `profile` selects
+       * the FilePass variant; `null` defaults to RC4 CryptoAPI 128.
+       * Valid values: `"rc4-cryptoapi"`, `"rc4-legacy"`, `"xor"`.
+       * `keyBits` controls RC4 CryptoAPI key size (40 or 128). XOR is
+       * not certified to interoperate with modern Excel.
+       * @param {string} password
+       * @param {string | null} [profile]
+       * @param {number | null} [key_bits]
+       * @returns {Uint8Array}
+       */
+      saveXlsBytesEncrypted(password, profile, key_bits) {
+        const ptr0 = passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(profile) ? 0 : passStringToWasm0(profile, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.workbook_saveXlsBytesEncrypted(this.__wbg_ptr, ptr0, len0, ptr1, len1, isLikeNone(key_bits) ? 4294967297 : key_bits >>> 0);
+        if (ret[3]) {
+          throw takeFromExternrefTable0(ret[2]);
+        }
+        var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v3;
+      }
+      /**
+       * Save XLSB bytes with form-control state synchronized into linked cells,
+       * replacing existing values and formulas in the output.
+       * @returns {Uint8Array}
+       */
+      saveXlsbBytes() {
+        const ret = wasm.workbook_saveXlsbBytes(this.__wbg_ptr);
+        if (ret[3]) {
+          throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+      }
+      /**
+       * Save XLSX bytes with form-control state synchronized into linked cells,
+       * replacing existing values and formulas in the output.
+       * @returns {Uint8Array}
+       */
+      saveXlsxBytes() {
+        const ret = wasm.workbook_saveXlsxBytes(this.__wbg_ptr);
+        if (ret[3]) {
+          throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+      }
+      /**
+       * Save the workbook as encrypted XLSX bytes after synchronizing
+       * form-control state into linked cells. `profile` selects
+       * the encryption variant; passing `null`/`undefined` uses the
+       * Agile-256 default. Valid values: `"agile"`, `"standard"`.
+       * `keyBits` and `spinCount` override the defaults where the
+       * profile supports them.
+       * @param {string} password
+       * @param {string | null} [profile]
+       * @param {number | null} [key_bits]
+       * @param {number | null} [spin_count]
+       * @returns {Uint8Array}
+       */
+      saveXlsxBytesEncrypted(password, profile, key_bits, spin_count) {
+        const ptr0 = passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(profile) ? 0 : passStringToWasm0(profile, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.workbook_saveXlsxBytesEncrypted(this.__wbg_ptr, ptr0, len0, ptr1, len1, isLikeNone(key_bits) ? 4294967297 : key_bits >>> 0, isLikeNone(spin_count) ? 4294967297 : spin_count >>> 0);
+        if (ret[3]) {
+          throw takeFromExternrefTable0(ret[2]);
+        }
+        var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v3;
+      }
+      /**
+       * @param {any} protection
+       */
+      setWorkbookProtection(protection) {
+        const ret = wasm.workbook_setWorkbookProtection(this.__wbg_ptr, protection);
+        if (ret[1]) {
+          throw takeFromExternrefTable0(ret[0]);
+        }
+      }
+      /**
+       * @returns {any}
+       */
+      get settings() {
+        const ret = wasm.workbook_settings(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @returns {number}
+       */
+      get sheetCount() {
+        const ret = wasm.workbook_sheetCount(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+      }
+      /**
+       * @param {string} name
+       * @returns {number | undefined}
+       */
+      sheetIndex(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.workbook_sheetIndex(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 4294967297 ? void 0 : ret[0];
+      }
+      /**
+       * @returns {string[]}
+       */
+      get sheetNames() {
+        const ret = wasm.workbook_sheetNames(this.__wbg_ptr);
+        if (ret[3]) {
+          throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+      }
+      /**
+       * @returns {any}
+       */
+      get sheetOrder() {
+        const ret = wasm.workbook_sheetOrder(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * Project all form-control state into linked cells.
+       * @returns {number}
+       */
+      syncFormControls() {
+        const ret = wasm.workbook_syncFormControls(this.__wbg_ptr);
+        return ret >>> 0;
+      }
+      /**
+       * Drive controls from formula-backed linked cells.
+       * @returns {number}
+       */
+      syncFormControlsFromLinkedCells() {
+        const ret = wasm.workbook_syncFormControlsFromLinkedCells(this.__wbg_ptr);
+        return ret >>> 0;
+      }
+      /**
+       * The workbook theme's 12 clrScheme colors as `RRGGBB` hex, in
+       * theme-index order (background 1, text 1, background 2, text 2,
+       * accent 1-6, hyperlink, followed hyperlink). The Office default
+       * palette when the file carries no theme.
+       * @returns {string[]}
+       */
+      get themePalette() {
+        const ret = wasm.workbook_themePalette(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+      }
+      /**
+       * @returns {number}
+       */
+      get totalSheetCount() {
+        const ret = wasm.workbook_totalSheetCount(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+      }
+      /**
+       * @returns {any}
+       */
+      get workbookProtection() {
+        const ret = wasm.workbook_workbookProtection(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+    };
+    if (Symbol.dispose) Workbook.prototype[Symbol.dispose] = Workbook.prototype.free;
+    Worksheet = class _Worksheet {
+      static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(_Worksheet.prototype);
+        obj.__wbg_ptr = ptr;
+        WorksheetFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+      }
+      __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WorksheetFinalization.unregister(this);
+        return ptr;
+      }
+      free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_worksheet_free(ptr, 0);
+      }
+      /**
+       * Append a top-level drawing and return its z-order index.
+       * @param {any} input
+       * @returns {number}
+       */
+      addDrawing(input) {
+        const ret = wasm.worksheet_addDrawing(this.__wbg_ptr, input);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+      }
+      /**
+       * @returns {any}
+       */
+      get autoFilter() {
+        const ret = wasm.worksheet_autoFilter(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @returns {number}
+       */
+      get cellCount() {
+        const ret = wasm.worksheet_cellCount(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+      }
+      /**
+       * @returns {number}
+       */
+      get chartCount() {
+        const ret = wasm.worksheet_chartCount(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+      }
+      /**
+       * @returns {number}
+       */
+      get chartExCount() {
+        const ret = wasm.worksheet_chartExCount(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+      }
+      /**
+       * All standard charts in depth-first drawing order.
+       * @returns {any}
+       */
+      get charts() {
+        const ret = wasm.worksheet_charts(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * All ChartEx charts in depth-first drawing order.
+       * @returns {any}
+       */
+      get chartsEx() {
+        const ret = wasm.worksheet_chartsEx(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @returns {any}
+       */
+      get colBreaks() {
+        const ret = wasm.worksheet_colBreaks(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @returns {string[]}
+       */
+      get commentAuthors() {
+        const ret = wasm.worksheet_commentAuthors(this.__wbg_ptr);
+        if (ret[3]) {
+          throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+      }
+      /**
+       * @returns {number}
+       */
+      get commentCount() {
+        const ret = wasm.worksheet_commentCount(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+      }
+      /**
+       * @returns {any}
+       */
+      get comments() {
+        const ret = wasm.worksheet_comments(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @returns {number}
+       */
+      get conditionalFormatCount() {
+        const ret = wasm.worksheet_conditionalFormatCount(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+      }
+      /**
+       * @returns {any}
+       */
+      get conditionalFormats() {
+        const ret = wasm.worksheet_conditionalFormats(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @returns {number}
+       */
+      get dataValidationCount() {
+        const ret = wasm.worksheet_dataValidationCount(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+      }
+      /**
+       * @returns {any}
+       */
+      get dataValidations() {
+        const ret = wasm.worksheet_dataValidations(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @returns {boolean}
+       */
+      get date1904() {
+        const ret = wasm.worksheet_date1904(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+      }
+      /**
+       * @returns {number}
+       */
+      get defaultColumnWidth() {
+        const ret = wasm.worksheet_defaultColumnWidth(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+      }
+      /**
+       * @returns {number}
+       */
+      get defaultRowHeight() {
+        const ret = wasm.worksheet_defaultRowHeight(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+      }
+      /**
+       * Return image bytes for an image drawing without copying them into metadata getters.
+       * @param {any} path
+       * @returns {Uint8Array}
+       */
+      drawingImageData(path) {
+        const ret = wasm.worksheet_drawingImageData(this.__wbg_ptr, path);
+        if (ret[3]) {
+          throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+      }
+      /**
+       * Return an image drawing's SVG companion bytes, when present.
+       * @param {any} path
+       * @returns {Uint8Array | undefined}
+       */
+      drawingSvgData(path) {
+        const ret = wasm.worksheet_drawingSvgData(this.__wbg_ptr, path);
+        if (ret[3]) {
+          throw takeFromExternrefTable0(ret[2]);
+        }
+        let v1;
+        if (ret[0] !== 0) {
+          v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+          wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+      }
+      /**
+       * The recursive drawing tree in top-level z-order.
+       * @returns {any}
+       */
+      get drawings() {
+        const ret = wasm.worksheet_drawings(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @returns {number}
+       */
+      get formControlCount() {
+        const ret = wasm.worksheet_formControlCount(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+      }
+      /**
+       * All form controls in depth-first drawing order.
+       * @returns {any}
+       */
+      get formControls() {
+        const ret = wasm.worksheet_formControls(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @returns {any}
+       */
+      get formulaCells() {
+        const ret = wasm.worksheet_formulaCells(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * Get the number of formula cells in this worksheet.
+       * @returns {number}
+       */
+      get formulaCount() {
+        const ret = wasm.worksheet_formulaCount(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+      }
+      /**
+       * @returns {any}
+       */
+      get freezePanes() {
+        const ret = wasm.worksheet_freezePanes(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @param {string} address
+       * @returns {CellValue}
+       */
+      getCalculatedValue(address) {
+        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.worksheet_getCalculatedValue(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return CellValue.__wrap(ret[0]);
+      }
+      /**
+       * @param {number} row
+       * @param {number} col
+       * @returns {CellValue}
+       */
+      getCalculatedValueAt(row, col) {
+        const ret = wasm.worksheet_getCalculatedValueAt(this.__wbg_ptr, row, col);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return CellValue.__wrap(ret[0]);
+      }
+      /**
+       * @param {string} address
+       * @returns {CellValue}
+       */
+      getCell(address) {
+        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.worksheet_getCell(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return CellValue.__wrap(ret[0]);
+      }
+      /**
+       * @param {number} row
+       * @param {number} col
+       * @returns {CellValue}
+       */
+      getCellAt(row, col) {
+        const ret = wasm.worksheet_getCellAt(this.__wbg_ptr, row, col);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return CellValue.__wrap(ret[0]);
+      }
+      /**
+       * @param {string} address
+       * @returns {any}
+       */
+      getCellStyle(address) {
+        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.worksheet_getCellStyle(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @param {number} row
+       * @param {number} col
+       * @returns {any}
+       */
+      getCellStyleAt(row, col) {
+        const ret = wasm.worksheet_getCellStyleAt(this.__wbg_ptr, row, col);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @param {number} col
+       * @returns {number}
+       */
+      getColumnOutlineLevel(col) {
+        const ret = wasm.worksheet_getColumnOutlineLevel(this.__wbg_ptr, col);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+      }
+      /**
+       * @param {number} col
+       * @returns {number | undefined}
+       */
+      getColumnWidth(col) {
+        const ret = wasm.worksheet_getColumnWidth(this.__wbg_ptr, col);
+        if (ret[3]) {
+          throw takeFromExternrefTable0(ret[2]);
+        }
+        return ret[0] === 0 ? void 0 : ret[1];
+      }
+      /**
+       * @param {string} address
+       * @returns {any}
+       */
+      getComment(address) {
+        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.worksheet_getComment(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @param {number} row
+       * @param {number} col
+       * @returns {any}
+       */
+      getCommentAt(row, col) {
+        const ret = wasm.worksheet_getCommentAt(this.__wbg_ptr, row, col);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @param {string} address
+       * @returns {string}
+       */
+      getFormattedValue(address) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+          const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+          const len0 = WASM_VECTOR_LEN;
+          const ret = wasm.worksheet_getFormattedValue(this.__wbg_ptr, ptr0, len0);
+          var ptr2 = ret[0];
+          var len2 = ret[1];
+          if (ret[3]) {
+            ptr2 = 0;
+            len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+          }
+          deferred3_0 = ptr2;
+          deferred3_1 = len2;
+          return getStringFromWasm0(ptr2, len2);
+        } finally {
+          wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+      }
+      /**
+       * @param {number} row
+       * @param {number} col
+       * @returns {string}
+       */
+      getFormattedValueAt(row, col) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+          const ret = wasm.worksheet_getFormattedValueAt(this.__wbg_ptr, row, col);
+          var ptr1 = ret[0];
+          var len1 = ret[1];
+          if (ret[3]) {
+            ptr1 = 0;
+            len1 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+          }
+          deferred2_0 = ptr1;
+          deferred2_1 = len1;
+          return getStringFromWasm0(ptr1, len1);
+        } finally {
+          wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+      }
+      /**
+       * @param {number} row
+       * @param {number} col
+       * @returns {string | undefined}
+       */
+      getFormulaAt(row, col) {
+        const ret = wasm.worksheet_getFormulaAt(this.__wbg_ptr, row, col);
+        if (ret[3]) {
+          throw takeFromExternrefTable0(ret[2]);
+        }
+        let v1;
+        if (ret[0] !== 0) {
+          v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+          wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+      }
+      /**
+       * @param {string} address
+       * @returns {any}
+       */
+      getHyperlink(address) {
+        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.worksheet_getHyperlink(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @param {number} row
+       * @param {number} col
+       * @returns {any}
+       */
+      getHyperlinkAt(row, col) {
+        const ret = wasm.worksheet_getHyperlinkAt(this.__wbg_ptr, row, col);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @param {number} row
+       * @param {number} col
+       * @returns {any}
+       */
+      getImageAt(row, col) {
+        const ret = wasm.worksheet_getImageAt(this.__wbg_ptr, row, col);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @param {number} row
+       * @param {number} col
+       * @returns {any}
+       */
+      getMergeSpan(row, col) {
+        const ret = wasm.worksheet_getMergeSpan(this.__wbg_ptr, row, col);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @param {number} row
+       * @returns {number | undefined}
+       */
+      getRowHeight(row) {
+        const ret = wasm.worksheet_getRowHeight(this.__wbg_ptr, row);
+        if (ret[3]) {
+          throw takeFromExternrefTable0(ret[2]);
+        }
+        return ret[0] === 0 ? void 0 : ret[1];
+      }
+      /**
+       * @param {number} row
+       * @returns {number}
+       */
+      getRowOutlineLevel(row) {
+        const ret = wasm.worksheet_getRowOutlineLevel(this.__wbg_ptr, row);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+      }
+      /**
+       * @param {number} start_row
+       * @param {number} max_rows
+       * @param {any} options
+       * @returns {any}
+       */
+      getRowsBatch(start_row, max_rows, options) {
+        const ret = wasm.worksheet_getRowsBatch(this.__wbg_ptr, start_row, max_rows, options);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @param {number} row
+       * @param {number} col
+       * @returns {any}
+       */
+      getSpillSource(row, col) {
+        const ret = wasm.worksheet_getSpillSource(this.__wbg_ptr, row, col);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @param {string} name
+       * @returns {any}
+       */
+      getTableByName(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.worksheet_getTableByName(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @param {string} address
+       * @returns {boolean}
+       */
+      hasComment(address) {
+        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.worksheet_hasComment(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+      }
+      /**
+       * @param {number} row
+       * @param {number} col
+       * @returns {boolean}
+       */
+      hasCommentAt(row, col) {
+        const ret = wasm.worksheet_hasCommentAt(this.__wbg_ptr, row, col);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+      }
+      /**
+       * @returns {number}
+       */
+      get hyperlinkCount() {
+        const ret = wasm.worksheet_hyperlinkCount(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+      }
+      /**
+       * @returns {any}
+       */
+      get hyperlinks() {
+        const ret = wasm.worksheet_hyperlinks(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @returns {number}
+       */
+      get imageCount() {
+        const ret = wasm.worksheet_imageCount(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+      }
+      /**
+       * All embedded images in depth-first drawing order, without image bytes.
+       * @returns {any}
+       */
+      get images() {
+        const ret = wasm.worksheet_images(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * Insert a top-level drawing at a z-order index.
+       * @param {number} index
+       * @param {any} input
+       */
+      insertDrawing(index, input) {
+        const ret = wasm.worksheet_insertDrawing(this.__wbg_ptr, index, input);
+        if (ret[1]) {
+          throw takeFromExternrefTable0(ret[0]);
+        }
+      }
+      /**
+       * @param {number} col
+       * @returns {boolean}
+       */
+      isColumnCollapsed(col) {
+        const ret = wasm.worksheet_isColumnCollapsed(this.__wbg_ptr, col);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+      }
+      /**
+       * @param {number} col
+       * @returns {boolean}
+       */
+      isColumnHidden(col) {
+        const ret = wasm.worksheet_isColumnHidden(this.__wbg_ptr, col);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+      }
+      /**
+       * @returns {boolean}
+       */
+      get isEmpty() {
+        const ret = wasm.worksheet_isEmpty(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+      }
+      /**
+       * @param {number} row
+       * @param {number} col
+       * @returns {boolean}
+       */
+      isMergedSecondary(row, col) {
+        const ret = wasm.worksheet_isMergedSecondary(this.__wbg_ptr, row, col);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+      }
+      /**
+       * @param {number} row
+       * @returns {boolean}
+       */
+      isRowCollapsed(row) {
+        const ret = wasm.worksheet_isRowCollapsed(this.__wbg_ptr, row);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+      }
+      /**
+       * @param {number} row
+       * @returns {boolean}
+       */
+      isRowHidden(row) {
+        const ret = wasm.worksheet_isRowHidden(this.__wbg_ptr, row);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+      }
+      /**
+       * @returns {boolean}
+       */
+      get isSelected() {
+        const ret = wasm.worksheet_isSelected(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+      }
+      /**
+       * @param {number} row
+       * @param {number} col
+       * @returns {boolean}
+       */
+      isSpillSource(row, col) {
+        const ret = wasm.worksheet_isSpillSource(this.__wbg_ptr, row, col);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+      }
+      /**
+       * @param {number} row
+       * @param {number} col
+       * @returns {boolean}
+       */
+      isSpillTarget(row, col) {
+        const ret = wasm.worksheet_isSpillTarget(this.__wbg_ptr, row, col);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+      }
+      /**
+       * @param {string} range_str
+       */
+      mergeCells(range_str) {
+        const ptr0 = passStringToWasm0(range_str, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.worksheet_mergeCells(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+          throw takeFromExternrefTable0(ret[0]);
+        }
+      }
+      /**
+       * @returns {any}
+       */
+      get mergedRegions() {
+        const ret = wasm.worksheet_mergedRegions(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * Move a top-level drawing to another z-order index.
+       * @param {number} from
+       * @param {number} to
+       */
+      moveDrawing(from, to) {
+        const ret = wasm.worksheet_moveDrawing(this.__wbg_ptr, from, to);
+        if (ret[1]) {
+          throw takeFromExternrefTable0(ret[0]);
+        }
+      }
+      /**
+       * @returns {string}
+       */
+      get name() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+          const ret = wasm.worksheet_name(this.__wbg_ptr);
+          var ptr1 = ret[0];
+          var len1 = ret[1];
+          if (ret[3]) {
+            ptr1 = 0;
+            len1 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+          }
+          deferred2_0 = ptr1;
+          deferred2_1 = len1;
+          return getStringFromWasm0(ptr1, len1);
+        } finally {
+          wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+      }
+      /**
+       * @returns {any}
+       */
+      get pageSetup() {
+        const ret = wasm.worksheet_pageSetup(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @returns {string | undefined}
+       */
+      get printArea() {
+        const ret = wasm.worksheet_printArea(this.__wbg_ptr);
+        if (ret[3]) {
+          throw takeFromExternrefTable0(ret[2]);
+        }
+        let v1;
+        if (ret[0] !== 0) {
+          v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+          wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+      }
+      /**
+       * @returns {any}
+       */
+      get protectedRanges() {
+        const ret = wasm.worksheet_protectedRanges(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @returns {any}
+       */
+      get protection() {
+        const ret = wasm.worksheet_protection(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * Remove a top-level drawing or nested group child.
+       * @param {any} path
+       */
+      removeDrawing(path) {
+        const ret = wasm.worksheet_removeDrawing(this.__wbg_ptr, path);
+        if (ret[1]) {
+          throw takeFromExternrefTable0(ret[0]);
+        }
+      }
+      /**
+       * @returns {Uint32Array | undefined}
+       */
+      get repeatCols() {
+        const ret = wasm.worksheet_repeatCols(this.__wbg_ptr);
+        if (ret[3]) {
+          throw takeFromExternrefTable0(ret[2]);
+        }
+        let v1;
+        if (ret[0] !== 0) {
+          v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+          wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        }
+        return v1;
+      }
+      /**
+       * @returns {Uint32Array | undefined}
+       */
+      get repeatRows() {
+        const ret = wasm.worksheet_repeatRows(this.__wbg_ptr);
+        if (ret[3]) {
+          throw takeFromExternrefTable0(ret[2]);
+        }
+        let v1;
+        if (ret[0] !== 0) {
+          v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+          wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        }
+        return v1;
+      }
+      /**
+       * @returns {any}
+       */
+      get rowBreaks() {
+        const ret = wasm.worksheet_rowBreaks(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @returns {any}
+       */
+      get selections() {
+        const ret = wasm.worksheet_selections(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @param {string} address
+       * @param {any} value
+       */
+      setCell(address, value) {
+        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.worksheet_setCell(this.__wbg_ptr, ptr0, len0, value);
+        if (ret[1]) {
+          throw takeFromExternrefTable0(ret[0]);
+        }
+      }
+      /**
+       * @param {string} address
+       * @param {any} style
+       */
+      setCellStyle(address, style) {
+        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.worksheet_setCellStyle(this.__wbg_ptr, ptr0, len0, style);
+        if (ret[1]) {
+          throw takeFromExternrefTable0(ret[0]);
+        }
+      }
+      /**
+       * @param {number} row
+       * @param {number} col
+       * @param {any} style
+       */
+      setCellStyleAt(row, col, style) {
+        const ret = wasm.worksheet_setCellStyleAt(this.__wbg_ptr, row, col, style);
+        if (ret[1]) {
+          throw takeFromExternrefTable0(ret[0]);
+        }
+      }
+      /**
+       * @param {number} col
+       * @param {number} width
+       */
+      setColumnWidth(col, width) {
+        const ret = wasm.worksheet_setColumnWidth(this.__wbg_ptr, col, width);
+        if (ret[1]) {
+          throw takeFromExternrefTable0(ret[0]);
+        }
+      }
+      /**
+       * Replace a top-level drawing or nested group child.
+       * @param {any} path
+       * @param {any} input
+       */
+      setDrawing(path, input) {
+        const ret = wasm.worksheet_setDrawing(this.__wbg_ptr, path, input);
+        if (ret[1]) {
+          throw takeFromExternrefTable0(ret[0]);
+        }
+      }
+      /**
+       * Apply Excel checkbox/radio semantics and synchronize linked cells immediately.
+       * @param {any} path
+       * @param {string} state
+       * @returns {any}
+       */
+      setFormControlCheckState(path, state) {
+        const ptr0 = passStringToWasm0(state, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.worksheet_setFormControlCheckState(this.__wbg_ptr, path, ptr0, len0);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @param {string} address
+       * @param {string} formula
+       */
+      setFormula(address, formula) {
+        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(formula, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.worksheet_setFormula(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+          throw takeFromExternrefTable0(ret[0]);
+        }
+      }
+      /**
+       * @param {any} ranges
+       */
+      setProtectedRanges(ranges) {
+        const ret = wasm.worksheet_setProtectedRanges(this.__wbg_ptr, ranges);
+        if (ret[1]) {
+          throw takeFromExternrefTable0(ret[0]);
+        }
+      }
+      /**
+       * @param {any} protection
+       */
+      setProtection(protection) {
+        const ret = wasm.worksheet_setProtection(this.__wbg_ptr, protection);
+        if (ret[1]) {
+          throw takeFromExternrefTable0(ret[0]);
+        }
+      }
+      /**
+       * @param {string} range_str
+       * @param {any} style
+       */
+      setRangeStyle(range_str, style) {
+        const ptr0 = passStringToWasm0(range_str, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.worksheet_setRangeStyle(this.__wbg_ptr, ptr0, len0, style);
+        if (ret[1]) {
+          throw takeFromExternrefTable0(ret[0]);
+        }
+      }
+      /**
+       * @param {number} row
+       * @param {number} height
+       */
+      setRowHeight(row, height) {
+        const ret = wasm.worksheet_setRowHeight(this.__wbg_ptr, row, height);
+        if (ret[1]) {
+          throw takeFromExternrefTable0(ret[0]);
+        }
+      }
+      /**
+       * @returns {any}
+       */
+      get splitPanes() {
+        const ret = wasm.worksheet_splitPanes(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @returns {any}
+       */
+      get tabColor() {
+        const ret = wasm.worksheet_tabColor(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @returns {number}
+       */
+      get tableCount() {
+        const ret = wasm.worksheet_tableCount(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+      }
+      /**
+       * @returns {any}
+       */
+      get tables() {
+        const ret = wasm.worksheet_tables(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @param {string} range_str
+       * @returns {boolean}
+       */
+      unmergeCells(range_str) {
+        const ptr0 = passStringToWasm0(range_str, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.worksheet_unmergeCells(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+      }
+      /**
+       * @returns {any}
+       */
+      usedRange() {
+        const ret = wasm.worksheet_usedRange(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+      }
+      /**
+       * @returns {string}
+       */
+      get visibility() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+          const ret = wasm.worksheet_visibility(this.__wbg_ptr);
+          var ptr1 = ret[0];
+          var len1 = ret[1];
+          if (ret[3]) {
+            ptr1 = 0;
+            len1 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+          }
+          deferred2_0 = ptr1;
+          deferred2_1 = len1;
+          return getStringFromWasm0(ptr1, len1);
+        } finally {
+          wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+      }
+      /**
+       * @returns {number | undefined}
+       */
+      get zoomScale() {
+        const ret = wasm.worksheet_zoomScale(this.__wbg_ptr);
+        if (ret[2]) {
+          throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 4294967297 ? void 0 : ret[0];
+      }
+    };
+    if (Symbol.dispose) Worksheet.prototype[Symbol.dispose] = Worksheet.prototype.free;
+    CellValueFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+    }, unregister: () => {
+    } } : new FinalizationRegistry((ptr) => wasm.__wbg_cellvalue_free(ptr >>> 0, 1));
+    WorkbookFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+    }, unregister: () => {
+    } } : new FinalizationRegistry((ptr) => wasm.__wbg_workbook_free(ptr >>> 0, 1));
+    WorksheetFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+    }, unregister: () => {
+    } } : new FinalizationRegistry((ptr) => wasm.__wbg_worksheet_free(ptr >>> 0, 1));
+    cachedDataViewMemory0 = null;
+    cachedUint32ArrayMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    MAX_SAFARI_DECODE_BYTES = 2146435072;
+    numBytesDecoded = 0;
+    cachedTextEncoder = new TextEncoder();
+    if (!("encodeInto" in cachedTextEncoder)) {
+      cachedTextEncoder.encodeInto = function(arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+          read: arg.length,
+          written: buf.length
+        };
+      };
+    }
+    WASM_VECTOR_LEN = 0;
+  }
+});
+
+// ../../node_modules/.pnpm/fflate@0.8.3/node_modules/fflate/esm/browser.js
+var u8 = Uint8Array;
+var u16 = Uint16Array;
+var i32 = Int32Array;
+var fleb = new u8([
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  3,
+  4,
+  4,
+  4,
+  4,
+  5,
+  5,
+  5,
+  5,
+  0,
+  /* unused */
+  0,
+  0,
+  /* impossible */
+  0
+]);
+var fdeb = new u8([
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  2,
+  2,
+  3,
+  3,
+  4,
+  4,
+  5,
+  5,
+  6,
+  6,
+  7,
+  7,
+  8,
+  8,
+  9,
+  9,
+  10,
+  10,
+  11,
+  11,
+  12,
+  12,
+  13,
+  13,
+  /* unused */
+  0,
+  0
+]);
+var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+var freb = function(eb, start) {
+  var b = new u16(31);
+  for (var i = 0; i < 31; ++i) {
+    b[i] = start += 1 << eb[i - 1];
+  }
+  var r = new i32(b[30]);
+  for (var i = 1; i < 30; ++i) {
+    for (var j = b[i]; j < b[i + 1]; ++j) {
+      r[j] = j - b[i] << 5 | i;
+    }
+  }
+  return { b, r };
+};
+var _a = freb(fleb, 2);
+var fl = _a.b;
+var revfl = _a.r;
+fl[28] = 258, revfl[258] = 28;
+var _b = freb(fdeb, 0);
+var fd = _b.b;
+var revfd = _b.r;
+var rev = new u16(32768);
+for (i = 0; i < 32768; ++i) {
+  x = (i & 43690) >> 1 | (i & 21845) << 1;
+  x = (x & 52428) >> 2 | (x & 13107) << 2;
+  x = (x & 61680) >> 4 | (x & 3855) << 4;
+  rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+}
+var x;
+var i;
+var hMap = (function(cd, mb, r) {
+  var s = cd.length;
+  var i = 0;
+  var l = new u16(mb);
+  for (; i < s; ++i) {
+    if (cd[i])
+      ++l[cd[i] - 1];
+  }
+  var le = new u16(mb);
+  for (i = 1; i < mb; ++i) {
+    le[i] = le[i - 1] + l[i - 1] << 1;
+  }
+  var co;
+  if (r) {
+    co = new u16(1 << mb);
+    var rvb = 15 - mb;
+    for (i = 0; i < s; ++i) {
+      if (cd[i]) {
+        var sv = i << 4 | cd[i];
+        var r_1 = mb - cd[i];
+        var v = le[cd[i] - 1]++ << r_1;
+        for (var m = v | (1 << r_1) - 1; v <= m; ++v) {
+          co[rev[v] >> rvb] = sv;
+        }
+      }
+    }
+  } else {
+    co = new u16(s);
+    for (i = 0; i < s; ++i) {
+      if (cd[i]) {
+        co[i] = rev[le[cd[i] - 1]++] >> 15 - cd[i];
+      }
+    }
+  }
+  return co;
+});
+var flt = new u8(288);
+for (i = 0; i < 144; ++i)
+  flt[i] = 8;
+var i;
+for (i = 144; i < 256; ++i)
+  flt[i] = 9;
+var i;
+for (i = 256; i < 280; ++i)
+  flt[i] = 7;
+var i;
+for (i = 280; i < 288; ++i)
+  flt[i] = 8;
+var i;
+var fdt = new u8(32);
+for (i = 0; i < 32; ++i)
+  fdt[i] = 5;
+var i;
+var flrm = /* @__PURE__ */ hMap(flt, 9, 1);
+var fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
+var max = function(a) {
+  var m = a[0];
+  for (var i = 1; i < a.length; ++i) {
+    if (a[i] > m)
+      m = a[i];
+  }
+  return m;
+};
+var bits = function(d, p, m) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
+};
+var bits16 = function(d, p) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+};
+var shft = function(p) {
+  return (p + 7) / 8 | 0;
+};
+var slc = function(v, s, e) {
+  if (s == null || s < 0)
+    s = 0;
+  if (e == null || e > v.length)
+    e = v.length;
+  return new u8(v.subarray(s, e));
+};
+var ec = [
+  "unexpected EOF",
+  "invalid block type",
+  "invalid length/literal",
+  "invalid distance",
+  "stream finished",
+  "no stream handler",
+  ,
+  // determined by compression function
+  "no callback",
+  "invalid UTF-8 data",
+  "extra field too long",
+  "date not in range 1980-2099",
+  "filename too long",
+  "stream finishing",
+  "invalid zip data"
+  // determined by unknown compression method
+];
+var err = function(ind, msg, nt) {
+  var e = new Error(msg || ec[ind]);
+  e.code = ind;
+  if (Error.captureStackTrace)
+    Error.captureStackTrace(e, err);
+  if (!nt)
+    throw e;
+  return e;
+};
+var inflt = function(dat, st, buf, dict) {
+  var sl = dat.length, dl = dict ? dict.length : 0;
+  if (!sl || st.f && !st.l)
+    return buf || new u8(0);
+  var noBuf = !buf;
+  var resize = noBuf || st.i != 2;
+  var noSt = st.i;
+  if (noBuf)
+    buf = new u8(sl * 3);
+  var cbuf = function(l2) {
+    var bl = buf.length;
+    if (l2 > bl) {
+      var nbuf = new u8(Math.max(bl * 2, l2));
+      nbuf.set(buf);
+      buf = nbuf;
+    }
+  };
+  var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+  var tbts = sl * 8;
+  do {
+    if (!lm) {
+      final = bits(dat, pos, 1);
+      var type = bits(dat, pos + 1, 3);
+      pos += 3;
+      if (!type) {
+        var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+        if (t > sl) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + l);
+        buf.set(dat.subarray(s, t), bt);
+        st.b = bt += l, st.p = pos = t * 8, st.f = final;
+        continue;
+      } else if (type == 1)
+        lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+      else if (type == 2) {
+        var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+        var tl = hLit + bits(dat, pos + 5, 31) + 1;
+        pos += 14;
+        var ldt = new u8(tl);
+        var clt = new u8(19);
+        for (var i = 0; i < hcLen; ++i) {
+          clt[clim[i]] = bits(dat, pos + i * 3, 7);
+        }
+        pos += hcLen * 3;
+        var clb = max(clt), clbmsk = (1 << clb) - 1;
+        var clm = hMap(clt, clb, 1);
+        for (var i = 0; i < tl; ) {
+          var r = clm[bits(dat, pos, clbmsk)];
+          pos += r & 15;
+          var s = r >> 4;
+          if (s < 16) {
+            ldt[i++] = s;
+          } else {
+            var c = 0, n = 0;
+            if (s == 16)
+              n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
+            else if (s == 17)
+              n = 3 + bits(dat, pos, 7), pos += 3;
+            else if (s == 18)
+              n = 11 + bits(dat, pos, 127), pos += 7;
+            while (n--)
+              ldt[i++] = c;
+          }
+        }
+        var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+        lbt = max(lt);
+        dbt = max(dt);
+        lm = hMap(lt, lbt, 1);
+        dm = hMap(dt, dbt, 1);
+      } else
+        err(1);
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+    }
+    if (resize)
+      cbuf(bt + 131072);
+    var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+    var lpos = pos;
+    for (; ; lpos = pos) {
+      var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+      pos += c & 15;
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+      if (!c)
+        err(2);
+      if (sym < 256)
+        buf[bt++] = sym;
+      else if (sym == 256) {
+        lpos = pos, lm = null;
+        break;
+      } else {
+        var add = sym - 254;
+        if (sym > 264) {
+          var i = sym - 257, b = fleb[i];
+          add = bits(dat, pos, (1 << b) - 1) + fl[i];
+          pos += b;
+        }
+        var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+        if (!d)
+          err(3);
+        pos += d & 15;
+        var dt = fd[dsym];
+        if (dsym > 3) {
+          var b = fdeb[dsym];
+          dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+        }
+        if (pos > tbts) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + 131072);
+        var end = bt + add;
+        if (bt < dt) {
+          var shift = dl - dt, dend = Math.min(dt, end);
+          if (shift + bt < 0)
+            err(3);
+          for (; bt < dend; ++bt)
+            buf[bt] = dict[shift + bt];
+        }
+        for (; bt < end; ++bt)
+          buf[bt] = buf[bt - dt];
+      }
+    }
+    st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+    if (lm)
+      final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+  } while (!final);
+  return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+};
+var et = /* @__PURE__ */ new u8(0);
+var b2 = function(d, b) {
+  return d[b] | d[b + 1] << 8;
+};
+var b4 = function(d, b) {
+  return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
+};
+var b8 = function(d, b) {
+  return b4(d, b) + b4(d, b + 4) * 4294967296;
+};
+function inflateSync(data, opts) {
+  return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
+}
+var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder();
+var tds = 0;
+try {
+  td.decode(et, { stream: true });
+  tds = 1;
+} catch (e) {
+}
+var dutf8 = function(d) {
+  for (var r = "", i = 0; ; ) {
+    var c = d[i++];
+    var eb = (c > 127) + (c > 223) + (c > 239);
+    if (i + eb > d.length)
+      return { s: r, r: slc(d, i - 1) };
+    if (!eb)
+      r += String.fromCharCode(c);
+    else if (eb == 3) {
+      c = ((c & 15) << 18 | (d[i++] & 63) << 12 | (d[i++] & 63) << 6 | d[i++] & 63) - 65536, r += String.fromCharCode(55296 | c >> 10, 56320 | c & 1023);
+    } else if (eb & 1)
+      r += String.fromCharCode((c & 31) << 6 | d[i++] & 63);
+    else
+      r += String.fromCharCode((c & 15) << 12 | (d[i++] & 63) << 6 | d[i++] & 63);
+  }
+};
+function strFromU8(dat, latin1) {
+  if (latin1) {
+    var r = "";
+    for (var i = 0; i < dat.length; i += 16384)
+      r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384));
+    return r;
+  } else if (td) {
+    return td.decode(dat);
+  } else {
+    var _a2 = dutf8(dat), s = _a2.s, r = _a2.r;
+    if (r.length)
+      err(8);
+    return s;
+  }
+}
+var slzh = function(d, b) {
+  return b + 30 + b2(d, b + 26) + b2(d, b + 28);
+};
+var zh = function(d, b, z) {
+  var fnl = b2(d, b + 28), efl = b2(d, b + 30), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl;
+  var _a2 = z64hs(d, es, efl, z, b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)), sc = _a2[0], su = _a2[1], off = _a2[2];
+  return [b2(d, b + 10), sc, su, fn, es + efl + b2(d, b + 32), off];
+};
+var z64hs = function(d, b, l, z, sc, su, off) {
+  var nsc = sc == 4294967295, nsu = su == 4294967295, noff = off == 4294967295, e = b + l;
+  var nf = nsc + nsu + noff;
+  if (z && nf) {
+    for (; b + 4 < e; b += 4 + b2(d, b + 2)) {
+      if (b2(d, b) == 1) {
+        return [
+          nsc ? b8(d, b + 4 + 8 * nsu) : sc,
+          nsu ? b8(d, b + 4) : su,
+          noff ? b8(d, b + 4 + 8 * (nsu + nsc)) : off,
+          1
+        ];
+      }
+    }
+    if (z < 2)
+      err(13);
+  }
+  return [sc, su, off, 0];
+};
+function unzipSync(data, opts) {
+  var files = {};
+  var e = data.length - 22;
+  for (; b4(data, e) != 101010256; --e) {
+    if (!e || data.length - e > 65558)
+      err(13);
+  }
+  ;
+  var c = b2(data, e + 8);
+  if (!c)
+    return {};
+  var o = b4(data, e + 16);
+  var z = b4(data, e - 20) == 117853008;
+  if (z) {
+    var ze = b4(data, e - 12);
+    z = b4(data, ze) == 101075792;
+    if (z) {
+      c = b4(data, ze + 32);
+      o = b4(data, ze + 48);
+    }
+  }
+  var fltr = opts && opts.filter;
+  for (var i = 0; i < c; ++i) {
+    var _a2 = zh(data, o, z), c_2 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
+    o = no;
+    if (!fltr || fltr({
+      name: fn,
+      size: sc,
+      originalSize: su,
+      compression: c_2
+    })) {
+      if (!c_2)
+        files[fn] = slc(data, b, b + sc);
+      else if (c_2 == 8)
+        files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) });
+      else
+        err(14, "unknown compression type " + c_2);
+    }
+  }
+  return files;
+}
 
 // src/builtin-chart-styles.ts
 function decodeSrgb(channel) {
@@ -74,7 +2929,6 @@ function getBuiltinChartSurfaceStyle(styleId) {
 }
 
 // src/charts.ts
-import { strFromU8, strToU8 } from "fflate";
 var CHART_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart";
 var CHART_EX_REL_TYPE = "http://schemas.microsoft.com/office/2014/relationships/chartEx";
 var CHART_STYLE_REL_TYPE = "http://schemas.microsoft.com/office/2011/relationships/chartStyle";
@@ -261,9 +3115,9 @@ function parseNumericPointCacheFromXmlFragment(fragment) {
   }
   const explicitPointCountMatch = fragment.match(/<c:ptCount\b[^>]*\bval="(\d+)"/i);
   const explicitPointCount = explicitPointCountMatch?.[1] ? Number(explicitPointCountMatch[1]) : Number.NaN;
-  const maxIndex = pointMatches.reduce((max, match) => {
+  const maxIndex = pointMatches.reduce((max2, match) => {
     const current = Number(match[1] ?? Number.NaN);
-    return Number.isFinite(current) ? Math.max(max, current) : max;
+    return Number.isFinite(current) ? Math.max(max2, current) : max2;
   }, -1);
   const pointCount = Math.max(
     pointMatches.length,
@@ -338,16 +3192,16 @@ function rgbToHsl(red, green, blue) {
   const normalizedRed = red / 255;
   const normalizedGreen = green / 255;
   const normalizedBlue = blue / 255;
-  const max = Math.max(normalizedRed, normalizedGreen, normalizedBlue);
+  const max2 = Math.max(normalizedRed, normalizedGreen, normalizedBlue);
   const min = Math.min(normalizedRed, normalizedGreen, normalizedBlue);
-  const lightness = (max + min) / 2;
-  if (max === min) {
+  const lightness = (max2 + min) / 2;
+  if (max2 === min) {
     return [0, 0, lightness];
   }
-  const delta = max - min;
-  const saturation = lightness > 0.5 ? delta / (2 - max - min) : delta / (max + min);
+  const delta = max2 - min;
+  const saturation = lightness > 0.5 ? delta / (2 - max2 - min) : delta / (max2 + min);
   let hue = 0;
-  switch (max) {
+  switch (max2) {
     case normalizedRed:
       hue = (normalizedGreen - normalizedBlue) / delta + (normalizedGreen < normalizedBlue ? 6 : 0);
       break;
@@ -855,7 +3709,7 @@ function parseChartCacheValues(parentNode, cacheName, mode) {
   if (pointNodes.length === 0) {
     return null;
   }
-  const maxIndex = pointNodes.reduce((max, point) => Math.max(max, point.index), 0);
+  const maxIndex = pointNodes.reduce((max2, point) => Math.max(max2, point.index), 0);
   const targetLength = Math.max(
     pointNodes.length,
     Number.isFinite(pointCount ?? Number.NaN) ? Number(pointCount) : 0,
@@ -896,7 +3750,7 @@ function parseChartMultiLevelCacheValues(parentNode, mode) {
   if (pointNodes.length === 0) {
     return null;
   }
-  const maxIndex = pointNodes.reduce((max, point) => Math.max(max, point.index), 0);
+  const maxIndex = pointNodes.reduce((max2, point) => Math.max(max2, point.index), 0);
   const targetLength = Math.max(
     pointNodes.length,
     Number.isFinite(pointCount ?? Number.NaN) ? Number(pointCount) : 0,
@@ -2969,16 +5823,16 @@ function rgbToHsl2(red, green, blue) {
   const normalizedRed = red / 255;
   const normalizedGreen = green / 255;
   const normalizedBlue = blue / 255;
-  const max = Math.max(normalizedRed, normalizedGreen, normalizedBlue);
+  const max2 = Math.max(normalizedRed, normalizedGreen, normalizedBlue);
   const min = Math.min(normalizedRed, normalizedGreen, normalizedBlue);
-  const lightness = (max + min) / 2;
-  if (max === min) {
+  const lightness = (max2 + min) / 2;
+  if (max2 === min) {
     return [0, 0, lightness];
   }
-  const delta = max - min;
-  const saturation = lightness > 0.5 ? delta / (2 - max - min) : delta / (max + min);
+  const delta = max2 - min;
+  const saturation = lightness > 0.5 ? delta / (2 - max2 - min) : delta / (max2 + min);
   let hue = 0;
-  switch (max) {
+  switch (max2) {
     case normalizedRed:
       hue = (normalizedGreen - normalizedBlue) / delta + (normalizedGreen < normalizedBlue ? 6 : 0);
       break;
@@ -3078,7 +5932,6 @@ function getCellGeneralAlignment(worksheet, row, col) {
 }
 
 // src/images.ts
-import { strFromU8 as strFromU82, strToU8 as strToU82, unzipSync, zipSync } from "fflate";
 var REL_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
 var SPREADSHEET_NS = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
 var DRAWING_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing";
@@ -3243,7 +6096,7 @@ function parseXml2(xml) {
 }
 function readArchiveText2(archive, path) {
   const entry = archive[path];
-  return entry ? strFromU82(entry) : null;
+  return entry ? strFromU8(entry) : null;
 }
 function parseColumnReference(reference) {
   let value = 0;
@@ -4237,7 +7090,7 @@ function parseSheetState(archive, path, options) {
   const maxMetadataCol = Math.max(maxContentCol, 0) + 256;
   getLocalElements(document2, "col").forEach((colNode) => {
     const min = Number(colNode.getAttribute("min") ?? 0) - 1;
-    const max = Number(colNode.getAttribute("max") ?? 0) - 1;
+    const max2 = Number(colNode.getAttribute("max") ?? 0) - 1;
     const width = Number(colNode.getAttribute("width") ?? Number.NaN);
     const styleId = Number(colNode.getAttribute("style") ?? Number.NaN);
     if (!Number.isFinite(width)) {
@@ -4245,7 +7098,7 @@ function parseSheetState(archive, path, options) {
         return;
       }
     }
-    for (let col = min; col <= Math.min(max, maxMetadataCol); col += 1) {
+    for (let col = min; col <= Math.min(max2, maxMetadataCol); col += 1) {
       if (col >= 0) {
         if (Number.isFinite(width)) {
           const widthPx = sheetColumnWidthToPixels(width, columnWidthCharacterWidthPx);
@@ -4688,8 +7541,8 @@ function safeCalculate(workbook2, options = {}) {
   const withSavedValues = options.reparse ? collectFormulaCellsWithSavedValues(workbook2) : [];
   try {
     workbook2.calculate();
-  } catch (err) {
-    console.warn("[react-xlsx] workbook.calculate() trapped; falling back to cached formula values", err);
+  } catch (err2) {
+    console.warn("[react-xlsx] workbook.calculate() trapped; falling back to cached formula values", err2);
     if (options.reparse) {
       try {
         return { workbook: options.reparse(), calculated: false, skipReason: "calculate-trapped" };
@@ -4747,7 +7600,7 @@ function setWasmSource(source) {
 }
 function getSheetsWasmModule() {
   if (!wasmModulePromise) {
-    wasmModulePromise = import("@dukelib/sheets-wasm").then(async (mod) => {
+    wasmModulePromise = Promise.resolve().then(() => (init_duke_sheets_wasm(), duke_sheets_wasm_exports)).then(async (mod) => {
       if (configuredWasmSource !== void 0) {
         await mod.default({ module_or_path: configuredWasmSource });
       } else {
@@ -4795,7 +7648,7 @@ function readXmlAttribute(tag, name) {
 }
 function readArchiveText3(archive, path) {
   const entry = archive[path];
-  return entry ? strFromU83(entry) : "";
+  return entry ? strFromU8(entry) : "";
 }
 function normalizeWorkbookRelationshipTarget(target) {
   if (target.startsWith("/")) {
@@ -4831,7 +7684,7 @@ function parseWorkbookSheetPathsFromArchive(archive) {
 }
 function parseWorkerSheetLayoutAssets(bytes, sheetCount) {
   try {
-    const archive = unzipSync2(bytes);
+    const archive = unzipSync(bytes);
     const workbookSheetPaths = parseWorkbookSheetPathsFromArchive(archive);
     const sheetPaths = workbookSheetPaths.length > 0 ? workbookSheetPaths : Array.from({ length: sheetCount }, (_, index) => `xl/worksheets/sheet${index + 1}.xml`);
     return sheetPaths.slice(0, sheetCount).map((path) => {
@@ -5305,17 +8158,17 @@ function cellAddressToA1(cell) {
   return `${label}${cell.row + 1}`;
 }
 async function loadWorkbook(buffer, skipXmlParsing = false, showHiddenSheets = false) {
-  const wasmModule = await getSheetsWasmModule();
+  const wasmModule2 = await getSheetsWasmModule();
   const bytes = new Uint8Array(buffer);
   const effectiveSkipXmlParsing = shouldSkipXmlParsingForWorkbook(bytes, skipXmlParsing);
-  let activeWorkbook = wasmModule.Workbook.fromBytes(bytes);
+  let activeWorkbook = wasmModule2.Workbook.fromBytes(bytes);
   let totalFormulas = 0;
   for (let index = 0; index < activeWorkbook.sheetCount; index += 1) {
     totalFormulas += activeWorkbook.getSheet(index).formulaCount;
   }
   if (totalFormulas <= FORMULA_COUNT_THRESHOLD) {
     const result = safeCalculate(activeWorkbook, {
-      reparse: () => wasmModule.Workbook.fromBytes(bytes)
+      reparse: () => wasmModule2.Workbook.fromBytes(bytes)
     });
     activeWorkbook = result.workbook;
   }
@@ -5371,17 +8224,17 @@ async function loadWorkbook(buffer, skipXmlParsing = false, showHiddenSheets = f
   };
 }
 async function parseCharts(buffer, skipXmlParsing = false, showHiddenSheets = false) {
-  const wasmModule = await getSheetsWasmModule();
+  const wasmModule2 = await getSheetsWasmModule();
   const bytes = new Uint8Array(buffer);
   const effectiveSkipXmlParsing = shouldSkipXmlParsingForWorkbook(bytes, skipXmlParsing);
-  let activeWorkbook = wasmModule.Workbook.fromBytes(bytes);
+  let activeWorkbook = wasmModule2.Workbook.fromBytes(bytes);
   let totalFormulas = 0;
   for (let index = 0; index < activeWorkbook.sheetCount; index += 1) {
     totalFormulas += activeWorkbook.getSheet(index).formulaCount;
   }
   if (totalFormulas <= FORMULA_COUNT_THRESHOLD) {
     const result = safeCalculate(activeWorkbook, {
-      reparse: () => wasmModule.Workbook.fromBytes(bytes)
+      reparse: () => wasmModule2.Workbook.fromBytes(bytes)
     });
     activeWorkbook = result.workbook;
   }
@@ -5475,4 +8328,5 @@ self.addEventListener("message", (event) => {
     });
   });
 });
+self.postMessage({ type: "ready" });
 //# sourceMappingURL=xlsx-worker.js.map