quake2ts 0.0.556 → 0.0.557

package/packages/engine/dist/esm/index.js

@@ -1,3 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
 // src/loop.ts
 var DEFAULT_FIXED_DELTA_MS = 25;
 var DEFAULT_MAX_SUBSTEPS = 5;
@@ -182,10 +188,10 @@ var CommandRegistry = class {
 };
 
 // ../shared/dist/esm/index.js
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
+var __defProp2 = Object.defineProperty;
+var __export2 = (target, all) => {
   for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+    __defProp2(target, name, { get: all[name], enumerable: true });
 };
 var ZERO_VEC3 = { x: 0, y: 0, z: 0 };
 var DEG_TO_RAD = Math.PI / 180;
@@ -205,8 +211,8 @@ function lengthVec3(a) {
   return Math.sqrt(lengthSquaredVec3(a));
 }
 function normalizeVec3(a) {
-  const len = lengthVec3(a);
-  return len === 0 ? a : scaleVec3(a, 1 / len);
+  const len2 = lengthVec3(a);
+  return len2 === 0 ? a : scaleVec3(a, 1 / len2);
 }
 var DEG2RAD_FACTOR = Math.PI / 180;
 var RAD2DEG_FACTOR = 180 / Math.PI;
@@ -544,7 +550,7 @@ var CS_ITEMS = ConfigStringIndex.Items;
 var CS_PLAYERS = ConfigStringIndex.Players;
 var CS_GENERAL = ConfigStringIndex.General;
 var replay_exports = {};
