@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-ATAWRACV.mjs

@@ -0,0 +1,62 @@
+import { GameError } from './chunk-XJIHN3BY.mjs';
+
+// src/game/render/media.ts
+var MEDIUM_DEFAULTS = { emission: 1, extinction: 1, albedo: [0.5, 0.5, 0.5] }, MEDIUM_CHANNEL_MAX = 255, MEDIUM_MAX = 16, MEDIUM_MAX_EDGE = 64, AXES = 3, GREEN_SHIFT = 8, BLUE_SHIFT = 16, ALPHA_SHIFT = 24;
+function channel(value) {
+  return Math.min((255), Math.max(0, Math.round(value))) | 0;
+}
+function mediumTexel(r, g, b, a) {
+  return (channel(r) | channel(g) << (8) | channel(b) << (16) | channel(a) << (24)) >>> 0;
+}
+function mediumTexelCount(size) {
+  return size[0] * size[1] * size[2];
+}
+function mediumIndex(size, x, y, z) {
+  return x >= 0 && x < size[0] && y >= 0 && y < size[1] && z >= 0 && z < size[2] ? (z * size[1] + y) * size[0] + x : -1;
+}
+function refuse(what) {
+  throw new GameError("invalid_argument", `a media volume ${what}`);
+}
+function finite(value) {
+  return Number.isFinite(value) && Number.isFinite(Math.fround(value));
+}
+function positive(value) {
+  return finite(value) && Math.fround(value) > 0 && finite(1 / Math.fround(value));
+}
+function writeMediumDesc(out, desc) {
+  let origin = [desc.origin.x, desc.origin.y, desc.origin.z], extent = [desc.extent.x, desc.extent.y, desc.extent.z], albedo = desc.albedo ?? MEDIUM_DEFAULTS.albedo, emission = desc.emission ?? MEDIUM_DEFAULTS.emission, extinction = desc.extinction ?? MEDIUM_DEFAULTS.extinction;
+  origin.every(finite) || refuse("needs a finite origin"), extent.every(positive) || refuse("needs a positive, finite extent on every axis"), (desc.size.length !== (3) || !desc.size.every((n) => Number.isInteger(n) && n >= 1 && n <= 64)) && refuse(`holds 1 to ${64} whole texels per axis`), (!positive(emission) || !positive(extinction)) && refuse("needs a positive, finite emission and extinction"), (albedo.length !== (3) || !albedo.every((v) => v >= 0 && v <= 1)) && refuse("albedo runs from 0 to 1 per channel"), out.fill(0, 0, 14);
+  for (let k = 0; k < (3); k++)
+    out[0 + k] = origin[k], out[3 + k] = extent[k], out[6 + k] = desc.size[k], out[11 + k] = albedo[k];
+  out[9] = emission, out[10] = extinction;
+}
+var MediumVolume = class {
+  constructor(port, id, desc) {
+    this.port = port;
+    this.id = id;
+    this.disposed = false;
+    this.desc = desc;
+  }
+  get size() {
+    return this.desc.size;
+  }
+  get texels() {
+    if (this.disposed) throw new GameError("unknown_resource", "this media volume was disposed");
+    return this.port.mediumTexels(this.id);
+  }
+  index(x, y, z) {
+    return mediumIndex(this.desc.size, x, y, z);
+  }
+  set(desc) {
+    if (this.disposed) throw new GameError("unknown_resource", "this media volume was disposed");
+    this.port.setMedium(this.id, desc), this.desc = desc;
+  }
+  mark() {
+    this.disposed || this.port.markMedium(this.id);
+  }
+  dispose() {
+    this.disposed || (this.disposed = true, this.port.destroyMedium(this.id));
+  }
+};
+
+export { MEDIUM_DEFAULTS, MEDIUM_MAX, MEDIUM_MAX_EDGE, MediumVolume, mediumIndex, mediumTexel, mediumTexelCount, writeMediumDesc };

package/dist/chunk-ATCURNUV.js

@@ -0,0 +1,14 @@
+'use strict';
+
+// src/game/kit/transforms.ts
+function writePosition(transforms, entity, source, offset) {
+  let o = transforms.row(entity) * 3, p = transforms.store.fields.position;
+  p[o] = source[offset], p[o + 1] = source[offset + 1], p[o + 2] = source[offset + 2];
+}
+function writeScale(transforms, entity, source, offset) {
+  let o = transforms.row(entity) * 3, s = transforms.store.fields.scale;
+  s[o] = source[offset], s[o + 1] = source[offset + 1], s[o + 2] = source[offset + 2];
+}
+
+exports.writePosition = writePosition;
+exports.writeScale = writeScale;

package/dist/chunk-AWPV33OO.js

@@ -0,0 +1,6 @@
+'use strict';
+
+// src/types/scheduling.ts
+var SHOPPER_RESCHEDULE_TYPE = "customer";
+
+exports.SHOPPER_RESCHEDULE_TYPE = SHOPPER_RESCHEDULE_TYPE;

package/dist/chunk-AYJPHKYV.js

