@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-KMKWGXMK.js

@@ -0,0 +1,856 @@
+'use strict';
+
+var chunk4ZDR72SG_js = require('./chunk-4ZDR72SG.js');
+
+// src/interactives/parts/format.ts
+var PART_MAGIC = 1414680643, PART_VERSION = 1, PART_HEADER_BYTES = 8, MANIFEST_MAGIC = 1296126019, MANIFEST_VERSION = 1, MANIFEST_HEADER_BYTES = 24, MANIFEST_PART_BYTES = chunk4ZDR72SG_js.DIGEST_BYTES + 8, SEGMENT_BYTES = 16, MAX_MANIFEST_PARTS = 65535, MAX_ASSET_BYTES = 512 * 1024 * 1024, PartKind = {
+  data: 0,
+  scene: 1,
+  mesh_index: 2,
+  mesh_vertex: 3,
+  skeleton: 4,
+  clip: 5,
+  texture: 6,
+  image: 7,
+  material: 8,
+  audio: 9,
+  shader: 10,
+  kernel: 11,
+  cell: 12,
+  font: 13
+}, PART_KIND_NAMES = Object.keys(PartKind);
+function partKindName(code) {
+  let name = PART_KIND_NAMES[code];
+  if (name === void 0) throw new PartFormatError(`unknown part kind ${code}`);
+  return name;
+}
+var SegmentOp = { literal: 0, part: 1, delta: 2 }, PartFormatError = class extends Error {
+  constructor(message) {
+    super(message), this.name = "PartFormatError";
+  }
+};
+function view(bytes) {
+  return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+function encodePart(kind, body) {
+  let out = new Uint8Array((8) + body.length), v = view(out);
+  return v.setUint32(0, (1414680643), true), v.setUint8(4, (1)), v.setUint8(5, kind), out.set(body, (8)), out;
+}
+function decodePart(payload) {
+  if (payload.length < (8)) throw new PartFormatError("a part is shorter than its header");
+  let v = view(payload);
+  if (v.getUint32(0, true) !== (1414680643)) throw new PartFormatError("not an asset part");
+  if (v.getUint8(4) !== (1)) throw new PartFormatError("unsupported asset part version");
+  let kind = v.getUint8(5);
+  return partKindName(kind), { kind, body: payload.subarray((8)) };
+}
+function isManifest(payload) {
+  return payload.length >= (24) && view(payload).getUint32(0, true) === (1296126019);
+}
+function manifestBytes(manifest) {
+  return (24) + manifest.parts.length * MANIFEST_PART_BYTES + manifest.segments.length * (16) + manifest.literal.length;
+}
+function encodeManifest(manifest) {
+  if (manifest.parts.length > (65535)) throw new PartFormatError(`an asset names ${manifest.parts.length} parts; the limit is ${(65535)}`);
+  let out = new Uint8Array(manifestBytes(manifest)), v = view(out);
+  v.setUint32(0, (1296126019), true), v.setUint8(4, (1)), v.setUint8(5, manifest.kind), v.setUint16(6, manifest.parts.length, true), v.setUint32(8, manifest.length, true), v.setUint32(12, manifest.segments.length, true), v.setUint32(16, manifest.literal.length, true);
+  let at = (24);
+  for (let part of manifest.parts) {
+    if (!chunk4ZDR72SG_js.unhexAt(part.digest, out, at, chunk4ZDR72SG_js.DIGEST_BYTES)) throw new PartFormatError(`part digest ${part.digest} is not 32 hex bytes`);
+    v.setUint8(at + chunk4ZDR72SG_js.DIGEST_BYTES, part.kind), v.setUint32(at + chunk4ZDR72SG_js.DIGEST_BYTES + 4, part.length, true), at += MANIFEST_PART_BYTES;
+  }
+  for (let s of manifest.segments)
+    v.setUint8(at, s.op), v.setUint16(at + 2, s.op === SegmentOp.literal ? 0 : s.part, true), v.setUint32(at + 4, s.offset, true), v.setUint32(at + 8, s.length, true), v.setUint32(at + 12, s.op === SegmentOp.delta ? s.output : s.length, true), at += (16);
+  return out.set(manifest.literal, at), checkManifest(decodeManifest(out)), out;
+}
+function decodeManifest(payload) {
+  if (!isManifest(payload)) throw new PartFormatError("not an asset manifest");
+  let v = view(payload);
+  if (v.getUint8(4) !== (1)) throw new PartFormatError("unsupported asset manifest version");
+  let kind = v.getUint8(5), partCount = v.getUint16(6, true), length = v.getUint32(8, true), segmentCount = v.getUint32(12, true), literalBytes = v.getUint32(16, true), literalAt = (24) + partCount * MANIFEST_PART_BYTES + segmentCount * (16);
+  if (literalAt + literalBytes !== payload.length) throw new PartFormatError("the asset manifest's tables do not match its length");
+  let parts = [], at = (24);
+  for (let p = 0; p < partCount; p++) {
+    let partKind = v.getUint8(at + chunk4ZDR72SG_js.DIGEST_BYTES);
+    partKindName(partKind), parts.push({ digest: chunk4ZDR72SG_js.hexAt(payload, at, chunk4ZDR72SG_js.DIGEST_BYTES), kind: partKind, length: v.getUint32(at + chunk4ZDR72SG_js.DIGEST_BYTES + 4, true) }), at += MANIFEST_PART_BYTES;
+  }
+  let segments = [];
+  for (let s = 0; s < segmentCount; s++) {
+    let op = v.getUint8(at), part = v.getUint16(at + 2, true), offset = v.getUint32(at + 4, true), len = v.getUint32(at + 8, true), output = v.getUint32(at + 12, true);
+    if (op === SegmentOp.literal) segments.push({ op, offset, length: len });
+    else if (op === SegmentOp.part) segments.push({ op, part, offset, length: len });
+    else if (op === SegmentOp.delta) segments.push({ op, part, offset, length: len, output });
+    else throw new PartFormatError(`unknown segment op ${op}`);
+    at += (16);
+  }
+  let manifest = { kind, length, parts, segments, literal: payload.subarray(literalAt) };
+  return checkManifest(manifest), manifest;
+}
+function segmentOutput(segment) {
+  return segment.op === SegmentOp.delta ? segment.output : segment.length;
+}
+function checkManifest(manifest) {
+  if (manifest.length > MAX_ASSET_BYTES) throw new PartFormatError(`an asset of ${manifest.length} bytes is larger than the ${MAX_ASSET_BYTES} byte limit`);
+  let total = 0;
+  for (let s of manifest.segments) {
+    if (s.op === SegmentOp.literal) {
+      if (s.offset + s.length > manifest.literal.length) throw new PartFormatError("a literal segment runs past the manifest's literal bytes");
+    } else {
+      let part = manifest.parts[s.part];
+      if (part === void 0) throw new PartFormatError(`a segment names part ${s.part} of ${manifest.parts.length}`);
+      if (s.op === SegmentOp.part && s.offset + s.length > part.length) throw new PartFormatError("a part segment runs past its part");
+      if (s.op === SegmentOp.delta && s.offset + s.length > manifest.literal.length) throw new PartFormatError("a delta segment runs past the manifest's literal bytes");
+    }
+    total += segmentOutput(s);
+  }
+  if (total !== manifest.length) throw new PartFormatError(`the asset manifest's segments make ${total} bytes, not ${manifest.length}`);
+}
+
+// src/interactives/parts/delta.ts
+var DeltaOp = { copy: 0, insert: 1, table: 2, map: 3, fill: 4 }, WINDOW = 32, INDEX_STEP = 8, MIN_MAP_RUN = 8, MIN_FILL_RUN = 16, MAX_STRIDE = 4, TABLE_ENTRIES = 256, UNSET = -1, HASH_BASE = 16777619, EMPTY_SLOT = -1, Writer = class {
+  constructor(capacity) {
+    this.length = 0;
+    this.buffer = new Uint8Array(Math.max(64, capacity));
+  }
+  reserve(bytes) {
+    if (this.length + bytes <= this.buffer.length) return;
+    let next = new Uint8Array(Math.max(this.buffer.length * 2, this.length + bytes));
+    next.set(this.buffer.subarray(0, this.length)), this.buffer = next;
+  }
+  byte(value) {
+    this.reserve(1), this.buffer[this.length++] = value;
+  }
+  varint(value) {
+    this.reserve(5);
+    let v = value >>> 0;
+    for (; v >= 128; )
+      this.buffer[this.length++] = v & 127 | 128, v >>>= 7;
+    this.buffer[this.length++] = v;
+  }
+  bytes(source) {
+    this.reserve(source.length), this.buffer.set(source, this.length), this.length += source.length;
+  }
+  done() {
+    return this.buffer.slice(0, this.length);
+  }
+}, Reader = class {
+  constructor(bytes) {
+    this.bytes = bytes;
+    this.at = 0;
+  }
+  get done() {
+    return this.at >= this.bytes.length;
+  }
+  byte() {
+    if (this.at >= this.bytes.length) throw new PartFormatError("a delta ends inside an operation");
+    return this.bytes[this.at++];
+  }
+  varint() {
+    let value = 0, shift = 0;
+    for (; ; ) {
+      let b = this.byte();
+      if (value += (b & 127) * 2 ** shift, (b & 128) === 0) return value;
+      if (shift += 7, shift > 28) throw new PartFormatError("a delta varint is too long");
+    }
+  }
+  take(length) {
+    if (this.at + length > this.bytes.length) throw new PartFormatError("a delta literal runs past its end");
+    let out = this.bytes.subarray(this.at, this.at + length);
+    return this.at += length, out;
+  }
+};
+function applyDelta(base, delta, out, at, length) {
+  let r = new Reader(delta), end = at + length;
+  if (end > out.length) throw new PartFormatError("a delta writes past its target");
+  let stride = 0, table = null, o = at;
+  for (; !r.done; ) {
+    let op = r.byte();
+    if (op === DeltaOp.copy) {
+      let offset = r.varint(), n = r.varint();
+      if (offset + n > base.length || o + n > end) throw new PartFormatError("a delta copy runs out of bounds");
+      out.set(base.subarray(offset, offset + n), o), o += n;
+    } else if (op === DeltaOp.insert) {
+      let n = r.varint();
+      if (o + n > end) throw new PartFormatError("a delta insert runs past its target");
+      out.set(r.take(n), o), o += n;
+    } else if (op === DeltaOp.table) {
+      if (stride = r.byte(), stride < 1 || stride > (4)) throw new PartFormatError(`a delta table has stride ${stride}`);
+      table = r.take(stride * (256));
+    } else if (op === DeltaOp.map) {
+      let offset = r.varint(), n = r.varint();
+      if (table === null) throw new PartFormatError("a delta maps before it declares a table");
+      if (offset + n > base.length || o + n > end) throw new PartFormatError("a delta map runs out of bounds");
+      for (let i = 0; i < n; i++) {
+        let p = offset + i;
+        out[o + i] = table[p % stride * (256) + base[p]];
+      }
+      o += n;
+    } else if (op === DeltaOp.fill) {
+      let n = r.varint(), value = r.byte();
+      if (o + n > end) throw new PartFormatError("a delta fill runs past its target");
+      out.fill(value, o, o + n), o += n;
+    } else
+      throw new PartFormatError(`unknown delta op ${op}`);
+  }
+  if (o !== end) throw new PartFormatError(`a delta made ${o - at} bytes, not ${length}`);
+}
+function emitLiteral(w, target, from, to) {
+  let start = from, i = from;
+  for (; i < to; ) {
+    let run = i + 1;
+    for (; run < to && target[run] === target[i]; ) run++;
+    run - i >= (16) && (i > start && (w.byte(DeltaOp.insert), w.varint(i - start), w.bytes(target.subarray(start, i))), w.byte(DeltaOp.fill), w.varint(run - i), w.byte(target[i]), start = run), i = run;
+  }
+  to > start && (w.byte(DeltaOp.insert), w.varint(to - start), w.bytes(target.subarray(start, to)));
+}
+function hashAt(bytes, at) {
+  let h = 0;
+  for (let i = 0; i < (32); i++) h = Math.imul(h, (16777619)) + bytes[at + i] | 0;
+  return h;
+}
+function topPower() {
+  let p = 1;
+  for (let i = 0; i < (32) - 1; i++) p = Math.imul(p, (16777619));
+  return p;
+}
+var TOP = topPower();
+function mix(h) {
+  let x = h ^ h >>> 16;
+  return x = Math.imul(x, 73244475), x ^ x >>> 16;
+}
+function indexBase(base) {
+  let entries = Math.max(1, Math.floor((base.length - (32)) / (8)) + 1), size = 1;
+  for (; size < entries * 2; ) size <<= 1;
+  let slots = new Int32Array(size).fill((-1)), mask = size - 1;
+  for (let p = 0; p + (32) <= base.length; p += (8)) {
+    let slot = mix(hashAt(base, p)) & mask;
+    for (; slots[slot] !== (-1) && hashAt(base, slots[slot]) !== hashAt(base, p); )
+      slot = slot + 1 & mask;
+    slots[slot] === (-1) && (slots[slot] = p);
+  }
+  return { slots, mask };
+}
+function lookup(base, index, hash) {
+  let slot = mix(hash) & index.mask;
+  for (; ; ) {
+    let p = index.slots[slot];
+    if (p === (-1)) return (-1);
+    if (hashAt(base, p) === hash) return p;
+    slot = slot + 1 & index.mask;
+  }
+}
+function copyDelta(base, target) {
+  let w = new Writer(target.length >>> 3);
+  if (base.length < (32) || target.length < (32))
+    return emitLiteral(w, target, 0, target.length), w.done();
+  let index = indexBase(base), pending = 0, i = 0, h = hashAt(target, 0);
+  for (; i + (32) <= target.length; ) {
+    let candidate = lookup(base, index, h), matched = 0, back = 0;
+    if (candidate !== (-1)) {
+      for (; candidate + matched < base.length && i + matched < target.length && base[candidate + matched] === target[i + matched]; ) matched++;
+      if (matched >= (32))
+        for (; back < i - pending && back < candidate && base[candidate - back - 1] === target[i - back - 1]; ) back++;
+    }
+    if (matched >= (32)) {
+      emitLiteral(w, target, pending, i - back), w.byte(DeltaOp.copy), w.varint(candidate - back), w.varint(matched + back), i += matched, pending = i, i + (32) <= target.length && (h = hashAt(target, i));
+      continue;
+    }
+    i + (32) < target.length && (h = Math.imul(h - Math.imul(target[i], TOP), (16777619)) + target[i + (32)] | 0), i++;
+  }
+  return emitLiteral(w, target, pending, target.length), w.done();
+}
+function remapDelta(base, target) {
+  if (base.length !== target.length || base.length < (256)) return null;
+  let best = null;
+  for (let stride2 = 1; stride2 <= (4); stride2++) {
+    let table2 = new Int16Array(stride2 * (256)).fill((-1)), misses = 0;
+    for (let p2 = 0; p2 < base.length; p2++) {
+      let slot = p2 % stride2 * (256) + base[p2];
+      table2[slot] === (-1) ? table2[slot] = target[p2] : table2[slot] !== target[p2] && misses++;
+    }
+    if ((best === null || misses < best.misses) && (best = { stride: stride2, table: table2, misses }), misses === 0) break;
+  }
+  if (best === null) return null;
+  let { stride, table } = best, w = new Writer(stride * (256) + best.misses * 2 + 16);
+  w.byte(DeltaOp.table), w.byte(stride);
+  let bytes = new Uint8Array(stride * (256));
+  for (let s = 0; s < bytes.length; s++) bytes[s] = table[s] === (-1) ? 0 : table[s];
+  w.bytes(bytes);
+  let fits2 = (p2) => bytes[p2 % stride * (256) + base[p2]] === target[p2], p = 0, literalStart = 0;
+  for (; p < target.length; ) {
+    if (!fits2(p)) {
+      p++;
+      continue;
+    }
+    let run = p;
+    for (; run < target.length && fits2(run); ) run++;
+    (run - p >= (8) || p === literalStart && run === target.length) && (emitLiteral(w, target, literalStart, p), w.byte(DeltaOp.map), w.varint(p), w.varint(run - p), literalStart = run), p = run;
+  }
+  return emitLiteral(w, target, literalStart, target.length), w.done();
+}
+function encodeDelta(base, target, limit = target.length) {
+  let copy2 = copyDelta(base, target), remap = remapDelta(base, target), best = remap !== null && remap.length < copy2.length ? remap : copy2;
+  return best.length < limit ? best : null;
+}
+
+// src/interactives/parts/assemble.ts
+function assembleInto(manifest, body, out, at = 0) {
+  if (at + manifest.length > out.length) throw new PartFormatError("the assembly target is smaller than the asset");
+  let o = at;
+  for (let s of manifest.segments) {
+    if (s.op === SegmentOp.literal) {
+      out.set(manifest.literal.subarray(s.offset, s.offset + s.length), o), o += s.length;
+      continue;
+    }
+    let part = body(s.part);
+    if (part.length !== manifest.parts[s.part].length) throw new PartFormatError(`part ${manifest.parts[s.part].digest} is ${part.length} bytes, not ${manifest.parts[s.part].length}`);
+    s.op === SegmentOp.part ? (out.set(part.subarray(s.offset, s.offset + s.length), o), o += s.length) : (applyDelta(part, manifest.literal.subarray(s.offset, s.offset + s.length), out, o, s.output), o += s.output);
+  }
+}
+function soleSpan(manifest) {
+  if (manifest.segments.length !== 1) return null;
+  let s = manifest.segments[0];
+  return s.op === SegmentOp.part ? { part: s.part, offset: s.offset } : null;
+}
+function assemble(manifest, body) {
+  let sole = soleSpan(manifest);
+  if (sole !== null)
+    return body(sole.part).subarray(sole.offset, sole.offset + manifest.length);
+  let out = new Uint8Array(manifest.length);
+  return assembleInto(manifest, body, out, 0), out;
+}
+
+// src/interactives/progressive/format.ts
+var PROGRESSIVE_MAGIC = 1196576835, PROGRESSIVE_VERSION = 1, HEADER_BYTES = 32, LEVEL_BYTES = 8, UNIT_BYTES = 12, SEGMENT_BYTES2 = 12, PATCH_BYTES = 16, PPM = 1e6, MAX_PROGRESSIVE_BYTES = 2147483647, MAX_PROGRESSIVE_DECODE_BYTES = MAX_ASSET_BYTES, Header = {
+  magic: 0,
+  version: 4,
+  kind: 5,
+  levels: 6,
+  output: 8,
+  units: 12,
+  segments: 16,
+  patches: 20,
+  table: 24,
+  staging: 28
+}, ProgressiveKind = {
+  opaque: 0,
+  texture: 1,
+  mesh: 2,
+  splat: 3,
+  audio: 4,
+  cells: 5
+}, KIND_NAMES = Object.keys(ProgressiveKind);
+function progressiveKindName(code) {
+  let name = KIND_NAMES[code];
+  if (name === void 0) throw new ProgressiveFormatError(`unknown progressive kind ${code}`);
+  return name;
+}
+var SEGMENT_STAGED = 1, PatchOp = {
+  write: 0,
+  staged: 1,
+  merge: 2,
+  unlift: 3,
+  length: 4,
+  fill: 5
+}, FILL_BYTE_MAX = 255, MERGE_PARAM_BYTES = 12, UNLIFT_PARAM_BYTES = 12, SAMPLE_BYTES = 2, ProgressiveFormatError = class extends Error {
+  constructor(message) {
+    super(message), this.name = "ProgressiveFormatError";
+  }
+}, TableWriter = class {
+  constructor() {
+    this.chunks = [];
+    this.length = 0;
+  }
+  bytes(data) {
+    let at = this.length;
+    return this.chunks.push(data), this.length += data.length, at;
+  }
+  words(...values) {
+    let data = new Uint8Array(values.length * 4), v = new DataView(data.buffer);
+    for (let i = 0; i < values.length; i++) v.setUint32(i * 4, values[i], true);
+    return this.bytes(data);
+  }
+  finish() {
+    let out = new Uint8Array(this.length), at = 0;
+    for (let c of this.chunks)
+      out.set(c, at), at += c.length;
+    return out;
+  }
+};
+function writePatch(table, dest, data) {
+  return { op: PatchOp.write, a: dest, b: table.bytes(data), c: data.length };
+}
+function headBytes(levels, units, segments, patches, table) {
+  return (32) + levels * (8) + units * (12) + segments * (12) + patches * (16) + table;
+}
+var ProgressiveLayout = class {
+  constructor() {
+    this.kind = ProgressiveKind.opaque;
+    this.output = 0;
+    this.levels = 0;
+    this.units = 0;
+    this.segments = 0;
+    this.patches = 0;
+    this.table = 0;
+    this.staging = 0;
+    this.levelsAt = 0;
+    this.unitsAt = 0;
+    this.segmentsAt = 0;
+    this.patchesAt = 0;
+    this.tableAt = 0;
+    this.head = 0;
+  }
+};
+function readLayout(view2, into = new ProgressiveLayout()) {
+  if (view2.byteLength < (32)) throw new ProgressiveFormatError("a progressive container is shorter than its header");
+  if (view2.getUint32(Header.magic, true) !== (1196576835)) throw new ProgressiveFormatError("not a progressive container");
+  if (view2.getUint8(Header.version) !== (1)) throw new ProgressiveFormatError("unsupported progressive container version");
+  let kind = view2.getUint8(Header.kind);
+  if (kind >= KIND_NAMES.length) throw new ProgressiveFormatError("unknown progressive kind");
+  let levels = view2.getUint16(Header.levels, true), units = view2.getUint32(Header.units, true), segments = view2.getUint32(Header.segments, true), patches = view2.getUint32(Header.patches, true), table = view2.getUint32(Header.table, true), head = headBytes(levels, units, segments, patches, table);
+  if (levels === 0 || units < levels || head > (2147483647)) throw new ProgressiveFormatError("the progressive container's tables are malformed");
+  let output = view2.getUint32(Header.output, true), staging = view2.getUint32(Header.staging, true);
+  if (head + output + staging > MAX_PROGRESSIVE_DECODE_BYTES) throw new ProgressiveFormatError("a progressive container decodes to more than the format allows");
+  return into.kind = kind, into.output = output, into.levels = levels, into.units = units, into.segments = segments, into.patches = patches, into.table = table, into.staging = staging, into.levelsAt = (32), into.unitsAt = into.levelsAt + levels * (8), into.segmentsAt = into.unitsAt + units * (12), into.patchesAt = into.segmentsAt + segments * (12), into.tableAt = into.patchesAt + patches * (16), into.head = head, into;
+}
+function fits(at, length, limit) {
+  return at >= 0 && length >= 0 && at + length <= limit;
+}
+function checkLayout(view2, l) {
+  let unitsEnd = 0, quality = 0;
+  for (let i = 0; i < l.levels; i++) {
+    let at = l.levelsAt + i * (8), end = view2.getUint32(at, true), q = view2.getUint32(at + 4, true);
+    if (end <= unitsEnd || end > l.units || q < quality || q > (1e6)) throw new ProgressiveFormatError(`progressive level ${i} is malformed`);
+    unitsEnd = end, quality = q;
+  }
+  if (unitsEnd !== l.units || quality !== (1e6)) throw new ProgressiveFormatError("the progressive levels do not end at full quality");
+  let segmentsEnd = 0, patchesEnd = 0;
+  quality = 0;
+  for (let u = 0; u < l.units; u++) {
+    let at = l.unitsAt + u * (12), s = view2.getUint32(at, true), p = view2.getUint32(at + 4, true), q = view2.getUint32(at + 8, true);
+    if (s < segmentsEnd || s > l.segments || p < patchesEnd || p > l.patches || q < quality || q > (1e6)) throw new ProgressiveFormatError(`progressive unit ${u} is malformed`);
+    segmentsEnd = s, patchesEnd = p, quality = q;
+  }
+  if (segmentsEnd !== l.segments || patchesEnd !== l.patches) throw new ProgressiveFormatError("the progressive units do not cover every segment and patch");
+  for (let s = 0; s < l.segments; s++) {
+    let at = l.segmentsAt + s * (12), dest = view2.getUint32(at, true), length = view2.getUint32(at + 4, true), staged = (view2.getUint32(at + 8, true) & (1)) !== 0;
+    if (!fits(dest, length, staged ? l.staging : l.output)) throw new ProgressiveFormatError(`progressive segment ${s} writes outside its target`);
+  }
+  for (let p = 0; p < l.patches; p++) {
+    let at = l.patchesAt + p * (16), op = view2.getUint8(at), a = view2.getUint32(at + 4, true), b = view2.getUint32(at + 8, true), c = view2.getUint32(at + 12, true);
+    if (op === PatchOp.write) {
+      if (!fits(a, c, l.output) || !fits(b, c, l.table)) throw new ProgressiveFormatError(`progressive patch ${p} is out of range`);
+    } else if (op === PatchOp.staged) {
+      if (!fits(a, c, l.output) || !fits(b, c, l.staging)) throw new ProgressiveFormatError(`progressive patch ${p} is out of range`);
+    } else if (op === PatchOp.merge) {
+      if (!fits(c, (12), l.table)) throw new ProgressiveFormatError(`progressive patch ${p} is out of range`);
+      let count = view2.getUint32(l.tableAt + c, true), element = view2.getUint32(l.tableAt + c + 4, true), step = view2.getUint32(l.tableAt + c + 8, true);
+      if (step < 2 || element === 0 || !fits(a, count * element, l.output) || !fits(b, (count - coarseKeys(count, step)) * element, l.staging))
+        throw new ProgressiveFormatError(`progressive patch ${p} merges outside its target`);
+    } else if (op === PatchOp.unlift) {
+      if (!fits(c, (12), l.table)) throw new ProgressiveFormatError(`progressive patch ${p} is out of range`);
+      let low = view2.getUint32(l.tableAt + c, true), frames = view2.getUint32(l.tableAt + c + 4, true), channels = view2.getUint32(l.tableAt + c + 8, true);
+      if (channels === 0 || low !== Math.ceil(frames / 2) || !fits(a, frames * channels * (2), l.output) || !fits(b, (frames - low) * channels * (2), l.staging))
+        throw new ProgressiveFormatError(`progressive patch ${p} lifts outside its target`);
+    } else if (op === PatchOp.length) {
+      if (a === 0 || a > l.output) throw new ProgressiveFormatError(`progressive patch ${p} sets a length outside the output`);
+    } else if (op === PatchOp.fill) {
+      if (b > (255) || !fits(a, c, l.output)) throw new ProgressiveFormatError(`progressive patch ${p} fills outside the output`);
+    } else
+      throw new ProgressiveFormatError(`unknown progressive patch op ${op}`);
+  }
+}
+function coarseKeys(count, step) {
+  if (count === 0) return 0;
+  let last = count - 1;
+  return Math.floor(last / step) + 1 + (last % step === 0 ? 0 : 1);
+}
+function isCoarseKey(index, count, step) {
+  return index % step === 0 || index === count - 1;
+}
+function encodeContainer(plan) {
+  let units = plan.levels.flat(), segments = units.flatMap((u) => u.segments), patches = units.flatMap((u) => u.patches), staging = 0, payload = 0;
+  for (let s of segments)
+    s.staged === true && (staging = Math.max(staging, s.dest + s.bytes.length)), payload += s.bytes.length;
+  let head = headBytes(plan.levels.length, units.length, segments.length, patches.length, plan.table.length);
+  if (head + payload > (2147483647) || head + plan.output + staging > MAX_PROGRESSIVE_DECODE_BYTES) throw new ProgressiveFormatError("a progressive container is larger than the format allows");
+  let out = new Uint8Array(head + payload), v = new DataView(out.buffer);
+  v.setUint32(Header.magic, (1196576835), true), v.setUint8(Header.version, (1)), v.setUint8(Header.kind, plan.kind), v.setUint16(Header.levels, plan.levels.length, true), v.setUint32(Header.output, plan.output, true), v.setUint32(Header.units, units.length, true), v.setUint32(Header.segments, segments.length, true), v.setUint32(Header.patches, patches.length, true), v.setUint32(Header.table, plan.table.length, true), v.setUint32(Header.staging, staging, true);
+  let layout = readLayout(v), unitCount = 0, segmentCount = 0, patchCount = 0, stream = head, levelEnds = [], unitEnds = [];
+  for (let l = 0; l < plan.levels.length; l++) {
+    let level = plan.levels[l];
+    for (let unit of level) {
+      for (let s of unit.segments) {
+        let at3 = layout.segmentsAt + segmentCount * (12);
+        v.setUint32(at3, s.dest, true), v.setUint32(at3 + 4, s.bytes.length, true), v.setUint32(at3 + 8, s.staged === true ? (1) : 0, true), out.set(s.bytes, stream), stream += s.bytes.length, segmentCount++;
+      }
+      for (let p of unit.patches) {
+        let at3 = layout.patchesAt + patchCount * (16);
+        v.setUint8(at3, p.op), v.setUint32(at3 + 4, p.a, true), v.setUint32(at3 + 8, p.b, true), v.setUint32(at3 + 12, p.c, true), patchCount++;
+      }
+      let at2 = layout.unitsAt + unitCount * (12);
+      v.setUint32(at2, segmentCount, true), v.setUint32(at2 + 4, patchCount, true), v.setUint32(at2 + 8, Math.round(unit.quality), true), unitCount++, unitEnds.push(stream);
+    }
+    let at = layout.levelsAt + l * (8);
+    v.setUint32(at, unitCount, true), v.setUint32(at + 4, Math.round(level[level.length - 1]?.quality ?? 0), true), levelEnds.push(stream);
+  }
+  return out.set(plan.table, layout.tableAt), checkLayout(v, layout), { bytes: out, head, first: levelEnds[0], levelEnds, unitEnds };
+}
+function containerBounds(bytes) {
+  if (!isProgressive(bytes)) return null;
+  let view2 = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength), layout;
+  try {
+    if (layout = readLayout(view2), layout.head > bytes.length) return null;
+    checkLayout(view2, layout);
+  } catch {
+    return null;
+  }
+  let unitEnds = [], at = layout.head, segment = 0;
+  for (let u = 0; u < layout.units; u++) {
+    let end = view2.getUint32(layout.unitsAt + u * (12), true);
+    for (; segment < end; segment++) at += view2.getUint32(layout.segmentsAt + segment * (12) + 4, true);
+    unitEnds.push(at);
+  }
+  if (at !== bytes.length) return null;
+  let baseUnits = view2.getUint32(layout.levelsAt, true);
+  return { kind: layout.kind, head: layout.head, first: unitEnds[baseUnits - 1], unitEnds };
+}
+function isProgressive(bytes) {
+  return bytes.length >= (32) && bytes[0] === 67 && bytes[1] === 80 && bytes[2] === 82 && bytes[3] === 71;
+}
+
+// src/interactives/progressive/lift.ts
+function wrap16(value) {
+  return value << 16 >> 16;
+}
+function liftForward(samples, frames, channels) {
+  let lowFrames = Math.ceil(frames / 2), detailFrames = frames - lowFrames, low = new Int16Array(lowFrames * channels), detail = new Int16Array(detailFrames * channels);
+  for (let c = 0; c < channels; c++) {
+    for (let i = 0; i < lowFrames; i++) low[i * channels + c] = samples[2 * i * channels + c];
+    for (let i = 0; i < detailFrames; i++) {
+      let s = low[i * channels + c], right = i + 1 < lowFrames ? low[(i + 1) * channels + c] : s;
+      detail[i * channels + c] = wrap16(samples[(2 * i + 1) * channels + c] - (s + right >> 1));
+    }
+    if (detailFrames !== 0)
+      for (let i = 0; i < lowFrames; i++) {
+        let left = detail[Math.max(0, i - 1) * channels + c], right = detail[Math.min(detailFrames - 1, i) * channels + c];
+        low[i * channels + c] = wrap16(low[i * channels + c] + (left + right + 2 >> 2));
+      }
+  }
+  return { low, detail };
+}
+function unliftInPlace(out, at, staging, detailAt, lowFrames, frames, channels, sampleBytes) {
+  let detailFrames = frames - lowFrames, frameBytes = channels * sampleBytes;
+  for (let c = 0; c < channels; c++) {
+    let lane = at + c * sampleBytes, detailLane = detailAt + c * sampleBytes, nextEven = 0;
+    for (let i = lowFrames - 1; i >= 0; i--) {
+      let even = out.getInt16(lane + i * frameBytes, true);
+      if (detailFrames > 0) {
+        let left = staging.getInt16(detailLane + Math.max(0, i - 1) * frameBytes, true), right = staging.getInt16(detailLane + Math.min(detailFrames - 1, i) * frameBytes, true);
+        even = wrap16(even - (left + right + 2 >> 2));
+      }
+      if (i < detailFrames) {
+        let right = i + 1 < lowFrames ? nextEven : even, odd = wrap16(staging.getInt16(detailLane + i * frameBytes, true) + (even + right >> 1));
+        out.setInt16(lane + (2 * i + 1) * frameBytes, odd, true);
+      }
+      out.setInt16(lane + 2 * i * frameBytes, even, true), nextEven = even;
+    }
+  }
+}
+
+// src/interactives/progressive/decoder.ts
+var NOT_KNOWN = -1, VIEW_CACHE = 8, EMPTY = new Uint8Array(0);
+function copy(dst, d, src, s, n) {
+  if (s === 0 && n === src.length) {
+    dst.set(src, d);
+    return;
+  }
+  for (let i = 0; i < n; i++) dst[d + i] = src[s + i];
+}
+var ProgressiveDecoder = class {
+  constructor() {
+    this.head = new Uint8Array((32));
+    this.headView = new DataView(this.head.buffer);
+    this.headLength = 0;
+    this.headNeeded = (32);
+    this.shape = new ProgressiveLayout();
+    this.layout = null;
+    this.out = EMPTY;
+    this.outView = new DataView(this.out.buffer);
+    this.view = null;
+    this.views = Array.from({ length: (8) }, () => null);
+    this.nextView = 0;
+    this.staging = EMPTY;
+    this.stagingView = new DataView(this.staging.buffer);
+    this.segment = 0;
+    this.segmentDone = 0;
+    this.unit = 0;
+    this.levelIndex = 0;
+    this.consumed = 0;
+    this.first = (-1);
+    this.full = (-1);
+    this.ppm = 0;
+  }
+  get ready() {
+    return this.layout !== null;
+  }
+  get usable() {
+    return this.levelIndex > 0;
+  }
+  get done() {
+    return this.layout !== null && this.unit === this.layout.units;
+  }
+  get kind() {
+    return this.layout?.kind ?? null;
+  }
+  get output() {
+    return this.levelIndex > 0 ? this.view : null;
+  }
+  get quality() {
+    return this.ppm;
+  }
+  get level() {
+    return this.levelIndex;
+  }
+  get levels() {
+    return this.layout?.levels ?? 0;
+  }
+  get units() {
+    return this.unit;
+  }
+  get received() {
+    return this.consumed;
+  }
+  get firstBytes() {
+    return this.first;
+  }
+  get fullBytes() {
+    return this.full;
+  }
+  get outputBytes() {
+    return this.layout?.output ?? (-1);
+  }
+  levelEndBytes(level) {
+    let l = this.layout;
+    if (l === null || level < 0 || level >= l.levels) return (-1);
+    let unitEnd = this.headView.getUint32(l.levelsAt + level * (8), true), segmentEnd = this.headView.getUint32(l.unitsAt + (unitEnd - 1) * (12), true), bytes = l.head;
+    for (let s = 0; s < segmentEnd; s++) bytes += this.headView.getUint32(l.segmentsAt + s * (12) + 4, true);
+    return bytes;
+  }
+  reset() {
+    this.headLength = 0, this.headNeeded = (32), this.layout = null, this.segment = 0, this.segmentDone = 0, this.unit = 0, this.levelIndex = 0, this.consumed = 0, this.first = (-1), this.full = (-1), this.ppm = 0;
+  }
+  push(src, start = 0, end = src.length) {
+    let at = start, completed = 0;
+    for (; at < end; ) {
+      let layout = this.layout;
+      if (layout === null) {
+        let take2 = Math.min(end - at, this.headNeeded - this.headLength);
+        copy(this.head, this.headLength, src, at, take2), this.headLength += take2, at += take2, this.consumed += take2, this.headLength === this.headNeeded && (completed += this.openHead());
+        continue;
+      }
+      if (this.segment >= layout.segments) break;
+      let record = layout.segmentsAt + this.segment * (12), dest = this.headView.getUint32(record, true), length = this.headView.getUint32(record + 4, true), staged = (this.headView.getUint32(record + 8, true) & (1)) !== 0, take = Math.min(end - at, length - this.segmentDone);
+      copy(staged ? this.staging : this.out, dest + this.segmentDone, src, at, take), this.segmentDone += take, at += take, this.consumed += take, this.segmentDone === length && (this.segment++, this.segmentDone = 0, completed += this.settle());
+    }
+    return completed;
+  }
+  viewOf(length) {
+    for (let i = 0; i < (8); i++) {
+      let cached = this.views[i];
+      if (cached !== null && cached.length === length) return cached;
+    }
+    let view2 = this.out.subarray(0, length);
+    return this.views[this.nextView] = view2, this.nextView = (this.nextView + 1) % (8), view2;
+  }
+  ensureHead(size) {
+    if (this.head.length >= size) return;
+    let grown = new Uint8Array(size);
+    grown.set(this.head.subarray(0, this.headLength)), this.head = grown, this.headView = new DataView(grown.buffer);
+  }
+  openHead() {
+    if (this.headNeeded === (32)) {
+      let size = readLayout(this.headView, this.shape).head;
+      if (size > (32))
+        return this.ensureHead(size), this.headNeeded = size, 0;
+    }
+    let layout = readLayout(this.headView, this.shape);
+    checkLayout(this.headView, layout), this.out.length < layout.output ? (this.out = new Uint8Array(layout.output), this.outView = new DataView(this.out.buffer), this.views.fill(null)) : this.out.fill(0, 0, layout.output), this.view = this.viewOf(layout.output), this.staging.length < layout.staging && (this.staging = new Uint8Array(layout.staging), this.stagingView = new DataView(this.staging.buffer)), this.layout = layout;
+    let payload = 0;
+    for (let s = 0; s < layout.segments; s++) payload += this.headView.getUint32(layout.segmentsAt + s * (12) + 4, true);
+    return this.full = layout.head + payload, this.first = this.levelEndBytes(0), this.settle();
+  }
+  settle() {
+    let l = this.layout;
+    if (l === null) return 0;
+    for (; this.segment < l.segments && this.headView.getUint32(l.segmentsAt + this.segment * (12) + 4, true) === 0; ) this.segment++;
+    let completed = 0;
+    for (; this.unit < l.units; ) {
+      let record = l.unitsAt + this.unit * (12);
+      if (this.segment < this.headView.getUint32(record, true)) break;
+      let firstPatch = this.unit === 0 ? 0 : this.headView.getUint32(record - (12) + 4, true), lastPatch = this.headView.getUint32(record + 4, true);
+      for (let p = firstPatch; p < lastPatch; p++) this.apply(l, l.patchesAt + p * (16));
+      for (this.ppm = this.headView.getUint32(record + 8, true), this.unit++, completed++; this.levelIndex < l.levels && this.unit >= this.headView.getUint32(l.levelsAt + this.levelIndex * (8), true); ) this.levelIndex++;
+    }
+    return completed;
+  }
+  apply(l, record) {
+    let h = this.headView, op = h.getUint8(record), a = h.getUint32(record + 4, true), b = h.getUint32(record + 8, true), c = h.getUint32(record + 12, true);
+    if (op === PatchOp.write)
+      copy(this.out, a, this.head, l.tableAt + b, c);
+    else if (op === PatchOp.staged)
+      copy(this.out, a, this.staging, b, c);
+    else if (op === PatchOp.merge) {
+      let count = h.getUint32(l.tableAt + c, true), element = h.getUint32(l.tableAt + c + 4, true), step = h.getUint32(l.tableAt + c + 8, true), coarse = coarseKeys(count, step) - 1, rest = count - coarse - 2;
+      for (let i = count - 1; i >= 0; i--) {
+        let to = a + i * element;
+        if (isCoarseKey(i, count, step)) {
+          let from = a + coarse * element;
+          from !== to && this.out.copyWithin(to, from, from + element), coarse--;
+        } else
+          copy(this.out, to, this.staging, b + rest * element, element), rest--;
+      }
+    } else if (op === PatchOp.length)
+      this.view = this.viewOf(a);
+    else if (op === PatchOp.fill)
+      this.out.fill(b, a, a + c);
+    else {
+      let low = h.getUint32(l.tableAt + c, true), frames = h.getUint32(l.tableAt + c + 4, true), channels = h.getUint32(l.tableAt + c + 8, true);
+      unliftInPlace(this.outView, a, this.stagingView, b, low, frames, channels, (2));
+    }
+  }
+};
+function decodeProgressive(container) {
+  let decoder = new ProgressiveDecoder();
+  decoder.push(container);
+  let output = decoder.output;
+  if (!decoder.done || output === null) throw new ProgressiveFormatError("the progressive container is truncated");
+  return output;
+}
+
+// src/interactives/progressive/load.ts
+var ProgressiveCancelled = class extends Error {
+  constructor(asset) {
+    super(`the progressive load of ${asset} was cancelled`);
+    this.asset = asset;
+    this.name = "ProgressiveCancelled";
+  }
+};
+function settled() {
+  let resolve = () => {
+  }, reject = () => {
+  }, promise = new Promise((ok, fail) => {
+    resolve = ok, reject = fail;
+  });
+  return promise.catch(() => {
+  }), { promise, resolve, reject };
+}
+var ProgressiveFeed = class {
+  constructor(asset, listener) {
+    this.asset = asset;
+    this.listener = listener;
+    this.decoder = new ProgressiveDecoder();
+    this.firstReady = settled();
+    this.doneReady = settled();
+    this.stopped = false;
+    this.finished = false;
+    this.first = this.firstReady.promise;
+    this.done = this.doneReady.promise;
+  }
+  get cancelled() {
+    return this.stopped;
+  }
+  get firstBytes() {
+    return this.decoder.firstBytes;
+  }
+  cancel() {
+    this.finished || (this.stopped = true, this.fail(new ProgressiveCancelled(this.asset)));
+  }
+  push(bytes) {
+    if (this.stopped || this.finished) return;
+    let completed;
+    try {
+      completed = this.decoder.push(bytes);
+    } catch (error) {
+      this.fail(error instanceof Error ? error : new ProgressiveFormatError(String(error)));
+      return;
+    }
+    let output = this.decoder.output;
+    if (completed === 0 || output === null) return;
+    let done = this.decoder.done;
+    this.listener?.(output, this.decoder.quality, this.decoder.level, done), this.firstReady.resolve(output), done && (this.finished = true, this.doneReady.resolve(output));
+  }
+  whole(bytes) {
+    this.push(bytes), !this.finished && !this.stopped && this.fail(new ProgressiveFormatError(`the progressive container for ${this.asset} is truncated`));
+  }
+  complete(bytes) {
+    this.stopped || this.finished || (this.finished = true, this.listener?.(bytes, (1e6), 0, true), this.firstReady.resolve(bytes), this.doneReady.resolve(bytes));
+  }
+  fail(error) {
+    this.finished = true, this.firstReady.reject(error), this.doneReady.reject(error);
+  }
+};
+
+exports.DeltaOp = DeltaOp;
+exports.FILL_BYTE_MAX = (255);
+exports.HEADER_BYTES = (32);
+exports.Header = Header;
+exports.LEVEL_BYTES = (8);
+exports.MANIFEST_HEADER_BYTES = (24);
+exports.MANIFEST_MAGIC = (1296126019);
+exports.MANIFEST_PART_BYTES = MANIFEST_PART_BYTES;
+exports.MANIFEST_VERSION = (1);
+exports.MAX_ASSET_BYTES = MAX_ASSET_BYTES;
+exports.MAX_MANIFEST_PARTS = (65535);
+exports.MAX_PROGRESSIVE_BYTES = (2147483647);
+exports.MAX_PROGRESSIVE_DECODE_BYTES = MAX_PROGRESSIVE_DECODE_BYTES;
+exports.MERGE_PARAM_BYTES = (12);
+exports.PART_HEADER_BYTES = (8);
+exports.PART_MAGIC = (1414680643);
+exports.PART_VERSION = (1);
+exports.PATCH_BYTES = (16);
+exports.PPM = (1e6);
+exports.PROGRESSIVE_MAGIC = (1196576835);
+exports.PROGRESSIVE_VERSION = (1);
+exports.PartFormatError = PartFormatError;
+exports.PartKind = PartKind;
+exports.PatchOp = PatchOp;
+exports.ProgressiveCancelled = ProgressiveCancelled;
+exports.ProgressiveDecoder = ProgressiveDecoder;
+exports.ProgressiveFeed = ProgressiveFeed;
+exports.ProgressiveFormatError = ProgressiveFormatError;
+exports.ProgressiveKind = ProgressiveKind;
+exports.ProgressiveLayout = ProgressiveLayout;
+exports.SAMPLE_BYTES = (2);
+exports.SEGMENT_BYTES = (16);
+exports.SEGMENT_BYTES2 = (12);
+exports.SEGMENT_STAGED = (1);
+exports.SegmentOp = SegmentOp;
+exports.TableWriter = TableWriter;
+exports.UNIT_BYTES = (12);
+exports.UNLIFT_PARAM_BYTES = (12);
+exports.applyDelta = applyDelta;
+exports.assemble = assemble;
+exports.assembleInto = assembleInto;
+exports.checkLayout = checkLayout;
+exports.coarseKeys = coarseKeys;
+exports.containerBounds = containerBounds;
+exports.decodeManifest = decodeManifest;
+exports.decodePart = decodePart;
+exports.decodeProgressive = decodeProgressive;
+exports.encodeContainer = encodeContainer;
+exports.encodeDelta = encodeDelta;
+exports.encodeManifest = encodeManifest;
+exports.encodePart = encodePart;
+exports.headBytes = headBytes;
+exports.isCoarseKey = isCoarseKey;
+exports.isManifest = isManifest;
+exports.isProgressive = isProgressive;
+exports.liftForward = liftForward;
+exports.manifestBytes = manifestBytes;
+exports.partKindName = partKindName;
+exports.progressiveKindName = progressiveKindName;
+exports.readLayout = readLayout;
+exports.segmentOutput = segmentOutput;
+exports.soleSpan = soleSpan;
+exports.writePatch = writePatch;