@casadi/casadi-reader 0.0.0-poc

package/dist/index.js

@@ -0,0 +1,740 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+
+// src/scheme.js
+var scheme_default = {
+  "wire": {
+    "magic": 123456789012345,
+    "protocol": 3
+  },
+  "operations": {
+    "OP_ACOS": 17,
+    "OP_ACOSH": 41,
+    "OP_ADD": 1,
+    "OP_ADDNONZEROS": 71,
+    "OP_ADDNONZEROS_PARAM": 72,
+    "OP_AND": 24,
+    "OP_ASIN": 16,
+    "OP_ASINH": 40,
+    "OP_ASSERTION": 76,
+    "OP_ASSIGN": 0,
+    "OP_ATAN": 18,
+    "OP_ATAN2": 43,
+    "OP_ATANH": 42,
+    "OP_BILIN": 58,
+    "OP_BSPLINE": 90,
+    "OP_CALL": 48,
+    "OP_CEIL": 27,
+    "OP_CONST": 44,
+    "OP_CONSTPOW": 9,
+    "OP_CONVEXIFY": 91,
+    "OP_COPYSIGN": 31,
+    "OP_COS": 14,
+    "OP_COSH": 38,
+    "OP_DETERMINANT": 55,
+    "OP_DIAGCAT": 62,
+    "OP_DIAGSPLIT": 65,
+    "OP_DIV": 4,
+    "OP_DOT": 57,
+    "OP_DUMP": 98,
+    "OP_EINSTEIN": 89,
+    "OP_EQ": 21,
+    "OP_ERF": 33,
+    "OP_ERFINV": 86,
+    "OP_EXP": 6,
+    "OP_EXPM1": 94,
+    "OP_FABS": 29,
+    "OP_FIND": 49,
+    "OP_FLOOR": 26,
+    "OP_FMAX": 35,
+    "OP_FMIN": 34,
+    "OP_FMOD": 28,
+    "OP_GETNONZEROS": 69,
+    "OP_GETNONZEROS_PARAM": 70,
+    "OP_HORZCAT": 60,
+    "OP_HORZREPMAT": 84,
+    "OP_HORZREPSUM": 85,
+    "OP_HORZSPLIT": 63,
+    "OP_HYPOT": 95,
+    "OP_IF_ELSE_ZERO": 32,
+    "OP_INPUT": 45,
+    "OP_INV": 36,
+    "OP_INVERSE": 56,
+    "OP_KRON": 99,
+    "OP_KRON_CONTRACT": 100,
+    "OP_LE": 20,
+    "OP_LIFT": 88,
+    "OP_LOG": 7,
+    "OP_LOG1P": 93,
+    "OP_LOGSUMEXP": 96,
+    "OP_LOW": 50,
+    "OP_LT": 19,
+    "OP_MAP": 51,
+    "OP_MMAX": 83,
+    "OP_MMIN": 82,
+    "OP_MONITOR": 77,
+    "OP_MTIMES": 52,
+    "OP_MUL": 3,
+    "OP_NE": 22,
+    "OP_NEG": 5,
+    "OP_NORM1": 79,
+    "OP_NORM2": 78,
+    "OP_NORMF": 81,
+    "OP_NORMINF": 80,
+    "OP_NOT": 23,
+    "OP_OR": 25,
+    "OP_OUTPUT": 46,
+    "OP_PARAMETER": 47,
+    "OP_POW": 8,
+    "OP_PRINTME": 87,
+    "OP_PROJECT": 75,
+    "OP_RANK1": 59,
+    "OP_REMAINDER": 97,
+    "OP_RESHAPE": 66,
+    "OP_SETNONZEROS": 73,
+    "OP_SETNONZEROS_PARAM": 74,
+    "OP_SIGN": 30,
+    "OP_SIN": 13,
+    "OP_SINH": 37,
+    "OP_SOLVE": 53,
+    "OP_SPARSITY_CAST": 92,
+    "OP_SQ": 11,
+    "OP_SQRT": 10,
+    "OP_SUB": 2,
+    "OP_SUBASSIGN": 68,
+    "OP_SUBREF": 67,
+    "OP_TAN": 15,
+    "OP_TANH": 39,
+    "OP_TRANSPOSE": 54,
+    "OP_TWICE": 12,
+    "OP_VERTCAT": 61,
+    "OP_VERTSPLIT": 64
+  },
+  "class_versions": {
+    "AlpaqaInterface": [
+      1
+    ],
+    "BSplineInterpolant": [
+      1
+    ],
+    "Bisection": [
+      1
+    ],
+    "BlazingSplineFunction": [
+      2
+    ],
+    "Blocksqp": [
+      1
+    ],
+    "BonminInterface": [
+      1
+    ],
+    "CbcInterface": [
+      1
+    ],
+    "ClarabelInterface": [
+      1
+    ],
+    "ClpInterface": [
+      1
+    ],
+    "Collocation": [
+      2
+    ],
+    "Conic": [
+      4
+    ],
+    "ConoptInterface": [
+      1
+    ],
+    "CplexInterface": [
+      1
+    ],
+    "CvodesInterface": [
+      3
+    ],
+    "DaqpInterface": [
+      1
+    ],
+    "DirResource": [
+      1
+    ],
+    "Dump": [
+      1
+    ],
+    "External": [
+      2
+    ],
+    "FatropConicInterface": [
+      1
+    ],
+    "FatropInterface": [
+      1
+    ],
+    "Feasiblesqpmethod": [
+      3
+    ],
+    "FixedStepIntegrator": [
+      3
+    ],
+    "Fmu2": [
+      2
+    ],
+    "Fmu3": [
+      1
+    ],
+    "FmuFunction": [
+      6
+    ],
+    "FmuInternal": [
+      4
+    ],
+    "FunctionInternal": [
+      8
+    ],
+    "GenericExternal": [
+      1
+    ],
+    "GurobiInterface": [
+      2
+    ],
+    "HighsInterface": [
+      1
+    ],
+    "HpipmInterface": [
+      1
+    ],
+    "IdasInterface": [
+      2
+    ],
+    "ImplicitFixedStepIntegrator": [
+      2
+    ],
+    "ImporterInternal": [
+      1
+    ],
+    "Integrator": [
+      3
+    ],
+    "Interpolant": [
+      2
+    ],
+    "IpoptInterface": [
+      3
+    ],
+    "Ipqp": [
+      1
+    ],
+    "KnitroInterface": [
+      2
+    ],
+    "LapackLu": [
+      1
+    ],
+    "LinearInterpolant": [
+      1
+    ],
+    "LinsolLdl": [
+      1
+    ],
+    "LinsolQr": [
+      2
+    ],
+    "MXFunction": [
+      3
+    ],
+    "MadmpecInterface": [
+      1
+    ],
+    "MadnlpInterface": [
+      2
+    ],
+    "MosekInterface": [
+      1
+    ],
+    "Mumps": [
+      1
+    ],
+    "Newton": [
+      1
+    ],
+    "Nlpsol": [
+      5
+    ],
+    "OnnxFunction": [
+      2
+    ],
+    "OnnxRuntimeInterface": [
+      1
+    ],
+    "OoqpInterface": [
+      1
+    ],
+    "OracleFunction": [
+      3
+    ],
+    "OsqpInterface": [
+      2
+    ],
+    "PiqpInterface": [
+      1
+    ],
+    "ProtoFunction": [
+      2
+    ],
+    "ProxqpInterface": [
+      1
+    ],
+    "QpToNlp": [
+      1
+    ],
+    "QpoasesInterface": [
+      1
+    ],
+    "Qrqp": [
+      1
+    ],
+    "ResourceInternal": [
+      1
+    ],
+    "Rootfinder": [
+      3
+    ],
+    "RungeKutta": [
+      2
+    ],
+    "SLEQPInterface": [
+      1
+    ],
+    "SXFunction": [
+      4
+    ],
+    "SnoptInterface": [
+      1
+    ],
+    "Sqpmethod": [
+      3
+    ],
+    "SundialsInterface": [
+      2
+    ],
+    "SuperscsInterface": [
+      1
+    ],
+    "Switch": [
+      1
+    ],
+    "SymbolicQr": [
+      1
+    ],
+    "UnoInterface": [
+      1
+    ],
+    "WorhpInterface": [
+      1
+    ],
+    "XFunction": [
+      1
+    ],
+    "XpressInterface": [
+      2
+    ],
+    "ZipMemResource": [
+      1
+    ],
+    "ZipResource": [
+      1
+    ]
+  }
+};
+
+// src/casadi-ops.js
+var OP = Object.fromEntries(Object.entries(scheme_default.operations).map(([name, id]) => [name.slice(3).toLowerCase(), id]));
+
+// src/source.js
+var EncodedSource = class {
+  constructor(text, { lazy = false, maxBytes = 1024 * 1024 * 1024 } = {}) {
+    if (typeof text !== "string") throw Error("Expected .casadi file text");
+    this.text = text.trim();
+    this.byteLength = this.text.length / 2;
+    this.decodedBytes = 0;
+    if (!Number.isSafeInteger(this.byteLength) || this.byteLength > maxBytes) throw Error("Invalid .casadi encoding or file too large");
+    if (!lazy && /[^a-p]/.test(this.text)) throw Error("Invalid .casadi encoding");
+  }
+  byte(offset) {
+    if (!Number.isSafeInteger(offset) || offset < 0 || offset >= this.byteLength) throw Error("Encoded source offset out of bounds");
+    const a = this.text.charCodeAt(2 * offset) - 97, b = this.text.charCodeAt(2 * offset + 1) - 97;
+    if (a < 0 || a > 15 || b < 0 || b > 15) throw Error("Invalid .casadi encoding at byte " + offset);
+    this.decodedBytes++;
+    return a | b << 4;
+  }
+  read(offset, length) {
+    if (!Number.isSafeInteger(length) || length < 0 || offset < 0 || offset + length > this.byteLength) throw Error("Encoded source range out of bounds");
+    return Uint8Array.from({ length }, (_, i) => this.byte(offset + i));
+  }
+  view(offset, length) {
+    return new DataView(this.read(offset, length).buffer);
+  }
+};
+var _source;
+var LazyBlob = class {
+  constructor(source, offset, byteLength) {
+    __privateAdd(this, _source);
+    __privateSet(this, _source, source);
+    this.offset = offset;
+    this.byteLength = byteLength;
+  }
+  read(offset = 0, length = this.byteLength - offset) {
+    if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 || length < 0 || offset + length > this.byteLength) throw Error("Blob slice out of bounds");
+    return __privateGet(this, _source).read(this.offset + offset, length);
+  }
+  toJSON() {
+    return { kind: "deferred_bytes", offset: this.offset, byteLength: this.byteLength, encoding: "casadi-nibbles" };
+  }
+};
+_source = new WeakMap();
+var _file;
+var LazyFileBlob = class {
+  constructor(file, offset, byteLength) {
+    __privateAdd(this, _file);
+    __privateSet(this, _file, file);
+    this.offset = offset;
+    this.byteLength = byteLength;
+  }
+  async read(offset = 0, length = this.byteLength - offset) {
+    if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 || length < 0 || offset + length > this.byteLength) throw Error("Blob slice out of bounds");
+    const text = await __privateGet(this, _file).slice(2 * (this.offset + offset), 2 * (this.offset + offset + length)).text();
+    return new EncodedSource(text).read(0, length);
+  }
+  toJSON() {
+    return { kind: "deferred_file_bytes", offset: this.offset, byteLength: this.byteLength, encoding: "casadi-nibbles" };
+  }
+};
+_file = new WeakMap();
+
+// src/index.js
+var names = new Map(Object.entries(OP).map(([name, id]) => [id, name]));
+var unary = new Set([
+  "neg",
+  "exp",
+  "log",
+  "sqrt",
+  "sq",
+  "twice",
+  "sin",
+  "cos",
+  "tan",
+  "asin",
+  "acos",
+  "atan",
+  "not",
+  "floor",
+  "ceil",
+  "fabs",
+  "sign",
+  "erf",
+  "inv",
+  "sinh",
+  "cosh",
+  "tanh",
+  "asinh",
+  "acosh",
+  "atanh"
+].map((n) => OP[n]));
+var binary = new Set([
+  "add",
+  "sub",
+  "mul",
+  "div",
+  "pow",
+  "constpow",
+  "lt",
+  "le",
+  "eq",
+  "ne",
+  "and",
+  "or",
+  "fmod",
+  "copysign",
+  "if_else_zero",
+  "fmin",
+  "fmax",
+  "atan2"
+].map((n) => OP[n]));
+var mappingOps = /* @__PURE__ */ new Set([OP.getnonzeros, OP.setnonzeros, OP.addnonzeros]);
+var maxItems = 1e6;
+var Reader = class {
+  constructor(text, options = {}) {
+    this.source = new EncodedSource(text, options);
+    this.lazy = !!options.lazy;
+    this.pos = 0;
+    this.shared = [];
+    this.depth = 0;
+    this.length = this.source.byteLength;
+  }
+  fail(message) {
+    throw Error(`.casadi byte ${this.pos}: ${message}`);
+  }
+  take(n) {
+    if (n < 0 || this.pos + n > this.length) this.fail("Truncated file");
+    const p = this.pos;
+    this.pos += n;
+    return p;
+  }
+  byte() {
+    return this.source.byte(this.take(1));
+  }
+  bool() {
+    const b = this.byte();
+    if (b > 1) this.fail("Invalid boolean");
+    return !!b;
+  }
+  int() {
+    return this.source.view(this.take(4), 4).getInt32(0, true);
+  }
+  long() {
+    const n = this.source.view(this.take(8), 8).getBigInt64(0, true);
+    if (n > BigInt(Number.MAX_SAFE_INTEGER) || n < BigInt(Number.MIN_SAFE_INTEGER)) this.fail("Integer outside JavaScript safe range");
+    return Number(n);
+  }
+  double() {
+    return this.source.view(this.take(8), 8).getFloat64(0, true);
+  }
+  count(n) {
+    if (!Number.isSafeInteger(n) || n < 0 || n > maxItems) this.fail("Invalid or excessive collection size");
+    return n;
+  }
+  string() {
+    const n = this.count(this.int()), start = this.take(n);
+    return new TextDecoder("utf-8", { fatal: true }).decode(this.source.read(start, n));
+  }
+  vector(read) {
+    const n = this.count(this.long());
+    return Array.from({ length: n }, () => read.call(this));
+  }
+  blob() {
+    const length = this.long(), offset = this.take(length);
+    return this.lazy ? new LazyBlob(this.source, offset, length) : this.source.read(offset, length);
+  }
+  emptyMap() {
+    if (this.long() !== 0) this.fail("Nonempty option/cache dictionaries are outside this proof of concept");
+    return {};
+  }
+  version(name, expected) {
+    if (!scheme_default.class_versions[name]?.includes(expected)) this.fail(`Vendored scheme does not describe ${name} version ${expected}`);
+    const v = this.int();
+    if (v !== expected) this.fail(`Unsupported ${name} serialization version ${v}; expected ${expected}`);
+  }
+  object(kind, read) {
+    const flag = this.byte();
+    if (flag === 114) {
+      const id = this.long(), entry = this.shared[id];
+      if (!entry || entry.kind !== kind && entry.value !== null) this.fail(`Invalid shared-object reference ${id}: expected ${kind}, got ${entry?.kind}; objects=${this.shared.map((e) => e.kind)}`);
+      return entry.value;
+    }
+    if (flag !== 100) this.fail("Invalid shared-object definition");
+    if (++this.depth > 256) this.fail("Object nesting limit exceeded");
+    const value = read.call(this);
+    --this.depth;
+    if (this.shared.length >= maxItems) this.fail("Too many shared objects");
+    this.shared.push({ kind, value });
+    return value;
+  }
+  sparsity() {
+    return this.object("S", function() {
+      const v = this.vector(this.long);
+      if (!v.length) return null;
+      const [rows, cols] = v;
+      this.count(rows);
+      this.count(cols);
+      const colind = v.slice(2, 3 + cols), row = v.slice(3 + cols);
+      if (colind.length !== cols + 1 || colind[0] !== 0 || colind[cols] !== row.length || colind.some((x, i) => x < 0 || x > row.length || i && x < colind[i - 1]) || row.some((x) => x < 0 || x >= rows)) this.fail("Invalid sparsity");
+      return { shape: [rows, cols], colind, row };
+    });
+  }
+  slice() {
+    return { start: this.long(), stop: this.long(), step: this.long() };
+  }
+  expand(s) {
+    if (!s.step) this.fail("Zero slice step");
+    const n = this.count(Math.max(0, Math.ceil((s.stop - s.start) / s.step)));
+    return Array.from({ length: n }, (_, i) => s.start + i * s.step);
+  }
+  mx() {
+    return this.object("X", function() {
+      const op = this.int(), name = names.get(op) || String(op);
+      let subtype, value;
+      if (binary.has(op)) subtype = this.byte();
+      else if (op === OP.const) {
+        subtype = String.fromCharCode(this.byte());
+        if (subtype === "D") value = this.double();
+        else if (subtype === "I") value = this.long();
+        else if (["0", "1", "-"].includes(subtype)) value = subtype === "-" ? -1 : Number(subtype);
+        else if (subtype !== "a") this.fail(`Unsupported constant subtype ${subtype}`);
+      } else if (mappingOps.has(op)) subtype = String.fromCharCode(this.byte());
+      else if (!unary.has(op) && ![OP.parameter, OP.input, OP.output, OP.reshape, OP.transpose].includes(op)) this.fail(`Unsupported MX operation ${name} (${op})`);
+      const deps = this.vector(this.mx), sp = this.sparsity(), info = {};
+      if (!sp && op !== OP.output) this.fail("Null node sparsity");
+      const node = { op, deps, sp, info };
+      if (unary.has(op) || binary.has(op)) {
+        if (this.int() !== op) this.fail("Inconsistent operation ID");
+      } else if (op === OP.parameter) node.symbol = this.string();
+      else if (op === OP.input || op === OP.output) {
+        info.ind = this.long();
+        info.segment = this.long();
+        info.offset = this.long();
+      } else if (op === OP.const) {
+        node.constants = subtype === "a" ? this.vector(this.double) : Array(sp.row.length).fill(value);
+      } else if (mappingOps.has(op)) {
+        if (subtype === "a") {
+          info.nz = this.vector(this.long);
+          node.mapping = info.nz;
+        } else if (subtype === "b") {
+          info.slice = this.slice();
+          node.mapping = this.expand(info.slice);
+        } else if (subtype === "c") {
+          info.inner = this.slice();
+          info.outer = this.slice();
+          const inner = this.expand(info.inner), outer = this.expand(info.outer);
+          this.count(inner.length * outer.length);
+          node.mapping = outer.flatMap((o) => inner.map((i) => i + o));
+        } else this.fail(`Unsupported mapping subtype ${subtype}`);
+        if (op !== OP.getnonzeros) info.add = op === OP.addnonzeros;
+      }
+      return node;
+    });
+  }
+  function() {
+    return this.object("F", function() {
+      if (this.bool()) return null;
+      const type = this.string();
+      if (type !== "MXFunction") this.fail(`Unsupported function type ${type}; this prototype reads MXFunction`);
+      this.version("ProtoFunction", 2);
+      const name = this.string();
+      for (let i = 0; i < 5; i++) this.bool();
+      this.version("FunctionInternal", 8);
+      this.vector(this.bool);
+      this.vector(this.bool);
+      const ins = this.vector(this.sparsity), outs = this.vector(this.sparsity);
+      const inputNames = this.vector(this.string), outputNames = this.vector(this.string);
+      if (this.bool()) this.fail("JIT functions are unsupported");
+      this.bool();
+      if (this.string() !== "source") this.fail("Linked/embedded JIT libraries are unsupported");
+      this.bool();
+      this.string();
+      this.emptyMap();
+      this.string();
+      this.bool();
+      this.emptyMap();
+      this.function();
+      this.double();
+      for (let i = 0; i < 8; i++) this.bool();
+      this.double();
+      this.double();
+      this.bool();
+      this.bool();
+      this.long();
+      this.bool();
+      this.double();
+      this.string();
+      this.bool();
+      this.bool();
+      this.bool();
+      this.long();
+      this.bool();
+      this.bool();
+      this.string();
+      this.string();
+      for (let i = 0; i < 4; i++) this.emptyMap();
+      this.function();
+      this.vector(this.function);
+      for (let i = 0; i < 8; i++) this.long();
+      this.version("XFunction", 1);
+      const inputNodes = this.vector(this.mx);
+      this.version("MXFunction", 3);
+      const n = this.count(this.long()), instructions = [];
+      for (let i = 0; i < n; i++) instructions.push({ node: this.mx(), arg: this.vector(this.long), res: this.vector(this.long) });
+      this.vector(this.long);
+      this.vector(this.mx);
+      this.vector(this.double);
+      this.bool();
+      this.bool();
+      this.bool();
+      this.vector(this.mx);
+      if (ins.length !== inputNames.length || outs.length !== outputNames.length) this.fail("Invalid function ports");
+      return { name, type, ins, outs, inputNames, outputNames, inputNodes, instructions };
+    });
+  }
+};
+function decodeCasadi(text, options = {}) {
+  const r = new Reader(text, options);
+  if (r.long() !== scheme_default.wire.magic) r.fail("Invalid serialization magic");
+  if (r.long() !== scheme_default.wire.protocol) r.fail("Unsupported serialization protocol");
+  if (r.bool()) r.fail("Debug serialization is outside this proof of concept");
+  if (r.byte() !== 5) r.fail("Expected a serialized Function");
+  const f = r.function();
+  if (!f) r.fail("Null Function");
+  if (r.pos !== r.length) r.fail("Trailing data or unsupported serialization layout");
+  const ids = new Map(r.shared.filter((e) => e.value !== null).map((e, i) => [e.value, i]));
+  const ref = (value) => value === null ? null : ids.get(value);
+  const objects = r.shared.filter((e) => e.value !== null).map(({ kind, value }) => {
+    if (kind === "S") return { kind: "sparsity", ...value };
+    if (kind === "X") return { kind: "mx", ...value, operation: names.get(value.op), ...value.constants ? { constants: value.constants.map(String) } : {}, deps: value.deps.map(ref), sp: ref(value.sp) };
+    if (kind === "F") return {
+      kind: "function",
+      ...value,
+      ins: value.ins.map(ref),
+      outs: value.outs.map(ref),
+      inputNodes: value.inputNodes.map(ref),
+      instructions: value.instructions.map((i) => ({ ...i, node: ref(i.node) }))
+    };
+    throw Error("Unsupported object kind");
+  });
+  return { format: "casadi_json", version: 1, serializationProtocol: 3, root: ref(f), objects };
+}
+function decodeResource(text, options = {}) {
+  return resourceDocument(new Reader(text, options));
+}
+function resourceDocument(r) {
+  if (r.long() !== scheme_default.wire.magic || r.long() !== scheme_default.wire.protocol) r.fail("Unsupported serialization header");
+  if (r.bool()) r.fail("Debug Resource streams are not supported by this entry point");
+  const resource = r.object("R", function() {
+    this.version("ResourceInternal", 1);
+    const type = this.string(), serializeMode = this.string();
+    this.version(type, 1);
+    if (type === "ZipMemResource") return { type, serializeMode, blob: this.blob() };
+    if (type === "ZipResource" || type === "DirResource") return { type, serializeMode, path: this.string() };
+    this.fail("Unsupported resource type " + type);
+  });
+  if (r.pos !== r.length) r.fail("Trailing Resource data");
+  return { format: "casadi_resource", version: 1, resource };
+}
+var readCasadi = decodeCasadi;
+async function openResource(file, { lazy = false, maxBytes = 1024 * 1024 * 1024 } = {}) {
+  if (!Number.isSafeInteger(file.size) || file.size % 2 || file.size / 2 > maxBytes) throw Error("Invalid encoded file size");
+  if (!lazy) return decodeResource(await file.text(), { maxBytes });
+  for (let prefix = 256; ; prefix *= 2) {
+    const text = await file.slice(0, Math.min(file.size, prefix)).text();
+    const reader = new Reader(text, { lazy: true, maxBytes });
+    reader.length = file.size / 2;
+    try {
+      const document = resourceDocument(reader), blob = document.resource.blob;
+      if (blob instanceof LazyBlob) document.resource.blob = new LazyFileBlob(file, blob.offset, blob.byteLength);
+      return document;
+    } catch (error) {
+      if (!/offset out of bounds|range out of bounds/.test(error.message) || prefix >= file.size || prefix >= 1024 * 1024) throw error;
+    }
+  }
+}
+export {
+  LazyBlob,
+  decodeCasadi,
+  decodeResource,
+  openResource,
+  readCasadi
+};