@@ -0,0 +1,337 @@
+'use strict';
+
+var chunkKMKWGXMK_js = require('./chunk-KMKWGXMK.js');
+var chunkQQABGCMM_js = require('./chunk-QQABGCMM.js');
+var chunk4ZDR72SG_js = require('./chunk-4ZDR72SG.js');
+
+// src/interactives/runtime/asset-parts.ts
+var AssetParts = class {
+  constructor() {
+    this.users = /* @__PURE__ */ new Map();
+    this.held = /* @__PURE__ */ new Map();
+    this.loading = /* @__PURE__ */ new Map();
+    this.lazy = /* @__PURE__ */ new Set();
+  }
+  use(chunk, lazy) {
+    lazy ? this.lazy.add(chunk) : this.users.set(chunk, (this.users.get(chunk) ?? 0) + 1);
+  }
+  register(manifest, parts) {
+    this.use(manifest.chunk, manifest.lazy === true);
+    for (let part of parts) this.use(part.chunk, part.lazy === true);
+  }
+  holds(digest) {
+    return this.held.has(digest);
+  }
+  fetch(digest, priority, source) {
+    let held = this.held.get(digest);
+    if (held !== void 0) return Promise.resolve(held);
+    let loading = this.loading.get(digest);
+    if (loading !== void 0) return loading;
+    let taken = source.take(digest, priority).then((payload) => (this.loading.delete(digest), !this.lazy.has(digest) && (this.users.get(digest) ?? 0) > 1 && this.held.set(digest, payload), payload));
+    return taken.catch(() => this.loading.delete(digest)), this.loading.set(digest, taken), taken;
+  }
+  shared(digest) {
+    return this.lazy.has(digest) || (this.users.get(digest) ?? 0) > 1;
+  }
+  done(digest, source) {
+    if (this.lazy.has(digest)) {
+      source.release(digest);
+      return;
+    }
+    let left = (this.users.get(digest) ?? 0) - 1;
+    if (left > 0) {
+      this.users.set(digest, left);
+      return;
+    }
+    this.users.delete(digest), this.held.delete(digest);
+  }
+  async stream(manifestDigest, priority, refine, source, feed) {
+    let manifest = chunkKMKWGXMK_js.decodeManifest(await this.fetch(manifestDigest, priority, source)), bodies = /* @__PURE__ */ new Map(), body = (part, at) => {
+      let known = bodies.get(part);
+      if (known !== void 0) return known;
+      let loading = this.fetch(manifest.parts[part].digest, at, source).then((payload) => chunkKMKWGXMK_js.decodePart(payload).body);
+      return loading.catch(() => {
+      }), bodies.set(part, loading), loading;
+    }, scheduled = false, scratch = new Uint8Array(0);
+    try {
+      let at = 0;
+      for (let index = 0; index < manifest.segments.length; index++) {
+        let s = manifest.segments[index];
+        if (feed.cancelled) return;
+        if (!scheduled && feed.firstBytes >= 0) {
+          scheduled = !0;
+          let offset = at;
+          for (let i = index; i < manifest.segments.length; i++) {
+            let next = manifest.segments[i];
+            next.op !== chunkKMKWGXMK_js.SegmentOp.literal && body(next.part, offset < feed.firstBytes ? priority : refine), offset += chunkKMKWGXMK_js.segmentOutput(next);
+          }
+        }
+        if (s.op === chunkKMKWGXMK_js.SegmentOp.literal)
+          feed.push(manifest.literal.subarray(s.offset, s.offset + s.length));
+        else if (s.op === chunkKMKWGXMK_js.SegmentOp.part) {
+          let part = await body(s.part, priority);
+          if (part.length !== manifest.parts[s.part].length) throw new chunkKMKWGXMK_js.PartFormatError(`part ${manifest.parts[s.part].digest} is ${part.length} bytes, not ${manifest.parts[s.part].length}`);
+          feed.push(part.subarray(s.offset, s.offset + s.length));
+        } else {
+          let base = await body(s.part, priority);
+          scratch.length < s.output && (scratch = new Uint8Array(s.output)), chunkKMKWGXMK_js.applyDelta(base, manifest.literal.subarray(s.offset, s.offset + s.length), scratch, 0, s.output), feed.push(scratch.subarray(0, s.output));
+        }
+        at += chunkKMKWGXMK_js.segmentOutput(s);
+      }
+    } finally {
+      for (let p of manifest.parts) this.done(p.digest, source);
+      this.done(manifestDigest, source);
+    }
+  }
+  async assemble(manifestDigest, priority, source) {
+    let manifest = chunkKMKWGXMK_js.decodeManifest(await this.fetch(manifestDigest, priority, source)), bodies = (await Promise.all(manifest.parts.map((p) => this.fetch(p.digest, priority, source)))).map((payload) => chunkKMKWGXMK_js.decodePart(payload).body), sole = chunkKMKWGXMK_js.soleSpan(manifest), out;
+    if (sole !== null) {
+      let view = bodies[sole.part].subarray(sole.offset, sole.offset + manifest.length);
+      out = this.shared(manifest.parts[sole.part].digest) ? view.slice() : view;
+    } else
+      out = new Uint8Array(manifest.length), chunkKMKWGXMK_js.assembleInto(manifest, (index) => bodies[index], out, 0);
+    for (let p of manifest.parts) this.done(p.digest, source);
+    return this.done(manifestDigest, source), out;
+  }
+};
+
+// src/interactives/runtime/assets.ts
+var MODULE_KEY_SEPARATOR = ",", CONTENT_PREFIX = "content/", TIERED_CONTENT = /^content@(low|mid|high)\/(.+)$/, DIGEST = /^[0-9a-f]{64}$/, PackageAssets = class {
+  constructor(joinedSource = null, compiler = null) {
+    this.joinedSource = joinedSource;
+    this.compiler = compiler;
+    this.arrived = /* @__PURE__ */ new Map();
+    this.tiered = /* @__PURE__ */ new Map();
+    this.waiting = /* @__PURE__ */ new Map();
+    this.paths = /* @__PURE__ */ new Map();
+    this.modules = /* @__PURE__ */ new Map();
+    this.lazyDigests = /* @__PURE__ */ new Set();
+    this.prefetching = /* @__PURE__ */ new Map();
+    this.prefetched = /* @__PURE__ */ new Set();
+    this.cancelled = /* @__PURE__ */ new Set();
+    this.networkListeners = [];
+    this.parted = /* @__PURE__ */ new Map();
+    this.assetParts = new AssetParts();
+    this.progressiveAssets = /* @__PURE__ */ new Set();
+    this.channel = null;
+    this.hint = null;
+    this.catalogPending = null;
+    this.catalogDone = () => {
+    };
+  }
+  joined(sha256, parts) {
+    if (this.joinedSource === null) return null;
+    let key = parts.join(MODULE_KEY_SEPARATOR), known = this.modules.get(key);
+    if (known !== void 0) return known;
+    let compiled = this.joinedSource(sha256, parts);
+    return compiled.catch(() => this.modules.delete(key)), this.modules.set(key, compiled), compiled;
+  }
+  warm(parts, compile) {
+    let key = parts.join(MODULE_KEY_SEPARATOR), known = this.modules.get(key);
+    if (known !== void 0) return known;
+    let binary = this.binary(parts);
+    if (binary === null) return null;
+    let compiled = compile(binary);
+    return compiled.catch(() => {
+    }), this.modules.set(key, compiled), compiled;
+  }
+  binary(parts) {
+    let bytes = 0;
+    for (let part of parts) {
+      let staged = this.arrived.get(part);
+      if (staged === void 0) return null;
+      bytes += staged.length;
+    }
+    return { parts, bytes };
+  }
+  module(parts) {
+    let key = parts.join(MODULE_KEY_SEPARATOR), known = this.modules.get(key);
+    if (known !== void 0) return known;
+    let compiler = this.compiler;
+    if (compiler === null) return null;
+    let compiled = this.joinTaken(parts).then(compiler);
+    return compiled.catch(() => this.modules.delete(key)), this.modules.set(key, compiled), compiled;
+  }
+  async joinTaken(parts) {
+    let taken = [], length = 0;
+    for (let part of parts) {
+      let bytes = await this.take(part);
+      taken.push(bytes), length += bytes.length;
+    }
+    if (taken.length === 1) return taken[0];
+    let joined = new Uint8Array(length), at = 0;
+    for (let bytes of taken)
+      joined.set(bytes, at), at += bytes.length;
+    return joined;
+  }
+  catalog(assets) {
+    for (let asset of assets) {
+      if (this.paths.set(asset.path, asset.chunk), asset.lazy === true && this.lazyDigests.add(asset.chunk), asset.progressive === true && this.progressiveAssets.add(asset.path), asset.parts !== void 0) {
+        this.parted.set(asset.path, asset.parts), this.assetParts.register(asset, asset.parts);
+        for (let part of asset.parts) part.lazy === true && this.lazyDigests.add(part.chunk);
+      }
+      let tiered = TIERED_CONTENT.exec(asset.path);
+      if (tiered === null) continue;
+      let plain = `${CONTENT_PREFIX}${tiered[2]}`, known = this.tiered.get(plain) ?? [];
+      known.push(asset.chunk), this.tiered.set(plain, known);
+    }
+  }
+  awaitCatalog() {
+    this.catalogPending === null && (this.catalogPending = new Promise((resolve) => {
+      this.catalogDone = resolve;
+    }));
+  }
+  catalogued() {
+    this.catalogPending = null, this.catalogDone();
+  }
+  /** An asset the follow index will catalog: not known yet, and not a chunk digest. */
+  uncatalogued(asset) {
+    return this.catalogPending === null || this.has(asset) || DIGEST.test(asset) ? null : this.catalogPending;
+  }
+  has(asset) {
+    return this.paths.has(asset) || this.tiered.has(asset);
+  }
+  resolve(asset) {
+    let alternatives = this.tiered.get(asset);
+    if (alternatives !== void 0) {
+      for (let digest of alternatives) if (this.arrived.has(digest)) return digest;
+    }
+    return this.paths.get(asset) ?? asset;
+  }
+  accept(digest, payload) {
+    let waiter = this.waiting.get(digest);
+    if (waiter !== void 0) {
+      this.waiting.delete(digest), waiter.needed && chunkQQABGCMM_js.chunkResolved(), waiter.resolve(payload.slice());
+      return;
+    }
+    if (this.cancelled.delete(digest)) {
+      this.channel?.release(digest);
+      return;
+    }
+    this.prefetching.delete(digest) && this.prefetched.add(digest), this.arrived.has(digest) || this.arrived.set(digest, payload.slice());
+  }
+  connect(channel) {
+    this.channel = channel;
+  }
+  network(hint) {
+    this.hint = hint;
+    for (let i = 0; i < this.networkListeners.length; i++) this.networkListeners[i](hint);
+  }
+  networkHint() {
+    return this.hint;
+  }
+  onNetwork(listener) {
+    return this.networkListeners.push(listener), () => {
+      let at = this.networkListeners.indexOf(listener);
+      at >= 0 && this.networkListeners.splice(at, 1);
+    };
+  }
+  fail(digest, reason) {
+    this.prefetching.delete(digest), this.cancelled.delete(digest);
+    let waiter = this.waiting.get(digest);
+    waiter !== void 0 && (this.waiting.delete(digest), waiter.needed && chunkQQABGCMM_js.chunkResolved(), waiter.reject(new ChunkUnavailable(digest, reason)));
+  }
+  prefetch(asset, priority = chunk4ZDR72SG_js.ChunkPriority.prefetch) {
+    let later = this.uncatalogued(asset);
+    if (later !== null)
+      return later.then(() => this.prefetch(asset, priority)), true;
+    let parts = this.parted.get(asset);
+    if (parts !== void 0) for (let part of parts) part.lazy === true && !this.assetParts.holds(part.chunk) && this.prefetch(part.chunk, priority);
+    let digest = this.resolve(asset), channel = this.channel;
+    if (channel === null || !this.lazyDigests.has(digest)) return false;
+    if (this.arrived.has(digest) || this.waiting.has(digest)) return true;
+    let known = this.prefetching.get(digest);
+    return known !== void 0 && known <= priority || (this.cancelled.delete(digest), this.prefetching.set(digest, priority), channel.request(digest, priority)), true;
+  }
+  cancelPrefetch(asset) {
+    let parts = this.parted.get(asset);
+    if (parts !== void 0) for (let part of parts) part.lazy === true && this.cancelPrefetch(part.chunk);
+    let digest = this.resolve(asset), channel = this.channel;
+    return channel === null ? false : this.prefetching.delete(digest) ? (this.cancelled.add(digest), channel.release(digest), true) : this.prefetched.delete(digest) ? (this.arrived.delete(digest), channel.release(digest), true) : false;
+  }
+  resident(asset) {
+    let parts = this.parted.get(asset);
+    if (parts !== void 0 && !parts.every((part) => this.arrived.has(part.chunk) || this.assetParts.holds(part.chunk))) return false;
+    let digest = this.resolve(asset);
+    return this.arrived.has(digest) || this.assetParts.holds(digest);
+  }
+  pending(asset) {
+    let parts = this.parted.get(asset);
+    if (parts !== void 0 && parts.some((part) => this.pending(part.chunk))) return true;
+    let digest = this.resolve(asset);
+    return this.prefetching.has(digest) || this.waiting.has(digest);
+  }
+  lazy(asset) {
+    return this.lazyDigests.has(this.resolve(asset));
+  }
+  requests() {
+    return this.channel !== null;
+  }
+  isProgressive(asset) {
+    return this.progressiveAssets.has(asset);
+  }
+  progressive(asset, listener = null, priority = chunk4ZDR72SG_js.ChunkPriority.now, refine = chunk4ZDR72SG_js.ChunkPriority.soon) {
+    let feed = new chunkKMKWGXMK_js.ProgressiveFeed(asset, listener), later = this.uncatalogued(asset);
+    return later !== null ? (priority === chunk4ZDR72SG_js.ChunkPriority.now && chunkQQABGCMM_js.chunkNeeded(), later.then(() => {
+      priority === chunk4ZDR72SG_js.ChunkPriority.now && chunkQQABGCMM_js.chunkResolved(), this.feedProgressive(feed, asset, priority, refine);
+    }), feed) : (this.feedProgressive(feed, asset, priority, refine), feed);
+  }
+  feedProgressive(feed, asset, priority, refine) {
+    if (!this.progressiveAssets.has(asset)) {
+      this.takeStored(asset, priority, priority === chunk4ZDR72SG_js.ChunkPriority.now).then(
+        (bytes) => feed.complete(bytes),
+        (error) => feed.fail(error)
+      );
+      return;
+    }
+    if (!this.parted.has(asset)) {
+      this.takeStored(asset, priority, priority === chunk4ZDR72SG_js.ChunkPriority.now).then(
+        (bytes) => feed.whole(bytes),
+        (error) => feed.fail(error)
+      );
+      return;
+    }
+    let stall = priority === chunk4ZDR72SG_js.ChunkPriority.now, source = { take: (digest, at) => this.takeStored(digest, at, stall && at === priority), release: (digest) => this.release(digest) };
+    this.assetParts.stream(this.resolve(asset), priority, refine, source, feed).catch((error) => feed.fail(error));
+  }
+  take(asset, priority = chunk4ZDR72SG_js.ChunkPriority.now, stall = priority === chunk4ZDR72SG_js.ChunkPriority.now) {
+    let later = this.uncatalogued(asset);
+    if (later !== null)
+      return stall && chunkQQABGCMM_js.chunkNeeded(), later.then(() => (stall && chunkQQABGCMM_js.chunkResolved(), this.take(asset, priority, stall)));
+    let stored = this.takeStored(asset, priority, stall);
+    return this.progressiveAssets.has(asset) ? stored.then(chunkKMKWGXMK_js.decodeProgressive) : stored;
+  }
+  takeStored(asset, priority, stall) {
+    if (this.parted.has(asset)) {
+      let source = { take: (digest2, at) => this.takeStored(digest2, at, stall), release: (digest2) => this.release(digest2) };
+      return this.assetParts.assemble(this.resolve(asset), priority, source);
+    }
+    let digest = this.resolve(asset), bytes = this.arrived.get(digest);
+    if (bytes !== void 0)
+      return this.arrived.delete(digest), this.prefetched.delete(digest), Promise.resolve(bytes);
+    if (this.waiting.has(digest)) return Promise.reject(new Error(`chunk ${digest} is already being awaited`));
+    let prefetching = this.prefetching.get(digest);
+    this.prefetching.delete(digest);
+    let requestable = this.channel !== null && this.lazyDigests.has(digest), needed = requestable && stall;
+    return new Promise((resolve, reject) => {
+      this.waiting.set(digest, { resolve, reject, needed }), needed && chunkQQABGCMM_js.chunkNeeded(), requestable && (prefetching === void 0 || priority < prefetching) && this.channel?.request(digest, priority);
+    });
+  }
+  release(asset) {
+    let digest = this.resolve(asset);
+    this.prefetched.delete(digest) && this.arrived.delete(digest), this.channel !== null && this.lazyDigests.has(digest) && this.channel.release(digest);
+  }
+}, ChunkUnavailable = class extends Error {
+  constructor(digest, reason) {
+    super(`the host could not deliver chunk ${digest} (${reason})`);
+    this.digest = digest;
+    this.reason = reason;
+    this.name = "ChunkUnavailable";
+  }
+};
+
+// src/interactives/runtime/frame-loop.ts
+var FIXED_STEP_MS = 16.666666666666668;
+
+exports.FIXED_STEP_MS = (16.666666666666668);
+exports.PackageAssets = PackageAssets;