-__export(replay_exports, {
+__export2(replay_exports, {
   addReplayFrame: () => addReplayFrame,
   createReplaySession: () => createReplaySession,
   deserializeReplay: () => deserializeReplay,
@@ -812,26 +818,26 @@ var BinaryStream = class {
     return value;
   }
   readString() {
-    let str = "";
+    let str3 = "";
     while (this.offset < this.length) {
       const charCode = this.readChar();
       if (charCode === -1 || charCode === 0) {
         break;
       }
-      str += String.fromCharCode(charCode);
+      str3 += String.fromCharCode(charCode);
     }
-    return str;
+    return str3;
   }
   readStringLine() {
-    let str = "";
+    let str3 = "";
     while (this.offset < this.length) {
       const charCode = this.readChar();
       if (charCode === -1 || charCode === 0 || charCode === 10) {
         break;
       }
-      str += String.fromCharCode(charCode);
+      str3 += String.fromCharCode(charCode);
     }
-    return str;
+    return str3;
   }
   readCoord() {
     return this.readShort() * (1 / 8);
@@ -842,12 +848,12 @@ var BinaryStream = class {
   readAngle16() {
     return this.readShort() * 360 / 65536;
   }
-  readData(length) {
-    if (this.offset + length > this.length) {
-      throw new Error(`Read out of bounds: ${this.offset + length} (length: ${this.length})`);
+  readData(length2) {
+    if (this.offset + length2 > this.length) {
+      throw new Error(`Read out of bounds: ${this.offset + length2} (length: ${this.length})`);
     }
-    const data = new Uint8Array(this.view.buffer, this.view.byteOffset + this.offset, length);
-    this.offset += length;
+    const data = new Uint8Array(this.view.buffer, this.view.byteOffset + this.offset, length2);
+    this.offset += length2;
     return new Uint8Array(data);
   }
   readPos(out) {
@@ -924,13 +930,13 @@ var BinaryWriter = class {
     this.offset += 4;
   }
   writeString(value) {
-    const len = value.length;
-    this.ensureSpace(len + 1);
-    for (let i = 0; i < len; i++) {
+    const len2 = value.length;
+    this.ensureSpace(len2 + 1);
+    for (let i = 0; i < len2; i++) {
       this.view.setUint8(this.offset + i, value.charCodeAt(i));
     }
-    this.view.setUint8(this.offset + len, 0);
-    this.offset += len + 1;
+    this.view.setUint8(this.offset + len2, 0);
+    this.offset += len2 + 1;
   }
   writeCoord(value) {
     this.writeShort(Math.trunc(value * 8));
@@ -955,9 +961,9 @@ var BinaryWriter = class {
     }
     for (let i = 0; i < ANORMS.length; i++) {
       const norm = ANORMS[i];
-      const dot = dir.x * norm[0] + dir.y * norm[1] + dir.z * norm[2];
-      if (dot > maxDot) {
-        maxDot = dot;
+      const dot2 = dir.x * norm[0] + dir.y * norm[1] + dir.z * norm[2];
+      if (dot2 > maxDot) {
+        maxDot = dot2;
         bestIndex = i;
       }
     }
@@ -1238,12 +1244,12 @@ var _NetChan = class _NetChan2 {
    * Writes a string to the reliable message buffer
    */
   writeReliableString(value) {
-    const len = value.length + 1;
-    if (this.reliableLength + len > _NetChan2.MAX_RELIABLE_BUFFER) {
+    const len2 = value.length + 1;
+    if (this.reliableLength + len2 > _NetChan2.MAX_RELIABLE_BUFFER) {
       throw new Error("NetChan reliable buffer overflow");
     }
     this.reliableMessage.writeString(value);
-    this.reliableLength += len;
+    this.reliableLength += len2;
   }
   /**
    * Returns the current reliable data buffer
@@ -2600,9 +2606,9 @@ var BspLoader = class {
   }
   async load(path) {
     const buffer = await this.vfs.readFile(path);
-    const copy = new Uint8Array(buffer.byteLength);
-    copy.set(buffer);
-    return parseBsp(copy.buffer);
+    const copy3 = new Uint8Array(buffer.byteLength);
+    copy3.set(buffer);
+    return parseBsp(copy3.buffer);
   }
 };
 function parseBsp(buffer) {
@@ -2621,11 +2627,11 @@ function parseBsp(buffer) {
   const lumps = /* @__PURE__ */ new Map();
   for (let i = 0; i < HEADER_LUMPS; i += 1) {
     const offset = view.getInt32(8 + i * 8, true);
-    const length = view.getInt32(12 + i * 8, true);
-    if (offset < 0 || length < 0 || offset + length > buffer.byteLength) {
+    const length2 = view.getInt32(12 + i * 8, true);
+    if (offset < 0 || length2 < 0 || offset + length2 > buffer.byteLength) {
       throw new BspParseError(`Invalid lump bounds for index ${i}`);
     }
-    lumps.set(i, { offset, length });
+    lumps.set(i, { offset, length: length2 });
   }
   const header = { version, lumps };
   const entities = parseEntities(buffer, lumps.get(0 /* Entities */));
@@ -2675,10 +2681,10 @@ function parseBsp(buffer) {
           continue;
         }
         const model = models[modelIndex];
-        const dist = intersectRayAabb(ray.origin, ray.direction, model.mins, model.maxs);
-        if (dist !== null && dist < minDistance) {
-          minDistance = dist;
-          closest = { entity, model, distance: dist };
+        const dist2 = intersectRayAabb(ray.origin, ray.direction, model.mins, model.maxs);
+        if (dist2 !== null && dist2 < minDistance) {
+          minDistance = dist2;
+          closest = { entity, model, distance: dist2 };
         }
       }
       return closest;
@@ -2756,9 +2762,9 @@ function parsePlanes(buffer, info) {
   const planes = [];
   for (let i = 0; i < count; i += 1) {
     const normal = [view.getFloat32(i * 20, true), view.getFloat32(i * 20 + 4, true), view.getFloat32(i * 20 + 8, true)];
-    const dist = view.getFloat32(i * 20 + 12, true);
+    const dist2 = view.getFloat32(i * 20 + 12, true);
     const type = view.getInt32(i * 20 + 16, true);
-    planes.push({ normal, dist, type });
+    planes.push({ normal, dist: dist2, type });
   }
   return planes;
 }
@@ -3049,11 +3055,11 @@ function createFaceLightmap(face, lightMaps, info) {
     return void 0;
   }
   const available = lightMaps.byteLength - face.lightOffset;
-  const length = Math.min(info?.length ?? available, available);
-  if (length <= 0) {
+  const length2 = Math.min(info?.length ?? available, available);
+  if (length2 <= 0) {
     return void 0;
   }
-  return lightMaps.subarray(face.lightOffset, face.lightOffset + length);
+  return lightMaps.subarray(face.lightOffset, face.lightOffset + length2);
 }
 
 // src/assets/md2.ts
@@ -3236,9 +3242,9 @@ var Md2Loader = class {
       return this.cache.get(path);
     }
     const bytes = await this.vfs.readFile(path);
-    const copy = new Uint8Array(bytes.byteLength);
-    copy.set(bytes);
-    const model = parseMd2(copy.buffer);
+    const copy3 = new Uint8Array(bytes.byteLength);
+    copy3.set(bytes);
+    const model = parseMd2(copy3.buffer);
     this.cache.set(path, model);
     return model;
   }
@@ -3255,9 +3261,9 @@ function readCString2(view, offset, maxLength) {
   }
   return String.fromCharCode(...chars);
 }
-function validateSection(buffer, offset, length, label) {
-  if (length === 0) return;
-  if (offset < HEADER_SIZE4 || offset + length > buffer.byteLength) {
+function validateSection(buffer, offset, length2, label) {
+  if (length2 === 0) return;
+  if (offset < HEADER_SIZE4 || offset + length2 > buffer.byteLength) {
     throw new Md2ParseError(`${label} section is out of bounds`);
   }
 }
@@ -3355,8 +3361,8 @@ function parseFrames(buffer, header) {
   for (let i = 0; i < header.numFrames; i += 1) {
     const base = header.offsetFrames + i * header.frameSize;
     const view = new DataView(buffer, base, header.frameSize);
-    const scale = { x: view.getFloat32(0, true), y: view.getFloat32(4, true), z: view.getFloat32(8, true) };
-    const translate = {
+    const scale3 = { x: view.getFloat32(0, true), y: view.getFloat32(4, true), z: view.getFloat32(8, true) };
+    const translate2 = {
       x: view.getFloat32(12, true),
       y: view.getFloat32(16, true),
       z: view.getFloat32(20, true)
@@ -3367,9 +3373,9 @@ function parseFrames(buffer, header) {
     let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
     for (let v = 0; v < header.numVertices; v += 1) {
       const offset = 40 + v * 4;
-      const x = view.getUint8(offset) * scale.x + translate.x;
-      const y = view.getUint8(offset + 1) * scale.y + translate.y;
-      const z = view.getUint8(offset + 2) * scale.z + translate.z;
+      const x = view.getUint8(offset) * scale3.x + translate2.x;
+      const y = view.getUint8(offset + 1) * scale3.y + translate2.y;
+      const z = view.getUint8(offset + 2) * scale3.z + translate2.z;
       if (x < minX) minX = x;
       if (y < minY) minY = y;
       if (z < minZ) minZ = z;
@@ -3468,8 +3474,8 @@ var Md3ParseError = class extends Error {
     this.name = "Md3ParseError";
   }
 };
-function readString(view, offset, length) {
-  const bytes = new Uint8Array(view.buffer, view.byteOffset + offset, length);
+function readString(view, offset, length2) {
+  const bytes = new Uint8Array(view.buffer, view.byteOffset + offset, length2);
   const decoded = new TextDecoder("utf-8").decode(bytes);
   return decoded.replace(/\0.*$/, "").trim();
 }
@@ -3759,9 +3765,9 @@ var SpriteLoader = class {
   }
   async load(path) {
     const bytes = await this.vfs.readFile(path);
-    const copy = new Uint8Array(bytes.byteLength);
-    copy.set(bytes);
-    return parseSprite(copy.buffer);
+    const copy3 = new Uint8Array(bytes.byteLength);
+    copy3.set(bytes);
+    return parseSprite(copy3.buffer);
   }
 };
 
@@ -3789,8 +3795,8 @@ function computeFrameBlend(state) {
   const baseFrame = Math.floor(normalizedPosition);
   const frame0 = state.sequence.start + baseFrame;
   const frame1 = baseFrame + 1 >= totalFrames ? loop ? state.sequence.start : state.sequence.end : frame0 + 1;
-  const lerp3 = !loop && baseFrame >= totalFrames - 1 ? 0 : normalizedPosition - baseFrame;
-  return { frame0, frame1, lerp: lerp3 };
+  const lerp4 = !loop && baseFrame >= totalFrames - 1 ? 0 : normalizedPosition - baseFrame;
+  return { frame0, frame1, lerp: lerp4 };
 }
 function createAnimationState(sequence) {
   return { sequence, time: 0 };
@@ -4105,8 +4111,8 @@ var WavParseError = class extends Error {
     this.name = "WavParseError";
   }
 };
-function readString2(view, offset, length) {
-  return new TextDecoder("ascii").decode(new Uint8Array(view.buffer, view.byteOffset + offset, length));
+function readString2(view, offset, length2) {
+  return new TextDecoder("ascii").decode(new Uint8Array(view.buffer, view.byteOffset + offset, length2));
 }
 function parseWav(buffer) {
   if (buffer.byteLength < 44) {
@@ -4850,8 +4856,8 @@ var SoundPrecache = class {
           continue;
         }
         const bytes = await this.vfs.readFile(path);
-        const copy = bytes.slice().buffer;
-        const buffer = await this.decodeAudio(context, copy);
+        const copy3 = bytes.slice().buffer;
+        const buffer = await this.decodeAudio(context, copy3);
         this.registry.register(path, buffer);
         report.loaded.push(path);
       } catch (error) {
@@ -5180,22 +5186,22 @@ var AudioSystem = class {
     active.gain.gain.value = active.baseGain * occlusionScale * playbackRateMute;
   }
   applyOcclusion(active, occlusion) {
-    const scale = clamp01(occlusion?.gainScale ?? 1);
+    const scale3 = clamp01(occlusion?.gainScale ?? 1);
     const playbackRateMute = Math.abs(this.playbackRate - 1) < 1e-3 ? 1 : 0;
-    active.gain.gain.value = active.baseGain * scale * playbackRateMute;
+    active.gain.gain.value = active.baseGain * scale3 * playbackRateMute;
     if (active.occlusion?.filter) {
       const cutoff = occlusion?.lowpassHz ?? 2e4;
       active.occlusion.filter.frequency.value = clamp(cutoff, 10, 2e4);
     }
     if (active.occlusion) {
-      active.occlusion.scale = scale;
+      active.occlusion.scale = scale3;
       active.occlusion.lowpassHz = occlusion?.lowpassHz;
     } else if (occlusion) {
-      active.occlusion = { scale, lowpassHz: occlusion.lowpassHz };
+      active.occlusion = { scale: scale3, lowpassHz: occlusion.lowpassHz };
     }
   }
 };
-var clamp = (value, min, max) => Math.min(max, Math.max(min, value));
+var clamp = (value, min2, max2) => Math.min(max2, Math.max(min2, value));
 var clamp01 = (value) => clamp(value, 0, 1);
 
 // src/audio/occlusion.ts
@@ -5203,9 +5209,9 @@ var AudioOcclusion = class {
   constructor(trace) {
     this.trace = trace;
     this.resolve = (listener, source, attenuation) => {
-      const dist = lengthVec3(subtractVec3(source, listener.origin));
+      const dist2 = lengthVec3(subtractVec3(source, listener.origin));
       const maxDist = calculateMaxAudibleDistance(attenuation);
-      const clampedDist = Math.min(dist, maxDist);
+      const clampedDist = Math.min(dist2, maxDist);
       const distanceFactor = clampedDist / Math.max(1, maxDist);
       const distanceCutoff = 2e4 * (1 - distanceFactor * 0.9);
       const tr = this.trace(listener.origin, source, void 0, void 0);
@@ -5976,15 +5982,15 @@ function buildBspGeometry(gl, surfaces, map, options = {}) {
 
 // src/render/culling.ts
 function normalizePlane(plane) {
-  const { normal, distance } = plane;
-  const length = Math.sqrt(normal.x * normal.x + normal.y * normal.y + normal.z * normal.z);
-  if (length === 0) {
+  const { normal, distance: distance2 } = plane;
+  const length2 = Math.sqrt(normal.x * normal.x + normal.y * normal.y + normal.z * normal.z);
+  if (length2 === 0) {
     return plane;
   }
-  const inv = 1 / length;
+  const inv = 1 / length2;
   return {
     normal: { x: normal.x * inv, y: normal.y * inv, z: normal.z * inv },
-    distance: distance * inv
+    distance: distance2 * inv
   };
 }
 function extractFrustumPlanes(matrix) {
@@ -6074,8 +6080,8 @@ function findLeafForPoint(map, point) {
   while (nodeIndex >= 0) {
     const node = map.nodes[nodeIndex];
     const plane = map.planes[node.planeIndex];
-    const dist = distanceToPlane(plane, point);
-    const side = dist >= 0 ? 0 : 1;
+    const dist2 = distanceToPlane(plane, point);
+    const side = dist2 >= 0 ? 0 : 1;
     const child = node.children[side];
     if (childIsLeaf(child)) {
       return childLeafIndex(child);
@@ -6092,14 +6098,14 @@ function collectFacesFromLeaf(map, leafIndex) {
   }
   return faces;
 }
-function traverse(map, nodeIndex, camera, frustum, viewCluster, visibleFaces, visitedFaces) {
+function traverse(map, nodeIndex, camera, frustum2, viewCluster, visibleFaces, visitedFaces) {
   if (childIsLeaf(nodeIndex)) {
     const leafIndex = childLeafIndex(nodeIndex);
     const leaf = map.leafs[leafIndex];
     if (!isClusterVisible(map.visibility, viewCluster, leaf.cluster)) {
       return;
     }
-    if (!leafIntersectsFrustum(leaf, frustum)) {
+    if (!leafIntersectsFrustum(leaf, frustum2)) {
       return;
     }
     const center = {
@@ -6122,24 +6128,24 @@ function traverse(map, nodeIndex, camera, frustum, viewCluster, visibleFaces, vi
   }
   const node = map.nodes[nodeIndex];
   const plane = map.planes[node.planeIndex];
-  const dist = distanceToPlane(plane, camera);
-  const nearChild = dist >= 0 ? node.children[0] : node.children[1];
-  const farChild = dist >= 0 ? node.children[1] : node.children[0];
+  const dist2 = distanceToPlane(plane, camera);
+  const nearChild = dist2 >= 0 ? node.children[0] : node.children[1];
+  const farChild = dist2 >= 0 ? node.children[1] : node.children[0];
   if (boxIntersectsFrustum(
     { x: node.mins[0], y: node.mins[1], z: node.mins[2] },
     { x: node.maxs[0], y: node.maxs[1], z: node.maxs[2] },
-    frustum
+    frustum2
   )) {
-    traverse(map, nearChild, camera, frustum, viewCluster, visibleFaces, visitedFaces);
-    traverse(map, farChild, camera, frustum, viewCluster, visibleFaces, visitedFaces);
+    traverse(map, nearChild, camera, frustum2, viewCluster, visibleFaces, visitedFaces);
+    traverse(map, farChild, camera, frustum2, viewCluster, visibleFaces, visitedFaces);
   }
 }
-function gatherVisibleFaces(map, cameraPosition, frustum) {
+function gatherVisibleFaces(map, cameraPosition, frustum2) {
   const viewLeaf = findLeafForPoint(map, cameraPosition);
   const viewCluster = viewLeaf >= 0 ? map.leafs[viewLeaf].cluster : -1;
   const visibleFaces = [];
   const visitedFaces = /* @__PURE__ */ new Set();
-  traverse(map, 0, cameraPosition, frustum, viewCluster, visibleFaces, visitedFaces);
+  traverse(map, 0, cameraPosition, frustum2, viewCluster, visibleFaces, visitedFaces);
   return visibleFaces;
 }
 
@@ -6984,7 +6990,7 @@ function buildMd2Geometry(model) {
   return { vertices, indices: new Uint16Array(indices) };
 }
 function buildMd2VertexData(model, geometry, blend) {
-  const { frame0, frame1, lerp: lerp3 } = blend;
+  const { frame0, frame1, lerp: lerp4 } = blend;
   const frameA = model.frames[frame0];
   const frameB = model.frames[frame1];
   if (!frameA || !frameB) {
@@ -6997,8 +7003,8 @@ function buildMd2VertexData(model, geometry, blend) {
     if (!vA || !vB) {
       throw new Error("MD2 vertex index out of range for frame");
     }
-    const position = lerpVec3(vA.position, vB.position, lerp3);
-    const normal = normalizeVec32(lerpVec3(vA.normal, vB.normal, lerp3));
+    const position = lerpVec3(vA.position, vB.position, lerp4);
+    const normal = normalizeVec32(lerpVec3(vA.normal, vB.normal, lerp4));
     const base = index * 8;
     data[base] = position.x;
     data[base + 1] = position.y;
@@ -7154,32 +7160,1754 @@ var Md2Pipeline = class {
   }
 };
 
+// ../../node_modules/.pnpm/gl-matrix@3.4.4/node_modules/gl-matrix/esm/common.js
+var EPSILON = 1e-6;
+var ARRAY_TYPE = typeof Float32Array !== "undefined" ? Float32Array : Array;
+var RANDOM = Math.random;
+function round(a) {
+  if (a >= 0) return Math.round(a);
+  return a % 0.5 === 0 ? Math.floor(a) : Math.round(a);
+}
+var degree = Math.PI / 180;
+var radian = 180 / Math.PI;
+
+// ../../node_modules/.pnpm/gl-matrix@3.4.4/node_modules/gl-matrix/esm/mat4.js
+var mat4_exports = {};
+__export(mat4_exports, {
+  add: () => add,
+  adjoint: () => adjoint,
+  clone: () => clone,
+  copy: () => copy,
+  create: () => create,
+  decompose: () => decompose,
+  determinant: () => determinant,
+  equals: () => equals,
+  exactEquals: () => exactEquals,
+  frob: () => frob,
+  fromQuat: () => fromQuat,
+  fromQuat2: () => fromQuat2,
+  fromRotation: () => fromRotation,
+  fromRotationTranslation: () => fromRotationTranslation,
+  fromRotationTranslationScale: () => fromRotationTranslationScale,
+  fromRotationTranslationScaleOrigin: () => fromRotationTranslationScaleOrigin,
+  fromScaling: () => fromScaling,
+  fromTranslation: () => fromTranslation,
+  fromValues: () => fromValues,
+  fromXRotation: () => fromXRotation,
+  fromYRotation: () => fromYRotation,
+  fromZRotation: () => fromZRotation,
+  frustum: () => frustum,
+  getRotation: () => getRotation,
+  getScaling: () => getScaling,
+  getTranslation: () => getTranslation,
+  identity: () => identity,
+  invert: () => invert,
+  lookAt: () => lookAt,
+  mul: () => mul,
+  multiply: () => multiply,
+  multiplyScalar: () => multiplyScalar,
+  multiplyScalarAndAdd: () => multiplyScalarAndAdd,
+  ortho: () => ortho,
+  orthoNO: () => orthoNO,
+  orthoZO: () => orthoZO,
+  perspective: () => perspective,
+  perspectiveFromFieldOfView: () => perspectiveFromFieldOfView,
+  perspectiveNO: () => perspectiveNO,
+  perspectiveZO: () => perspectiveZO,
+  rotate: () => rotate,
+  rotateX: () => rotateX,
+  rotateY: () => rotateY,
+  rotateZ: () => rotateZ,
+  scale: () => scale,
+  set: () => set,
+  str: () => str,
+  sub: () => sub,
+  subtract: () => subtract,
+  targetTo: () => targetTo,
+  translate: () => translate,
+  transpose: () => transpose
+});
+function create() {
+  var out = new ARRAY_TYPE(16);
+  if (ARRAY_TYPE != Float32Array) {
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 0;
+    out[4] = 0;
+    out[6] = 0;
+    out[7] = 0;
+    out[8] = 0;
+    out[9] = 0;
+    out[11] = 0;
+    out[12] = 0;
+    out[13] = 0;
+    out[14] = 0;
+  }
+  out[0] = 1;
+  out[5] = 1;
+  out[10] = 1;
+  out[15] = 1;
+  return out;
+}
+function clone(a) {
+  var out = new ARRAY_TYPE(16);
+  out[0] = a[0];
+  out[1] = a[1];
+  out[2] = a[2];
+  out[3] = a[3];
+  out[4] = a[4];
+  out[5] = a[5];
+  out[6] = a[6];
+  out[7] = a[7];
+  out[8] = a[8];
+  out[9] = a[9];
+  out[10] = a[10];
+  out[11] = a[11];
+  out[12] = a[12];
+  out[13] = a[13];
+  out[14] = a[14];
+  out[15] = a[15];
+  return out;
+}
+function copy(out, a) {
+  out[0] = a[0];
+  out[1] = a[1];
+  out[2] = a[2];
+  out[3] = a[3];
+  out[4] = a[4];
+  out[5] = a[5];
+  out[6] = a[6];
+  out[7] = a[7];
+  out[8] = a[8];
+  out[9] = a[9];
+  out[10] = a[10];
+  out[11] = a[11];
+  out[12] = a[12];
+  out[13] = a[13];
+  out[14] = a[14];
+  out[15] = a[15];
+  return out;
+}
+function fromValues(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {
+  var out = new ARRAY_TYPE(16);
+  out[0] = m00;
+  out[1] = m01;
+  out[2] = m02;
+  out[3] = m03;
+  out[4] = m10;
+  out[5] = m11;
+  out[6] = m12;
+  out[7] = m13;
+  out[8] = m20;
+  out[9] = m21;
+  out[10] = m22;
+  out[11] = m23;
+  out[12] = m30;
+  out[13] = m31;
+  out[14] = m32;
+  out[15] = m33;
+  return out;
+}
+function set(out, m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {
+  out[0] = m00;
+  out[1] = m01;
+  out[2] = m02;
+  out[3] = m03;
+  out[4] = m10;
+  out[5] = m11;
+  out[6] = m12;
+  out[7] = m13;
+  out[8] = m20;
+  out[9] = m21;
+  out[10] = m22;
+  out[11] = m23;
+  out[12] = m30;
+  out[13] = m31;
+  out[14] = m32;
+  out[15] = m33;
+  return out;
+}
+function identity(out) {
+  out[0] = 1;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = 1;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[10] = 1;
+  out[11] = 0;
+  out[12] = 0;
+  out[13] = 0;
+  out[14] = 0;
+  out[15] = 1;
+  return out;
+}
+function transpose(out, a) {
+  if (out === a) {
+    var a01 = a[1], a02 = a[2], a03 = a[3];
+    var a12 = a[6], a13 = a[7];
+    var a23 = a[11];
+    out[1] = a[4];
+    out[2] = a[8];
+    out[3] = a[12];
+    out[4] = a01;
+    out[6] = a[9];
+    out[7] = a[13];
+    out[8] = a02;
+    out[9] = a12;
+    out[11] = a[14];
+    out[12] = a03;
+    out[13] = a13;
+    out[14] = a23;
+  } else {
+    out[0] = a[0];
+    out[1] = a[4];
+    out[2] = a[8];
+    out[3] = a[12];
+    out[4] = a[1];
+    out[5] = a[5];
+    out[6] = a[9];
+    out[7] = a[13];
+    out[8] = a[2];
+    out[9] = a[6];
+    out[10] = a[10];
+    out[11] = a[14];
+    out[12] = a[3];
+    out[13] = a[7];
+    out[14] = a[11];
+    out[15] = a[15];
+  }
+  return out;
+}
+function invert(out, a) {
+  var a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3];
+  var a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7];
+  var a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11];
+  var a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15];
+  var b00 = a00 * a11 - a01 * a10;
+  var b01 = a00 * a12 - a02 * a10;
+  var b02 = a00 * a13 - a03 * a10;
+  var b03 = a01 * a12 - a02 * a11;
+  var b04 = a01 * a13 - a03 * a11;
+  var b05 = a02 * a13 - a03 * a12;
+  var b06 = a20 * a31 - a21 * a30;
+  var b07 = a20 * a32 - a22 * a30;
+  var b08 = a20 * a33 - a23 * a30;
+  var b09 = a21 * a32 - a22 * a31;
+  var b10 = a21 * a33 - a23 * a31;
+  var b11 = a22 * a33 - a23 * a32;
+  var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+  if (!det) {
+    return null;
+  }
+  det = 1 / det;
+  out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
+  out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
+  out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
+  out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;
+  out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
+  out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
+  out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
+  out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;
+  out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+  out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+  out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+  out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;
+  out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;
+  out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;
+  out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;
+  out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
+  return out;
+}
+function adjoint(out, a) {
+  var a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3];
+  var a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7];
+  var a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11];
+  var a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15];
+  var b00 = a00 * a11 - a01 * a10;
+  var b01 = a00 * a12 - a02 * a10;
+  var b02 = a00 * a13 - a03 * a10;
+  var b03 = a01 * a12 - a02 * a11;
+  var b04 = a01 * a13 - a03 * a11;
+  var b05 = a02 * a13 - a03 * a12;
+  var b06 = a20 * a31 - a21 * a30;
+  var b07 = a20 * a32 - a22 * a30;
+  var b08 = a20 * a33 - a23 * a30;
+  var b09 = a21 * a32 - a22 * a31;
+  var b10 = a21 * a33 - a23 * a31;
+  var b11 = a22 * a33 - a23 * a32;
+  out[0] = a11 * b11 - a12 * b10 + a13 * b09;
+  out[1] = a02 * b10 - a01 * b11 - a03 * b09;
+  out[2] = a31 * b05 - a32 * b04 + a33 * b03;
+  out[3] = a22 * b04 - a21 * b05 - a23 * b03;
+  out[4] = a12 * b08 - a10 * b11 - a13 * b07;
+  out[5] = a00 * b11 - a02 * b08 + a03 * b07;
+  out[6] = a32 * b02 - a30 * b05 - a33 * b01;
+  out[7] = a20 * b05 - a22 * b02 + a23 * b01;
+  out[8] = a10 * b10 - a11 * b08 + a13 * b06;
+  out[9] = a01 * b08 - a00 * b10 - a03 * b06;
+  out[10] = a30 * b04 - a31 * b02 + a33 * b00;
+  out[11] = a21 * b02 - a20 * b04 - a23 * b00;
+  out[12] = a11 * b07 - a10 * b09 - a12 * b06;
+  out[13] = a00 * b09 - a01 * b07 + a02 * b06;
+  out[14] = a31 * b01 - a30 * b03 - a32 * b00;
+  out[15] = a20 * b03 - a21 * b01 + a22 * b00;
+  return out;
+}
+function determinant(a) {
+  var a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3];
+  var a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7];
+  var a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11];
+  var a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15];
+  var b0 = a00 * a11 - a01 * a10;
+  var b1 = a00 * a12 - a02 * a10;
+  var b2 = a01 * a12 - a02 * a11;
+  var b3 = a20 * a31 - a21 * a30;
+  var b4 = a20 * a32 - a22 * a30;
+  var b5 = a21 * a32 - a22 * a31;
+  var b6 = a00 * b5 - a01 * b4 + a02 * b3;
+  var b7 = a10 * b5 - a11 * b4 + a12 * b3;
+  var b8 = a20 * b2 - a21 * b1 + a22 * b0;
+  var b9 = a30 * b2 - a31 * b1 + a32 * b0;
+  return a13 * b6 - a03 * b7 + a33 * b8 - a23 * b9;
+}
+function multiply(out, a, b) {
+  var a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3];
+  var a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7];
+  var a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11];
+  var a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15];
+  var b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3];
+  out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  b0 = b[4];
+  b1 = b[5];
+  b2 = b[6];
+  b3 = b[7];
+  out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  b0 = b[8];
+  b1 = b[9];
+  b2 = b[10];
+  b3 = b[11];
+  out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  b0 = b[12];
+  b1 = b[13];
+  b2 = b[14];
+  b3 = b[15];
+  out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  return out;
+}
+function translate(out, a, v) {
+  var x = v[0], y = v[1], z = v[2];
+  var a00, a01, a02, a03;
+  var a10, a11, a12, a13;
+  var a20, a21, a22, a23;
+  if (a === out) {
+    out[12] = a[0] * x + a[4] * y + a[8] * z + a[12];
+    out[13] = a[1] * x + a[5] * y + a[9] * z + a[13];
+    out[14] = a[2] * x + a[6] * y + a[10] * z + a[14];
+    out[15] = a[3] * x + a[7] * y + a[11] * z + a[15];
+  } else {
+    a00 = a[0];
+    a01 = a[1];
+    a02 = a[2];
+    a03 = a[3];
+    a10 = a[4];
+    a11 = a[5];
+    a12 = a[6];
+    a13 = a[7];
+    a20 = a[8];
+    a21 = a[9];
+    a22 = a[10];
+    a23 = a[11];
+    out[0] = a00;
+    out[1] = a01;
+    out[2] = a02;
+    out[3] = a03;
+    out[4] = a10;
+    out[5] = a11;
+    out[6] = a12;
+    out[7] = a13;
+    out[8] = a20;
+    out[9] = a21;
+    out[10] = a22;
+    out[11] = a23;
+    out[12] = a00 * x + a10 * y + a20 * z + a[12];
+    out[13] = a01 * x + a11 * y + a21 * z + a[13];
+    out[14] = a02 * x + a12 * y + a22 * z + a[14];
+    out[15] = a03 * x + a13 * y + a23 * z + a[15];
+  }
+  return out;
+}
+function scale(out, a, v) {
+  var x = v[0], y = v[1], z = v[2];
+  out[0] = a[0] * x;
+  out[1] = a[1] * x;
+  out[2] = a[2] * x;
+  out[3] = a[3] * x;
+  out[4] = a[4] * y;
+  out[5] = a[5] * y;
+  out[6] = a[6] * y;
+  out[7] = a[7] * y;
+  out[8] = a[8] * z;
+  out[9] = a[9] * z;
+  out[10] = a[10] * z;
+  out[11] = a[11] * z;
+  out[12] = a[12];
+  out[13] = a[13];
+  out[14] = a[14];
+  out[15] = a[15];
+  return out;
+}
+function rotate(out, a, rad, axis) {
+  var x = axis[0], y = axis[1], z = axis[2];
+  var len2 = Math.sqrt(x * x + y * y + z * z);
+  var s, c, t;
+  var a00, a01, a02, a03;
+  var a10, a11, a12, a13;
+  var a20, a21, a22, a23;
+  var b00, b01, b02;
+  var b10, b11, b12;
+  var b20, b21, b22;
+  if (len2 < EPSILON) {
+    return null;
+  }
+  len2 = 1 / len2;
+  x *= len2;
+  y *= len2;
+  z *= len2;
+  s = Math.sin(rad);
+  c = Math.cos(rad);
+  t = 1 - c;
+  a00 = a[0];
+  a01 = a[1];
+  a02 = a[2];
+  a03 = a[3];
+  a10 = a[4];
+  a11 = a[5];
+  a12 = a[6];
+  a13 = a[7];
+  a20 = a[8];
+  a21 = a[9];
+  a22 = a[10];
+  a23 = a[11];
+  b00 = x * x * t + c;
+  b01 = y * x * t + z * s;
+  b02 = z * x * t - y * s;
+  b10 = x * y * t - z * s;
+  b11 = y * y * t + c;
+  b12 = z * y * t + x * s;
+  b20 = x * z * t + y * s;
+  b21 = y * z * t - x * s;
+  b22 = z * z * t + c;
+  out[0] = a00 * b00 + a10 * b01 + a20 * b02;
+  out[1] = a01 * b00 + a11 * b01 + a21 * b02;
+  out[2] = a02 * b00 + a12 * b01 + a22 * b02;
+  out[3] = a03 * b00 + a13 * b01 + a23 * b02;
+  out[4] = a00 * b10 + a10 * b11 + a20 * b12;
+  out[5] = a01 * b10 + a11 * b11 + a21 * b12;
+  out[6] = a02 * b10 + a12 * b11 + a22 * b12;
+  out[7] = a03 * b10 + a13 * b11 + a23 * b12;
+  out[8] = a00 * b20 + a10 * b21 + a20 * b22;
+  out[9] = a01 * b20 + a11 * b21 + a21 * b22;
+  out[10] = a02 * b20 + a12 * b21 + a22 * b22;
+  out[11] = a03 * b20 + a13 * b21 + a23 * b22;
+  if (a !== out) {
+    out[12] = a[12];
+    out[13] = a[13];
+    out[14] = a[14];
+    out[15] = a[15];
+  }
+  return out;
+}
+function rotateX(out, a, rad) {
+  var s = Math.sin(rad);
+  var c = Math.cos(rad);
+  var a10 = a[4];
+  var a11 = a[5];
+  var a12 = a[6];
+  var a13 = a[7];
+  var a20 = a[8];
+  var a21 = a[9];
+  var a22 = a[10];
+  var a23 = a[11];
+  if (a !== out) {
+    out[0] = a[0];
+    out[1] = a[1];
+    out[2] = a[2];
+    out[3] = a[3];
+    out[12] = a[12];
+    out[13] = a[13];
+    out[14] = a[14];
+    out[15] = a[15];
+  }
+  out[4] = a10 * c + a20 * s;
+  out[5] = a11 * c + a21 * s;
+  out[6] = a12 * c + a22 * s;
+  out[7] = a13 * c + a23 * s;
+  out[8] = a20 * c - a10 * s;
+  out[9] = a21 * c - a11 * s;
+  out[10] = a22 * c - a12 * s;
+  out[11] = a23 * c - a13 * s;
+  return out;
+}
+function rotateY(out, a, rad) {
+  var s = Math.sin(rad);
+  var c = Math.cos(rad);
+  var a00 = a[0];
+  var a01 = a[1];
+  var a02 = a[2];
+  var a03 = a[3];
+  var a20 = a[8];
+  var a21 = a[9];
+  var a22 = a[10];
+  var a23 = a[11];
+  if (a !== out) {
+    out[4] = a[4];
+    out[5] = a[5];
+    out[6] = a[6];
+    out[7] = a[7];
+    out[12] = a[12];
+    out[13] = a[13];
+    out[14] = a[14];
+    out[15] = a[15];
+  }
+  out[0] = a00 * c - a20 * s;
+  out[1] = a01 * c - a21 * s;
+  out[2] = a02 * c - a22 * s;
+  out[3] = a03 * c - a23 * s;
+  out[8] = a00 * s + a20 * c;
+  out[9] = a01 * s + a21 * c;
+  out[10] = a02 * s + a22 * c;
+  out[11] = a03 * s + a23 * c;
+  return out;
+}
+function rotateZ(out, a, rad) {
+  var s = Math.sin(rad);
+  var c = Math.cos(rad);
+  var a00 = a[0];
+  var a01 = a[1];
+  var a02 = a[2];
+  var a03 = a[3];
+  var a10 = a[4];
+  var a11 = a[5];
+  var a12 = a[6];
+  var a13 = a[7];
+  if (a !== out) {
+    out[8] = a[8];
+    out[9] = a[9];
+    out[10] = a[10];
+    out[11] = a[11];
+    out[12] = a[12];
+    out[13] = a[13];
+    out[14] = a[14];
+    out[15] = a[15];
+  }
+  out[0] = a00 * c + a10 * s;
+  out[1] = a01 * c + a11 * s;
+  out[2] = a02 * c + a12 * s;
+  out[3] = a03 * c + a13 * s;
+  out[4] = a10 * c - a00 * s;
+  out[5] = a11 * c - a01 * s;
+  out[6] = a12 * c - a02 * s;
+  out[7] = a13 * c - a03 * s;
+  return out;
+}
+function fromTranslation(out, v) {
+  out[0] = 1;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = 1;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[10] = 1;
+  out[11] = 0;
+  out[12] = v[0];
+  out[13] = v[1];
+  out[14] = v[2];
+  out[15] = 1;
+  return out;
+}
+function fromScaling(out, v) {
+  out[0] = v[0];
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = v[1];
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[10] = v[2];
+  out[11] = 0;
+  out[12] = 0;
+  out[13] = 0;
+  out[14] = 0;
+  out[15] = 1;
+  return out;
+}
+function fromRotation(out, rad, axis) {
+  var x = axis[0], y = axis[1], z = axis[2];
+  var len2 = Math.sqrt(x * x + y * y + z * z);
+  var s, c, t;
+  if (len2 < EPSILON) {
+    return null;
+  }
+  len2 = 1 / len2;
+  x *= len2;
+  y *= len2;
+  z *= len2;
+  s = Math.sin(rad);
+  c = Math.cos(rad);
+  t = 1 - c;
+  out[0] = x * x * t + c;
+  out[1] = y * x * t + z * s;
+  out[2] = z * x * t - y * s;
+  out[3] = 0;
+  out[4] = x * y * t - z * s;
+  out[5] = y * y * t + c;
+  out[6] = z * y * t + x * s;
+  out[7] = 0;
+  out[8] = x * z * t + y * s;
+  out[9] = y * z * t - x * s;
+  out[10] = z * z * t + c;
+  out[11] = 0;
+  out[12] = 0;
+  out[13] = 0;
+  out[14] = 0;
+  out[15] = 1;
+  return out;
+}
+function fromXRotation(out, rad) {
+  var s = Math.sin(rad);
+  var c = Math.cos(rad);
+  out[0] = 1;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = c;
+  out[6] = s;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = -s;
+  out[10] = c;
+  out[11] = 0;
+  out[12] = 0;
+  out[13] = 0;
+  out[14] = 0;
+  out[15] = 1;
+  return out;
+}
+function fromYRotation(out, rad) {
+  var s = Math.sin(rad);
+  var c = Math.cos(rad);
+  out[0] = c;
+  out[1] = 0;
+  out[2] = -s;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = 1;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = s;
+  out[9] = 0;
+  out[10] = c;
+  out[11] = 0;
+  out[12] = 0;
+  out[13] = 0;
+  out[14] = 0;
+  out[15] = 1;
+  return out;
+}
+function fromZRotation(out, rad) {
+  var s = Math.sin(rad);
+  var c = Math.cos(rad);
+  out[0] = c;
+  out[1] = s;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = -s;
+  out[5] = c;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[10] = 1;
+  out[11] = 0;
+  out[12] = 0;
+  out[13] = 0;
+  out[14] = 0;
+  out[15] = 1;
+  return out;
+}
+function fromRotationTranslation(out, q, v) {
+  var x = q[0], y = q[1], z = q[2], w = q[3];
+  var x2 = x + x;
+  var y2 = y + y;
+  var z2 = z + z;
+  var xx = x * x2;
+  var xy = x * y2;
+  var xz = x * z2;
+  var yy = y * y2;
+  var yz = y * z2;
+  var zz = z * z2;
+  var wx = w * x2;
+  var wy = w * y2;
+  var wz = w * z2;
+  out[0] = 1 - (yy + zz);
+  out[1] = xy + wz;
+  out[2] = xz - wy;
+  out[3] = 0;
+  out[4] = xy - wz;
+  out[5] = 1 - (xx + zz);
+  out[6] = yz + wx;
+  out[7] = 0;
+  out[8] = xz + wy;
+  out[9] = yz - wx;
+  out[10] = 1 - (xx + yy);
+  out[11] = 0;
+  out[12] = v[0];
+  out[13] = v[1];
+  out[14] = v[2];
+  out[15] = 1;
+  return out;
+}
+function fromQuat2(out, a) {
+  var translation = new ARRAY_TYPE(3);
+  var bx = -a[0], by = -a[1], bz = -a[2], bw = a[3], ax = a[4], ay = a[5], az = a[6], aw = a[7];
+  var magnitude = bx * bx + by * by + bz * bz + bw * bw;
+  if (magnitude > 0) {
+    translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2 / magnitude;
+    translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2 / magnitude;
+    translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2 / magnitude;
+  } else {
+    translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2;
+    translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2;
+    translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2;
+  }
+  fromRotationTranslation(out, a, translation);
+  return out;
+}
+function getTranslation(out, mat) {
+  out[0] = mat[12];
+  out[1] = mat[13];
+  out[2] = mat[14];
+  return out;
+}
+function getScaling(out, mat) {
+  var m11 = mat[0];
+  var m12 = mat[1];
+  var m13 = mat[2];
+  var m21 = mat[4];
+  var m22 = mat[5];
+  var m23 = mat[6];
+  var m31 = mat[8];
+  var m32 = mat[9];
+  var m33 = mat[10];
+  out[0] = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13);
+  out[1] = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23);
+  out[2] = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33);
+  return out;
+}
+function getRotation(out, mat) {
+  var scaling = new ARRAY_TYPE(3);
+  getScaling(scaling, mat);
+  var is1 = 1 / scaling[0];
+  var is2 = 1 / scaling[1];
+  var is3 = 1 / scaling[2];
+  var sm11 = mat[0] * is1;
+  var sm12 = mat[1] * is2;
+  var sm13 = mat[2] * is3;
+  var sm21 = mat[4] * is1;
+  var sm22 = mat[5] * is2;
+  var sm23 = mat[6] * is3;
+  var sm31 = mat[8] * is1;
+  var sm32 = mat[9] * is2;
+  var sm33 = mat[10] * is3;
+  var trace = sm11 + sm22 + sm33;
+  var S = 0;
+  if (trace > 0) {
+    S = Math.sqrt(trace + 1) * 2;
+    out[3] = 0.25 * S;
+    out[0] = (sm23 - sm32) / S;
+    out[1] = (sm31 - sm13) / S;
+    out[2] = (sm12 - sm21) / S;
+  } else if (sm11 > sm22 && sm11 > sm33) {
+    S = Math.sqrt(1 + sm11 - sm22 - sm33) * 2;
+    out[3] = (sm23 - sm32) / S;
+    out[0] = 0.25 * S;
+    out[1] = (sm12 + sm21) / S;
+    out[2] = (sm31 + sm13) / S;
+  } else if (sm22 > sm33) {
+    S = Math.sqrt(1 + sm22 - sm11 - sm33) * 2;
+    out[3] = (sm31 - sm13) / S;
+    out[0] = (sm12 + sm21) / S;
+    out[1] = 0.25 * S;
+    out[2] = (sm23 + sm32) / S;
+  } else {
+    S = Math.sqrt(1 + sm33 - sm11 - sm22) * 2;
+    out[3] = (sm12 - sm21) / S;
+    out[0] = (sm31 + sm13) / S;
+    out[1] = (sm23 + sm32) / S;
+    out[2] = 0.25 * S;
+  }
+  return out;
+}
+function decompose(out_r, out_t, out_s, mat) {
+  out_t[0] = mat[12];
+  out_t[1] = mat[13];
+  out_t[2] = mat[14];
+  var m11 = mat[0];
+  var m12 = mat[1];
+  var m13 = mat[2];
+  var m21 = mat[4];
+  var m22 = mat[5];
+  var m23 = mat[6];
+  var m31 = mat[8];
+  var m32 = mat[9];
+  var m33 = mat[10];
+  out_s[0] = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13);
+  out_s[1] = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23);
+  out_s[2] = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33);
+  var is1 = 1 / out_s[0];
+  var is2 = 1 / out_s[1];
+  var is3 = 1 / out_s[2];
+  var sm11 = m11 * is1;
+  var sm12 = m12 * is2;
+  var sm13 = m13 * is3;
+  var sm21 = m21 * is1;
+  var sm22 = m22 * is2;
+  var sm23 = m23 * is3;
+  var sm31 = m31 * is1;
+  var sm32 = m32 * is2;
+  var sm33 = m33 * is3;
+  var trace = sm11 + sm22 + sm33;
+  var S = 0;
+  if (trace > 0) {
+    S = Math.sqrt(trace + 1) * 2;
+    out_r[3] = 0.25 * S;
+    out_r[0] = (sm23 - sm32) / S;
+    out_r[1] = (sm31 - sm13) / S;
+    out_r[2] = (sm12 - sm21) / S;
+  } else if (sm11 > sm22 && sm11 > sm33) {
+    S = Math.sqrt(1 + sm11 - sm22 - sm33) * 2;
+    out_r[3] = (sm23 - sm32) / S;
+    out_r[0] = 0.25 * S;
+    out_r[1] = (sm12 + sm21) / S;
+    out_r[2] = (sm31 + sm13) / S;
+  } else if (sm22 > sm33) {
+    S = Math.sqrt(1 + sm22 - sm11 - sm33) * 2;
+    out_r[3] = (sm31 - sm13) / S;
+    out_r[0] = (sm12 + sm21) / S;
+    out_r[1] = 0.25 * S;
+    out_r[2] = (sm23 + sm32) / S;
+  } else {
+    S = Math.sqrt(1 + sm33 - sm11 - sm22) * 2;
+    out_r[3] = (sm12 - sm21) / S;
+    out_r[0] = (sm31 + sm13) / S;
+    out_r[1] = (sm23 + sm32) / S;
+    out_r[2] = 0.25 * S;
+  }
+  return out_r;
+}
+function fromRotationTranslationScale(out, q, v, s) {
+  var x = q[0], y = q[1], z = q[2], w = q[3];
+  var x2 = x + x;
+  var y2 = y + y;
+  var z2 = z + z;
+  var xx = x * x2;
+  var xy = x * y2;
+  var xz = x * z2;
+  var yy = y * y2;
+  var yz = y * z2;
+  var zz = z * z2;
+  var wx = w * x2;
+  var wy = w * y2;
+  var wz = w * z2;
+  var sx = s[0];
+  var sy = s[1];
+  var sz = s[2];
+  out[0] = (1 - (yy + zz)) * sx;
+  out[1] = (xy + wz) * sx;
+  out[2] = (xz - wy) * sx;
+  out[3] = 0;
+  out[4] = (xy - wz) * sy;
+  out[5] = (1 - (xx + zz)) * sy;
+  out[6] = (yz + wx) * sy;
+  out[7] = 0;
+  out[8] = (xz + wy) * sz;
+  out[9] = (yz - wx) * sz;
+  out[10] = (1 - (xx + yy)) * sz;
+  out[11] = 0;
+  out[12] = v[0];
+  out[13] = v[1];
+  out[14] = v[2];
+  out[15] = 1;
+  return out;
+}
+function fromRotationTranslationScaleOrigin(out, q, v, s, o) {
+  var x = q[0], y = q[1], z = q[2], w = q[3];
+  var x2 = x + x;
+  var y2 = y + y;
+  var z2 = z + z;
+  var xx = x * x2;
+  var xy = x * y2;
+  var xz = x * z2;
+  var yy = y * y2;
+  var yz = y * z2;
+  var zz = z * z2;
+  var wx = w * x2;
+  var wy = w * y2;
+  var wz = w * z2;
+  var sx = s[0];
+  var sy = s[1];
+  var sz = s[2];
+  var ox = o[0];
+  var oy = o[1];
+  var oz = o[2];
+  var out0 = (1 - (yy + zz)) * sx;
+  var out1 = (xy + wz) * sx;
+  var out2 = (xz - wy) * sx;
+  var out4 = (xy - wz) * sy;
+  var out5 = (1 - (xx + zz)) * sy;
+  var out6 = (yz + wx) * sy;
+  var out8 = (xz + wy) * sz;
+  var out9 = (yz - wx) * sz;
+  var out10 = (1 - (xx + yy)) * sz;
+  out[0] = out0;
+  out[1] = out1;
+  out[2] = out2;
+  out[3] = 0;
+  out[4] = out4;
+  out[5] = out5;
+  out[6] = out6;
+  out[7] = 0;
+  out[8] = out8;
+  out[9] = out9;
+  out[10] = out10;
+  out[11] = 0;
+  out[12] = v[0] + ox - (out0 * ox + out4 * oy + out8 * oz);
+  out[13] = v[1] + oy - (out1 * ox + out5 * oy + out9 * oz);
+  out[14] = v[2] + oz - (out2 * ox + out6 * oy + out10 * oz);
+  out[15] = 1;
+  return out;
+}
+function fromQuat(out, q) {
+  var x = q[0], y = q[1], z = q[2], w = q[3];
+  var x2 = x + x;
+  var y2 = y + y;
+  var z2 = z + z;
+  var xx = x * x2;
+  var yx = y * x2;
+  var yy = y * y2;
+  var zx = z * x2;
+  var zy = z * y2;
+  var zz = z * z2;
+  var wx = w * x2;
+  var wy = w * y2;
+  var wz = w * z2;
+  out[0] = 1 - yy - zz;
+  out[1] = yx + wz;
+  out[2] = zx - wy;
+  out[3] = 0;
+  out[4] = yx - wz;
+  out[5] = 1 - xx - zz;
+  out[6] = zy + wx;
+  out[7] = 0;
+  out[8] = zx + wy;
+  out[9] = zy - wx;
+  out[10] = 1 - xx - yy;
+  out[11] = 0;
+  out[12] = 0;
+  out[13] = 0;
+  out[14] = 0;
+  out[15] = 1;
+  return out;
+}
+function frustum(out, left, right, bottom, top, near, far) {
+  var rl = 1 / (right - left);
+  var tb = 1 / (top - bottom);
+  var nf = 1 / (near - far);
+  out[0] = near * 2 * rl;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = near * 2 * tb;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = (right + left) * rl;
+  out[9] = (top + bottom) * tb;
+  out[10] = (far + near) * nf;
+  out[11] = -1;
+  out[12] = 0;
+  out[13] = 0;
+  out[14] = far * near * 2 * nf;
+  out[15] = 0;
+  return out;
+}
+function perspectiveNO(out, fovy, aspect, near, far) {
+  var f = 1 / Math.tan(fovy / 2);
+  out[0] = f / aspect;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = f;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[11] = -1;
+  out[12] = 0;
+  out[13] = 0;
+  out[15] = 0;
+  if (far != null && far !== Infinity) {
+    var nf = 1 / (near - far);
+    out[10] = (far + near) * nf;
+    out[14] = 2 * far * near * nf;
+  } else {
+    out[10] = -1;
+    out[14] = -2 * near;
+  }
+  return out;
+}
+var perspective = perspectiveNO;
+function perspectiveZO(out, fovy, aspect, near, far) {
+  var f = 1 / Math.tan(fovy / 2);
+  out[0] = f / aspect;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = f;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[11] = -1;
+  out[12] = 0;
+  out[13] = 0;
+  out[15] = 0;
+  if (far != null && far !== Infinity) {
+    var nf = 1 / (near - far);
+    out[10] = far * nf;
+    out[14] = far * near * nf;
+  } else {
+    out[10] = -1;
+    out[14] = -near;
+  }
+  return out;
+}
+function perspectiveFromFieldOfView(out, fov, near, far) {
+  var upTan = Math.tan(fov.upDegrees * Math.PI / 180);
+  var downTan = Math.tan(fov.downDegrees * Math.PI / 180);
+  var leftTan = Math.tan(fov.leftDegrees * Math.PI / 180);
+  var rightTan = Math.tan(fov.rightDegrees * Math.PI / 180);
+  var xScale = 2 / (leftTan + rightTan);
+  var yScale = 2 / (upTan + downTan);
+  out[0] = xScale;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = yScale;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = -((leftTan - rightTan) * xScale * 0.5);
+  out[9] = (upTan - downTan) * yScale * 0.5;
+  out[10] = far / (near - far);
+  out[11] = -1;
+  out[12] = 0;
+  out[13] = 0;
+  out[14] = far * near / (near - far);
+  out[15] = 0;
+  return out;
+}
+function orthoNO(out, left, right, bottom, top, near, far) {
+  var lr = 1 / (left - right);
+  var bt = 1 / (bottom - top);
+  var nf = 1 / (near - far);
+  out[0] = -2 * lr;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = -2 * bt;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[10] = 2 * nf;
+  out[11] = 0;
+  out[12] = (left + right) * lr;
+  out[13] = (top + bottom) * bt;
+  out[14] = (far + near) * nf;
+  out[15] = 1;
+  return out;
+}
+var ortho = orthoNO;
+function orthoZO(out, left, right, bottom, top, near, far) {
+  var lr = 1 / (left - right);
+  var bt = 1 / (bottom - top);
+  var nf = 1 / (near - far);
+  out[0] = -2 * lr;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = -2 * bt;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[10] = nf;
+  out[11] = 0;
+  out[12] = (left + right) * lr;
+  out[13] = (top + bottom) * bt;
+  out[14] = near * nf;
+  out[15] = 1;
+  return out;
+}
+function lookAt(out, eye, center, up) {
+  var x0, x1, x2, y0, y1, y2, z0, z1, z2, len2;
+  var eyex = eye[0];
+  var eyey = eye[1];
+  var eyez = eye[2];
+  var upx = up[0];
+  var upy = up[1];
+  var upz = up[2];
+  var centerx = center[0];
+  var centery = center[1];
+  var centerz = center[2];
+  if (Math.abs(eyex - centerx) < EPSILON && Math.abs(eyey - centery) < EPSILON && Math.abs(eyez - centerz) < EPSILON) {
+    return identity(out);
+  }
+  z0 = eyex - centerx;
+  z1 = eyey - centery;
+  z2 = eyez - centerz;
+  len2 = 1 / Math.sqrt(z0 * z0 + z1 * z1 + z2 * z2);
+  z0 *= len2;
+  z1 *= len2;
+  z2 *= len2;
+  x0 = upy * z2 - upz * z1;
+  x1 = upz * z0 - upx * z2;
+  x2 = upx * z1 - upy * z0;
+  len2 = Math.sqrt(x0 * x0 + x1 * x1 + x2 * x2);
+  if (!len2) {
+    x0 = 0;
+    x1 = 0;
+    x2 = 0;
+  } else {
+    len2 = 1 / len2;
+    x0 *= len2;
+    x1 *= len2;
+    x2 *= len2;
+  }
+  y0 = z1 * x2 - z2 * x1;
+  y1 = z2 * x0 - z0 * x2;
+  y2 = z0 * x1 - z1 * x0;
+  len2 = Math.sqrt(y0 * y0 + y1 * y1 + y2 * y2);
+  if (!len2) {
+    y0 = 0;
+    y1 = 0;
+    y2 = 0;
+  } else {
+    len2 = 1 / len2;
+    y0 *= len2;
+    y1 *= len2;
+    y2 *= len2;
+  }
+  out[0] = x0;
+  out[1] = y0;
+  out[2] = z0;
+  out[3] = 0;
+  out[4] = x1;
+  out[5] = y1;
+  out[6] = z1;
+  out[7] = 0;
+  out[8] = x2;
+  out[9] = y2;
+  out[10] = z2;
+  out[11] = 0;
+  out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez);
+  out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez);
+  out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez);
+  out[15] = 1;
+  return out;
+}
+function targetTo(out, eye, target, up) {
+  var eyex = eye[0], eyey = eye[1], eyez = eye[2], upx = up[0], upy = up[1], upz = up[2];
+  var z0 = eyex - target[0], z1 = eyey - target[1], z2 = eyez - target[2];
+  var len2 = z0 * z0 + z1 * z1 + z2 * z2;
+  if (len2 > 0) {
+    len2 = 1 / Math.sqrt(len2);
+    z0 *= len2;
+    z1 *= len2;
+    z2 *= len2;
+  }
+  var x0 = upy * z2 - upz * z1, x1 = upz * z0 - upx * z2, x2 = upx * z1 - upy * z0;
+  len2 = x0 * x0 + x1 * x1 + x2 * x2;
+  if (len2 > 0) {
+    len2 = 1 / Math.sqrt(len2);
+    x0 *= len2;
+    x1 *= len2;
+    x2 *= len2;
+  }
+  out[0] = x0;
+  out[1] = x1;
+  out[2] = x2;
+  out[3] = 0;
+  out[4] = z1 * x2 - z2 * x1;
+  out[5] = z2 * x0 - z0 * x2;
+  out[6] = z0 * x1 - z1 * x0;
+  out[7] = 0;
+  out[8] = z0;
+  out[9] = z1;
+  out[10] = z2;
+  out[11] = 0;
+  out[12] = eyex;
+  out[13] = eyey;
+  out[14] = eyez;
+  out[15] = 1;
+  return out;
+}
+function str(a) {
+  return "mat4(" + a[0] + ", " + a[1] + ", " + a[2] + ", " + a[3] + ", " + a[4] + ", " + a[5] + ", " + a[6] + ", " + a[7] + ", " + a[8] + ", " + a[9] + ", " + a[10] + ", " + a[11] + ", " + a[12] + ", " + a[13] + ", " + a[14] + ", " + a[15] + ")";
+}
+function frob(a) {
+  return Math.sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3] + a[4] * a[4] + a[5] * a[5] + a[6] * a[6] + a[7] * a[7] + a[8] * a[8] + a[9] * a[9] + a[10] * a[10] + a[11] * a[11] + a[12] * a[12] + a[13] * a[13] + a[14] * a[14] + a[15] * a[15]);
+}
+function add(out, a, b) {
+  out[0] = a[0] + b[0];
+  out[1] = a[1] + b[1];
+  out[2] = a[2] + b[2];
+  out[3] = a[3] + b[3];
+  out[4] = a[4] + b[4];
+  out[5] = a[5] + b[5];
+  out[6] = a[6] + b[6];
+  out[7] = a[7] + b[7];
+  out[8] = a[8] + b[8];
+  out[9] = a[9] + b[9];
+  out[10] = a[10] + b[10];
+  out[11] = a[11] + b[11];
+  out[12] = a[12] + b[12];
+  out[13] = a[13] + b[13];
+  out[14] = a[14] + b[14];
+  out[15] = a[15] + b[15];
+  return out;
+}
+function subtract(out, a, b) {
+  out[0] = a[0] - b[0];
+  out[1] = a[1] - b[1];
+  out[2] = a[2] - b[2];
+  out[3] = a[3] - b[3];
+  out[4] = a[4] - b[4];
+  out[5] = a[5] - b[5];
+  out[6] = a[6] - b[6];
+  out[7] = a[7] - b[7];
+  out[8] = a[8] - b[8];
+  out[9] = a[9] - b[9];
+  out[10] = a[10] - b[10];
+  out[11] = a[11] - b[11];
+  out[12] = a[12] - b[12];
+  out[13] = a[13] - b[13];
+  out[14] = a[14] - b[14];
+  out[15] = a[15] - b[15];
+  return out;
+}
+function multiplyScalar(out, a, b) {
+  out[0] = a[0] * b;
+  out[1] = a[1] * b;
+  out[2] = a[2] * b;
+  out[3] = a[3] * b;
+  out[4] = a[4] * b;
+  out[5] = a[5] * b;
+  out[6] = a[6] * b;
+  out[7] = a[7] * b;
+  out[8] = a[8] * b;
+  out[9] = a[9] * b;
+  out[10] = a[10] * b;
+  out[11] = a[11] * b;
+  out[12] = a[12] * b;
+  out[13] = a[13] * b;
+  out[14] = a[14] * b;
+  out[15] = a[15] * b;
+  return out;
+}
+function multiplyScalarAndAdd(out, a, b, scale3) {
+  out[0] = a[0] + b[0] * scale3;
+  out[1] = a[1] + b[1] * scale3;
+  out[2] = a[2] + b[2] * scale3;
+  out[3] = a[3] + b[3] * scale3;
+  out[4] = a[4] + b[4] * scale3;
+  out[5] = a[5] + b[5] * scale3;
+  out[6] = a[6] + b[6] * scale3;
+  out[7] = a[7] + b[7] * scale3;
+  out[8] = a[8] + b[8] * scale3;
+  out[9] = a[9] + b[9] * scale3;
+  out[10] = a[10] + b[10] * scale3;
+  out[11] = a[11] + b[11] * scale3;
+  out[12] = a[12] + b[12] * scale3;
+  out[13] = a[13] + b[13] * scale3;
+  out[14] = a[14] + b[14] * scale3;
+  out[15] = a[15] + b[15] * scale3;
+  return out;
+}
+function exactEquals(a, b) {
+  return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5] && a[6] === b[6] && a[7] === b[7] && a[8] === b[8] && a[9] === b[9] && a[10] === b[10] && a[11] === b[11] && a[12] === b[12] && a[13] === b[13] && a[14] === b[14] && a[15] === b[15];
+}
+function equals(a, b) {
+  var a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3];
+  var a4 = a[4], a5 = a[5], a6 = a[6], a7 = a[7];
+  var a8 = a[8], a9 = a[9], a10 = a[10], a11 = a[11];
+  var a12 = a[12], a13 = a[13], a14 = a[14], a15 = a[15];
+  var b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3];
+  var b4 = b[4], b5 = b[5], b6 = b[6], b7 = b[7];
+  var b8 = b[8], b9 = b[9], b10 = b[10], b11 = b[11];
+  var b12 = b[12], b13 = b[13], b14 = b[14], b15 = b[15];
+  return Math.abs(a0 - b0) <= EPSILON * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= EPSILON * Math.max(1, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= EPSILON * Math.max(1, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= EPSILON * Math.max(1, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= EPSILON * Math.max(1, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= EPSILON * Math.max(1, Math.abs(a7), Math.abs(b7)) && Math.abs(a8 - b8) <= EPSILON * Math.max(1, Math.abs(a8), Math.abs(b8)) && Math.abs(a9 - b9) <= EPSILON * Math.max(1, Math.abs(a9), Math.abs(b9)) && Math.abs(a10 - b10) <= EPSILON * Math.max(1, Math.abs(a10), Math.abs(b10)) && Math.abs(a11 - b11) <= EPSILON * Math.max(1, Math.abs(a11), Math.abs(b11)) && Math.abs(a12 - b12) <= EPSILON * Math.max(1, Math.abs(a12), Math.abs(b12)) && Math.abs(a13 - b13) <= EPSILON * Math.max(1, Math.abs(a13), Math.abs(b13)) && Math.abs(a14 - b14) <= EPSILON * Math.max(1, Math.abs(a14), Math.abs(b14)) && Math.abs(a15 - b15) <= EPSILON * Math.max(1, Math.abs(a15), Math.abs(b15));
+}
+var mul = multiply;
+var sub = subtract;
+
+// ../../node_modules/.pnpm/gl-matrix@3.4.4/node_modules/gl-matrix/esm/vec3.js
+var vec3_exports = {};
+__export(vec3_exports, {
+  add: () => add2,
+  angle: () => angle,
+  bezier: () => bezier,
+  ceil: () => ceil,
+  clone: () => clone2,
+  copy: () => copy2,
+  create: () => create2,
+  cross: () => cross,
+  dist: () => dist,
+  distance: () => distance,
+  div: () => div,
+  divide: () => divide,
+  dot: () => dot,
+  equals: () => equals2,
+  exactEquals: () => exactEquals2,
+  floor: () => floor,
+  forEach: () => forEach,
+  fromValues: () => fromValues2,
+  hermite: () => hermite,
+  inverse: () => inverse,
+  len: () => len,
+  length: () => length,
+  lerp: () => lerp2,
+  max: () => max,
+  min: () => min,
+  mul: () => mul2,
+  multiply: () => multiply2,
+  negate: () => negate,
+  normalize: () => normalize,
+  random: () => random,
+  rotateX: () => rotateX2,
+  rotateY: () => rotateY2,
+  rotateZ: () => rotateZ2,
+  round: () => round2,
+  scale: () => scale2,
+  scaleAndAdd: () => scaleAndAdd,
+  set: () => set2,
+  slerp: () => slerp,
+  sqrDist: () => sqrDist,
+  sqrLen: () => sqrLen,
+  squaredDistance: () => squaredDistance,
+  squaredLength: () => squaredLength,
+  str: () => str2,
+  sub: () => sub2,
+  subtract: () => subtract2,
+  transformMat3: () => transformMat3,
+  transformMat4: () => transformMat4,
+  transformQuat: () => transformQuat,
+  zero: () => zero
+});
+function create2() {
+  var out = new ARRAY_TYPE(3);
+  if (ARRAY_TYPE != Float32Array) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+  }
+  return out;
+}
+function clone2(a) {
+  var out = new ARRAY_TYPE(3);
+  out[0] = a[0];
+  out[1] = a[1];
+  out[2] = a[2];
+  return out;
+}
+function length(a) {
+  var x = a[0];
+  var y = a[1];
+  var z = a[2];
+  return Math.sqrt(x * x + y * y + z * z);
+}
+function fromValues2(x, y, z) {
+  var out = new ARRAY_TYPE(3);
+  out[0] = x;
+  out[1] = y;
+  out[2] = z;
+  return out;
+}
+function copy2(out, a) {
+  out[0] = a[0];
+  out[1] = a[1];
+  out[2] = a[2];
+  return out;
+}
+function set2(out, x, y, z) {
+  out[0] = x;
+  out[1] = y;
+  out[2] = z;
+  return out;
+}
+function add2(out, a, b) {
+  out[0] = a[0] + b[0];
+  out[1] = a[1] + b[1];
+  out[2] = a[2] + b[2];
+  return out;
+}
+function subtract2(out, a, b) {
+  out[0] = a[0] - b[0];
+  out[1] = a[1] - b[1];
+  out[2] = a[2] - b[2];
+  return out;
+}
+function multiply2(out, a, b) {
+  out[0] = a[0] * b[0];
+  out[1] = a[1] * b[1];
+  out[2] = a[2] * b[2];
+  return out;
+}
+function divide(out, a, b) {
+  out[0] = a[0] / b[0];
+  out[1] = a[1] / b[1];
+  out[2] = a[2] / b[2];
+  return out;
+}
+function ceil(out, a) {
+  out[0] = Math.ceil(a[0]);
+  out[1] = Math.ceil(a[1]);
+  out[2] = Math.ceil(a[2]);
+  return out;
+}
+function floor(out, a) {
+  out[0] = Math.floor(a[0]);
+  out[1] = Math.floor(a[1]);
+  out[2] = Math.floor(a[2]);
+  return out;
+}
+function min(out, a, b) {
+  out[0] = Math.min(a[0], b[0]);
+  out[1] = Math.min(a[1], b[1]);
+  out[2] = Math.min(a[2], b[2]);
+  return out;
+}
+function max(out, a, b) {
+  out[0] = Math.max(a[0], b[0]);
+  out[1] = Math.max(a[1], b[1]);
+  out[2] = Math.max(a[2], b[2]);
+  return out;
+}
+function round2(out, a) {
+  out[0] = round(a[0]);
+  out[1] = round(a[1]);
+  out[2] = round(a[2]);
+  return out;
+}
+function scale2(out, a, b) {
+  out[0] = a[0] * b;
+  out[1] = a[1] * b;
+  out[2] = a[2] * b;
+  return out;
+}
+function scaleAndAdd(out, a, b, scale3) {
+  out[0] = a[0] + b[0] * scale3;
+  out[1] = a[1] + b[1] * scale3;
+  out[2] = a[2] + b[2] * scale3;
+  return out;
+}
+function distance(a, b) {
+  var x = b[0] - a[0];
+  var y = b[1] - a[1];
+  var z = b[2] - a[2];
+  return Math.sqrt(x * x + y * y + z * z);
+}
+function squaredDistance(a, b) {
+  var x = b[0] - a[0];
+  var y = b[1] - a[1];
+  var z = b[2] - a[2];
+  return x * x + y * y + z * z;
+}
+function squaredLength(a) {
+  var x = a[0];
+  var y = a[1];
+  var z = a[2];
+  return x * x + y * y + z * z;
+}
+function negate(out, a) {
+  out[0] = -a[0];
+  out[1] = -a[1];
+  out[2] = -a[2];
+  return out;
+}
+function inverse(out, a) {
+  out[0] = 1 / a[0];
+  out[1] = 1 / a[1];
+  out[2] = 1 / a[2];
+  return out;
+}
+function normalize(out, a) {
+  var x = a[0];
+  var y = a[1];
+  var z = a[2];
+  var len2 = x * x + y * y + z * z;
+  if (len2 > 0) {
+    len2 = 1 / Math.sqrt(len2);
+  }
+  out[0] = a[0] * len2;
+  out[1] = a[1] * len2;
+  out[2] = a[2] * len2;
+  return out;
+}
+function dot(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function cross(out, a, b) {
+  var ax = a[0], ay = a[1], az = a[2];
+  var bx = b[0], by = b[1], bz = b[2];
+  out[0] = ay * bz - az * by;
+  out[1] = az * bx - ax * bz;
+  out[2] = ax * by - ay * bx;
+  return out;
+}
+function lerp2(out, a, b, t) {
+  var ax = a[0];
+  var ay = a[1];
+  var az = a[2];
+  out[0] = ax + t * (b[0] - ax);
+  out[1] = ay + t * (b[1] - ay);
+  out[2] = az + t * (b[2] - az);
+  return out;
+}
+function slerp(out, a, b, t) {
+  var angle2 = Math.acos(Math.min(Math.max(dot(a, b), -1), 1));
+  var sinTotal = Math.sin(angle2);
+  var ratioA = Math.sin((1 - t) * angle2) / sinTotal;
+  var ratioB = Math.sin(t * angle2) / sinTotal;
+  out[0] = ratioA * a[0] + ratioB * b[0];
+  out[1] = ratioA * a[1] + ratioB * b[1];
+  out[2] = ratioA * a[2] + ratioB * b[2];
+  return out;
+}
+function hermite(out, a, b, c, d, t) {
+  var factorTimes2 = t * t;
+  var factor1 = factorTimes2 * (2 * t - 3) + 1;
+  var factor2 = factorTimes2 * (t - 2) + t;
+  var factor3 = factorTimes2 * (t - 1);
+  var factor4 = factorTimes2 * (3 - 2 * t);
+  out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;
+  out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;
+  out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;
+  return out;
+}
+function bezier(out, a, b, c, d, t) {
+  var inverseFactor = 1 - t;
+  var inverseFactorTimesTwo = inverseFactor * inverseFactor;
+  var factorTimes2 = t * t;
+  var factor1 = inverseFactorTimesTwo * inverseFactor;
+  var factor2 = 3 * t * inverseFactorTimesTwo;
+  var factor3 = 3 * factorTimes2 * inverseFactor;
+  var factor4 = factorTimes2 * t;
+  out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;
+  out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;
+  out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;
+  return out;
+}
+function random(out, scale3) {
+  scale3 = scale3 === void 0 ? 1 : scale3;
+  var r = RANDOM() * 2 * Math.PI;
+  var z = RANDOM() * 2 - 1;
+  var zScale = Math.sqrt(1 - z * z) * scale3;
+  out[0] = Math.cos(r) * zScale;
+  out[1] = Math.sin(r) * zScale;
+  out[2] = z * scale3;
+  return out;
+}
+function transformMat4(out, a, m) {
+  var x = a[0], y = a[1], z = a[2];
+  var w = m[3] * x + m[7] * y + m[11] * z + m[15];
+  w = w || 1;
+  out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w;
+  out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w;
+  out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;
+  return out;
+}
+function transformMat3(out, a, m) {
+  var x = a[0], y = a[1], z = a[2];
+  out[0] = x * m[0] + y * m[3] + z * m[6];
+  out[1] = x * m[1] + y * m[4] + z * m[7];
+  out[2] = x * m[2] + y * m[5] + z * m[8];
+  return out;
+}
+function transformQuat(out, a, q) {
+  var qx = q[0], qy = q[1], qz = q[2], qw = q[3];
+  var vx = a[0], vy = a[1], vz = a[2];
+  var tx = qy * vz - qz * vy;
+  var ty = qz * vx - qx * vz;
+  var tz = qx * vy - qy * vx;
+  tx = tx + tx;
+  ty = ty + ty;
+  tz = tz + tz;
+  out[0] = vx + qw * tx + qy * tz - qz * ty;
+  out[1] = vy + qw * ty + qz * tx - qx * tz;
+  out[2] = vz + qw * tz + qx * ty - qy * tx;
+  return out;
+}
+function rotateX2(out, a, b, rad) {
+  var p = [], r = [];
+  p[0] = a[0] - b[0];
+  p[1] = a[1] - b[1];
+  p[2] = a[2] - b[2];
+  r[0] = p[0];
+  r[1] = p[1] * Math.cos(rad) - p[2] * Math.sin(rad);
+  r[2] = p[1] * Math.sin(rad) + p[2] * Math.cos(rad);
+  out[0] = r[0] + b[0];
+  out[1] = r[1] + b[1];
+  out[2] = r[2] + b[2];
+  return out;
+}
+function rotateY2(out, a, b, rad) {
+  var p = [], r = [];
+  p[0] = a[0] - b[0];
+  p[1] = a[1] - b[1];
+  p[2] = a[2] - b[2];
+  r[0] = p[2] * Math.sin(rad) + p[0] * Math.cos(rad);
+  r[1] = p[1];
+  r[2] = p[2] * Math.cos(rad) - p[0] * Math.sin(rad);
+  out[0] = r[0] + b[0];
+  out[1] = r[1] + b[1];
+  out[2] = r[2] + b[2];
+  return out;
+}
+function rotateZ2(out, a, b, rad) {
+  var p = [], r = [];
+  p[0] = a[0] - b[0];
+  p[1] = a[1] - b[1];
+  p[2] = a[2] - b[2];
+  r[0] = p[0] * Math.cos(rad) - p[1] * Math.sin(rad);
+  r[1] = p[0] * Math.sin(rad) + p[1] * Math.cos(rad);
+  r[2] = p[2];
+  out[0] = r[0] + b[0];
+  out[1] = r[1] + b[1];
+  out[2] = r[2] + b[2];
+  return out;
+}
+function angle(a, b) {
+  var ax = a[0], ay = a[1], az = a[2], bx = b[0], by = b[1], bz = b[2], mag = Math.sqrt((ax * ax + ay * ay + az * az) * (bx * bx + by * by + bz * bz)), cosine = mag && dot(a, b) / mag;
+  return Math.acos(Math.min(Math.max(cosine, -1), 1));
+}
+function zero(out) {
+  out[0] = 0;
+  out[1] = 0;
+  out[2] = 0;
+  return out;
+}
+function str2(a) {
+  return "vec3(" + a[0] + ", " + a[1] + ", " + a[2] + ")";
+}
+function exactEquals2(a, b) {
+  return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
+}
+function equals2(a, b) {
+  var a0 = a[0], a1 = a[1], a2 = a[2];
+  var b0 = b[0], b1 = b[1], b2 = b[2];
+  return Math.abs(a0 - b0) <= EPSILON * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1, Math.abs(a2), Math.abs(b2));
+}
+var sub2 = subtract2;
+var mul2 = multiply2;
+var div = divide;
+var dist = distance;
+var sqrDist = squaredDistance;
+var len = length;
+var sqrLen = squaredLength;
+var forEach = (function() {
+  var vec = create2();
+  return function(a, stride, offset, count, fn, arg) {
+    var i, l;
+    if (!stride) {
+      stride = 3;
+    }
+    if (!offset) {
+      offset = 0;
+    }
+    if (count) {
+      l = Math.min(count * stride + offset, a.length);
+    } else {
+      l = a.length;
+    }
+    for (i = offset; i < l; i += stride) {
+      vec[0] = a[i];
+      vec[1] = a[i + 1];
+      vec[2] = a[i + 2];
+      fn(vec, vec, arg);
+      a[i] = vec[0];
+      a[i + 1] = vec[1];
+      a[i + 2] = vec[2];
+    }
+    return a;
+  };
+})();
+
 // src/render/camera.ts
-import { mat4, vec3 } from "gl-matrix";
 var Camera = class {
   constructor() {
-    this._position = vec3.create();
-    this._angles = vec3.create();
+    this._position = vec3_exports.create();
+    this._angles = vec3_exports.create();
     // pitch, yaw, roll
-    this._bobAngles = vec3.create();
-    this._bobOffset = vec3.create();
-    this._kickAngles = vec3.create();
+    this._bobAngles = vec3_exports.create();
+    this._bobOffset = vec3_exports.create();
+    this._kickAngles = vec3_exports.create();
     this._rollAngle = 0;
     this._fov = 90;
     this._aspect = 1;
     this._near = 0.1;
     this._far = 1e3;
-    this._viewMatrix = mat4.create();
-    this._projectionMatrix = mat4.create();
-    this._viewProjectionMatrix = mat4.create();
+    this._viewMatrix = mat4_exports.create();
+    this._projectionMatrix = mat4_exports.create();
+    this._viewProjectionMatrix = mat4_exports.create();
     this._dirty = true;
   }
   get position() {
     return this._position;
   }
   set position(value) {
-    if (!vec3.equals(this._position, value)) {
-      vec3.copy(this._position, value);
+    if (!vec3_exports.equals(this._position, value)) {
+      vec3_exports.copy(this._position, value);
       this._dirty = true;
       this.triggerMoveEvent();
     }
@@ -7188,8 +8916,8 @@ var Camera = class {
     return this._angles;
   }
   set angles(value) {
-    if (!vec3.equals(this._angles, value)) {
-      vec3.copy(this._angles, value);
+    if (!vec3_exports.equals(this._angles, value)) {
+      vec3_exports.copy(this._angles, value);
       this._dirty = true;
       this.triggerMoveEvent();
     }
@@ -7198,21 +8926,21 @@ var Camera = class {
     return this._bobAngles;
   }
   set bobAngles(value) {
-    vec3.copy(this._bobAngles, value);
+    vec3_exports.copy(this._bobAngles, value);
     this._dirty = true;
   }
   get kickAngles() {
     return this._kickAngles;
   }
   set kickAngles(value) {
-    vec3.copy(this._kickAngles, value);
+    vec3_exports.copy(this._kickAngles, value);
     this._dirty = true;
   }
   get bobOffset() {
     return this._bobOffset;
   }
   set bobOffset(value) {
-    vec3.copy(this._bobOffset, value);
+    vec3_exports.copy(this._bobOffset, value);
     this._dirty = true;
   }
   get rollAngle() {
@@ -7238,17 +8966,17 @@ var Camera = class {
   }
   // API Methods
   setPosition(x, y, z) {
-    const newPos = vec3.fromValues(x, y, z);
-    if (!vec3.equals(this._position, newPos)) {
-      vec3.copy(this._position, newPos);
+    const newPos = vec3_exports.fromValues(x, y, z);
+    if (!vec3_exports.equals(this._position, newPos)) {
+      vec3_exports.copy(this._position, newPos);
       this._dirty = true;
       this.triggerMoveEvent();
     }
   }
   setRotation(pitch, yaw, roll) {
-    const newAngles = vec3.fromValues(pitch, yaw, roll);
-    if (!vec3.equals(this._angles, newAngles)) {
-      vec3.copy(this._angles, newAngles);
+    const newAngles = vec3_exports.fromValues(pitch, yaw, roll);
+    if (!vec3_exports.equals(this._angles, newAngles)) {
+      vec3_exports.copy(this._angles, newAngles);
       this._dirty = true;
       this.triggerMoveEvent();
     }
@@ -7260,10 +8988,10 @@ var Camera = class {
     this.aspect = aspect;
   }
   lookAt(target) {
-    const direction = vec3.create();
-    vec3.subtract(direction, target, this._position);
-    const len = vec3.length(direction);
-    if (len < 1e-3) return;
+    const direction = vec3_exports.create();
+    vec3_exports.subtract(direction, target, this._position);
+    const len2 = vec3_exports.length(direction);
+    if (len2 < 1e-3) return;
     const yaw = Math.atan2(direction[1], direction[0]) * RAD2DEG;
     const hyp = Math.hypot(direction[0], direction[1]);
     const pitch = -Math.atan2(direction[2], hyp) * RAD2DEG;
@@ -7272,8 +9000,8 @@ var Camera = class {
   triggerMoveEvent() {
     if (this.onCameraMove) {
       this.onCameraMove({
-        position: vec3.clone(this._position),
-        angles: vec3.clone(this._angles)
+        position: vec3_exports.clone(this._position),
+        angles: vec3_exports.clone(this._angles)
       });
     }
   }
@@ -7290,8 +9018,8 @@ var Camera = class {
     return this._viewProjectionMatrix;
   }
   getViewmodelProjectionMatrix(fov) {
-    const projectionMatrix = mat4.create();
-    mat4.perspective(
+    const projectionMatrix = mat4_exports.create();
+    mat4_exports.perspective(
       projectionMatrix,
       fov * DEG2RAD,
       this._aspect,
@@ -7303,19 +9031,19 @@ var Camera = class {
   screenToWorldRay(screenX, screenY) {
     const ndcX = screenX * 2 - 1;
     const ndcY = 1 - screenY * 2;
-    const clipStart = vec3.fromValues(ndcX, ndcY, -1);
-    const clipEnd = vec3.fromValues(ndcX, ndcY, 1);
-    const invViewProj = mat4.create();
-    mat4.invert(invViewProj, this.viewProjectionMatrix);
-    const worldStart = vec3.create();
-    const worldEnd = vec3.create();
-    vec3.transformMat4(worldStart, clipStart, invViewProj);
-    vec3.transformMat4(worldEnd, clipEnd, invViewProj);
-    const direction = vec3.create();
-    vec3.subtract(direction, worldEnd, worldStart);
-    vec3.normalize(direction, direction);
+    const clipStart = vec3_exports.fromValues(ndcX, ndcY, -1);
+    const clipEnd = vec3_exports.fromValues(ndcX, ndcY, 1);
+    const invViewProj = mat4_exports.create();
+    mat4_exports.invert(invViewProj, this.viewProjectionMatrix);
+    const worldStart = vec3_exports.create();
+    const worldEnd = vec3_exports.create();
+    vec3_exports.transformMat4(worldStart, clipStart, invViewProj);
+    vec3_exports.transformMat4(worldEnd, clipEnd, invViewProj);
+    const direction = vec3_exports.create();
+    vec3_exports.subtract(direction, worldEnd, worldStart);
+    vec3_exports.normalize(direction, direction);
     return {
-      origin: vec3.clone(this._position),
+      origin: vec3_exports.clone(this._position),
       direction
     };
   }
@@ -7323,14 +9051,14 @@ var Camera = class {
     if (!this._dirty) {
       return;
     }
-    mat4.perspective(
+    mat4_exports.perspective(
       this._projectionMatrix,
       this._fov * DEG2RAD,
       this._aspect,
       this._near,
       this._far
     );
-    const quakeToGl = mat4.fromValues(
+    const quakeToGl = mat4_exports.fromValues(
       0,
       0,
       -1,
@@ -7358,18 +9086,18 @@ var Camera = class {
     const pitchRad = pitch * DEG2RAD;
     const yawRad = yaw * DEG2RAD;
     const rollRad = roll * DEG2RAD;
-    const rotationQuake = mat4.create();
-    mat4.identity(rotationQuake);
-    mat4.rotateZ(rotationQuake, rotationQuake, -yawRad);
-    mat4.rotateY(rotationQuake, rotationQuake, -pitchRad);
-    mat4.rotateX(rotationQuake, rotationQuake, -rollRad);
-    const rotationGl = mat4.create();
-    mat4.multiply(rotationGl, quakeToGl, rotationQuake);
-    const positionWithOffset = vec3.add(vec3.create(), this._position, this._bobOffset);
-    const negativePosition = vec3.negate(vec3.create(), positionWithOffset);
-    const rotatedPosQuake = vec3.create();
-    vec3.transformMat4(rotatedPosQuake, negativePosition, rotationQuake);
-    const translationGl = vec3.fromValues(
+    const rotationQuake = mat4_exports.create();
+    mat4_exports.identity(rotationQuake);
+    mat4_exports.rotateZ(rotationQuake, rotationQuake, -yawRad);
+    mat4_exports.rotateY(rotationQuake, rotationQuake, -pitchRad);
+    mat4_exports.rotateX(rotationQuake, rotationQuake, -rollRad);
+    const rotationGl = mat4_exports.create();
+    mat4_exports.multiply(rotationGl, quakeToGl, rotationQuake);
+    const positionWithOffset = vec3_exports.add(vec3_exports.create(), this._position, this._bobOffset);
+    const negativePosition = vec3_exports.negate(vec3_exports.create(), positionWithOffset);
+    const rotatedPosQuake = vec3_exports.create();
+    vec3_exports.transformMat4(rotatedPosQuake, negativePosition, rotationQuake);
+    const translationGl = vec3_exports.fromValues(
       rotatedPosQuake[1] ? -rotatedPosQuake[1] : 0,
       // Y in Quake -> -X in WebGL
       rotatedPosQuake[2] || 0,
@@ -7377,11 +9105,11 @@ var Camera = class {
       rotatedPosQuake[0] ? -rotatedPosQuake[0] : 0
       // X in Quake -> -Z in WebGL
     );
-    mat4.copy(this._viewMatrix, rotationGl);
+    mat4_exports.copy(this._viewMatrix, rotationGl);
     this._viewMatrix[12] = translationGl[0];
     this._viewMatrix[13] = translationGl[1];
     this._viewMatrix[14] = translationGl[2];
-    mat4.multiply(
+    mat4_exports.multiply(
       this._viewProjectionMatrix,
       this._projectionMatrix,
       this._viewMatrix
@@ -7394,11 +9122,11 @@ var Camera = class {
 var DEFAULT_AMBIENT = [0.2, 0.2, 0.2];
 var DEFAULT_DIRECTION = { x: 0, y: 0, z: 1 };
 var DEFAULT_DIRECTION_COLOR = [0.8, 0.8, 0.8];
-function lerp2(a, b, t) {
+function lerp3(a, b, t) {
   return a + (b - a) * t;
 }
 function lerpVec32(a, b, t) {
-  return { x: lerp2(a.x, b.x, t), y: lerp2(a.y, b.y, t), z: lerp2(a.z, b.z, t) };
+  return { x: lerp3(a.x, b.x, t), y: lerp3(a.y, b.y, t), z: lerp3(a.z, b.z, t) };
 }
 function clamp012(v) {
   if (v < 0) return 0;
@@ -7445,8 +9173,8 @@ function evaluateLighting(normal, position, lighting) {
       const radiusSq = light.radius * light.radius;
       if (distSq < radiusSq && radiusSq > 0) {
         const attenuation = 1 - Math.sqrt(distSq) / light.radius;
-        const dist = Math.sqrt(distSq);
-        const lightDotN = dist > 0 ? clamp012(-(dx * n.x + dy * n.y + dz * n.z) / dist) : 0;
+        const dist2 = Math.sqrt(distSq);
+        const lightDotN = dist2 > 0 ? clamp012(-(dx * n.x + dy * n.y + dz * n.z) / dist2) : 0;
         const amount = clamp012(attenuation * lightDotN);
         r += light.color[0] * amount;
         g += light.color[1] * amount;
@@ -8120,11 +9848,11 @@ function spawnBlood(context) {
 function spawnTeleportFlash(context) {
   const { system, origin } = context;
   for (let i = 0; i < 30; i += 1) {
-    const angle = system.rng.frandom() * Math.PI * 2;
+    const angle2 = system.rng.frandom() * Math.PI * 2;
     const radius = 8 + system.rng.frandom() * 8;
     system.spawn({
       position: origin,
-      velocity: { x: Math.cos(angle) * radius, y: Math.sin(angle) * radius, z: 100 + system.rng.frandom() * 80 },
+      velocity: { x: Math.cos(angle2) * radius, y: Math.sin(angle2) * radius, z: 100 + system.rng.frandom() * 80 },
       color: [0.4, 0.6, 1, 0.9],
       size: 4,
       lifetime: 0.5,
@@ -8227,11 +9955,11 @@ function spawnRailTrail(context) {
   const dx = end.x - start.x;
   const dy = end.y - start.y;
   const dz = end.z - start.z;
-  const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
-  if (dist < 1) return;
-  const dir = { x: dx / dist, y: dy / dist, z: dz / dist };
+  const dist2 = Math.sqrt(dx * dx + dy * dy + dz * dz);
+  if (dist2 < 1) return;
+  const dir = { x: dx / dist2, y: dy / dist2, z: dz / dist2 };
   const step = 8;
-  for (let d = 0; d < dist; d += step) {
+  for (let d = 0; d < dist2; d += step) {
     const x = start.x + dir.x * d;
     const y = start.y + dir.y * d;
     const z = start.z + dir.z * d;
@@ -8371,20 +10099,20 @@ var DemoReader = class {
     let scanOffset = 0;
     this.messageOffsets = [];
     while (scanOffset + 4 <= this.buffer.byteLength) {
-      const length = this.view.getInt32(scanOffset, true);
-      if (length === -1) {
+      const length2 = this.view.getInt32(scanOffset, true);
+      if (length2 === -1) {
         break;
       }
-      if (length < 0 || length > 2097152) {
-        console.warn(`DemoReader: Invalid block length ${length} at offset ${scanOffset} during scan`);
+      if (length2 < 0 || length2 > 2097152) {
+        console.warn(`DemoReader: Invalid block length ${length2} at offset ${scanOffset} during scan`);
         break;
       }
-      if (scanOffset + 4 + length > this.buffer.byteLength) {
+      if (scanOffset + 4 + length2 > this.buffer.byteLength) {
         console.warn(`DemoReader: Incomplete block at offset ${scanOffset} during scan`);
         break;
       }
       this.messageOffsets.push(scanOffset);
-      scanOffset += 4 + length;
+      scanOffset += 4 + length2;
     }
   }
   /**
@@ -8402,18 +10130,18 @@ var DemoReader = class {
     if (this.offset + 4 > this.buffer.byteLength) {
       return null;
     }
-    const length = this.view.getInt32(this.offset, true);
-    if (length === -1) {
+    const length2 = this.view.getInt32(this.offset, true);
+    if (length2 === -1) {
       return null;
     }
-    if (length < 0 || this.offset + 4 + length > this.buffer.byteLength) {
+    if (length2 < 0 || this.offset + 4 + length2 > this.buffer.byteLength) {
       return null;
     }
     this.offset += 4;
-    const blockData = this.buffer.slice(this.offset, this.offset + length);
-    this.offset += length;
+    const blockData = this.buffer.slice(this.offset, this.offset + length2);
+    this.offset += length2;
     return {
-      length,
+      length: length2,
       data: new BinaryStream(blockData)
     };
   }
@@ -8450,14 +10178,14 @@ var DemoReader = class {
     const blockInfos = [];
     let tempOffset = this.offset;
     while (tempOffset + 4 <= this.buffer.byteLength) {
-      const length = this.view.getInt32(tempOffset, true);
-      if (length === -1) break;
-      if (length < 0 || tempOffset + 4 + length > this.buffer.byteLength) {
+      const length2 = this.view.getInt32(tempOffset, true);
+      if (length2 === -1) break;
+      if (length2 < 0 || tempOffset + 4 + length2 > this.buffer.byteLength) {
         break;
       }
-      blockInfos.push({ offset: tempOffset + 4, length });
-      totalLength += length;
-      tempOffset += 4 + length;
+      blockInfos.push({ offset: tempOffset + 4, length: length2 });
+      totalLength += length2;
+      tempOffset += 4 + length2;
     }
     const result = new Uint8Array(totalLength);
     let resultOffset = 0;
@@ -8514,9 +10242,9 @@ var Z_BINARY = 0;
 var Z_TEXT = 1;
 var Z_UNKNOWN$1 = 2;
 function zero$1(buf) {
-  let len = buf.length;
-  while (--len >= 0) {
-    buf[len] = 0;
+  let len2 = buf.length;
+  while (--len2 >= 0) {
+    buf[len2] = 0;
   }
 }
 var STORED_BLOCK = 0;
@@ -8579,22 +10307,22 @@ function TreeDesc(dyn_tree, stat_desc) {
   this.max_code = 0;
   this.stat_desc = stat_desc;
 }
-var d_code = (dist) => {
-  return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)];
+var d_code = (dist2) => {
+  return dist2 < 256 ? _dist_code[dist2] : _dist_code[256 + (dist2 >>> 7)];
 };
 var put_short = (s, w) => {
   s.pending_buf[s.pending++] = w & 255;
   s.pending_buf[s.pending++] = w >>> 8 & 255;
 };
-var send_bits = (s, value, length) => {
-  if (s.bi_valid > Buf_size - length) {
+var send_bits = (s, value, length2) => {
+  if (s.bi_valid > Buf_size - length2) {
     s.bi_buf |= value << s.bi_valid & 65535;
     put_short(s, s.bi_buf);
     s.bi_buf = value >> Buf_size - s.bi_valid;
-    s.bi_valid += length - Buf_size;
+    s.bi_valid += length2 - Buf_size;
   } else {
     s.bi_buf |= value << s.bi_valid & 65535;
-    s.bi_valid += length;
+    s.bi_valid += length2;
   }
 };
 var send_code = (s, c, tree) => {
@@ -8605,13 +10333,13 @@ var send_code = (s, c, tree) => {
     /*.Len*/
   );
 };
-var bi_reverse = (code, len) => {
+var bi_reverse = (code, len2) => {
   let res = 0;
   do {
     res |= code & 1;
     code >>>= 1;
     res <<= 1;
-  } while (--len > 0);
+  } while (--len2 > 0);
   return res >>> 1;
 };
 var bi_flush = (s) => {
@@ -8703,40 +10431,40 @@ var gen_codes = (tree, max_code, bl_count) => {
     next_code[bits] = code;
   }
   for (n = 0; n <= max_code; n++) {
-    let len = tree[n * 2 + 1];
-    if (len === 0) {
+    let len2 = tree[n * 2 + 1];
+    if (len2 === 0) {
       continue;
     }
-    tree[n * 2] = bi_reverse(next_code[len]++, len);
+    tree[n * 2] = bi_reverse(next_code[len2]++, len2);
   }
 };
 var tr_static_init = () => {
   let n;
   let bits;
-  let length;
+  let length2;
   let code;
-  let dist;
+  let dist2;
   const bl_count = new Array(MAX_BITS$1 + 1);
-  length = 0;
+  length2 = 0;
   for (code = 0; code < LENGTH_CODES$1 - 1; code++) {
-    base_length[code] = length;
+    base_length[code] = length2;
     for (n = 0; n < 1 << extra_lbits[code]; n++) {
-      _length_code[length++] = code;
+      _length_code[length2++] = code;
     }
   }
-  _length_code[length - 1] = code;
-  dist = 0;
+  _length_code[length2 - 1] = code;
+  dist2 = 0;
   for (code = 0; code < 16; code++) {
-    base_dist[code] = dist;
+    base_dist[code] = dist2;
     for (n = 0; n < 1 << extra_dbits[code]; n++) {
-      _dist_code[dist++] = code;
+      _dist_code[dist2++] = code;
     }
   }
-  dist >>= 7;
+  dist2 >>= 7;
   for (; code < D_CODES$1; code++) {
-    base_dist[code] = dist << 7;
+    base_dist[code] = dist2 << 7;
     for (n = 0; n < 1 << extra_dbits[code] - 7; n++) {
-      _dist_code[256 + dist++] = code;
+      _dist_code[256 + dist2++] = code;
     }
   }
   for (bits = 0; bits <= MAX_BITS$1; bits++) {
@@ -8818,17 +10546,17 @@ var pqdownheap = (s, tree, k) => {
   s.heap[k] = v;
 };
 var compress_block = (s, ltree, dtree) => {
-  let dist;
+  let dist2;
   let lc;
   let sx = 0;
   let code;
   let extra;
   if (s.sym_next !== 0) {
     do {
-      dist = s.pending_buf[s.sym_buf + sx++] & 255;
-      dist += (s.pending_buf[s.sym_buf + sx++] & 255) << 8;
+      dist2 = s.pending_buf[s.sym_buf + sx++] & 255;
+      dist2 += (s.pending_buf[s.sym_buf + sx++] & 255) << 8;
       lc = s.pending_buf[s.sym_buf + sx++];
-      if (dist === 0) {
+      if (dist2 === 0) {
         send_code(s, lc, ltree);
       } else {
         code = _length_code[lc];
@@ -8838,13 +10566,13 @@ var compress_block = (s, ltree, dtree) => {
           lc -= base_length[code];
           send_bits(s, lc, extra);
         }
-        dist--;
-        code = d_code(dist);
+        dist2--;
+        code = d_code(dist2);
         send_code(s, code, dtree);
         extra = extra_dbits[code];
         if (extra !== 0) {
-          dist -= base_dist[code];
-          send_bits(s, dist, extra);
+          dist2 -= base_dist[code];
+          send_bits(s, dist2, extra);
         }
       }
     } while (sx < s.sym_next);
@@ -9121,17 +10849,17 @@ var _tr_flush_block$1 = (s, buf, stored_len, last) => {
     bi_windup(s);
   }
 };
-var _tr_tally$1 = (s, dist, lc) => {
-  s.pending_buf[s.sym_buf + s.sym_next++] = dist;
-  s.pending_buf[s.sym_buf + s.sym_next++] = dist >> 8;
+var _tr_tally$1 = (s, dist2, lc) => {
+  s.pending_buf[s.sym_buf + s.sym_next++] = dist2;
+  s.pending_buf[s.sym_buf + s.sym_next++] = dist2 >> 8;
   s.pending_buf[s.sym_buf + s.sym_next++] = lc;
-  if (dist === 0) {
+  if (dist2 === 0) {
     s.dyn_ltree[lc * 2]++;
   } else {
     s.matches++;
-    dist--;
+    dist2--;
     s.dyn_ltree[(_length_code[lc] + LITERALS$1 + 1) * 2]++;
-    s.dyn_dtree[d_code(dist) * 2]++;
+    s.dyn_dtree[d_code(dist2) * 2]++;
   }
   return s.sym_next === s.sym_end;
 };
@@ -9147,11 +10875,11 @@ var trees = {
   _tr_tally: _tr_tally_1,
   _tr_align: _tr_align_1
 };
-var adler32 = (adler, buf, len, pos) => {
+var adler32 = (adler, buf, len2, pos) => {
   let s1 = adler & 65535 | 0, s2 = adler >>> 16 & 65535 | 0, n = 0;
-  while (len !== 0) {
-    n = len > 2e3 ? 2e3 : len;
-    len -= n;
+  while (len2 !== 0) {
+    n = len2 > 2e3 ? 2e3 : len2;
+    len2 -= n;
     do {
       s1 = s1 + buf[pos++] | 0;
       s2 = s2 + s1 | 0;
@@ -9174,9 +10902,9 @@ var makeTable = () => {
   return table;
 };
 var crcTable = new Uint32Array(makeTable());
-var crc322 = (crc, buf, len, pos) => {
+var crc322 = (crc, buf, len2, pos) => {
   const t = crcTable;
-  const end = pos + len;
+  const end = pos + len2;
   crc ^= -1;
   for (let i = pos; i < end; i++) {
     crc = crc >>> 8 ^ t[(crc ^ buf[i]) & 255];
@@ -9299,10 +11027,10 @@ var err = (strm, errorCode) => {
 var rank = (f) => {
   return f * 2 - (f > 4 ? 9 : 0);
 };
-var zero = (buf) => {
-  let len = buf.length;
-  while (--len >= 0) {
-    buf[len] = 0;
+var zero2 = (buf) => {
+  let len2 = buf.length;
+  while (--len2 >= 0) {
+    buf[len2] = 0;
   }
 };
 var slide_hash = (s) => {
@@ -9326,19 +11054,19 @@ var HASH_ZLIB = (s, prev, data) => (prev << s.hash_shift ^ data) & s.hash_mask;
 var HASH = HASH_ZLIB;
 var flush_pending = (strm) => {
   const s = strm.state;
-  let len = s.pending;
-  if (len > strm.avail_out) {
-    len = strm.avail_out;
+  let len2 = s.pending;
+  if (len2 > strm.avail_out) {
+    len2 = strm.avail_out;
   }
-  if (len === 0) {
+  if (len2 === 0) {
     return;
   }
-  strm.output.set(s.pending_buf.subarray(s.pending_out, s.pending_out + len), strm.next_out);
-  strm.next_out += len;
-  s.pending_out += len;
-  strm.total_out += len;
-  strm.avail_out -= len;
-  s.pending -= len;
+  strm.output.set(s.pending_buf.subarray(s.pending_out, s.pending_out + len2), strm.next_out);
+  strm.next_out += len2;
+  s.pending_out += len2;
+  strm.total_out += len2;
+  strm.avail_out -= len2;
+  s.pending -= len2;
   if (s.pending === 0) {
     s.pending_out = 0;
   }
@@ -9356,29 +11084,29 @@ var putShortMSB = (s, b) => {
   s.pending_buf[s.pending++] = b & 255;
 };
 var read_buf = (strm, buf, start, size) => {
-  let len = strm.avail_in;
-  if (len > size) {
-    len = size;
+  let len2 = strm.avail_in;
+  if (len2 > size) {
+    len2 = size;
   }
-  if (len === 0) {
+  if (len2 === 0) {
     return 0;
   }
-  strm.avail_in -= len;
-  buf.set(strm.input.subarray(strm.next_in, strm.next_in + len), start);
+  strm.avail_in -= len2;
+  buf.set(strm.input.subarray(strm.next_in, strm.next_in + len2), start);
   if (strm.state.wrap === 1) {
-    strm.adler = adler32_1(strm.adler, buf, len, start);
+    strm.adler = adler32_1(strm.adler, buf, len2, start);
   } else if (strm.state.wrap === 2) {
-    strm.adler = crc32_1(strm.adler, buf, len, start);
+    strm.adler = crc32_1(strm.adler, buf, len2, start);
   }
-  strm.next_in += len;
-  strm.total_in += len;
-  return len;
+  strm.next_in += len2;
+  strm.total_in += len2;
+  return len2;
 };
 var longest_match = (s, cur_match) => {
   let chain_length = s.max_chain_length;
   let scan = s.strstart;
   let match;
-  let len;
+  let len2;
   let best_len = s.prev_length;
   let nice_match = s.nice_match;
   const limit = s.strstart > s.w_size - MIN_LOOKAHEAD ? s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0;
@@ -9403,12 +11131,12 @@ var longest_match = (s, cur_match) => {
     match++;
     do {
     } while (_win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && scan < strend);
-    len = MAX_MATCH - (strend - scan);
+    len2 = MAX_MATCH - (strend - scan);
     scan = strend - MAX_MATCH;
-    if (len > best_len) {
+    if (len2 > best_len) {
       s.match_start = cur_match;
-      best_len = len;
-      if (len >= nice_match) {
+      best_len = len2;
+      if (len2 >= nice_match) {
         break;
       }
       scan_end1 = _win[scan + best_len - 1];
@@ -9422,7 +11150,7 @@ var longest_match = (s, cur_match) => {
 };
 var fill_window = (s) => {
   const _w_size = s.w_size;
-  let n, more, str;
+  let n, more, str3;
   do {
     more = s.window_size - s.lookahead - s.strstart;
     if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) {
@@ -9442,14 +11170,14 @@ var fill_window = (s) => {
     n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more);
     s.lookahead += n;
     if (s.lookahead + s.insert >= MIN_MATCH) {
-      str = s.strstart - s.insert;
-      s.ins_h = s.window[str];
-      s.ins_h = HASH(s, s.ins_h, s.window[str + 1]);
+      str3 = s.strstart - s.insert;
+      s.ins_h = s.window[str3];
+      s.ins_h = HASH(s, s.ins_h, s.window[str3 + 1]);
       while (s.insert) {
-        s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH - 1]);
-        s.prev[str & s.w_mask] = s.head[s.ins_h];
-        s.head[s.ins_h] = str;
-        str++;
+        s.ins_h = HASH(s, s.ins_h, s.window[str3 + MIN_MATCH - 1]);
+        s.prev[str3 & s.w_mask] = s.head[s.ins_h];
+        s.head[s.ins_h] = str3;
+        str3++;
         s.insert--;
         if (s.lookahead + s.insert < MIN_MATCH) {
           break;
@@ -9460,48 +11188,48 @@ var fill_window = (s) => {
 };
 var deflate_stored = (s, flush) => {
   let min_block = s.pending_buf_size - 5 > s.w_size ? s.w_size : s.pending_buf_size - 5;
-  let len, left, have, last = 0;
+  let len2, left, have, last = 0;
   let used = s.strm.avail_in;
   do {
-    len = 65535;
+    len2 = 65535;
     have = s.bi_valid + 42 >> 3;
     if (s.strm.avail_out < have) {
       break;
     }
     have = s.strm.avail_out - have;
     left = s.strstart - s.block_start;
-    if (len > left + s.strm.avail_in) {
-      len = left + s.strm.avail_in;
+    if (len2 > left + s.strm.avail_in) {
+      len2 = left + s.strm.avail_in;
     }
-    if (len > have) {
-      len = have;
+    if (len2 > have) {
+      len2 = have;
     }
-    if (len < min_block && (len === 0 && flush !== Z_FINISH$3 || flush === Z_NO_FLUSH$2 || len !== left + s.strm.avail_in)) {
+    if (len2 < min_block && (len2 === 0 && flush !== Z_FINISH$3 || flush === Z_NO_FLUSH$2 || len2 !== left + s.strm.avail_in)) {
       break;
     }
-    last = flush === Z_FINISH$3 && len === left + s.strm.avail_in ? 1 : 0;
+    last = flush === Z_FINISH$3 && len2 === left + s.strm.avail_in ? 1 : 0;
     _tr_stored_block(s, 0, 0, last);
-    s.pending_buf[s.pending - 4] = len;
-    s.pending_buf[s.pending - 3] = len >> 8;
-    s.pending_buf[s.pending - 2] = ~len;
-    s.pending_buf[s.pending - 1] = ~len >> 8;
+    s.pending_buf[s.pending - 4] = len2;
+    s.pending_buf[s.pending - 3] = len2 >> 8;
+    s.pending_buf[s.pending - 2] = ~len2;
+    s.pending_buf[s.pending - 1] = ~len2 >> 8;
     flush_pending(s.strm);
     if (left) {
-      if (left > len) {
-        left = len;
+      if (left > len2) {
+        left = len2;
       }
       s.strm.output.set(s.window.subarray(s.block_start, s.block_start + left), s.strm.next_out);
       s.strm.next_out += left;
       s.strm.avail_out -= left;
       s.strm.total_out += left;
       s.block_start += left;
-      len -= left;
+      len2 -= left;
     }
-    if (len) {
-      read_buf(s.strm, s.strm.output, s.strm.next_out, len);
-      s.strm.next_out += len;
-      s.strm.avail_out -= len;
-      s.strm.total_out += len;
+    if (len2) {
+      read_buf(s.strm, s.strm.output, s.strm.next_out, len2);
+      s.strm.next_out += len2;
+      s.strm.avail_out -= len2;
+      s.strm.total_out += len2;
     }
   } while (last === 0);
   used -= s.strm.avail_in;
@@ -9566,10 +11294,10 @@ var deflate_stored = (s, flush) => {
   min_block = have > s.w_size ? s.w_size : have;
   left = s.strstart - s.block_start;
   if (left >= min_block || (left || flush === Z_FINISH$3) && flush !== Z_NO_FLUSH$2 && s.strm.avail_in === 0 && left <= have) {
-    len = left > have ? have : left;
-    last = flush === Z_FINISH$3 && s.strm.avail_in === 0 && len === left ? 1 : 0;
-    _tr_stored_block(s, s.block_start, len, last);
-    s.block_start += len;
+    len2 = left > have ? have : left;
+    last = flush === Z_FINISH$3 && s.strm.avail_in === 0 && len2 === left ? 1 : 0;
+    _tr_stored_block(s, s.block_start, len2, last);
+    s.block_start += len2;
     flush_pending(s.strm);
   }
   return last ? BS_FINISH_STARTED : BS_NEED_MORE;
@@ -9861,7 +11589,7 @@ var configuration_table = [
 ];
 var lm_init = (s) => {
   s.window_size = 2 * s.w_size;
-  zero(s.head);
+  zero2(s.head);
   s.max_lazy_match = configuration_table[s.level].max_lazy;
   s.good_match = configuration_table[s.level].good_length;
   s.nice_match = configuration_table[s.level].nice_length;
@@ -9915,19 +11643,19 @@ function DeflateState() {
   this.dyn_ltree = new Uint16Array(HEAP_SIZE * 2);
   this.dyn_dtree = new Uint16Array((2 * D_CODES + 1) * 2);
   this.bl_tree = new Uint16Array((2 * BL_CODES + 1) * 2);
-  zero(this.dyn_ltree);
-  zero(this.dyn_dtree);
-  zero(this.bl_tree);
+  zero2(this.dyn_ltree);
+  zero2(this.dyn_dtree);
+  zero2(this.bl_tree);
   this.l_desc = null;
   this.d_desc = null;
   this.bl_desc = null;
   this.bl_count = new Uint16Array(MAX_BITS + 1);
   this.heap = new Uint16Array(2 * L_CODES + 1);
-  zero(this.heap);
+  zero2(this.heap);
   this.heap_len = 0;
   this.heap_max = 0;
   this.depth = new Uint16Array(2 * L_CODES + 1);
-  zero(this.depth);
+  zero2(this.depth);
   this.sym_buf = 0;
   this.lit_bufsize = 0;
   this.sym_next = 0;
@@ -10138,20 +11866,20 @@ var deflate$2 = (strm, flush) => {
       let beg = s.pending;
       let left = (s.gzhead.extra.length & 65535) - s.gzindex;
       while (s.pending + left > s.pending_buf_size) {
-        let copy = s.pending_buf_size - s.pending;
-        s.pending_buf.set(s.gzhead.extra.subarray(s.gzindex, s.gzindex + copy), s.pending);
+        let copy3 = s.pending_buf_size - s.pending;
+        s.pending_buf.set(s.gzhead.extra.subarray(s.gzindex, s.gzindex + copy3), s.pending);
         s.pending = s.pending_buf_size;
         if (s.gzhead.hcrc && s.pending > beg) {
           strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);
         }
-        s.gzindex += copy;
+        s.gzindex += copy3;
         flush_pending(strm);
         if (s.pending !== 0) {
           s.last_flush = -1;
           return Z_OK$3;
         }
         beg = 0;
-        left -= copy;
+        left -= copy3;
       }
       let gzhead_extra = new Uint8Array(s.gzhead.extra);
       s.pending_buf.set(gzhead_extra.subarray(s.gzindex, s.gzindex + left), s.pending);
@@ -10259,7 +11987,7 @@ var deflate$2 = (strm, flush) => {
       } else if (flush !== Z_BLOCK$1) {
         _tr_stored_block(s, 0, 0, false);
         if (flush === Z_FULL_FLUSH$1) {
-          zero(s.head);
+          zero2(s.head);
           if (s.lookahead === 0) {
             s.strstart = 0;
             s.block_start = 0;
@@ -10323,7 +12051,7 @@ var deflateSetDictionary = (strm, dictionary) => {
   s.wrap = 0;
   if (dictLength >= s.w_size) {
     if (wrap === 0) {
-      zero(s.head);
+      zero2(s.head);
       s.strstart = 0;
       s.block_start = 0;
       s.insert = 0;
@@ -10341,15 +12069,15 @@ var deflateSetDictionary = (strm, dictionary) => {
   strm.input = dictionary;
   fill_window(s);
   while (s.lookahead >= MIN_MATCH) {
-    let str = s.strstart;
+    let str3 = s.strstart;
     let n = s.lookahead - (MIN_MATCH - 1);
     do {
-      s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH - 1]);
-      s.prev[str & s.w_mask] = s.head[s.ins_h];
-      s.head[s.ins_h] = str;
-      str++;
+      s.ins_h = HASH(s, s.ins_h, s.window[str3 + MIN_MATCH - 1]);
+      s.prev[str3 & s.w_mask] = s.head[s.ins_h];
+      s.head[s.ins_h] = str3;
+      str3++;
     } while (--n);
-    s.strstart = str;
+    s.strstart = str3;
     s.lookahead = MIN_MATCH - 1;
     fill_window(s);
   }
@@ -10407,11 +12135,11 @@ var assign = function(obj) {
   return obj;
 };
 var flattenChunks = (chunks) => {
-  let len = 0;
+  let len2 = 0;
   for (let i = 0, l = chunks.length; i < l; i++) {
-    len += chunks[i].length;
+    len2 += chunks[i].length;
   }
-  const result = new Uint8Array(len);
+  const result = new Uint8Array(len2);
   for (let i = 0, pos = 0, l = chunks.length; i < l; i++) {
     let chunk = chunks[i];
     result.set(chunk, pos);
@@ -10434,15 +12162,15 @@ for (let q = 0; q < 256; q++) {
   _utf8len[q] = q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1;
 }
 _utf8len[254] = _utf8len[254] = 1;
-var string2buf = (str) => {
+var string2buf = (str3) => {
   if (typeof TextEncoder === "function" && TextEncoder.prototype.encode) {
-    return new TextEncoder().encode(str);
+    return new TextEncoder().encode(str3);
   }
-  let buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0;
+  let buf, c, c2, m_pos, i, str_len = str3.length, buf_len = 0;
   for (m_pos = 0; m_pos < str_len; m_pos++) {
-    c = str.charCodeAt(m_pos);
+    c = str3.charCodeAt(m_pos);
     if ((c & 64512) === 55296 && m_pos + 1 < str_len) {
-      c2 = str.charCodeAt(m_pos + 1);
+      c2 = str3.charCodeAt(m_pos + 1);
       if ((c2 & 64512) === 56320) {
         c = 65536 + (c - 55296 << 10) + (c2 - 56320);
         m_pos++;
@@ -10452,9 +12180,9 @@ var string2buf = (str) => {
   }
   buf = new Uint8Array(buf_len);
   for (i = 0, m_pos = 0; i < buf_len; m_pos++) {
-    c = str.charCodeAt(m_pos);
+    c = str3.charCodeAt(m_pos);
     if ((c & 64512) === 55296 && m_pos + 1 < str_len) {
-      c2 = str.charCodeAt(m_pos + 1);
+      c2 = str3.charCodeAt(m_pos + 1);
       if ((c2 & 64512) === 56320) {
         c = 65536 + (c - 55296 << 10) + (c2 - 56320);
         m_pos++;
@@ -10478,26 +12206,26 @@ var string2buf = (str) => {
   }
   return buf;
 };
-var buf2binstring = (buf, len) => {
-  if (len < 65534) {
+var buf2binstring = (buf, len2) => {
+  if (len2 < 65534) {
     if (buf.subarray && STR_APPLY_UIA_OK) {
-      return String.fromCharCode.apply(null, buf.length === len ? buf : buf.subarray(0, len));
+      return String.fromCharCode.apply(null, buf.length === len2 ? buf : buf.subarray(0, len2));
     }
   }
   let result = "";
-  for (let i = 0; i < len; i++) {
+  for (let i = 0; i < len2; i++) {
     result += String.fromCharCode(buf[i]);
   }
   return result;
 };
-var buf2string = (buf, max) => {
-  const len = max || buf.length;
+var buf2string = (buf, max2) => {
+  const len2 = max2 || buf.length;
   if (typeof TextDecoder === "function" && TextDecoder.prototype.decode) {
-    return new TextDecoder().decode(buf.subarray(0, max));
+    return new TextDecoder().decode(buf.subarray(0, max2));
   }
   let i, out;
-  const utf16buf = new Array(len * 2);
-  for (out = 0, i = 0; i < len; ) {
+  const utf16buf = new Array(len2 * 2);
+  for (out = 0, i = 0; i < len2; ) {
     let c = buf[i++];
     if (c < 128) {
       utf16buf[out++] = c;
@@ -10510,7 +12238,7 @@ var buf2string = (buf, max) => {
       continue;
     }
     c &= c_len === 2 ? 31 : c_len === 3 ? 15 : 7;
-    while (c_len > 1 && i < len) {
+    while (c_len > 1 && i < len2) {
       c = c << 6 | buf[i++] & 63;
       c_len--;
     }
@@ -10528,22 +12256,22 @@ var buf2string = (buf, max) => {
   }
   return buf2binstring(utf16buf, out);
 };
-var utf8border = (buf, max) => {
-  max = max || buf.length;
-  if (max > buf.length) {
-    max = buf.length;
+var utf8border = (buf, max2) => {
+  max2 = max2 || buf.length;
+  if (max2 > buf.length) {
+    max2 = buf.length;
   }
-  let pos = max - 1;
+  let pos = max2 - 1;
   while (pos >= 0 && (buf[pos] & 192) === 128) {
     pos--;
   }
   if (pos < 0) {
-    return max;
+    return max2;
   }
   if (pos === 0) {
-    return max;
+    return max2;
   }
-  return pos + _utf8len[buf[pos]] > max ? pos : max;
+  return pos + _utf8len[buf[pos]] > max2 ? pos : max2;
 };
 var strings = {
   string2buf,
@@ -10742,8 +12470,8 @@ var inffast = function inflate_fast(strm, start) {
   let dmask;
   let here;
   let op;
-  let len;
-  let dist;
+  let len2;
+  let dist2;
   let from;
   let from_source;
   let input, output;
@@ -10784,14 +12512,14 @@ var inffast = function inflate_fast(strm, start) {
           if (op === 0) {
             output[_out++] = here & 65535;
           } else if (op & 16) {
-            len = here & 65535;
+            len2 = here & 65535;
             op &= 15;
             if (op) {
               if (bits < op) {
                 hold += input[_in++] << bits;
                 bits += 8;
               }
-              len += hold & (1 << op) - 1;
+              len2 += hold & (1 << op) - 1;
               hold >>>= op;
               bits -= op;
             }
@@ -10809,7 +12537,7 @@ var inffast = function inflate_fast(strm, start) {
                 bits -= op;
                 op = here >>> 16 & 255;
                 if (op & 16) {
-                  dist = here & 65535;
+                  dist2 = here & 65535;
                   op &= 15;
                   if (bits < op) {
                     hold += input[_in++] << bits;
@@ -10819,8 +12547,8 @@ var inffast = function inflate_fast(strm, start) {
                       bits += 8;
                     }
                   }
-                  dist += hold & (1 << op) - 1;
-                  if (dist > dmax) {
+                  dist2 += hold & (1 << op) - 1;
+                  if (dist2 > dmax) {
                     strm.msg = "invalid distance too far back";
                     state.mode = BAD$1;
                     break top;
@@ -10828,8 +12556,8 @@ var inffast = function inflate_fast(strm, start) {
                   hold >>>= op;
                   bits -= op;
                   op = _out - beg;
-                  if (dist > op) {
-                    op = dist - op;
+                  if (dist2 > op) {
+                    op = dist2 - op;
                     if (op > whave) {
                       if (state.sane) {
                         strm.msg = "invalid distance too far back";
@@ -10841,67 +12569,67 @@ var inffast = function inflate_fast(strm, start) {
                     from_source = s_window;
                     if (wnext === 0) {
                       from += wsize - op;
-                      if (op < len) {
-                        len -= op;
+                      if (op < len2) {
+                        len2 -= op;
                         do {
                           output[_out++] = s_window[from++];
                         } while (--op);
-                        from = _out - dist;
+                        from = _out - dist2;
                         from_source = output;
                       }
                     } else if (wnext < op) {
                       from += wsize + wnext - op;
                       op -= wnext;
-                      if (op < len) {
-                        len -= op;
+                      if (op < len2) {
+                        len2 -= op;
                         do {
                           output[_out++] = s_window[from++];
                         } while (--op);
                         from = 0;
-                        if (wnext < len) {
+                        if (wnext < len2) {
                           op = wnext;
-                          len -= op;
+                          len2 -= op;
                           do {
                             output[_out++] = s_window[from++];
                           } while (--op);
-                          from = _out - dist;
+                          from = _out - dist2;
                           from_source = output;
                         }
                       }
                     } else {
                       from += wnext - op;
-                      if (op < len) {
-                        len -= op;
+                      if (op < len2) {
+                        len2 -= op;
                         do {
                           output[_out++] = s_window[from++];
                         } while (--op);
-                        from = _out - dist;
+                        from = _out - dist2;
                         from_source = output;
                       }
                     }
-                    while (len > 2) {
+                    while (len2 > 2) {
                       output[_out++] = from_source[from++];
                       output[_out++] = from_source[from++];
                       output[_out++] = from_source[from++];
-                      len -= 3;
+                      len2 -= 3;
                     }
-                    if (len) {
+                    if (len2) {
                       output[_out++] = from_source[from++];
-                      if (len > 1) {
+                      if (len2 > 1) {
                         output[_out++] = from_source[from++];
                       }
                     }
                   } else {
-                    from = _out - dist;
+                    from = _out - dist2;
                     do {
                       output[_out++] = output[from++];
                       output[_out++] = output[from++];
                       output[_out++] = output[from++];
-                      len -= 3;
-                    } while (len > 2);
-                    if (len) {
+                      len2 -= 3;
+                    } while (len2 > 2);
+                    if (len2) {
                       output[_out++] = output[from++];
-                      if (len > 1) {
+                      if (len2 > 1) {
                         output[_out++] = output[from++];
                       }
                     }
@@ -10930,9 +12658,9 @@ var inffast = function inflate_fast(strm, start) {
           break;
         }
     } while (_in < last && _out < end);
-  len = bits >> 3;
-  _in -= len;
-  bits -= len << 3;
+  len2 = bits >> 3;
+  _in -= len2;
+  bits -= len2 << 3;
   hold &= (1 << bits) - 1;
   strm.next_in = _in;
   strm.next_out = _out;
@@ -11088,9 +12816,9 @@ var dext = new Uint8Array([
 ]);
 var inflate_table = (type, lens, lens_index, codes, table, table_index, work, opts) => {
   const bits = opts.bits;
-  let len = 0;
+  let len2 = 0;
   let sym = 0;
-  let min = 0, max = 0;
+  let min2 = 0, max2 = 0;
   let root = 0;
   let curr = 0;
   let drop = 0;
@@ -11108,49 +12836,49 @@ var inflate_table = (type, lens, lens_index, codes, table, table_index, work, op
   const offs = new Uint16Array(MAXBITS + 1);
   let extra = null;
   let here_bits, here_op, here_val;
-  for (len = 0; len <= MAXBITS; len++) {
-    count[len] = 0;
+  for (len2 = 0; len2 <= MAXBITS; len2++) {
+    count[len2] = 0;
   }
   for (sym = 0; sym < codes; sym++) {
     count[lens[lens_index + sym]]++;
   }
   root = bits;
-  for (max = MAXBITS; max >= 1; max--) {
-    if (count[max] !== 0) {
+  for (max2 = MAXBITS; max2 >= 1; max2--) {
+    if (count[max2] !== 0) {
       break;
     }
   }
-  if (root > max) {
-    root = max;
+  if (root > max2) {
+    root = max2;
   }
-  if (max === 0) {
+  if (max2 === 0) {
     table[table_index++] = 1 << 24 | 64 << 16 | 0;
     table[table_index++] = 1 << 24 | 64 << 16 | 0;
     opts.bits = 1;
     return 0;
   }
-  for (min = 1; min < max; min++) {
-    if (count[min] !== 0) {
+  for (min2 = 1; min2 < max2; min2++) {
+    if (count[min2] !== 0) {
       break;
     }
   }
-  if (root < min) {
-    root = min;
+  if (root < min2) {
+    root = min2;
   }
   left = 1;
-  for (len = 1; len <= MAXBITS; len++) {
+  for (len2 = 1; len2 <= MAXBITS; len2++) {
     left <<= 1;
-    left -= count[len];
+    left -= count[len2];
     if (left < 0) {
       return -1;
     }
   }
-  if (left > 0 && (type === CODES$1 || max !== 1)) {
+  if (left > 0 && (type === CODES$1 || max2 !== 1)) {
     return -1;
   }
   offs[1] = 0;
-  for (len = 1; len < MAXBITS; len++) {
-    offs[len + 1] = offs[len] + count[len];
+  for (len2 = 1; len2 < MAXBITS; len2++) {
+    offs[len2 + 1] = offs[len2] + count[len2];
   }
   for (sym = 0; sym < codes; sym++) {
     if (lens[lens_index + sym] !== 0) {
@@ -11171,7 +12899,7 @@ var inflate_table = (type, lens, lens_index, codes, table, table_index, work, op
   }
   huff = 0;
   sym = 0;
-  len = min;
+  len2 = min2;
   next = table_index;
   curr = root;
   drop = 0;
@@ -11182,7 +12910,7 @@ var inflate_table = (type, lens, lens_index, codes, table, table_index, work, op
     return 1;
   }
   for (; ; ) {
-    here_bits = len - drop;
+    here_bits = len2 - drop;
     if (work[sym] + 1 < match) {
       here_op = 0;
       here_val = work[sym];
@@ -11193,14 +12921,14 @@ var inflate_table = (type, lens, lens_index, codes, table, table_index, work, op
       here_op = 32 + 64;
       here_val = 0;
     }
-    incr = 1 << len - drop;
+    incr = 1 << len2 - drop;
     fill = 1 << curr;
-    min = fill;
+    min2 = fill;
     do {
       fill -= incr;
       table[next + (huff >> drop) + fill] = here_bits << 24 | here_op << 16 | here_val | 0;
     } while (fill !== 0);
-    incr = 1 << len - 1;
+    incr = 1 << len2 - 1;
     while (huff & incr) {
       incr >>= 1;
     }
@@ -11211,20 +12939,20 @@ var inflate_table = (type, lens, lens_index, codes, table, table_index, work, op
       huff = 0;
     }
     sym++;
-    if (--count[len] === 0) {
-      if (len === max) {
+    if (--count[len2] === 0) {
+      if (len2 === max2) {
         break;
       }
-      len = lens[lens_index + work[sym]];
+      len2 = lens[lens_index + work[sym]];
     }
-    if (len > root && (huff & mask) !== low) {
+    if (len2 > root && (huff & mask) !== low) {
       if (drop === 0) {
         drop = root;
       }
-      next += min;
-      curr = len - drop;
+      next += min2;
+      curr = len2 - drop;
       left = 1 << curr;
-      while (curr + drop < max) {
+      while (curr + drop < max2) {
         left -= count[curr + drop];
         if (left <= 0) {
           break;
@@ -11241,7 +12969,7 @@ var inflate_table = (type, lens, lens_index, codes, table, table_index, work, op
     }
   }
   if (huff !== 0) {
-    table[next + huff] = len - drop << 24 | 64 << 16 | 0;
+    table[next + huff] = len2 - drop << 24 | 64 << 16 | 0;
   }
   opts.bits = root;
   return 0;
@@ -11460,8 +13188,8 @@ var fixedtables = (state) => {
   state.distcode = distfix;
   state.distbits = 5;
 };
-var updatewindow = (strm, src, end, copy) => {
-  let dist;
+var updatewindow = (strm, src, end, copy3) => {
+  let dist2;
   const state = strm.state;
   if (state.window === null) {
     state.wsize = 1 << state.wbits;
@@ -11469,28 +13197,28 @@ var updatewindow = (strm, src, end, copy) => {
     state.whave = 0;
     state.window = new Uint8Array(state.wsize);
   }
-  if (copy >= state.wsize) {
+  if (copy3 >= state.wsize) {
     state.window.set(src.subarray(end - state.wsize, end), 0);
     state.wnext = 0;
     state.whave = state.wsize;
   } else {
-    dist = state.wsize - state.wnext;
-    if (dist > copy) {
-      dist = copy;
-    }
-    state.window.set(src.subarray(end - copy, end - copy + dist), state.wnext);
-    copy -= dist;
-    if (copy) {
-      state.window.set(src.subarray(end - copy, end), 0);
-      state.wnext = copy;
+    dist2 = state.wsize - state.wnext;
+    if (dist2 > copy3) {
+      dist2 = copy3;
+    }
+    state.window.set(src.subarray(end - copy3, end - copy3 + dist2), state.wnext);
+    copy3 -= dist2;
+    if (copy3) {
+      state.window.set(src.subarray(end - copy3, end), 0);
+      state.wnext = copy3;
       state.whave = state.wsize;
     } else {
-      state.wnext += dist;
+      state.wnext += dist2;
       if (state.wnext === state.wsize) {
         state.wnext = 0;
       }
       if (state.whave < state.wsize) {
-        state.whave += dist;
+        state.whave += dist2;
       }
     }
   }
@@ -11505,13 +13233,13 @@ var inflate$2 = (strm, flush) => {
   let hold;
   let bits;
   let _in, _out;
-  let copy;
+  let copy3;
   let from;
   let from_source;
   let here = 0;
   let here_bits, here_op, here_val;
   let last_bits, last_op, last_val;
-  let len;
+  let len2;
   let ret;
   const hbuf = new Uint8Array(4);
   let opts;
@@ -11583,11 +13311,11 @@ var inflate$2 = (strm, flush) => {
           }
           hold >>>= 4;
           bits -= 4;
-          len = (hold & 15) + 8;
+          len2 = (hold & 15) + 8;
           if (state.wbits === 0) {
-            state.wbits = len;
+            state.wbits = len2;
           }
-          if (len > 15 || len > state.wbits) {
+          if (len2 > 15 || len2 > state.wbits) {
             strm.msg = "invalid window size";
             state.mode = BAD;
             break;
@@ -11704,13 +13432,13 @@ var inflate$2 = (strm, flush) => {
         /* falls through */
         case EXTRA:
           if (state.flags & 1024) {
-            copy = state.length;
-            if (copy > have) {
-              copy = have;
+            copy3 = state.length;
+            if (copy3 > have) {
+              copy3 = have;
             }
-            if (copy) {
+            if (copy3) {
               if (state.head) {
-                len = state.head.extra_len - state.length;
+                len2 = state.head.extra_len - state.length;
                 if (!state.head.extra) {
                   state.head.extra = new Uint8Array(state.head.extra_len);
                 }
@@ -11719,18 +13447,18 @@ var inflate$2 = (strm, flush) => {
                     next,
                     // extra field is limited to 65536 bytes
                     // - no need for additional size check
-                    next + copy
+                    next + copy3
                   ),
                   /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/
-                  len
+                  len2
                 );
               }
               if (state.flags & 512 && state.wrap & 4) {
-                state.check = crc32_1(state.check, input, copy, next);
+                state.check = crc32_1(state.check, input, copy3, next);
               }
-              have -= copy;
-              next += copy;
-              state.length -= copy;
+              have -= copy3;
+              next += copy3;
+              state.length -= copy3;
             }
             if (state.length) {
               break inf_leave;
@@ -11744,19 +13472,19 @@ var inflate$2 = (strm, flush) => {
             if (have === 0) {
               break inf_leave;
             }
-            copy = 0;
+            copy3 = 0;
             do {
-              len = input[next + copy++];
-              if (state.head && len && state.length < 65536) {
-                state.head.name += String.fromCharCode(len);
+              len2 = input[next + copy3++];
+              if (state.head && len2 && state.length < 65536) {
+                state.head.name += String.fromCharCode(len2);
               }
-            } while (len && copy < have);
+            } while (len2 && copy3 < have);
             if (state.flags & 512 && state.wrap & 4) {
-              state.check = crc32_1(state.check, input, copy, next);
+              state.check = crc32_1(state.check, input, copy3, next);
             }
-            have -= copy;
-            next += copy;
-            if (len) {
+            have -= copy3;
+            next += copy3;
+            if (len2) {
               break inf_leave;
             }
           } else if (state.head) {
@@ -11770,19 +13498,19 @@ var inflate$2 = (strm, flush) => {
             if (have === 0) {
               break inf_leave;
             }
-            copy = 0;
+            copy3 = 0;
             do {
-              len = input[next + copy++];
-              if (state.head && len && state.length < 65536) {
-                state.head.comment += String.fromCharCode(len);
+              len2 = input[next + copy3++];
+              if (state.head && len2 && state.length < 65536) {
+                state.head.comment += String.fromCharCode(len2);
               }
-            } while (len && copy < have);
+            } while (len2 && copy3 < have);
             if (state.flags & 512 && state.wrap & 4) {
-              state.check = crc32_1(state.check, input, copy, next);
+              state.check = crc32_1(state.check, input, copy3, next);
             }
-            have -= copy;
-            next += copy;
-            if (len) {
+            have -= copy3;
+            next += copy3;
+            if (len2) {
               break inf_leave;
             }
           } else if (state.head) {
@@ -11916,23 +13644,23 @@ var inflate$2 = (strm, flush) => {
           state.mode = COPY;
         /* falls through */
         case COPY:
-          copy = state.length;
-          if (copy) {
-            if (copy > have) {
-              copy = have;
+          copy3 = state.length;
+          if (copy3) {
+            if (copy3 > have) {
+              copy3 = have;
             }
-            if (copy > left) {
-              copy = left;
+            if (copy3 > left) {
+              copy3 = left;
             }
-            if (copy === 0) {
+            if (copy3 === 0) {
               break inf_leave;
             }
-            output.set(input.subarray(next, next + copy), put);
-            have -= copy;
-            next += copy;
-            left -= copy;
-            put += copy;
-            state.length -= copy;
+            output.set(input.subarray(next, next + copy3), put);
+            have -= copy3;
+            next += copy3;
+            left -= copy3;
+            put += copy3;
+            state.length -= copy3;
             break;
           }
           state.mode = TYPE;
@@ -12032,8 +13760,8 @@ var inflate$2 = (strm, flush) => {
                   state.mode = BAD;
                   break;
                 }
-                len = state.lens[state.have - 1];
-                copy = 3 + (hold & 3);
+                len2 = state.lens[state.have - 1];
+                copy3 = 3 + (hold & 3);
                 hold >>>= 2;
                 bits -= 2;
               } else if (here_val === 17) {
@@ -12048,8 +13776,8 @@ var inflate$2 = (strm, flush) => {
                 }
                 hold >>>= here_bits;
                 bits -= here_bits;
-                len = 0;
-                copy = 3 + (hold & 7);
+                len2 = 0;
+                copy3 = 3 + (hold & 7);
                 hold >>>= 3;
                 bits -= 3;
               } else {
@@ -12064,18 +13792,18 @@ var inflate$2 = (strm, flush) => {
                 }
                 hold >>>= here_bits;
                 bits -= here_bits;
-                len = 0;
-                copy = 11 + (hold & 127);
+                len2 = 0;
+                copy3 = 11 + (hold & 127);
                 hold >>>= 7;
                 bits -= 7;
               }
-              if (state.have + copy > state.nlen + state.ndist) {
+              if (state.have + copy3 > state.nlen + state.ndist) {
                 strm.msg = "invalid bit length repeat";
                 state.mode = BAD;
                 break;
               }
-              while (copy--) {
-                state.lens[state.have++] = len;
+              while (copy3--) {
+                state.lens[state.have++] = len2;
               }
             }
           }
@@ -12293,39 +14021,39 @@ var inflate$2 = (strm, flush) => {
           if (left === 0) {
             break inf_leave;
           }
-          copy = _out - left;
-          if (state.offset > copy) {
-            copy = state.offset - copy;
-            if (copy > state.whave) {
+          copy3 = _out - left;
+          if (state.offset > copy3) {
+            copy3 = state.offset - copy3;
+            if (copy3 > state.whave) {
               if (state.sane) {
                 strm.msg = "invalid distance too far back";
                 state.mode = BAD;
                 break;
               }
             }
-            if (copy > state.wnext) {
-              copy -= state.wnext;
-              from = state.wsize - copy;
+            if (copy3 > state.wnext) {
+              copy3 -= state.wnext;
+              from = state.wsize - copy3;
             } else {
-              from = state.wnext - copy;
+              from = state.wnext - copy3;
             }
-            if (copy > state.length) {
-              copy = state.length;
+            if (copy3 > state.length) {
+              copy3 = state.length;
             }
             from_source = state.window;
           } else {
             from_source = output;
             from = put - state.offset;
-            copy = state.length;
+            copy3 = state.length;
           }
-          if (copy > left) {
-            copy = left;
+          if (copy3 > left) {
+            copy3 = left;
           }
-          left -= copy;
-          state.length -= copy;
+          left -= copy3;
+          state.length -= copy3;
           do {
             output[put++] = from_source[from++];
-          } while (--copy);
+          } while (--copy3);
           if (state.length === 0) {
             state.mode = LEN;
           }
@@ -12789,18 +14517,18 @@ var _StreamingBuffer = class _StreamingBuffer {
       _StreamingBuffer.MAX_STRING_LENGTH,
       this.writeOffset - this.readOffset
     );
-    let length = 0;
-    while (length < maxLength && this.buffer[this.readOffset + length] !== 0) {
-      length++;
+    let length2 = 0;
+    while (length2 < maxLength && this.buffer[this.readOffset + length2] !== 0) {
+      length2++;
     }
-    if (length >= maxLength) {
+    if (length2 >= maxLength) {
       if (this.writeOffset - this.readOffset <= maxLength) {
         throw new Error("Buffer underflow");
       }
       throw new Error("String exceeds max length");
     }
-    const bytes = this.buffer.slice(this.readOffset, this.readOffset + length);
-    this.readOffset += length + 1;
+    const bytes = this.buffer.slice(this.readOffset, this.readOffset + length2);
+    this.readOffset += length2 + 1;
     return new TextDecoder("latin1").decode(bytes);
   }
   /**
@@ -13266,8 +14994,8 @@ var NetworkMessageParser = class _NetworkMessageParser {
   }
   parsePrint() {
     const id = this.stream.readByte();
-    const str = this.stream.readString();
-    if (this.handler) this.handler.onPrint(id, str);
+    const str3 = this.stream.readString();
+    if (this.handler) this.handler.onPrint(id, str3);
   }
   parseStuffText() {
     const text = this.stream.readString();
@@ -13311,8 +15039,8 @@ var NetworkMessageParser = class _NetworkMessageParser {
   }
   parseConfigString() {
     const index = this.stream.readShort();
-    const str = this.stream.readString();
-    if (this.handler) this.handler.onConfigString(index, str);
+    const str3 = this.stream.readString();
+    if (this.handler) this.handler.onConfigString(index, str3);
   }
   parseSplitClient() {
     const clientNum = this.stream.readByte();
@@ -13327,8 +15055,8 @@ var NetworkMessageParser = class _NetworkMessageParser {
       const blastStream = new BinaryStream(decompressed.buffer);
       while (blastStream.hasMore()) {
         const index = blastStream.readUShort();
-        const str = blastStream.readString();
-        if (this.handler) this.handler.onConfigString(index, str);
+        const str3 = blastStream.readString();
+        if (this.handler) this.handler.onConfigString(index, str3);
       }
     } catch (e) {
       console.error("svc_configblast error", e);
@@ -13890,10 +15618,10 @@ var DemoAnalyzer = class {
           frameDuration = 1 / tickRate;
         }
       },
-      onConfigString: (index, str) => {
-        this.configStrings.set(index, str);
+      onConfigString: (index, str3) => {
+        this.configStrings.set(index, str3);
         if (index === 0) {
-          this.parseServerInfo(str);
+          this.parseServerInfo(str3);
         }
       },
       onSpawnBaseline: (entity) => {
@@ -14046,8 +15774,8 @@ var DemoAnalyzer = class {
   recordEvent(event) {
     this.events.push(event);
   }
-  parseServerInfo(str) {
-    const parts = str.split("\\");
+  parseServerInfo(str3) {
+    const parts = str3.split("\\");
     for (let i = 1; i < parts.length; i += 2) {
       if (i + 1 < parts.length) {
         this.serverInfo[parts[i]] = parts[i + 1];
@@ -14658,8 +16386,8 @@ var DemoPlaybackController = class {
   getCameraMode() {
     return this.cameraMode;
   }
-  setThirdPersonDistance(distance) {
-    this.thirdPersonDistance = distance;
+  setThirdPersonDistance(distance2) {
+    this.thirdPersonDistance = distance2;
   }
   setThirdPersonOffset(offset) {
     this.thirdPersonOffset = offset;
@@ -14839,9 +16567,9 @@ var DemoValidator = class {
       return { valid: false, error: "File too small to be a valid demo" };
     }
     const view = new DataView(buffer);
-    const length = view.getInt32(0, true);
-    if (length <= 0 || length > buffer.byteLength - 4) {
-      return { valid: false, error: `Invalid first block length: ${length}` };
+    const length2 = view.getInt32(0, true);
+    if (length2 <= 0 || length2 > buffer.byteLength - 4) {
+      return { valid: false, error: `Invalid first block length: ${length2}` };
     }
     const firstCmd = view.getUint8(4);
     if (firstCmd !== ServerCommand.serverdata) {
@@ -14851,7 +16579,7 @@ var DemoValidator = class {
       };
     }
     let version = -1;
-    if (length >= 5) {
+    if (length2 >= 5) {
       version = view.getInt32(5, true);
     }
     return { valid: true, version };
@@ -14936,10 +16664,10 @@ var MessageWriter = class {
     this.writer.writeShort(playerNum);
     this.writer.writeString(levelName);
   }
-  writeConfigString(index, str, protocolVersion = 0) {
+  writeConfigString(index, str3, protocolVersion = 0) {
     this.writeCommand(ServerCommand.configstring, protocolVersion);
     this.writer.writeShort(index);
-    this.writer.writeString(str);
+    this.writer.writeString(str3);
   }
   writeSpawnBaseline(entity, protocolVersion) {
     this.writeCommand(ServerCommand.spawnbaseline, protocolVersion);
@@ -15439,8 +17167,8 @@ var DemoClipper = class {
       onServerData: (protocol, serverCount, attractLoop, gameDir, playerNum, levelName, tickRate, demoType) => {
         state.serverData = { protocol, serverCount, attractLoop, gameDir, playerNum, levelName, tickRate, demoType };
       },
-      onConfigString: (index, str) => {
-        state.configStrings.set(index, str);
+      onConfigString: (index, str3) => {
+        state.configStrings.set(index, str3);
       },
       onSpawnBaseline: (entity) => {
         state.entityBaselines.set(entity.number, { ...entity });
@@ -15537,8 +17265,8 @@ var DemoClipper = class {
         serverData.levelName
       );
     }
-    for (const [index, str] of worldState.configStrings) {
-      headerWriter.writeConfigString(index, str, serverData.protocol);
+    for (const [index, str3] of worldState.configStrings) {
+      headerWriter.writeConfigString(index, str3, serverData.protocol);
     }
     for (const entity of worldState.entityBaselines.values()) {
       headerWriter.writeSpawnBaseline(entity, serverData.protocol);
@@ -15573,7 +17301,7 @@ var DemoClipper = class {
         const passthroughHandler = {
           onServerData: () => {
           },
-          onConfigString: (idx, str) => blockWriter.writeConfigString(idx, str, serverData.protocol),
+          onConfigString: (idx, str3) => blockWriter.writeConfigString(idx, str3, serverData.protocol),
           onSpawnBaseline: (ent) => blockWriter.writeSpawnBaseline(ent, serverData.protocol),
           onCenterPrint: (msg) => blockWriter.writeCenterPrint(msg, serverData.protocol),
           onStuffText: (txt) => blockWriter.writeStuffText(txt, serverData.protocol),
@@ -15753,7 +17481,7 @@ function drawLine(buffer, width, height, x0, y0, x1, y1, r, g, b, a) {
     }
   }
 }
-function projectPoint(v, width, height, center, scale) {
+function projectPoint(v, width, height, center, scale3) {
   const cosY = 0.707;
   const sinY = 0.707;
   const x1 = (v.x - center.x) * cosY - (v.y - center.y) * sinY;
@@ -15763,8 +17491,8 @@ function projectPoint(v, width, height, center, scale) {
   const sinX = 0.5;
   const y2 = y1 * cosX - z1 * sinX;
   const z2 = y1 * sinX + z1 * cosX;
-  const screenX = width / 2 + x1 * scale;
-  const screenY = height / 2 - z2 * scale;
+  const screenX = width / 2 + x1 * scale3;
+  const screenY = height / 2 - z2 * scale3;
   return { x: screenX, y: screenY };
 }
 var AssetPreviewGenerator = class {
@@ -15835,35 +17563,35 @@ var AssetPreviewGenerator = class {
         return null;
       }
       if (vertices.length === 0) return null;
-      const min = { x: Infinity, y: Infinity, z: Infinity };
-      const max = { x: -Infinity, y: -Infinity, z: -Infinity };
+      const min2 = { x: Infinity, y: Infinity, z: Infinity };
+      const max2 = { x: -Infinity, y: -Infinity, z: -Infinity };
       for (const v of vertices) {
-        min.x = Math.min(min.x, v.x);
-        min.y = Math.min(min.y, v.y);
-        min.z = Math.min(min.z, v.z);
-        max.x = Math.max(max.x, v.x);
-        max.y = Math.max(max.y, v.y);
-        max.z = Math.max(max.z, v.z);
+        min2.x = Math.min(min2.x, v.x);
+        min2.y = Math.min(min2.y, v.y);
+        min2.z = Math.min(min2.z, v.z);
+        max2.x = Math.max(max2.x, v.x);
+        max2.y = Math.max(max2.y, v.y);
+        max2.z = Math.max(max2.z, v.z);
       }
       const center = {
-        x: (min.x + max.x) / 2,
-        y: (min.y + max.y) / 2,
-        z: (min.z + max.z) / 2
+        x: (min2.x + max2.x) / 2,
+        y: (min2.y + max2.y) / 2,
+        z: (min2.z + max2.z) / 2
       };
-      const sizeX = max.x - min.x;
-      const sizeY = max.y - min.y;
-      const sizeZ = max.z - min.z;
+      const sizeX = max2.x - min2.x;
+      const sizeY = max2.y - min2.y;
+      const sizeZ = max2.z - min2.z;
       const maxDim = Math.max(sizeX, sizeY, sizeZ);
       const safeMaxDim = Math.max(maxDim, 1e-3);
-      const scale = size * 0.8 / safeMaxDim;
+      const scale3 = size * 0.8 / safeMaxDim;
       const buffer = new Uint8ClampedArray(size * size * 4);
       for (let i = 0; i < indices.length; i += 2) {
         const idx0 = indices[i];
         const idx1 = indices[i + 1];
         const v0 = vertices[idx0];
         const v1 = vertices[idx1];
-        const p0 = projectPoint(v0, size, size, center, scale);
-        const p1 = projectPoint(v1, size, size, center, scale);
+        const p0 = projectPoint(v0, size, size, center, scale3);
+        const p1 = projectPoint(v1, size, size, center, scale3);
         drawLine(buffer, size, size, p0.x, p0.y, p1.x, p1.y, 0, 255, 0, 255);
       }
       return new ImageData(buffer, size, size);
@@ -15958,19 +17686,19 @@ var MapAnalyzer = class {
 function parseEntLump(text) {
   const entities = [];
   let cursor = 0;
-  const length = text.length;
+  const length2 = text.length;
   function skipWhitespace() {
-    while (cursor < length && /\s/.test(text[cursor])) {
+    while (cursor < length2 && /\s/.test(text[cursor])) {
       cursor++;
     }
   }
   function readToken() {
     skipWhitespace();
-    if (cursor >= length) return null;
+    if (cursor >= length2) return null;
     if (text[cursor] === '"') {
       cursor++;
       const start = cursor;
-      while (cursor < length && text[cursor] !== '"') {
+      while (cursor < length2 && text[cursor] !== '"') {
         if (text[cursor] === "\n") {
         }
         cursor++;
@@ -15982,19 +17710,19 @@ function parseEntLump(text) {
       return text[cursor++];
     } else {
       if (text.startsWith("//", cursor)) {
-        while (cursor < length && text[cursor] !== "\n") {
+        while (cursor < length2 && text[cursor] !== "\n") {
           cursor++;
         }
         return readToken();
       }
       const start = cursor;
-      while (cursor < length && !/\s/.test(text[cursor]) && text[cursor] !== "}" && text[cursor] !== "{") {
+      while (cursor < length2 && !/\s/.test(text[cursor]) && text[cursor] !== "}" && text[cursor] !== "{") {
         cursor++;
       }
       return text.substring(start, cursor);
     }
   }
-  while (cursor < length) {
+  while (cursor < length2) {
     const token = readToken();
     if (token === null) break;
     if (token === "{") {