package/dist/chunk-AZ5BGWHB.js

@@ -0,0 +1,162 @@
+'use strict';
+
+// src/game/math/mat4.ts
+function mat4Identity(out, o) {
+  out[o] = 1, out[o + 1] = 0, out[o + 2] = 0, out[o + 3] = 0, out[o + 4] = 0, out[o + 5] = 1, out[o + 6] = 0, out[o + 7] = 0, out[o + 8] = 0, out[o + 9] = 0, out[o + 10] = 1, out[o + 11] = 0, out[o + 12] = 0, out[o + 13] = 0, out[o + 14] = 0, out[o + 15] = 1;
+}
+function mat4Compose(out, o, px, py, pz, qx, qy, qz, qw, sx, sy, sz) {
+  let x2 = qx + qx, y2 = qy + qy, z2 = qz + qz, xx = qx * x2, xy = qx * y2, xz = qx * z2, yy = qy * y2, yz = qy * z2, zz = qz * z2, wx = qw * x2, wy = qw * y2, wz = qw * z2;
+  out[o] = (1 - (yy + zz)) * sx, out[o + 1] = (xy + wz) * sx, out[o + 2] = (xz - wy) * sx, out[o + 3] = 0, out[o + 4] = (xy - wz) * sy, out[o + 5] = (1 - (xx + zz)) * sy, out[o + 6] = (yz + wx) * sy, out[o + 7] = 0, out[o + 8] = (xz + wy) * sz, out[o + 9] = (yz - wx) * sz, out[o + 10] = (1 - (xx + yy)) * sz, out[o + 11] = 0, out[o + 12] = px, out[o + 13] = py, out[o + 14] = pz, out[o + 15] = 1;
+}
+function mat4Multiply(out, o, a, ao, b, bo) {
+  let a00 = a[ao], a01 = a[ao + 1], a02 = a[ao + 2], a03 = a[ao + 3], a10 = a[ao + 4], a11 = a[ao + 5], a12 = a[ao + 6], a13 = a[ao + 7], a20 = a[ao + 8], a21 = a[ao + 9], a22 = a[ao + 10], a23 = a[ao + 11], a30 = a[ao + 12], a31 = a[ao + 13], a32 = a[ao + 14], a33 = a[ao + 15];
+  for (let col = 0; col < 4; col++) {
+    let c = bo + col * 4, b0 = b[c], b1 = b[c + 1], b2 = b[c + 2], b3 = b[c + 3], r = o + col * 4;
+    out[r] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30, out[r + 1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31, out[r + 2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32, out[r + 3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  }
+}
+function mat4TransformPoint(m, o, v) {
+  let x = v.x, y = v.y, z = v.z, w = m[o + 3] * x + m[o + 7] * y + m[o + 11] * z + m[o + 15], inv = Math.abs(w) > 1e-6 ? 1 / w : 1;
+  return v.set(
+    (m[o] * x + m[o + 4] * y + m[o + 8] * z + m[o + 12]) * inv,
+    (m[o + 1] * x + m[o + 5] * y + m[o + 9] * z + m[o + 13]) * inv,
+    (m[o + 2] * x + m[o + 6] * y + m[o + 10] * z + m[o + 14]) * inv
+  );
+}
+function mat4Translation(m, o, out) {
+  return out.set(m[o + 12], m[o + 13], m[o + 14]);
+}
+function mat4ComposeArrays(out, o, position, po, rotation, ro, scale, so) {
+  let qx = rotation[ro], qy = rotation[ro + 1], qz = rotation[ro + 2], qw = rotation[ro + 3], sx = scale[so], sy = scale[so + 1], sz = scale[so + 2], x2 = qx + qx, y2 = qy + qy, z2 = qz + qz, xx = qx * x2, xy = qx * y2, xz = qx * z2, yy = qy * y2, yz = qy * z2, zz = qz * z2, wx = qw * x2, wy = qw * y2, wz = qw * z2;
+  out[o] = (1 - (yy + zz)) * sx, out[o + 1] = (xy + wz) * sx, out[o + 2] = (xz - wy) * sx, out[o + 3] = 0, out[o + 4] = (xy - wz) * sy, out[o + 5] = (1 - (xx + zz)) * sy, out[o + 6] = (yz + wx) * sy, out[o + 7] = 0, out[o + 8] = (xz + wy) * sz, out[o + 9] = (yz - wx) * sz, out[o + 10] = (1 - (xx + yy)) * sz, out[o + 11] = 0, out[o + 12] = position[po], out[o + 13] = position[po + 1], out[o + 14] = position[po + 2], out[o + 15] = 1;
+}
+function quatSlerpArrays(out, o, a, ao, b, bo, weights, wi) {
+  let t = weights[wi], ax = a[ao], ay = a[ao + 1], az = a[ao + 2], aw = a[ao + 3], bx = b[bo], by = b[bo + 1], bz = b[bo + 2], bw = b[bo + 3], cos = ax * bx + ay * by + az * bz + aw * bw;
+  cos < 0 && (cos = -cos, bx = -bx, by = -by, bz = -bz, bw = -bw);
+  let wa, wb;
+  if (cos > 0.9995)
+    wa = 1 - t, wb = t;
+  else {
+    let angle = Math.acos(cos), sin = Math.sin(angle);
+    wa = Math.sin((1 - t) * angle) / sin, wb = Math.sin(t * angle) / sin;
+  }
+  let x = ax * wa + bx * wb, y = ay * wa + by * wb, z = az * wa + bz * wb, w = aw * wa + bw * wb, len = Math.sqrt(x * x + y * y + z * z + w * w);
+  if (len > 1e-6) {
+    let inv = 1 / len;
+    x *= inv, y *= inv, z *= inv, w *= inv;
+  }
+  out[o] = x, out[o + 1] = y, out[o + 2] = z, out[o + 3] = w;
+}
+function mat4Copy(out, o, m, mo) {
+  for (let i = 0; i < 16; i++) out[o + i] = m[mo + i];
+}
+function mat4Transpose(out, o, m, mo) {
+  let m01 = m[mo + 1], m02 = m[mo + 2], m03 = m[mo + 3], m12 = m[mo + 6], m13 = m[mo + 7], m23 = m[mo + 11];
+  out[o] = m[mo], out[o + 1] = m[mo + 4], out[o + 2] = m[mo + 8], out[o + 3] = m[mo + 12], out[o + 4] = m01, out[o + 5] = m[mo + 5], out[o + 6] = m[mo + 9], out[o + 7] = m[mo + 13], out[o + 8] = m02, out[o + 9] = m12, out[o + 10] = m[mo + 10], out[o + 11] = m[mo + 14], out[o + 12] = m03, out[o + 13] = m13, out[o + 14] = m23, out[o + 15] = m[mo + 15];
+}
+function mat4Determinant(m, mo) {
+  let n11 = m[mo], n21 = m[mo + 1], n31 = m[mo + 2], n41 = m[mo + 3], n12 = m[mo + 4], n22 = m[mo + 5], n32 = m[mo + 6], n42 = m[mo + 7], n13 = m[mo + 8], n23 = m[mo + 9], n33 = m[mo + 10], n43 = m[mo + 11], n14 = m[mo + 12], n24 = m[mo + 13], n34 = m[mo + 14], n44 = m[mo + 15], t1 = n11 * n22 - n21 * n12, t2 = n11 * n32 - n31 * n12, t3 = n11 * n42 - n41 * n12, t4 = n21 * n32 - n31 * n22, t5 = n21 * n42 - n41 * n22, t6 = n31 * n42 - n41 * n32, t7 = n13 * n24 - n23 * n14, t8 = n13 * n34 - n33 * n14, t9 = n13 * n44 - n43 * n14, t10 = n23 * n34 - n33 * n24, t11 = n23 * n44 - n43 * n24, t12 = n33 * n44 - n43 * n34;
+  return t1 * t12 - t2 * t11 + t3 * t10 + t4 * t9 - t5 * t8 + t6 * t7;
+}
+function mat4Invert(out, o, m, mo) {
+  let n11 = m[mo], n21 = m[mo + 1], n31 = m[mo + 2], n41 = m[mo + 3], n12 = m[mo + 4], n22 = m[mo + 5], n32 = m[mo + 6], n42 = m[mo + 7], n13 = m[mo + 8], n23 = m[mo + 9], n33 = m[mo + 10], n43 = m[mo + 11], n14 = m[mo + 12], n24 = m[mo + 13], n34 = m[mo + 14], n44 = m[mo + 15], t1 = n11 * n22 - n21 * n12, t2 = n11 * n32 - n31 * n12, t3 = n11 * n42 - n41 * n12, t4 = n21 * n32 - n31 * n22, t5 = n21 * n42 - n41 * n22, t6 = n31 * n42 - n41 * n32, t7 = n13 * n24 - n23 * n14, t8 = n13 * n34 - n33 * n14, t9 = n13 * n44 - n43 * n14, t10 = n23 * n34 - n33 * n24, t11 = n23 * n44 - n43 * n24, t12 = n33 * n44 - n43 * n34, det = t1 * t12 - t2 * t11 + t3 * t10 + t4 * t9 - t5 * t8 + t6 * t7;
+  if (det === 0) {
+    for (let i = 0; i < 16; i++) out[o + i] = 0;
+    return false;
+  }
+  let inv = 1 / det;
+  return out[o] = (n22 * t12 - n32 * t11 + n42 * t10) * inv, out[o + 1] = (n31 * t11 - n21 * t12 - n41 * t10) * inv, out[o + 2] = (n24 * t6 - n34 * t5 + n44 * t4) * inv, out[o + 3] = (n33 * t5 - n23 * t6 - n43 * t4) * inv, out[o + 4] = (n32 * t9 - n12 * t12 - n42 * t8) * inv, out[o + 5] = (n11 * t12 - n31 * t9 + n41 * t8) * inv, out[o + 6] = (n34 * t3 - n14 * t6 - n44 * t2) * inv, out[o + 7] = (n13 * t6 - n33 * t3 + n43 * t2) * inv, out[o + 8] = (n12 * t11 - n22 * t9 + n42 * t7) * inv, out[o + 9] = (n21 * t9 - n11 * t11 - n41 * t7) * inv, out[o + 10] = (n14 * t5 - n24 * t3 + n44 * t1) * inv, out[o + 11] = (n23 * t3 - n13 * t5 - n43 * t1) * inv, out[o + 12] = (n22 * t8 - n12 * t10 - n32 * t7) * inv, out[o + 13] = (n11 * t10 - n21 * t8 + n31 * t7) * inv, out[o + 14] = (n24 * t2 - n14 * t4 - n34 * t1) * inv, out[o + 15] = (n13 * t4 - n23 * t2 + n33 * t1) * inv, true;
+}
+function quatFromRotationColumns(out, o, m11, m21, m31, m12, m22, m32, m13, m23, m33) {
+  let trace = m11 + m22 + m33, x, y, z, w;
+  if (trace > 0) {
+    let s = 0.5 / Math.sqrt(trace + 1);
+    w = 0.25 / s, x = (m32 - m23) * s, y = (m13 - m31) * s, z = (m21 - m12) * s;
+  } else if (m11 > m22 && m11 > m33) {
+    let s = 2 * Math.sqrt(1 + m11 - m22 - m33);
+    w = (m32 - m23) / s, x = 0.25 * s, y = (m12 + m21) / s, z = (m13 + m31) / s;
+  } else if (m22 > m33) {
+    let s = 2 * Math.sqrt(1 + m22 - m11 - m33);
+    w = (m13 - m31) / s, x = (m12 + m21) / s, y = 0.25 * s, z = (m23 + m32) / s;
+  } else {
+    let s = 2 * Math.sqrt(1 + m33 - m11 - m22);
+    w = (m21 - m12) / s, x = (m13 + m31) / s, y = (m23 + m32) / s, z = 0.25 * s;
+  }
+  out[o] = x, out[o + 1] = y, out[o + 2] = z, out[o + 3] = w;
+}
+function mat4Decompose(m, mo, position, po, rotation, ro, scale, so) {
+  position[po] = m[mo + 12], position[po + 1] = m[mo + 13], position[po + 2] = m[mo + 14];
+  let a = m[mo], b = m[mo + 1], c = m[mo + 2], d = m[mo + 4], e = m[mo + 5], f = m[mo + 6], g = m[mo + 8], h = m[mo + 9], i = m[mo + 10], det = a * (e * i - f * h) - d * (b * i - c * h) + g * (b * f - c * e);
+  if (det === 0) {
+    scale[so] = 1, scale[so + 1] = 1, scale[so + 2] = 1, rotation[ro] = 0, rotation[ro + 1] = 0, rotation[ro + 2] = 0, rotation[ro + 3] = 1;
+    return;
+  }
+  let sx = Math.sqrt(a * a + b * b + c * c), sy = Math.sqrt(d * d + e * e + f * f), sz = Math.sqrt(g * g + h * h + i * i);
+  det < 0 && (sx = -sx);
+  let ix = 1 / sx, iy = 1 / sy, iz = 1 / sz;
+  quatFromRotationColumns(rotation, ro, a * ix, b * ix, c * ix, d * iy, e * iy, f * iy, g * iz, h * iz, i * iz), scale[so] = sx, scale[so + 1] = sy, scale[so + 2] = sz;
+}
+function mat4LookAt(out, o, eyeX, eyeY, eyeZ, targetX, targetY, targetZ, upX, upY, upZ) {
+  let zx = eyeX - targetX, zy = eyeY - targetY, zz = eyeZ - targetZ, len = Math.sqrt(zx * zx + zy * zy + zz * zz);
+  len < 1e-6 && (zz = 1, len = 1), zx /= len, zy /= len, zz /= len;
+  let xx = upY * zz - upZ * zy, xy = upZ * zx - upX * zz, xz = upX * zy - upY * zx;
+  if (len = Math.sqrt(xx * xx + xy * xy + xz * xz), len < 1e-6) {
+    Math.abs(upZ) === 1 ? zx += 1e-4 : zz += 1e-4;
+    let zl = Math.sqrt(zx * zx + zy * zy + zz * zz);
+    zx /= zl, zy /= zl, zz /= zl, xx = upY * zz - upZ * zy, xy = upZ * zx - upX * zz, xz = upX * zy - upY * zx, len = Math.sqrt(xx * xx + xy * xy + xz * xz);
+  }
+  xx /= len, xy /= len, xz /= len;
+  let yx = zy * xz - zz * xy, yy = zz * xx - zx * xz, yz = zx * xy - zy * xx;
+  out[o] = xx, out[o + 1] = xy, out[o + 2] = xz, out[o + 3] = 0, out[o + 4] = yx, out[o + 5] = yy, out[o + 6] = yz, out[o + 7] = 0, out[o + 8] = zx, out[o + 9] = zy, out[o + 10] = zz, out[o + 11] = 0, out[o + 12] = eyeX, out[o + 13] = eyeY, out[o + 14] = eyeZ, out[o + 15] = 1;
+}
+function mat4Perspective(out, o, fovYRadians, aspect, near, far) {
+  let f = 1 / Math.tan(fovYRadians / 2), range = 1 / (near - far);
+  for (let i = 0; i < 16; i++) out[o + i] = 0;
+  out[o] = f / aspect, out[o + 5] = f, out[o + 10] = (far + near) * range, out[o + 11] = -1, out[o + 14] = 2 * far * near * range;
+}
+function mat4Frustum(out, o, left, right, bottom, top, near, far) {
+  for (let i = 0; i < 16; i++) out[o + i] = 0;
+  out[o] = 2 * near / (right - left), out[o + 5] = 2 * near / (top - bottom), out[o + 8] = (right + left) / (right - left), out[o + 9] = (top + bottom) / (top - bottom), out[o + 10] = -(far + near) / (far - near), out[o + 11] = -1, out[o + 14] = -2 * far * near / (far - near);
+}
+function mat4Orthographic(out, o, left, right, bottom, top, near, far) {
+  for (let i = 0; i < 16; i++) out[o + i] = 0;
+  out[o] = 2 / (right - left), out[o + 5] = 2 / (top - bottom), out[o + 10] = -2 / (far - near), out[o + 12] = -(right + left) / (right - left), out[o + 13] = -(top + bottom) / (top - bottom), out[o + 14] = -(far + near) / (far - near), out[o + 15] = 1;
+}
+function mat4TransformPointArrays(m, mo, v, vo, out, oo) {
+  let x = v[vo], y = v[vo + 1], z = v[vo + 2], w = m[mo + 3] * x + m[mo + 7] * y + m[mo + 11] * z + m[mo + 15], inv = Math.abs(w) > 1e-6 ? 1 / w : 1;
+  out[oo] = (m[mo] * x + m[mo + 4] * y + m[mo + 8] * z + m[mo + 12]) * inv, out[oo + 1] = (m[mo + 1] * x + m[mo + 5] * y + m[mo + 9] * z + m[mo + 13]) * inv, out[oo + 2] = (m[mo + 2] * x + m[mo + 6] * y + m[mo + 10] * z + m[mo + 14]) * inv;
+}
+function mat4TransformDirection(m, o, v) {
+  let x = v.x, y = v.y, z = v.z;
+  return v.set(m[o] * x + m[o + 4] * y + m[o + 8] * z, m[o + 1] * x + m[o + 5] * y + m[o + 9] * z, m[o + 2] * x + m[o + 6] * y + m[o + 10] * z), v.normalize();
+}
+function mat4MaxScale(m, mo) {
+  let sx = m[mo] * m[mo] + m[mo + 1] * m[mo + 1] + m[mo + 2] * m[mo + 2], sy = m[mo + 4] * m[mo + 4] + m[mo + 5] * m[mo + 5] + m[mo + 6] * m[mo + 6], sz = m[mo + 8] * m[mo + 8] + m[mo + 9] * m[mo + 9] + m[mo + 10] * m[mo + 10];
+  return Math.sqrt(Math.max(sx, sy, sz));
+}
+var slerpScratchA = new Float32Array(4), slerpScratchB = new Float32Array(4), slerpWeight = new Float64Array(1);
+function slerpInto(out, o, ax, ay, az, aw, bx, by, bz, bw, t) {
+  slerpScratchA[0] = ax, slerpScratchA[1] = ay, slerpScratchA[2] = az, slerpScratchA[3] = aw, slerpScratchB[0] = bx, slerpScratchB[1] = by, slerpScratchB[2] = bz, slerpScratchB[3] = bw, slerpWeight[0] = t, quatSlerpArrays(out, o, slerpScratchA, 0, slerpScratchB, 0, slerpWeight, 0);
+}
+
+exports.mat4Compose = mat4Compose;
+exports.mat4ComposeArrays = mat4ComposeArrays;
+exports.mat4Copy = mat4Copy;
+exports.mat4Decompose = mat4Decompose;
+exports.mat4Determinant = mat4Determinant;
+exports.mat4Frustum = mat4Frustum;
+exports.mat4Identity = mat4Identity;
+exports.mat4Invert = mat4Invert;
+exports.mat4LookAt = mat4LookAt;
+exports.mat4MaxScale = mat4MaxScale;
+exports.mat4Multiply = mat4Multiply;
+exports.mat4Orthographic = mat4Orthographic;
+exports.mat4Perspective = mat4Perspective;
+exports.mat4TransformDirection = mat4TransformDirection;
+exports.mat4TransformPoint = mat4TransformPoint;
+exports.mat4TransformPointArrays = mat4TransformPointArrays;
+exports.mat4Translation = mat4Translation;
+exports.mat4Transpose = mat4Transpose;
+exports.quatFromRotationColumns = quatFromRotationColumns;
+exports.quatSlerpArrays = quatSlerpArrays;
+exports.slerpInto = slerpInto;