quake2ts 0.0.7

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

@@ -0,0 +1,2594 @@
+// src/math/vec3.ts
+var ZERO_VEC3 = { x: 0, y: 0, z: 0 };
+var STOP_EPSILON = 0.1;
+var DEG_TO_RAD = Math.PI / 180;
+function addVec3(a, b) {
+  return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
+}
+function subtractVec3(a, b) {
+  return { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
+}
+function multiplyVec3(a, b) {
+  return { x: a.x * b.x, y: a.y * b.y, z: a.z * b.z };
+}
+function scaleVec3(a, scalar) {
+  return { x: a.x * scalar, y: a.y * scalar, z: a.z * scalar };
+}
+function negateVec3(a) {
+  return scaleVec3(a, -1);
+}
+function dotVec3(a, b) {
+  return a.x * b.x + a.y * b.y + a.z * b.z;
+}
+function crossVec3(a, b) {
+  return {
+    x: a.y * b.z - a.z * b.y,
+    y: a.z * b.x - a.x * b.z,
+    z: a.x * b.y - a.y * b.x
+  };
+}
+function lengthSquaredVec3(a) {
+  return dotVec3(a, a);
+}
+function lengthVec3(a) {
+  return Math.sqrt(lengthSquaredVec3(a));
+}
+function normalizeVec3(a) {
+  const len = lengthVec3(a);
+  return len === 0 ? a : scaleVec3(a, 1 / len);
+}
+function projectPointOnPlane(point, normal) {
+  const invDenom = 1 / dotVec3(normal, normal);
+  const d = dotVec3(normal, point) * invDenom;
+  return subtractVec3(point, scaleVec3(normal, invDenom * d));
+}
+function perpendicularVec3(src) {
+  let pos = 0;
+  let minElement = Math.abs(src.x);
+  if (Math.abs(src.y) < minElement) {
+    pos = 1;
+    minElement = Math.abs(src.y);
+  }
+  if (Math.abs(src.z) < minElement) {
+    pos = 2;
+  }
+  const axis = pos === 0 ? { x: 1, y: 0, z: 0 } : pos === 1 ? { x: 0, y: 1, z: 0 } : { x: 0, y: 0, z: 1 };
+  return normalizeVec3(projectPointOnPlane(axis, src));
+}
+function closestPointToBox(point, mins, maxs) {
+  return {
+    x: point.x < mins.x ? mins.x : point.x > maxs.x ? maxs.x : point.x,
+    y: point.y < mins.y ? mins.y : point.y > maxs.y ? maxs.y : point.y,
+    z: point.z < mins.z ? mins.z : point.z > maxs.z ? maxs.z : point.z
+  };
+}
+function distanceBetweenBoxesSquared(aMins, aMaxs, bMins, bMaxs) {
+  let lengthSq = 0;
+  if (aMaxs.x < bMins.x) {
+    const d = aMaxs.x - bMins.x;
+    lengthSq += d * d;
+  } else if (aMins.x > bMaxs.x) {
+    const d = aMins.x - bMaxs.x;
+    lengthSq += d * d;
+  }
+  if (aMaxs.y < bMins.y) {
+    const d = aMaxs.y - bMins.y;
+    lengthSq += d * d;
+  } else if (aMins.y > bMaxs.y) {
+    const d = aMins.y - bMaxs.y;
+    lengthSq += d * d;
+  }
+  if (aMaxs.z < bMins.z) {
+    const d = aMaxs.z - bMins.z;
+    lengthSq += d * d;
+  } else if (aMins.z > bMaxs.z) {
+    const d = aMins.z - bMaxs.z;
+    lengthSq += d * d;
+  }
+  return lengthSq;
+}
+function createEmptyBounds3() {
+  return {
+    mins: { x: Number.POSITIVE_INFINITY, y: Number.POSITIVE_INFINITY, z: Number.POSITIVE_INFINITY },
+    maxs: { x: Number.NEGATIVE_INFINITY, y: Number.NEGATIVE_INFINITY, z: Number.NEGATIVE_INFINITY }
+  };
+}
+function addPointToBounds(point, bounds) {
+  return {
+    mins: {
+      x: Math.min(bounds.mins.x, point.x),
+      y: Math.min(bounds.mins.y, point.y),
+      z: Math.min(bounds.mins.z, point.z)
+    },
+    maxs: {
+      x: Math.max(bounds.maxs.x, point.x),
+      y: Math.max(bounds.maxs.y, point.y),
+      z: Math.max(bounds.maxs.z, point.z)
+    }
+  };
+}
+function boxesIntersect(a, b) {
+  return a.mins.x <= b.maxs.x && a.maxs.x >= b.mins.x && a.mins.y <= b.maxs.y && a.maxs.y >= b.mins.y && a.mins.z <= b.maxs.z && a.maxs.z >= b.mins.z;
+}
+function clipVelocityVec3(inVel, normal, overbounce) {
+  const backoff = dotVec3(inVel, normal) * overbounce;
+  let outX = inVel.x - normal.x * backoff;
+  let outY = inVel.y - normal.y * backoff;
+  let outZ = inVel.z - normal.z * backoff;
+  if (outX > -STOP_EPSILON && outX < STOP_EPSILON) {
+    outX = 0;
+  }
+  if (outY > -STOP_EPSILON && outY < STOP_EPSILON) {
+    outY = 0;
+  }
+  if (outZ > -STOP_EPSILON && outZ < STOP_EPSILON) {
+    outZ = 0;
+  }
+  return { x: outX, y: outY, z: outZ };
+}
+function clipVelocityAgainstPlanes(velocity, planes, overbounce, primalVelocity) {
+  if (planes.length === 0) {
+    return velocity;
+  }
+  let working = velocity;
+  for (let i = 0; i < planes.length; i++) {
+    working = clipVelocityVec3(working, planes[i], overbounce);
+    let j = 0;
+    for (; j < planes.length; j++) {
+      if (j === i) {
+        continue;
+      }
+      if (dotVec3(working, planes[j]) < 0) {
+        break;
+      }
+    }
+    if (j === planes.length) {
+      if (primalVelocity && dotVec3(working, primalVelocity) <= 0) {
+        return ZERO_VEC3;
+      }
+      return working;
+    }
+  }
+  if (planes.length === 2) {
+    const dir = crossVec3(planes[0], planes[1]);
+    const d = dotVec3(dir, velocity);
+    const creaseVelocity = scaleVec3(dir, d);
+    if (primalVelocity && dotVec3(creaseVelocity, primalVelocity) <= 0) {
+      return ZERO_VEC3;
+    }
+    return creaseVelocity;
+  }
+  if (primalVelocity && dotVec3(working, primalVelocity) <= 0) {
+    return ZERO_VEC3;
+  }
+  return ZERO_VEC3;
+}
+function slideClipVelocityVec3(inVel, normal, overbounce) {
+  return clipVelocityVec3(inVel, normal, overbounce);
+}
+function projectSourceVec3(point, distance, forward, right) {
+  return {
+    x: point.x + forward.x * distance.x + right.x * distance.y,
+    y: point.y + forward.y * distance.x + right.y * distance.y,
+    z: point.z + forward.z * distance.x + right.z * distance.y + distance.z
+  };
+}
+function projectSourceVec3WithUp(point, distance, forward, right, up) {
+  return {
+    x: point.x + forward.x * distance.x + right.x * distance.y + up.x * distance.z,
+    y: point.y + forward.y * distance.x + right.y * distance.y + up.y * distance.z,
+    z: point.z + forward.z * distance.x + right.z * distance.y + up.z * distance.z
+  };
+}
+function slerpVec3(from, to, t) {
+  const dot = dotVec3(from, to);
+  let aFactor;
+  let bFactor;
+  if (Math.abs(dot) > 0.9995) {
+    aFactor = 1 - t;
+    bFactor = t;
+  } else {
+    const ang = Math.acos(dot);
+    const sinOmega = Math.sin(ang);
+    const sinAOmega = Math.sin((1 - t) * ang);
+    const sinBOmega = Math.sin(t * ang);
+    aFactor = sinAOmega / sinOmega;
+    bFactor = sinBOmega / sinOmega;
+  }
+  return {
+    x: from.x * aFactor + to.x * bFactor,
+    y: from.y * aFactor + to.y * bFactor,
+    z: from.z * aFactor + to.z * bFactor
+  };
+}
+function concatRotationMatrices(a, b) {
+  const row = (rowIndex) => [
+    a[rowIndex][0] * b[0][0] + a[rowIndex][1] * b[1][0] + a[rowIndex][2] * b[2][0],
+    a[rowIndex][0] * b[0][1] + a[rowIndex][1] * b[1][1] + a[rowIndex][2] * b[2][1],
+    a[rowIndex][0] * b[0][2] + a[rowIndex][1] * b[1][2] + a[rowIndex][2] * b[2][2]
+  ];
+  const result = [row(0), row(1), row(2)];
+  return result;
+}
+function rotatePointAroundVector(dir, point, degrees) {
+  const axisLength = lengthVec3(dir);
+  if (axisLength === 0) {
+    return point;
+  }
+  const vf = normalizeVec3(dir);
+  const vr = perpendicularVec3(vf);
+  const vup = crossVec3(vr, vf);
+  const m = [
+    [vr.x, vup.x, vf.x],
+    [vr.y, vup.y, vf.y],
+    [vr.z, vup.z, vf.z]
+  ];
+  const im = [
+    [m[0][0], m[1][0], m[2][0]],
+    [m[0][1], m[1][1], m[2][1]],
+    [m[0][2], m[1][2], m[2][2]]
+  ];
+  const radians = degrees * DEG_TO_RAD;
+  const cos = Math.cos(radians);
+  const sin = Math.sin(radians);
+  const zrot = [
+    [cos, sin, 0],
+    [-sin, cos, 0],
+    [0, 0, 1]
+  ];
+  const rot = concatRotationMatrices(concatRotationMatrices(m, zrot), im);
+  return {
+    x: rot[0][0] * point.x + rot[0][1] * point.y + rot[0][2] * point.z,
+    y: rot[1][0] * point.x + rot[1][1] * point.y + rot[1][2] * point.z,
+    z: rot[2][0] * point.x + rot[2][1] * point.y + rot[2][2] * point.z
+  };
+}
+
+// src/math/angles.ts
+var PITCH = 0;
+var YAW = 1;
+var ROLL = 2;
+var DEG2RAD_FACTOR = Math.PI / 180;
+var RAD2DEG_FACTOR = 180 / Math.PI;
+function axisComponent(vec, axis) {
+  switch (axis) {
+    case PITCH:
+      return vec.x;
+    case YAW:
+      return vec.y;
+    case ROLL:
+    default:
+      return vec.z;
+  }
+}
+function degToRad(degrees) {
+  return degrees * DEG2RAD_FACTOR;
+}
+function radToDeg(radians) {
+  return radians * RAD2DEG_FACTOR;
+}
+function lerpAngle(from, to, frac) {
+  let target = to;
+  if (target - from > 180) {
+    target -= 360;
+  } else if (target - from < -180) {
+    target += 360;
+  }
+  return from + frac * (target - from);
+}
+function angleMod(angle) {
+  const value = angle % 360;
+  return value < 0 ? 360 + value : value;
+}
+function angleVectors(angles) {
+  const yaw = degToRad(axisComponent(angles, YAW));
+  const pitch = degToRad(axisComponent(angles, PITCH));
+  const roll = degToRad(axisComponent(angles, ROLL));
+  const sy = Math.sin(yaw);
+  const cy = Math.cos(yaw);
+  const sp = Math.sin(pitch);
+  const cp = Math.cos(pitch);
+  const sr = Math.sin(roll);
+  const cr = Math.cos(roll);
+  const forward = {
+    x: cp * cy,
+    y: cp * sy,
+    z: -sp
+  };
+  const right = {
+    x: -sr * sp * cy - cr * -sy,
+    y: -sr * sp * sy - cr * cy,
+    z: -sr * cp
+  };
+  const up = {
+    x: cr * sp * cy - sr * -sy,
+    y: cr * sp * sy - sr * cy,
+    z: cr * cp
+  };
+  return { forward, right, up };
+}
+function vectorToYaw(vec) {
+  const pitch = axisComponent(vec, PITCH);
+  const yawAxis = axisComponent(vec, YAW);
+  if (pitch === 0) {
+    if (yawAxis === 0) {
+      return 0;
+    }
+    return yawAxis > 0 ? 90 : 270;
+  }
+  const yaw = radToDeg(Math.atan2(yawAxis, pitch));
+  return yaw < 0 ? yaw + 360 : yaw;
+}
+function vectorToAngles(vec) {
+  const x = vec.x;
+  const y = vec.y;
+  const z = vec.z;
+  if (y === 0 && x === 0) {
+    return { x: z > 0 ? -90 : -270, y: 0, z: 0 };
+  }
+  let yaw;
+  if (x) {
+    yaw = radToDeg(Math.atan2(y, x));
+  } else if (y > 0) {
+    yaw = 90;
+  } else {
+    yaw = 270;
+  }
+  if (yaw < 0) {
+    yaw += 360;
+  }
+  const forward = Math.sqrt(x * x + y * y);
+  let pitch = radToDeg(Math.atan2(z, forward));
+  if (pitch < 0) {
+    pitch += 360;
+  }
+  return { x: -pitch, y: yaw, z: 0 };
+}
+
+// src/math/color.ts
+function addBlendColor(r, g, b, a, current) {
+  if (a <= 0) {
+    return current;
+  }
+  const oldR = current[0];
+  const oldG = current[1];
+  const oldB = current[2];
+  const oldA = current[3];
+  const a2 = oldA + (1 - oldA) * a;
+  if (a2 <= 0) {
+    return [0, 0, 0, 0];
+  }
+  const a3 = oldA / a2;
+  const newR = oldR * a3 + r * (1 - a3);
+  const newG = oldG * a3 + g * (1 - a3);
+  const newB = oldB * a3 + b * (1 - a3);
+  return [newR, newG, newB, a2];
+}
+
+// src/math/random.ts
+var STATE_SIZE = 624;
+var MIDDLE_WORD = 397;
+var MATRIX_A = 2567483615;
+var UPPER_MASK = 2147483648;
+var LOWER_MASK = 2147483647;
+var TWO_POW_32 = 4294967296;
+var MersenneTwister19937 = class {
+  constructor(seed = 5489) {
+    this.state = new Uint32Array(STATE_SIZE);
+    this.index = STATE_SIZE;
+    this.seed(seed);
+  }
+  seed(seed) {
+    this.state[0] = seed >>> 0;
+    for (let i = 1; i < STATE_SIZE; i++) {
+      const prev = this.state[i - 1] ^ this.state[i - 1] >>> 30;
+      const next = Math.imul(prev >>> 0, 1812433253) + i;
+      this.state[i] = next >>> 0;
+    }
+    this.index = STATE_SIZE;
+  }
+  nextUint32() {
+    if (this.index >= STATE_SIZE) {
+      this.twist();
+    }
+    let y = this.state[this.index++];
+    y ^= y >>> 11;
+    y ^= y << 7 & 2636928640;
+    y ^= y << 15 & 4022730752;
+    y ^= y >>> 18;
+    return y >>> 0;
+  }
+  twist() {
+    for (let i = 0; i < STATE_SIZE; i++) {
+      const y = this.state[i] & UPPER_MASK | this.state[(i + 1) % STATE_SIZE] & LOWER_MASK;
+      let next = this.state[(i + MIDDLE_WORD) % STATE_SIZE] ^ y >>> 1;
+      if ((y & 1) !== 0) {
+        next ^= MATRIX_A;
+      }
+      this.state[i] = next >>> 0;
+    }
+    this.index = 0;
+  }
+};
+var RandomGenerator = class {
+  constructor(options = {}) {
+    this.mt = new MersenneTwister19937(options.seed);
+  }
+  /** Uniform float in [0, 1). */
+  frandom() {
+    return this.mt.nextUint32() / TWO_POW_32;
+  }
+  /** Uniform float in [min, max). */
+  frandomRange(minInclusive, maxExclusive) {
+    return minInclusive + (maxExclusive - minInclusive) * this.frandom();
+  }
+  /** Uniform float in [0, max). */
+  frandomMax(maxExclusive) {
+    return this.frandomRange(0, maxExclusive);
+  }
+  /** Uniform float in [-1, 1). */
+  crandom() {
+    return this.frandomRange(-1, 1);
+  }
+  /** Uniform float in (-1, 1). */
+  crandomOpen() {
+    const epsilon = Number.EPSILON;
+    return this.frandomRange(-1 + epsilon, 1);
+  }
+  /** Raw uint32 sample. */
+  irandomUint32() {
+    return this.mt.nextUint32();
+  }
+  /** Uniform integer in [min, max). */
+  irandomRange(minInclusive, maxExclusive) {
+    if (maxExclusive - minInclusive <= 1) {
+      return minInclusive;
+    }
+    const span = maxExclusive - minInclusive;
+    const limit = TWO_POW_32 - TWO_POW_32 % span;
+    let sample;
+    do {
+      sample = this.mt.nextUint32();
+    } while (sample >= limit);
+    return minInclusive + sample % span;
+  }
+  /** Uniform integer in [0, max). */
+  irandom(maxExclusive) {
+    if (maxExclusive <= 0) {
+      return 0;
+    }
+    return this.irandomRange(0, maxExclusive);
+  }
+  /** Uniform time in milliseconds [min, max). */
+  randomTimeRange(minMs, maxMs) {
+    if (maxMs <= minMs) {
+      return minMs;
+    }
+    return this.irandomRange(minMs, maxMs);
+  }
+  /** Uniform time in milliseconds [0, max). */
+  randomTime(maxMs) {
+    return this.irandom(maxMs);
+  }
+  randomIndex(container) {
+    return this.irandom(container.length);
+  }
+};
+function createRandomGenerator(options) {
+  return new RandomGenerator(options);
+}
+
+// src/bsp/contents.ts
+var CONTENTS_NONE = 0;
+var CONTENTS_SOLID = 1 << 0;
+var CONTENTS_WINDOW = 1 << 1;
+var CONTENTS_AUX = 1 << 2;
+var CONTENTS_LAVA = 1 << 3;
+var CONTENTS_SLIME = 1 << 4;
+var CONTENTS_WATER = 1 << 5;
+var CONTENTS_MIST = 1 << 6;
+var CONTENTS_NO_WATERJUMP = 1 << 13;
+var CONTENTS_PROJECTILECLIP = 1 << 14;
+var CONTENTS_AREAPORTAL = 1 << 15;
+var CONTENTS_PLAYERCLIP = 1 << 16;
+var CONTENTS_MONSTERCLIP = 1 << 17;
+var CONTENTS_CURRENT_0 = 1 << 18;
+var CONTENTS_CURRENT_90 = 1 << 19;
+var CONTENTS_CURRENT_180 = 1 << 20;
+var CONTENTS_CURRENT_270 = 1 << 21;
+var CONTENTS_CURRENT_UP = 1 << 22;
+var CONTENTS_CURRENT_DOWN = 1 << 23;
+var CONTENTS_ORIGIN = 1 << 24;
+var CONTENTS_MONSTER = 1 << 25;
+var CONTENTS_DEADMONSTER = 1 << 26;
+var CONTENTS_DETAIL = 1 << 27;
+var CONTENTS_TRANSLUCENT = 1 << 28;
+var CONTENTS_LADDER = 1 << 29;
+var CONTENTS_PLAYER = 1 << 30;
+var CONTENTS_PROJECTILE = 1 << 31;
+var LAST_VISIBLE_CONTENTS = CONTENTS_MIST;
+var SURF_NONE = 0;
+var SURF_LIGHT = 1 << 0;
+var SURF_SLICK = 1 << 1;
+var SURF_SKY = 1 << 2;
+var SURF_WARP = 1 << 3;
+var SURF_TRANS33 = 1 << 4;
+var SURF_TRANS66 = 1 << 5;
+var SURF_FLOWING = 1 << 6;
+var SURF_NODRAW = 1 << 7;
+var SURF_ALPHATEST = 1 << 25;
+var SURF_N64_UV = 1 << 28;
+var SURF_N64_SCROLL_X = 1 << 29;
+var SURF_N64_SCROLL_Y = 1 << 30;
+var SURF_N64_SCROLL_FLIP = 1 << 31;
+var MASK_ALL = 4294967295;
+var MASK_SOLID = CONTENTS_SOLID | CONTENTS_WINDOW;
+var MASK_PLAYERSOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW | CONTENTS_MONSTER | CONTENTS_PLAYER;
+var MASK_DEADSOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW;
+var MASK_MONSTERSOLID = CONTENTS_SOLID | CONTENTS_MONSTERCLIP | CONTENTS_WINDOW | CONTENTS_MONSTER | CONTENTS_PLAYER;
+var MASK_WATER = CONTENTS_WATER | CONTENTS_LAVA | CONTENTS_SLIME;
+var MASK_OPAQUE = CONTENTS_SOLID | CONTENTS_SLIME | CONTENTS_LAVA;
+var MASK_SHOT = CONTENTS_SOLID | CONTENTS_MONSTER | CONTENTS_PLAYER | CONTENTS_WINDOW | CONTENTS_DEADMONSTER;
+var MASK_CURRENT = CONTENTS_CURRENT_0 | CONTENTS_CURRENT_90 | CONTENTS_CURRENT_180 | CONTENTS_CURRENT_270 | CONTENTS_CURRENT_UP | CONTENTS_CURRENT_DOWN;
+var MASK_BLOCK_SIGHT = CONTENTS_SOLID | CONTENTS_LAVA | CONTENTS_SLIME | CONTENTS_MONSTER | CONTENTS_PLAYER;
+var MASK_NAV_SOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW;
+var MASK_LADDER_NAV_SOLID = CONTENTS_SOLID | CONTENTS_WINDOW;
+var MASK_WALK_NAV_SOLID = CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_WINDOW | CONTENTS_MONSTERCLIP;
+var MASK_PROJECTILE = MASK_SHOT | CONTENTS_PROJECTILECLIP;
+function hasAllContents(mask, flags) {
+  return (mask & flags) === flags;
+}
+function hasAnyContents(mask, flags) {
+  return (mask & flags) !== 0;
+}
+function addContents(mask, flags) {
+  return mask | flags;
+}
+function removeContents(mask, flags) {
+  return mask & ~flags;
+}
+function hasSurfaceFlags(surface, flags) {
+  return (surface & flags) === flags;
+}
+function combineSurfaceFlags(...flags) {
+  let mask = SURF_NONE;
+  for (const flag of flags) {
+    mask |= flag;
+  }
+  return mask;
+}
+
+// src/bsp/collision.ts
+var PlaneSide = /* @__PURE__ */ ((PlaneSide2) => {
+  PlaneSide2[PlaneSide2["FRONT"] = 1] = "FRONT";
+  PlaneSide2[PlaneSide2["BACK"] = 2] = "BACK";
+  PlaneSide2[PlaneSide2["CROSS"] = 3] = "CROSS";
+  return PlaneSide2;
+})(PlaneSide || {});
+var DIST_EPSILON = 0.03125;
+function buildCollisionModel(lumps) {
+  const planes = lumps.planes.map((plane) => ({
+    ...plane,
+    signbits: computePlaneSignBits(plane.normal)
+  }));
+  const nodes = lumps.nodes.map((node) => ({
+    plane: planes[node.planenum],
+    children: node.children
+  }));
+  const brushes = lumps.brushes.map((brush) => {
+    const sides = lumps.brushSides.slice(brush.firstSide, brush.firstSide + brush.numSides).map((side) => ({
+      plane: planes[side.planenum],
+      surfaceFlags: side.surfaceFlags
+    }));
+    return {
+      contents: brush.contents,
+      sides,
+      checkcount: 0
+    };
+  });
+  const leaves = lumps.leaves.map((leaf) => ({
+    contents: leaf.contents,
+    cluster: leaf.cluster,
+    area: leaf.area,
+    firstLeafBrush: leaf.firstLeafBrush,
+    numLeafBrushes: leaf.numLeafBrushes
+  }));
+  const bmodels = lumps.bmodels.map((model) => ({
+    mins: model.mins,
+    maxs: model.maxs,
+    origin: model.origin,
+    headnode: model.headnode
+  }));
+  return {
+    planes,
+    nodes,
+    leaves,
+    brushes,
+    leafBrushes: lumps.leafBrushes,
+    bmodels
+  };
+}
+function computePlaneSignBits(normal) {
+  let bits = 0;
+  if (normal.x < 0) bits |= 1;
+  if (normal.y < 0) bits |= 2;
+  if (normal.z < 0) bits |= 4;
+  return bits;
+}
+function planeDistanceToPoint(plane, point) {
+  return plane.normal.x * point.x + plane.normal.y * point.y + plane.normal.z * point.z - plane.dist;
+}
+function pointOnPlaneSide(plane, point, epsilon = 0) {
+  const dist = planeDistanceToPoint(plane, point);
+  if (dist > epsilon) {
+    return 1 /* FRONT */;
+  }
+  if (dist < -epsilon) {
+    return 2 /* BACK */;
+  }
+  return 3 /* CROSS */;
+}
+function boxOnPlaneSide(mins, maxs, plane, epsilon = 0) {
+  let dist1;
+  let dist2;
+  switch (plane.signbits) {
+    case 0:
+      dist1 = plane.normal.x * maxs.x + plane.normal.y * maxs.y + plane.normal.z * maxs.z;
+      dist2 = plane.normal.x * mins.x + plane.normal.y * mins.y + plane.normal.z * mins.z;
+      break;
+    case 1:
+      dist1 = plane.normal.x * mins.x + plane.normal.y * maxs.y + plane.normal.z * maxs.z;
+      dist2 = plane.normal.x * maxs.x + plane.normal.y * mins.y + plane.normal.z * mins.z;
+      break;
+    case 2:
+      dist1 = plane.normal.x * maxs.x + plane.normal.y * mins.y + plane.normal.z * maxs.z;
+      dist2 = plane.normal.x * mins.x + plane.normal.y * maxs.y + plane.normal.z * mins.z;
+      break;
+    case 3:
+      dist1 = plane.normal.x * mins.x + plane.normal.y * mins.y + plane.normal.z * maxs.z;
+      dist2 = plane.normal.x * maxs.x + plane.normal.y * maxs.y + plane.normal.z * mins.z;
+      break;
+    case 4:
+      dist1 = plane.normal.x * maxs.x + plane.normal.y * maxs.y + plane.normal.z * mins.z;
+      dist2 = plane.normal.x * mins.x + plane.normal.y * mins.y + plane.normal.z * maxs.z;
+      break;
+    case 5:
+      dist1 = plane.normal.x * mins.x + plane.normal.y * maxs.y + plane.normal.z * mins.z;
+      dist2 = plane.normal.x * maxs.x + plane.normal.y * mins.y + plane.normal.z * maxs.z;
+      break;
+    case 6:
+      dist1 = plane.normal.x * maxs.x + plane.normal.y * mins.y + plane.normal.z * mins.z;
+      dist2 = plane.normal.x * mins.x + plane.normal.y * maxs.y + plane.normal.z * maxs.z;
+      break;
+    default:
+      dist1 = plane.normal.x * mins.x + plane.normal.y * mins.y + plane.normal.z * mins.z;
+      dist2 = plane.normal.x * maxs.x + plane.normal.y * maxs.y + plane.normal.z * maxs.z;
+      break;
+  }
+  let sides = 0;
+  if (dist1 - plane.dist >= -epsilon) sides = 1 /* FRONT */;
+  if (dist2 - plane.dist <= epsilon) sides |= 2 /* BACK */;
+  return sides;
+}
+function pointInsideBrush(point, brush, epsilon = DIST_EPSILON) {
+  for (const side of brush.sides) {
+    const dist = planeDistanceToPoint(side.plane, point);
+    if (dist > epsilon) {
+      return false;
+    }
+  }
+  return true;
+}
+function testBoxInBrush(origin, mins, maxs, brush) {
+  for (const side of brush.sides) {
+    const offset = side.plane.normal.x * (side.plane.normal.x < 0 ? maxs.x : mins.x) + side.plane.normal.y * (side.plane.normal.y < 0 ? maxs.y : mins.y) + side.plane.normal.z * (side.plane.normal.z < 0 ? maxs.z : mins.z);
+    const dist = side.plane.dist - offset;
+    const d1 = origin.x * side.plane.normal.x + origin.y * side.plane.normal.y + origin.z * side.plane.normal.z - dist;
+    if (d1 > 0) {
+      return { startsolid: false, allsolid: false, contents: 0 };
+    }
+  }
+  return { startsolid: true, allsolid: true, contents: brush.contents };
+}
+function clipBoxToBrush({ start, end, mins, maxs, brush, trace }) {
+  if (brush.sides.length === 0) return;
+  const isPoint = mins.x === 0 && mins.y === 0 && mins.z === 0 && maxs.x === 0 && maxs.y === 0 && maxs.z === 0;
+  let enterfrac = -1;
+  let leavefrac = 1;
+  let clipplane = null;
+  let leadside = null;
+  let getout = false;
+  let startout = false;
+  for (const side of brush.sides) {
+    const { plane } = side;
+    let dist = plane.dist;
+    if (!isPoint) {
+      const ofsX = plane.normal.x < 0 ? maxs.x : mins.x;
+      const ofsY = plane.normal.y < 0 ? maxs.y : mins.y;
+      const ofsZ = plane.normal.z < 0 ? maxs.z : mins.z;
+      dist -= plane.normal.x * ofsX + plane.normal.y * ofsY + plane.normal.z * ofsZ;
+    }
+    const d1 = start.x * plane.normal.x + start.y * plane.normal.y + start.z * plane.normal.z - dist;
+    const d2 = end.x * plane.normal.x + end.y * plane.normal.y + end.z * plane.normal.z - dist;
+    if (d2 > 0) getout = true;
+    if (d1 > 0) startout = true;
+    if (d1 > 0 && d2 >= d1) {
+      return;
+    }
+    if (d1 <= 0 && d2 <= 0) {
+      continue;
+    }
+    if (d1 > d2) {
+      const f = (d1 - DIST_EPSILON) / (d1 - d2);
+      if (f > enterfrac) {
+        enterfrac = f;
+        clipplane = plane;
+        leadside = side;
+      }
+    } else {
+      const f = (d1 + DIST_EPSILON) / (d1 - d2);
+      if (f < leavefrac) leavefrac = f;
+    }
+  }
+  if (!startout) {
+    trace.startsolid = true;
+    if (!getout) trace.allsolid = true;
+    return;
+  }
+  if (enterfrac < leavefrac && enterfrac > -1 && enterfrac < trace.fraction) {
+    trace.fraction = enterfrac < 0 ? 0 : enterfrac;
+    trace.plane = clipplane;
+    trace.contents = brush.contents;
+    trace.surfaceFlags = leadside?.surfaceFlags ?? 0;
+  }
+}
+function createDefaultTrace() {
+  return {
+    fraction: 1,
+    plane: null,
+    contents: 0,
+    surfaceFlags: 0,
+    startsolid: false,
+    allsolid: false
+  };
+}
+
+// src/protocol/cvar.ts
+var CvarFlags = /* @__PURE__ */ ((CvarFlags2) => {
+  CvarFlags2[CvarFlags2["None"] = 0] = "None";
+  CvarFlags2[CvarFlags2["Archive"] = 1] = "Archive";
+  CvarFlags2[CvarFlags2["UserInfo"] = 2] = "UserInfo";
+  CvarFlags2[CvarFlags2["ServerInfo"] = 4] = "ServerInfo";
+  CvarFlags2[CvarFlags2["Latch"] = 8] = "Latch";
+  CvarFlags2[CvarFlags2["Cheat"] = 16] = "Cheat";
+  return CvarFlags2;
+})(CvarFlags || {});
+
+// src/protocol/configstrings.ts
+var MAX_STRING_CHARS = 1024;
+var MAX_STRING_TOKENS = 80;
+var MAX_TOKEN_CHARS = 512;
+var MAX_QPATH = 64;
+var MAX_OSPATH = 128;
+var MAX_CLIENTS = 256;
+var MAX_EDICTS = 8192;
+var MAX_LIGHTSTYLES = 256;
+var MAX_MODELS = 8192;
+var MAX_SOUNDS = 2048;
+var MAX_IMAGES = 512;
+var MAX_ITEMS = 256;
+var MAX_GENERAL = MAX_CLIENTS * 2;
+var MAX_SHADOW_LIGHTS = 256;
+var MAX_WHEEL_ITEMS = 32;
+var CS_MAX_STRING_LENGTH = 96;
+var CS_MAX_STRING_LENGTH_OLD = 64;
+var ConfigStringIndex = ((ConfigStringIndex2) => {
+  ConfigStringIndex2[ConfigStringIndex2["Name"] = 0] = "Name";
+  ConfigStringIndex2[ConfigStringIndex2["CdTrack"] = 1] = "CdTrack";
+  ConfigStringIndex2[ConfigStringIndex2["Sky"] = 2] = "Sky";
+  ConfigStringIndex2[ConfigStringIndex2["SkyAxis"] = 3] = "SkyAxis";
+  ConfigStringIndex2[ConfigStringIndex2["SkyRotate"] = 4] = "SkyRotate";
+  ConfigStringIndex2[ConfigStringIndex2["StatusBar"] = 5] = "StatusBar";
+  ConfigStringIndex2[ConfigStringIndex2["AirAccel"] = 59] = "AirAccel";
+  ConfigStringIndex2[ConfigStringIndex2["MaxClients"] = 60] = "MaxClients";
+  ConfigStringIndex2[ConfigStringIndex2["MapChecksum"] = 61] = "MapChecksum";
+  ConfigStringIndex2[ConfigStringIndex2["Models"] = 62] = "Models";
+  ConfigStringIndex2[ConfigStringIndex2["Sounds"] = 62 /* Models */ + MAX_MODELS] = "Sounds";
+  ConfigStringIndex2[ConfigStringIndex2["Images"] = ConfigStringIndex2.Sounds + MAX_SOUNDS] = "Images";
+  ConfigStringIndex2[ConfigStringIndex2["Lights"] = ConfigStringIndex2.Images + MAX_IMAGES] = "Lights";
+  ConfigStringIndex2[ConfigStringIndex2["ShadowLights"] = ConfigStringIndex2.Lights + MAX_LIGHTSTYLES] = "ShadowLights";
+  ConfigStringIndex2[ConfigStringIndex2["Items"] = ConfigStringIndex2.ShadowLights + MAX_SHADOW_LIGHTS] = "Items";
+  ConfigStringIndex2[ConfigStringIndex2["PlayerSkins"] = ConfigStringIndex2.Items + MAX_ITEMS] = "PlayerSkins";
+  ConfigStringIndex2[ConfigStringIndex2["General"] = ConfigStringIndex2.PlayerSkins + MAX_CLIENTS] = "General";
+  ConfigStringIndex2[ConfigStringIndex2["WheelWeapons"] = ConfigStringIndex2.General + MAX_GENERAL] = "WheelWeapons";
+  ConfigStringIndex2[ConfigStringIndex2["WheelAmmo"] = ConfigStringIndex2.WheelWeapons + MAX_WHEEL_ITEMS] = "WheelAmmo";
+  ConfigStringIndex2[ConfigStringIndex2["WheelPowerups"] = ConfigStringIndex2.WheelAmmo + MAX_WHEEL_ITEMS] = "WheelPowerups";
+  ConfigStringIndex2[ConfigStringIndex2["CdLoopCount"] = ConfigStringIndex2.WheelPowerups + MAX_WHEEL_ITEMS] = "CdLoopCount";
+  ConfigStringIndex2[ConfigStringIndex2["GameStyle"] = ConfigStringIndex2.CdLoopCount + 1] = "GameStyle";
+  ConfigStringIndex2[ConfigStringIndex2["MaxConfigStrings"] = ConfigStringIndex2.GameStyle + 1] = "MaxConfigStrings";
+  return ConfigStringIndex2;
+})(ConfigStringIndex || {});
+var MAX_CONFIGSTRINGS = ConfigStringIndex.MaxConfigStrings;
+function configStringSize(index) {
+  if (index >= 5 /* StatusBar */ && index < 59 /* AirAccel */) {
+    return CS_MAX_STRING_LENGTH * (59 /* AirAccel */ - index);
+  }
+  if (index >= ConfigStringIndex.General && index < ConfigStringIndex.WheelWeapons) {
+    return CS_MAX_STRING_LENGTH * (ConfigStringIndex.MaxConfigStrings - index);
+  }
+  return CS_MAX_STRING_LENGTH;
+}
+
+// src/pmove/constants.ts
+var WaterLevel = /* @__PURE__ */ ((WaterLevel3) => {
+  WaterLevel3[WaterLevel3["None"] = 0] = "None";
+  WaterLevel3[WaterLevel3["Feet"] = 1] = "Feet";
+  WaterLevel3[WaterLevel3["Waist"] = 2] = "Waist";
+  WaterLevel3[WaterLevel3["Under"] = 3] = "Under";
+  return WaterLevel3;
+})(WaterLevel || {});
+function isAtLeastWaistDeep(level) {
+  return level >= 2 /* Waist */;
+}
+function isUnderwater(level) {
+  return level === 3 /* Under */;
+}
+var PmFlag = /* @__PURE__ */ ((PmFlag2) => {
+  PmFlag2[PmFlag2["Ducked"] = 1] = "Ducked";
+  PmFlag2[PmFlag2["JumpHeld"] = 2] = "JumpHeld";
+  PmFlag2[PmFlag2["OnGround"] = 4] = "OnGround";
+  PmFlag2[PmFlag2["TimeWaterJump"] = 8] = "TimeWaterJump";
+  PmFlag2[PmFlag2["TimeLand"] = 16] = "TimeLand";
+  PmFlag2[PmFlag2["TimeTeleport"] = 32] = "TimeTeleport";
+  PmFlag2[PmFlag2["NoPositionalPrediction"] = 64] = "NoPositionalPrediction";
+  PmFlag2[PmFlag2["OnLadder"] = 128] = "OnLadder";
+  PmFlag2[PmFlag2["NoAngularPrediction"] = 256] = "NoAngularPrediction";
+  PmFlag2[PmFlag2["IgnorePlayerCollision"] = 512] = "IgnorePlayerCollision";
+  PmFlag2[PmFlag2["TimeTrick"] = 1024] = "TimeTrick";
+  return PmFlag2;
+})(PmFlag || {});
+function hasPmFlag(flags, flag) {
+  return (flags & flag) !== 0;
+}
+function addPmFlag(flags, flag) {
+  return flags | flag;
+}
+function removePmFlag(flags, flag) {
+  return flags & ~flag;
+}
+var PmType = /* @__PURE__ */ ((PmType2) => {
+  PmType2[PmType2["Normal"] = 0] = "Normal";
+  PmType2[PmType2["Grapple"] = 1] = "Grapple";
+  PmType2[PmType2["NoClip"] = 2] = "NoClip";
+  PmType2[PmType2["Spectator"] = 3] = "Spectator";
+  PmType2[PmType2["Dead"] = 4] = "Dead";
+  PmType2[PmType2["Gib"] = 5] = "Gib";
+  PmType2[PmType2["Freeze"] = 6] = "Freeze";
+  return PmType2;
+})(PmType || {});
+var PlayerButton = /* @__PURE__ */ ((PlayerButton2) => {
+  PlayerButton2[PlayerButton2["None"] = 0] = "None";
+  PlayerButton2[PlayerButton2["Attack"] = 1] = "Attack";
+  PlayerButton2[PlayerButton2["Use"] = 2] = "Use";
+  PlayerButton2[PlayerButton2["Holster"] = 4] = "Holster";
+  PlayerButton2[PlayerButton2["Jump"] = 8] = "Jump";
+  PlayerButton2[PlayerButton2["Crouch"] = 16] = "Crouch";
+  PlayerButton2[PlayerButton2["Any"] = 128] = "Any";
+  return PlayerButton2;
+})(PlayerButton || {});
+
+// src/pmove/pmove.ts
+function applyPmoveFriction(params) {
+  const {
+    velocity,
+    frametime,
+    onGround,
+    groundIsSlick,
+    onLadder,
+    waterlevel,
+    pmFriction,
+    pmStopSpeed,
+    pmWaterFriction
+  } = params;
+  const speed = lengthVec3(velocity);
+  if (speed < 1) {
+    return { x: 0, y: 0, z: velocity.z };
+  }
+  let drop = 0;
+  if (onGround && !groundIsSlick || onLadder) {
+    const control = speed < pmStopSpeed ? pmStopSpeed : speed;
+    const friction = pmFriction;
+    drop += control * friction * frametime;
+  }
+  if (waterlevel > 0 && !onLadder) {
+    drop += speed * pmWaterFriction * waterlevel * frametime;
+  }
+  let newspeed = speed - drop;
+  if (newspeed < 0) {
+    newspeed = 0;
+  }
+  if (newspeed === speed) {
+    return velocity;
+  }
+  const scale = newspeed / speed;
+  return scaleVec3(velocity, scale);
+}
+function applyPmoveAccelerate(params) {
+  const { velocity, wishdir, wishspeed, accel, frametime } = params;
+  const currentSpeed = dotVec3(velocity, wishdir);
+  const addSpeed = wishspeed - currentSpeed;
+  if (addSpeed <= 0) {
+    return velocity;
+  }
+  let accelSpeed = accel * frametime * wishspeed;
+  if (accelSpeed > addSpeed) {
+    accelSpeed = addSpeed;
+  }
+  return {
+    x: velocity.x + wishdir.x * accelSpeed,
+    y: velocity.y + wishdir.y * accelSpeed,
+    z: velocity.z + wishdir.z * accelSpeed
+  };
+}
+function applyPmoveAirAccelerate(params) {
+  const { velocity, wishdir, wishspeed, accel, frametime } = params;
+  const wishspd = Math.min(wishspeed, 30);
+  const currentSpeed = dotVec3(velocity, wishdir);
+  const addSpeed = wishspd - currentSpeed;
+  if (addSpeed <= 0) {
+    return velocity;
+  }
+  let accelSpeed = accel * wishspeed * frametime;
+  if (accelSpeed > addSpeed) {
+    accelSpeed = addSpeed;
+  }
+  return {
+    x: velocity.x + wishdir.x * accelSpeed,
+    y: velocity.y + wishdir.y * accelSpeed,
+    z: velocity.z + wishdir.z * accelSpeed
+  };
+}
+function pmoveCmdScale(cmd, maxSpeed) {
+  const forward = Math.abs(cmd.forwardmove);
+  const side = Math.abs(cmd.sidemove);
+  const up = Math.abs(cmd.upmove);
+  const max = Math.max(forward, side, up);
+  if (max === 0) {
+    return 0;
+  }
+  const total = Math.sqrt(cmd.forwardmove * cmd.forwardmove + cmd.sidemove * cmd.sidemove + cmd.upmove * cmd.upmove);
+  return maxSpeed * max / (127 * total);
+}
+function buildAirGroundWish(params) {
+  const { forward, right, cmd, maxSpeed } = params;
+  let wishvel = {
+    x: forward.x * cmd.forwardmove + right.x * cmd.sidemove,
+    y: forward.y * cmd.forwardmove + right.y * cmd.sidemove,
+    z: 0
+  };
+  let wishspeed = lengthVec3(wishvel);
+  if (wishspeed > maxSpeed) {
+    const scale = maxSpeed / wishspeed;
+    wishvel = scaleVec3(wishvel, scale);
+    wishspeed = maxSpeed;
+  }
+  return {
+    wishdir: wishspeed === 0 ? wishvel : normalizeVec3(wishvel),
+    wishspeed
+  };
+}
+function buildWaterWish(params) {
+  const { forward, right, cmd, maxSpeed } = params;
+  let wishvel = {
+    x: forward.x * cmd.forwardmove + right.x * cmd.sidemove,
+    y: forward.y * cmd.forwardmove + right.y * cmd.sidemove,
+    z: 0
+  };
+  if (cmd.upmove > 10) {
+    wishvel = addVec3(wishvel, { x: 0, y: 0, z: cmd.upmove });
+  } else if (cmd.upmove < -10) {
+    wishvel = addVec3(wishvel, { x: 0, y: 0, z: cmd.upmove });
+  } else {
+    wishvel = addVec3(wishvel, { x: 0, y: 0, z: 10 });
+  }
+  let wishspeed = lengthVec3(wishvel);
+  if (wishspeed > maxSpeed) {
+    const scale = maxSpeed / wishspeed;
+    wishvel = scaleVec3(wishvel, scale);
+    wishspeed = maxSpeed;
+  }
+  wishspeed *= 0.5;
+  return {
+    wishdir: wishspeed === 0 ? wishvel : normalizeVec3(wishvel),
+    wishspeed
+  };
+}
+
+// src/pmove/slide.ts
+var DEFAULT_MAX_CLIP_PLANES = 5;
+var DEFAULT_MAX_BUMPS = 4;
+var DEFAULT_STEP_SIZE = 18;
+var MIN_STEP_NORMAL = 0.7;
+var SLIDEMOVE_BLOCKED_FLOOR = 1;
+var SLIDEMOVE_BLOCKED_WALL = 2;
+function resolveSlideMove(initialVelocity, planesEncountered, overbounce, maxClipPlanes = DEFAULT_MAX_CLIP_PLANES, primalVelocity = initialVelocity) {
+  if (planesEncountered.length === 0) {
+    return { velocity: initialVelocity, planes: [], stopped: false };
+  }
+  const planes = [];
+  let velocity = initialVelocity;
+  for (const plane of planesEncountered) {
+    if (planes.length >= maxClipPlanes) {
+      return { velocity: ZERO_VEC3, planes, stopped: true };
+    }
+    const duplicate = planes.find((existing) => dotVec3(existing, plane) > 0.99);
+    if (duplicate) {
+      continue;
+    }
+    planes.push(plane);
+    let clipped;
+    let i = 0;
+    for (; i < planes.length; i++) {
+      const candidate = clipVelocityVec3(velocity, planes[i], overbounce);
+      let j = 0;
+      for (; j < planes.length; j++) {
+        if (j === i) continue;
+        if (dotVec3(candidate, planes[j]) < 0) break;
+      }
+      if (j === planes.length) {
+        clipped = candidate;
+        break;
+      }
+    }
+    if (clipped) {
+      velocity = clipped;
+    } else {
+      if (planes.length !== 2) {
+        return { velocity: ZERO_VEC3, planes, stopped: true };
+      }
+      const dir = crossVec3(planes[0], planes[1]);
+      const d = dotVec3(dir, velocity);
+      velocity = scaleVec3(dir, d);
+    }
+    if (dotVec3(velocity, primalVelocity) <= 0) {
+      return { velocity: ZERO_VEC3, planes, stopped: true };
+    }
+  }
+  const stopped = velocity.x === 0 && velocity.y === 0 && velocity.z === 0;
+  return { velocity, planes, stopped };
+}
+function slideMove(params) {
+  const {
+    origin: initialOrigin,
+    velocity: initialVelocity,
+    frametime,
+    overbounce,
+    trace,
+    maxBumps = DEFAULT_MAX_BUMPS,
+    maxClipPlanes = DEFAULT_MAX_CLIP_PLANES,
+    mins,
+    maxs,
+    hasTime = false
+  } = params;
+  let origin = initialOrigin;
+  let velocity = initialVelocity;
+  const planes = [];
+  const primalVelocity = initialVelocity;
+  let timeLeft = frametime;
+  let blocked = 0;
+  for (let bump = 0; bump < maxBumps; bump++) {
+    if (velocity.x === 0 && velocity.y === 0 && velocity.z === 0) {
+      break;
+    }
+    const end = addVec3(origin, scaleVec3(velocity, timeLeft));
+    const tr = trace(origin, end, mins, maxs);
+    if (tr.allsolid) {
+      const velocity2 = hasTime ? primalVelocity : ZERO_VEC3;
+      return { origin: tr.endpos, velocity: velocity2, planes, stopped: true, blocked };
+    }
+    if (tr.startsolid) {
+      const velocity2 = hasTime ? primalVelocity : ZERO_VEC3;
+      return { origin: tr.endpos, velocity: velocity2, planes, stopped: true, blocked };
+    }
+    if (tr.fraction > 0) {
+      origin = tr.endpos;
+    }
+    if (tr.fraction === 1) {
+      break;
+    }
+    if (!tr.planeNormal) {
+      const velocity2 = hasTime ? primalVelocity : ZERO_VEC3;
+      return { origin, velocity: velocity2, planes, stopped: true, blocked };
+    }
+    if (tr.planeNormal.z > 0.7) {
+      blocked |= SLIDEMOVE_BLOCKED_FLOOR;
+    }
+    if (tr.planeNormal.z === 0) {
+      blocked |= SLIDEMOVE_BLOCKED_WALL;
+    }
+    planes.push(tr.planeNormal);
+    timeLeft -= timeLeft * tr.fraction;
+    const resolved = resolveSlideMove(velocity, planes, overbounce, maxClipPlanes, primalVelocity);
+    velocity = resolved.velocity;
+    planes.splice(0, planes.length, ...resolved.planes);
+    if (primalVelocity.z > 0 && velocity.z < 0) {
+      velocity = { ...velocity, z: 0 };
+    }
+    if (resolved.stopped) {
+      const velocityOut2 = hasTime ? primalVelocity : velocity;
+      return { origin, velocity: velocityOut2, planes, stopped: true, blocked };
+    }
+  }
+  const velocityOut = hasTime ? primalVelocity : velocity;
+  return { origin, velocity: velocityOut, planes, stopped: velocityOut.x === 0 && velocityOut.y === 0 && velocityOut.z === 0, blocked };
+}
+function stepSlideMove(params) {
+  const { mins, maxs, stepSize = DEFAULT_STEP_SIZE, ...rest } = params;
+  const startOrigin = params.origin;
+  const startVelocity = params.velocity;
+  const downResult = slideMove({ ...rest, mins, maxs });
+  const upTarget = addVec3(startOrigin, { x: 0, y: 0, z: stepSize });
+  const upTrace = rest.trace(startOrigin, upTarget, mins, maxs);
+  if (upTrace.allsolid) {
+    return { ...downResult, stepped: false, stepHeight: 0 };
+  }
+  const actualStep = upTrace.endpos.z - startOrigin.z;
+  const steppedResult = slideMove({ ...rest, origin: upTrace.endpos, velocity: startVelocity, mins, maxs });
+  const pushDownTarget = addVec3(steppedResult.origin, { x: 0, y: 0, z: -actualStep });
+  const downTrace = rest.trace(steppedResult.origin, pushDownTarget, mins, maxs);
+  let steppedOrigin = steppedResult.origin;
+  let stepNormal = downTrace.planeNormal;
+  if (!downTrace.allsolid) {
+    steppedOrigin = downTrace.endpos;
+  }
+  const planarDistanceSquared = (a, b) => (a.x - b.x) ** 2 + (a.y - b.y) ** 2;
+  const downDist = planarDistanceSquared(downResult.origin, startOrigin);
+  const upDist = planarDistanceSquared(steppedOrigin, startOrigin);
+  if (downDist > upDist || stepNormal && stepNormal.z < MIN_STEP_NORMAL) {
+    return { ...downResult, stepped: false, stepHeight: 0 };
+  }
+  const steppedVelocity = { ...steppedResult.velocity, z: downResult.velocity.z };
+  const steppedBlocked = steppedResult.blocked;
+  const stopped = steppedVelocity.x === 0 && steppedVelocity.y === 0 && steppedVelocity.z === 0;
+  return {
+    origin: steppedOrigin,
+    velocity: steppedVelocity,
+    planes: steppedResult.planes,
+    blocked: steppedBlocked,
+    stopped,
+    stepped: true,
+    stepHeight: actualStep,
+    stepNormal
+  };
+}
+
+// src/pmove/stuck.ts
+var AXES = ["x", "y", "z"];
+var SIDE_CHECKS = [
+  { normal: [0, 0, 1], mins: [-1, -1, 0], maxs: [1, 1, 0] },
+  { normal: [0, 0, -1], mins: [-1, -1, 0], maxs: [1, 1, 0] },
+  { normal: [1, 0, 0], mins: [0, -1, -1], maxs: [0, 1, 1] },
+  { normal: [-1, 0, 0], mins: [0, -1, -1], maxs: [0, 1, 1] },
+  { normal: [0, 1, 0], mins: [-1, 0, -1], maxs: [1, 0, 1] },
+  { normal: [0, -1, 0], mins: [-1, 0, -1], maxs: [1, 0, 1] }
+];
+var ZERO_VEC = { x: 0, y: 0, z: 0 };
+function cloneMutable(vec) {
+  return { x: vec.x, y: vec.y, z: vec.z };
+}
+function tupleToVec3(tuple) {
+  return { x: tuple[0], y: tuple[1], z: tuple[2] };
+}
+function adjustAxis(vec, axis, delta) {
+  if (delta === 0) return;
+  switch (axis) {
+    case "x":
+      vec.x += delta;
+      break;
+    case "y":
+      vec.y += delta;
+      break;
+    case "z":
+      vec.z += delta;
+      break;
+  }
+}
+function setAxis(vec, axis, value) {
+  switch (axis) {
+    case "x":
+      vec.x = value;
+      break;
+    case "y":
+      vec.y = value;
+      break;
+    case "z":
+      vec.z = value;
+      break;
+  }
+}
+function axisValue(vec, axis) {
+  switch (axis) {
+    case "x":
+      return vec.x;
+    case "y":
+      return vec.y;
+    case "z":
+    default:
+      return vec.z;
+  }
+}
+function boundValue(code, axis, mins, maxs) {
+  if (code === -1) {
+    return axisValue(mins, axis);
+  }
+  if (code === 1) {
+    return axisValue(maxs, axis);
+  }
+  return 0;
+}
+function applySideOffset(base, side, mins, maxs) {
+  const result = cloneMutable(base);
+  for (let i = 0; i < AXES.length; i++) {
+    const axis = AXES[i];
+    const normal = side.normal[i];
+    if (normal < 0) {
+      adjustAxis(result, axis, axisValue(mins, axis));
+    } else if (normal > 0) {
+      adjustAxis(result, axis, axisValue(maxs, axis));
+    }
+  }
+  return result;
+}
+function buildSideBounds(side, mins, maxs) {
+  const localMins = cloneMutable(ZERO_VEC);
+  const localMaxs = cloneMutable(ZERO_VEC);
+  for (let i = 0; i < AXES.length; i++) {
+    const axis = AXES[i];
+    setAxis(localMins, axis, boundValue(side.mins[i], axis, mins, maxs));
+    setAxis(localMaxs, axis, boundValue(side.maxs[i], axis, mins, maxs));
+  }
+  return { mins: localMins, maxs: localMaxs };
+}
+function addEpsilon(source, axis, direction) {
+  if (!axis || direction === 0) {
+    return source;
+  }
+  const clone = cloneMutable(source);
+  adjustAxis(clone, axis, direction);
+  return clone;
+}
+function addEpsilonImmutable(vec, axis, direction) {
+  if (!axis || direction === 0) {
+    return vec;
+  }
+  switch (axis) {
+    case "x":
+      return { ...vec, x: vec.x + direction };
+    case "y":
+      return { ...vec, y: vec.y + direction };
+    case "z":
+    default:
+      return { ...vec, z: vec.z + direction };
+  }
+}
+function fixStuckObjectGeneric(params) {
+  const { origin, mins, maxs, trace } = params;
+  const initial = trace(origin, mins, maxs, origin);
+  if (!initial.startsolid) {
+    return { result: "good-position", origin: { ...origin } };
+  }
+  const candidates = [];
+  for (let i = 0; i < SIDE_CHECKS.length; i++) {
+    const side = SIDE_CHECKS[i];
+    const { mins: localMins, maxs: localMaxs } = buildSideBounds(side, mins, maxs);
+    let start = applySideOffset(origin, side, mins, maxs);
+    let tr = trace(start, localMins, localMaxs, start);
+    let epsilonAxis;
+    let epsilonDir = 0;
+    if (tr.startsolid) {
+      for (let axisIndex = 0; axisIndex < AXES.length; axisIndex++) {
+        if (side.normal[axisIndex] !== 0) {
+          continue;
+        }
+        const axis = AXES[axisIndex];
+        let epsilonStart = cloneMutable(start);
+        adjustAxis(epsilonStart, axis, 1);
+        tr = trace(epsilonStart, localMins, localMaxs, epsilonStart);
+        if (!tr.startsolid) {
+          start = epsilonStart;
+          epsilonAxis = axis;
+          epsilonDir = 1;
+          break;
+        }
+        epsilonStart = cloneMutable(start);
+        adjustAxis(epsilonStart, axis, -1);
+        tr = trace(epsilonStart, localMins, localMaxs, epsilonStart);
+        if (!tr.startsolid) {
+          start = epsilonStart;
+          epsilonAxis = axis;
+          epsilonDir = -1;
+          break;
+        }
+      }
+    }
+    if (tr.startsolid) {
+      continue;
+    }
+    const otherSide = SIDE_CHECKS[i ^ 1];
+    let oppositeStart = applySideOffset(origin, otherSide, mins, maxs);
+    oppositeStart = addEpsilon(oppositeStart, epsilonAxis, epsilonDir);
+    tr = trace(start, localMins, localMaxs, oppositeStart);
+    if (tr.startsolid) {
+      continue;
+    }
+    const normal = tupleToVec3(side.normal);
+    const end = addVec3(tr.endpos ?? oppositeStart, scaleVec3(normal, 0.125));
+    const delta = subtractVec3(end, oppositeStart);
+    let newOrigin = addVec3(origin, delta);
+    newOrigin = addEpsilonImmutable(newOrigin, epsilonAxis, epsilonDir);
+    const validation = trace(newOrigin, mins, maxs, newOrigin);
+    if (validation.startsolid) {
+      continue;
+    }
+    candidates.push({ origin: newOrigin, distance: lengthSquaredVec3(delta) });
+  }
+  if (candidates.length === 0) {
+    return { result: "no-good-position", origin: { ...origin } };
+  }
+  candidates.sort((a, b) => a.distance - b.distance);
+  return { result: "fixed", origin: { ...candidates[0].origin } };
+}
+
+// src/pmove/currents.ts
+var DEFAULT_GROUND_CURRENT_SCALE = 100;
+var DEFAULT_FORWARD_LADDER_CLAMP = 200;
+var DEFAULT_SIDE_LADDER_CLAMP = 150;
+var LADDER_HORIZONTAL_CAP = 25;
+var LADDER_ASCEND_PITCH_THRESHOLD = 15;
+var LADDER_TRACE_DISTANCE = 1;
+var UP_VECTOR = { x: 0, y: 0, z: 1 };
+var DEFAULT_TRACE = (_, end) => ({
+  fraction: 1,
+  endpos: end,
+  allsolid: false,
+  startsolid: false
+});
+function currentVectorFromContents(contents) {
+  let x = 0;
+  let y = 0;
+  let z = 0;
+  if (contents & CONTENTS_CURRENT_0) {
+    x += 1;
+  }
+  if (contents & CONTENTS_CURRENT_90) {
+    y += 1;
+  }
+  if (contents & CONTENTS_CURRENT_180) {
+    x -= 1;
+  }
+  if (contents & CONTENTS_CURRENT_270) {
+    y -= 1;
+  }
+  if (contents & CONTENTS_CURRENT_UP) {
+    z += 1;
+  }
+  if (contents & CONTENTS_CURRENT_DOWN) {
+    z -= 1;
+  }
+  if (x === 0 && y === 0 && z === 0) {
+    return ZERO_VEC3;
+  }
+  return { x, y, z };
+}
+function waterCurrentVelocity(params) {
+  const { watertype, waterlevel, onGround, waterSpeed } = params;
+  if ((watertype & MASK_CURRENT) === 0) {
+    return ZERO_VEC3;
+  }
+  const direction = currentVectorFromContents(watertype);
+  if (direction === ZERO_VEC3) {
+    return ZERO_VEC3;
+  }
+  let scale = waterSpeed;
+  if (waterlevel === 1 /* Feet */ && onGround) {
+    scale *= 0.5;
+  }
+  return scaleVec3(direction, scale);
+}
+function groundCurrentVelocity(params) {
+  const { groundContents, scale = DEFAULT_GROUND_CURRENT_SCALE } = params;
+  const direction = currentVectorFromContents(groundContents);
+  if (direction === ZERO_VEC3) {
+    return ZERO_VEC3;
+  }
+  return scaleVec3(direction, scale);
+}
+function applyPmoveAddCurrents(params) {
+  const {
+    wishVelocity,
+    onLadder,
+    onGround,
+    waterlevel,
+    watertype,
+    groundContents,
+    cmd,
+    viewPitch,
+    maxSpeed,
+    ladderMod,
+    waterSpeed,
+    forward,
+    origin,
+    mins,
+    maxs,
+    trace = DEFAULT_TRACE
+  } = params;
+  let adjusted = wishVelocity;
+  if (onLadder) {
+    adjusted = applyLadderAdjustments({
+      wishVelocity: adjusted,
+      cmd,
+      waterlevel,
+      viewPitch,
+      maxSpeed,
+      ladderMod,
+      onGround,
+      forward,
+      origin,
+      mins,
+      maxs,
+      trace
+    });
+  }
+  const waterVelocity = waterCurrentVelocity({ watertype, waterlevel, onGround, waterSpeed });
+  if (waterVelocity !== ZERO_VEC3) {
+    adjusted = addVec3(adjusted, waterVelocity);
+  }
+  if (onGround) {
+    const groundVelocity = groundCurrentVelocity({ groundContents });
+    if (groundVelocity !== ZERO_VEC3) {
+      adjusted = addVec3(adjusted, groundVelocity);
+    }
+  }
+  return adjusted;
+}
+function applyLadderAdjustments(params) {
+  const { wishVelocity, cmd, waterlevel, viewPitch, maxSpeed, ladderMod, onGround, forward, origin, mins, maxs, trace } = params;
+  const buttons = cmd.buttons ?? 0;
+  let adjusted = { ...wishVelocity };
+  if ((buttons & (8 /* Jump */ | 16 /* Crouch */)) !== 0) {
+    const ladderSpeed = isAtLeastWaistDeep(waterlevel) ? maxSpeed : DEFAULT_FORWARD_LADDER_CLAMP;
+    adjusted = {
+      ...adjusted,
+      z: buttons & 8 /* Jump */ ? ladderSpeed : -ladderSpeed
+    };
+  } else if (cmd.forwardmove) {
+    const clamped = clamp(cmd.forwardmove, -DEFAULT_FORWARD_LADDER_CLAMP, DEFAULT_FORWARD_LADDER_CLAMP);
+    if (cmd.forwardmove > 0) {
+      const climb = viewPitch < LADDER_ASCEND_PITCH_THRESHOLD ? clamped : -clamped;
+      adjusted = { ...adjusted, z: climb };
+    } else {
+      if (!onGround) {
+        adjusted = { ...adjusted, x: 0, y: 0 };
+      }
+      adjusted = { ...adjusted, z: clamped };
+    }
+  } else {
+    adjusted = { ...adjusted, z: 0 };
+  }
+  if (!onGround) {
+    if (cmd.sidemove) {
+      let sideSpeed = clamp(cmd.sidemove, -DEFAULT_SIDE_LADDER_CLAMP, DEFAULT_SIDE_LADDER_CLAMP);
+      if (waterlevel < 2 /* Waist */) {
+        sideSpeed *= ladderMod;
+      }
+      const flatForward = normalizeVec3({ x: forward.x, y: forward.y, z: 0 });
+      if (flatForward.x !== 0 || flatForward.y !== 0) {
+        const spot = addVec3(origin, scaleVec3(flatForward, LADDER_TRACE_DISTANCE));
+        const tr = trace(origin, spot, mins, maxs);
+        if (tr.fraction !== 1 && !tr.allsolid && tr.contents !== void 0 && (tr.contents & CONTENTS_LADDER) !== 0 && tr.planeNormal) {
+          const right = crossVec3(tr.planeNormal, UP_VECTOR);
+          adjusted = { ...adjusted, x: 0, y: 0 };
+          adjusted = addVec3(adjusted, scaleVec3(right, -sideSpeed));
+        }
+      }
+    } else {
+      adjusted = {
+        ...adjusted,
+        x: clampHorizontal(adjusted.x),
+        y: clampHorizontal(adjusted.y)
+      };
+    }
+  }
+  return adjusted;
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function clampHorizontal(value) {
+  if (value < -LADDER_HORIZONTAL_CAP) {
+    return -LADDER_HORIZONTAL_CAP;
+  }
+  if (value > LADDER_HORIZONTAL_CAP) {
+    return LADDER_HORIZONTAL_CAP;
+  }
+  return value;
+}
+
+// src/pmove/fly.ts
+var FLY_FRICTION_MULTIPLIER = 1.5;
+var BUTTON_VERTICAL_SCALE = 0.5;
+var DEFAULT_OVERBOUNCE = 1.01;
+function applyPmoveFlyMove(params) {
+  const {
+    origin,
+    cmd,
+    frametime,
+    pmFriction,
+    pmStopSpeed,
+    pmMaxSpeed,
+    pmAccelerate,
+    pmWaterSpeed,
+    doclip,
+    forward,
+    right,
+    mins,
+    maxs,
+    trace,
+    overbounce = DEFAULT_OVERBOUNCE,
+    stepSize,
+    maxBumps,
+    maxClipPlanes
+  } = params;
+  let velocity = applyFlyFriction({ velocity: params.velocity, pmFriction, pmStopSpeed, frametime });
+  const wishdirVelocity = buildFlyWishVelocity({
+    cmd,
+    forward,
+    right,
+    pmMaxSpeed,
+    pmWaterSpeed
+  });
+  if (wishdirVelocity.wishspeed > 0) {
+    velocity = applyPmoveAccelerate({
+      velocity,
+      wishdir: wishdirVelocity.wishdir,
+      wishspeed: wishdirVelocity.accelSpeed,
+      accel: pmAccelerate,
+      frametime
+    });
+  }
+  if (!doclip) {
+    const originDelta = scaleVec3(velocity, frametime);
+    const nextOrigin = addVec3(origin, originDelta);
+    return {
+      origin: nextOrigin,
+      velocity,
+      planes: [],
+      blocked: 0,
+      stopped: velocity.x === 0 && velocity.y === 0 && velocity.z === 0,
+      stepped: false,
+      stepHeight: 0
+    };
+  }
+  if (!trace || !mins || !maxs) {
+    throw new Error("applyPmoveFlyMove: doclip=true requires trace/mins/maxs");
+  }
+  return stepSlideMove({
+    origin,
+    velocity,
+    frametime,
+    overbounce,
+    trace,
+    mins,
+    maxs,
+    stepSize,
+    maxBumps,
+    maxClipPlanes
+  });
+}
+function applyFlyFriction(params) {
+  const { velocity, pmFriction, pmStopSpeed, frametime } = params;
+  const speed = lengthVec3(velocity);
+  if (speed < 1) {
+    return { x: 0, y: 0, z: 0 };
+  }
+  const friction = pmFriction * FLY_FRICTION_MULTIPLIER;
+  const control = speed < pmStopSpeed ? pmStopSpeed : speed;
+  const drop = control * friction * frametime;
+  let newspeed = speed - drop;
+  if (newspeed < 0) {
+    newspeed = 0;
+  }
+  if (newspeed === speed) {
+    return velocity;
+  }
+  return scaleVec3(velocity, newspeed / speed);
+}
+function buildFlyWishVelocity(params) {
+  const { cmd, forward, right, pmMaxSpeed, pmWaterSpeed } = params;
+  const forwardNorm = normalizeVec3(forward);
+  const rightNorm = normalizeVec3(right);
+  const wishvel = {
+    x: forwardNorm.x * cmd.forwardmove + rightNorm.x * cmd.sidemove,
+    y: forwardNorm.y * cmd.forwardmove + rightNorm.y * cmd.sidemove,
+    z: forwardNorm.z * cmd.forwardmove + rightNorm.z * cmd.sidemove
+  };
+  let adjusted = wishvel;
+  const buttons = cmd.buttons ?? 0;
+  if (buttons & 8 /* Jump */) {
+    adjusted = addVec3(adjusted, { x: 0, y: 0, z: pmWaterSpeed * BUTTON_VERTICAL_SCALE });
+  }
+  if (buttons & 16 /* Crouch */) {
+    adjusted = addVec3(adjusted, { x: 0, y: 0, z: -pmWaterSpeed * BUTTON_VERTICAL_SCALE });
+  }
+  let wishspeed = lengthVec3(adjusted);
+  let wishdir = wishspeed === 0 ? { x: 0, y: 0, z: 0 } : normalizeVec3(adjusted);
+  if (wishspeed > pmMaxSpeed) {
+    const scale = pmMaxSpeed / wishspeed;
+    adjusted = scaleVec3(adjusted, scale);
+    wishspeed = pmMaxSpeed;
+    wishdir = wishspeed === 0 ? { x: 0, y: 0, z: 0 } : normalizeVec3(adjusted);
+  }
+  const accelSpeed = wishspeed * 2;
+  return { wishdir, wishspeed, accelSpeed };
+}
+
+// src/pmove/water.ts
+function getWaterLevel(params) {
+  const { origin, mins, viewheight, pointContents } = params;
+  const sample2 = viewheight - mins.z;
+  const sample1 = sample2 / 2;
+  const point = {
+    x: origin.x,
+    y: origin.y,
+    z: origin.z + mins.z + 1
+  };
+  let contents = pointContents(point);
+  if ((contents & MASK_WATER) === 0) {
+    return { waterlevel: 0 /* None */, watertype: CONTENTS_NONE };
+  }
+  const watertype = contents;
+  let waterlevel = 1 /* Feet */;
+  let point2 = { x: point.x, y: point.y, z: origin.z + mins.z + sample1 };
+  contents = pointContents(point2);
+  if ((contents & MASK_WATER) !== 0) {
+    waterlevel = 2 /* Waist */;
+    let point3 = { x: point.x, y: point.y, z: origin.z + mins.z + sample2 };
+    contents = pointContents(point3);
+    if ((contents & MASK_WATER) !== 0) {
+      waterlevel = 3 /* Under */;
+    }
+  }
+  return { waterlevel, watertype };
+}
+
+// src/pmove/jump.ts
+var DEFAULT_JUMP_HEIGHT = 270;
+function hasButton(buttons, button) {
+  return (buttons & button) !== 0;
+}
+function checkJump(params) {
+  const { pmFlags, pmType, buttons, waterlevel, onGround, velocity, jumpHeight = DEFAULT_JUMP_HEIGHT } = params;
+  if (pmFlags & 16 /* TimeLand */) {
+    return { pmFlags, onGround, velocity, jumpSound: false, jumped: false };
+  }
+  const holdingJump = hasButton(buttons, 8 /* Jump */);
+  let nextFlags = pmFlags;
+  let nextOnGround = onGround;
+  let jumpSound = false;
+  let jumped = false;
+  let nextVelocity = velocity;
+  if (!holdingJump) {
+    nextFlags = removePmFlag(nextFlags, 2 /* JumpHeld */);
+    return { pmFlags: nextFlags, onGround: nextOnGround, velocity: nextVelocity, jumpSound, jumped };
+  }
+  if (hasPmJumpHold(nextFlags)) {
+    return { pmFlags: nextFlags, onGround: nextOnGround, velocity: nextVelocity, jumpSound, jumped };
+  }
+  if (pmType === 4 /* Dead */) {
+    return { pmFlags: nextFlags, onGround: nextOnGround, velocity: nextVelocity, jumpSound, jumped };
+  }
+  if (waterlevel >= 2 /* Waist */) {
+    nextOnGround = false;
+    return { pmFlags: nextFlags, onGround: nextOnGround, velocity: nextVelocity, jumpSound, jumped };
+  }
+  if (!nextOnGround) {
+    return { pmFlags: nextFlags, onGround: nextOnGround, velocity: nextVelocity, jumpSound, jumped };
+  }
+  nextFlags = addPmFlag(nextFlags, 2 /* JumpHeld */);
+  nextFlags = removePmFlag(nextFlags, 4 /* OnGround */);
+  nextOnGround = false;
+  jumpSound = true;
+  jumped = true;
+  const z = velocity.z + jumpHeight;
+  const finalZ = z < jumpHeight ? jumpHeight : z;
+  nextVelocity = { ...velocity, z: finalZ };
+  return { pmFlags: nextFlags, onGround: nextOnGround, velocity: nextVelocity, jumpSound, jumped };
+}
+function hasPmJumpHold(flags) {
+  return (flags & 2 /* JumpHeld */) !== 0;
+}
+
+// src/pmove/dimensions.ts
+function createVec3(x, y, z) {
+  return { x, y, z };
+}
+function computePlayerDimensions(pmType, pmFlags) {
+  const minsBase = createVec3(-16, -16, 0);
+  const maxsBase = createVec3(16, 16, 16);
+  if (pmType === 5 /* Gib */) {
+    return {
+      mins: minsBase,
+      maxs: maxsBase,
+      viewheight: 8
+    };
+  }
+  const ducked = pmType === 4 /* Dead */ || (pmFlags & 1 /* Ducked */) !== 0;
+  const mins = createVec3(minsBase.x, minsBase.y, -24);
+  const maxs = createVec3(maxsBase.x, maxsBase.y, ducked ? 4 : 32);
+  return {
+    mins,
+    maxs,
+    viewheight: ducked ? -2 : 22
+  };
+}
+
+// src/pmove/duck.ts
+var CROUCH_MAX_Z = 4;
+var STAND_MAX_Z = 32;
+var ABOVE_WATER_OFFSET = 8;
+function checkDuckState(params) {
+  const { pmType } = params;
+  if (pmType === 5 /* Gib */) {
+    const dims2 = computePlayerDimensions(pmType, params.pmFlags);
+    return { pmFlags: params.pmFlags, ducked: hasPmFlag(params.pmFlags, 1 /* Ducked */), changed: false, ...dims2 };
+  }
+  let flags = params.pmFlags;
+  let changed = false;
+  if (pmType === 4 /* Dead */) {
+    if (!hasPmFlag(flags, 1 /* Ducked */)) {
+      flags = addPmFlag(flags, 1 /* Ducked */);
+      changed = true;
+    }
+  } else if (shouldDuck(params)) {
+    if (!hasPmFlag(flags, 1 /* Ducked */) && !isDuckBlocked(params)) {
+      flags = addPmFlag(flags, 1 /* Ducked */);
+      changed = true;
+    }
+  } else if (hasPmFlag(flags, 1 /* Ducked */) && !isStandBlocked(params)) {
+    flags = removePmFlag(flags, 1 /* Ducked */);
+    changed = true;
+  }
+  const dims = computePlayerDimensions(pmType, flags);
+  const ducked = pmType === 4 /* Dead */ || hasPmFlag(flags, 1 /* Ducked */);
+  return { pmFlags: flags, ducked, changed, ...dims };
+}
+function shouldDuck(params) {
+  if ((params.buttons & 16 /* Crouch */) === 0) {
+    return false;
+  }
+  if (params.onLadder || params.n64Physics) {
+    return false;
+  }
+  if (params.hasGroundEntity) {
+    return true;
+  }
+  if (params.waterlevel <= 1 /* Feet */ && !isAboveWater(params)) {
+    return true;
+  }
+  return false;
+}
+function isDuckBlocked(params) {
+  const trace = params.trace({
+    start: params.origin,
+    end: params.origin,
+    mins: params.mins,
+    maxs: withZ(params.maxs, CROUCH_MAX_Z),
+    mask: MASK_SOLID
+  });
+  return trace.allsolid;
+}
+function isStandBlocked(params) {
+  const trace = params.trace({
+    start: params.origin,
+    end: params.origin,
+    mins: params.mins,
+    maxs: withZ(params.maxs, STAND_MAX_Z),
+    mask: MASK_SOLID
+  });
+  return trace.allsolid;
+}
+function isAboveWater(params) {
+  const below = { x: params.origin.x, y: params.origin.y, z: params.origin.z - ABOVE_WATER_OFFSET };
+  const solidTrace = params.trace({
+    start: params.origin,
+    end: below,
+    mins: params.mins,
+    maxs: params.maxs,
+    mask: MASK_SOLID
+  });
+  if (solidTrace.fraction < 1) {
+    return false;
+  }
+  const waterTrace = params.trace({
+    start: params.origin,
+    end: below,
+    mins: params.mins,
+    maxs: params.maxs,
+    mask: MASK_WATER
+  });
+  return waterTrace.fraction < 1;
+}
+function withZ(vec, z) {
+  return { x: vec.x, y: vec.y, z };
+}
+
+// src/pmove/categorize.ts
+var GROUND_PROBE_DISTANCE = 0.25;
+var LADDER_BYPASS_VELOCITY = 180;
+var TRICK_VELOCITY_THRESHOLD = 100;
+var SLANTED_NORMAL_THRESHOLD = 0.7;
+var TRICK_NORMAL_THRESHOLD = 0.9;
+var TRICK_PM_TIME = 64;
+var LAND_PM_TIME = 128;
+var IMPACT_CLIP_OVERBOUNCE = 1.01;
+var WATERJUMP_CLEAR = 8 /* TimeWaterJump */ | 16 /* TimeLand */ | 32 /* TimeTeleport */ | 1024 /* TimeTrick */;
+function categorizePosition(params) {
+  const {
+    pmType,
+    n64Physics,
+    velocity,
+    startVelocity,
+    origin,
+    mins,
+    maxs,
+    viewheight,
+    trace,
+    pointContents
+  } = params;
+  let pmFlags = params.pmFlags;
+  let pmTime = params.pmTime;
+  let impactDelta;
+  let onGround = hasPmFlag(pmFlags, 4 /* OnGround */);
+  let groundTrace;
+  let groundContents = CONTENTS_NONE;
+  const forceAirborne = velocity.z > LADDER_BYPASS_VELOCITY || pmType === 1 /* Grapple */;
+  if (forceAirborne) {
+    pmFlags = removePmFlag(pmFlags, 4 /* OnGround */);
+    onGround = false;
+  } else {
+    const end = { x: origin.x, y: origin.y, z: origin.z - GROUND_PROBE_DISTANCE };
+    const traceResult = trace(origin, end, mins, maxs);
+    groundTrace = traceResult;
+    groundContents = traceResult.contents ?? CONTENTS_NONE;
+    const planeNormal = traceResult.planeNormal;
+    let slantedGround = traceResult.fraction < 1 && !!planeNormal && planeNormal.z < SLANTED_NORMAL_THRESHOLD;
+    if (slantedGround && planeNormal) {
+      const slantEnd = addVec3(origin, planeNormal);
+      const slantTrace = trace(origin, slantEnd, mins, maxs);
+      if (slantTrace.fraction < 1 && !slantTrace.startsolid) {
+        slantedGround = false;
+      }
+    }
+    if (traceResult.fraction === 1 || !planeNormal || slantedGround && !traceResult.startsolid) {
+      pmFlags = removePmFlag(pmFlags, 4 /* OnGround */);
+      onGround = false;
+    } else {
+      onGround = true;
+      if (hasPmFlag(pmFlags, 8 /* TimeWaterJump */)) {
+        pmFlags &= ~WATERJUMP_CLEAR;
+        pmTime = 0;
+      }
+      const wasOnGround = hasPmFlag(pmFlags, 4 /* OnGround */);
+      if (!wasOnGround) {
+        if (!n64Physics && velocity.z >= TRICK_VELOCITY_THRESHOLD && planeNormal.z >= TRICK_NORMAL_THRESHOLD && !hasPmFlag(pmFlags, 1 /* Ducked */)) {
+          pmFlags = addPmFlag(pmFlags, 1024 /* TimeTrick */);
+          pmTime = TRICK_PM_TIME;
+        }
+        const clipped = clipVelocityVec3(velocity, planeNormal, IMPACT_CLIP_OVERBOUNCE);
+        impactDelta = startVelocity.z - clipped.z;
+      }
+      pmFlags = addPmFlag(pmFlags, 4 /* OnGround */);
+      if (!wasOnGround && (n64Physics || hasPmFlag(pmFlags, 1 /* Ducked */))) {
+        pmFlags = addPmFlag(pmFlags, 16 /* TimeLand */);
+        pmTime = LAND_PM_TIME;
+      }
+    }
+  }
+  const { waterlevel, watertype } = getWaterLevel({
+    origin,
+    mins,
+    viewheight,
+    pointContents
+  });
+  return {
+    pmFlags,
+    pmTime,
+    onGround: hasPmFlag(pmFlags, 4 /* OnGround */),
+    groundTrace,
+    groundContents,
+    waterlevel,
+    watertype,
+    impactDelta
+  };
+}
+
+// src/pmove/move.ts
+var DEFAULT_AIR_ACCELERATE = 1;
+var WATER_DRIFT_SPEED = 60;
+var DEFAULT_STEP_OVERBOUNCE = 1.01;
+function applyPmoveAirMove(params) {
+  const {
+    origin,
+    frametime,
+    mins,
+    maxs,
+    trace,
+    overbounce = DEFAULT_STEP_OVERBOUNCE,
+    stepSize,
+    maxBumps,
+    maxClipPlanes,
+    hasTime,
+    forward,
+    right,
+    cmd,
+    pmFlags,
+    onGround,
+    gravity,
+    pmType,
+    pmAccelerate,
+    pmAirAccelerate = DEFAULT_AIR_ACCELERATE,
+    pmMaxSpeed,
+    pmDuckSpeed,
+    onLadder,
+    waterlevel,
+    watertype,
+    groundContents,
+    viewPitch,
+    ladderMod,
+    pmWaterSpeed
+  } = params;
+  let velocity = { ...params.velocity };
+  let wishvel = buildPlanarWishVelocity(forward, right, cmd);
+  wishvel = applyPmoveAddCurrents({
+    wishVelocity: wishvel,
+    onLadder,
+    onGround,
+    waterlevel,
+    watertype,
+    groundContents,
+    cmd,
+    viewPitch,
+    maxSpeed: hasPmFlag(pmFlags, 1 /* Ducked */) ? pmDuckSpeed : pmMaxSpeed,
+    ladderMod,
+    waterSpeed: pmWaterSpeed,
+    forward,
+    origin,
+    mins,
+    maxs,
+    trace
+  });
+  const ducked = hasPmFlag(pmFlags, 1 /* Ducked */);
+  const maxSpeed = ducked ? pmDuckSpeed : pmMaxSpeed;
+  let wishdir = wishvel;
+  let wishspeed = lengthVec3(wishdir);
+  if (wishspeed !== 0) {
+    wishdir = normalizeVec3(wishdir);
+  }
+  if (wishspeed > maxSpeed) {
+    const scale = maxSpeed / wishspeed;
+    wishvel = scaleVec3(wishvel, scale);
+    wishspeed = maxSpeed;
+    if (wishspeed !== 0) {
+      wishdir = normalizeVec3(wishvel);
+    }
+  }
+  if (onLadder) {
+    velocity = applyPmoveAccelerate({ velocity, wishdir, wishspeed, accel: pmAccelerate, frametime });
+    if (Math.abs(wishvel.z) < Number.EPSILON) {
+      velocity = dampVerticalVelocity(velocity, gravity, frametime);
+    }
+    return runStepSlideMove({
+      origin,
+      velocity,
+      frametime,
+      mins,
+      maxs,
+      trace,
+      overbounce,
+      stepSize,
+      maxBumps,
+      maxClipPlanes,
+      hasTime
+    });
+  }
+  if (onGround) {
+    velocity = { ...velocity, z: 0 };
+    velocity = applyPmoveAccelerate({ velocity, wishdir, wishspeed, accel: pmAccelerate, frametime });
+    if (gravity > 0) {
+      velocity = { ...velocity, z: 0 };
+    } else {
+      velocity = { ...velocity, z: velocity.z - gravity * frametime };
+    }
+    if (velocity.x === 0 && velocity.y === 0) {
+      return {
+        origin,
+        velocity,
+        planes: [],
+        blocked: 0,
+        stopped: true,
+        stepped: false,
+        stepHeight: 0
+      };
+    }
+    return runStepSlideMove({
+      origin,
+      velocity,
+      frametime,
+      mins,
+      maxs,
+      trace,
+      overbounce,
+      stepSize,
+      maxBumps,
+      maxClipPlanes,
+      hasTime
+    });
+  }
+  if (pmAirAccelerate > 0) {
+    velocity = applyPmoveAirAccelerate({
+      velocity,
+      wishdir,
+      wishspeed,
+      accel: pmAirAccelerate,
+      frametime
+    });
+  } else {
+    velocity = applyPmoveAccelerate({ velocity, wishdir, wishspeed, accel: DEFAULT_AIR_ACCELERATE, frametime });
+  }
+  if (pmType !== 1 /* Grapple */) {
+    velocity = { ...velocity, z: velocity.z - gravity * frametime };
+  }
+  return runStepSlideMove({
+    origin,
+    velocity,
+    frametime,
+    mins,
+    maxs,
+    trace,
+    overbounce,
+    stepSize,
+    maxBumps,
+    maxClipPlanes,
+    hasTime
+  });
+}
+function applyPmoveWaterMove(params) {
+  const {
+    origin,
+    frametime,
+    mins,
+    maxs,
+    trace,
+    overbounce = DEFAULT_STEP_OVERBOUNCE,
+    stepSize,
+    maxBumps,
+    maxClipPlanes,
+    hasTime,
+    forward,
+    right,
+    cmd,
+    pmFlags,
+    onGround,
+    pmMaxSpeed,
+    pmDuckSpeed,
+    pmWaterAccelerate,
+    pmWaterSpeed,
+    onLadder,
+    watertype,
+    groundContents,
+    waterlevel,
+    viewPitch,
+    ladderMod
+  } = params;
+  let velocity = { ...params.velocity };
+  let wishvel = buildFullWishVelocity(forward, right, cmd);
+  if (isIdleInWater(cmd, onGround)) {
+    wishvel = { ...wishvel, z: wishvel.z - WATER_DRIFT_SPEED };
+  } else {
+    if (hasButton2(cmd, 16 /* Crouch */)) {
+      wishvel = addVec3(wishvel, { x: 0, y: 0, z: -pmWaterSpeed * 0.5 });
+    } else if (hasButton2(cmd, 8 /* Jump */)) {
+      wishvel = addVec3(wishvel, { x: 0, y: 0, z: pmWaterSpeed * 0.5 });
+    }
+  }
+  wishvel = applyPmoveAddCurrents({
+    wishVelocity: wishvel,
+    onLadder,
+    onGround,
+    waterlevel,
+    watertype,
+    groundContents,
+    cmd,
+    viewPitch,
+    maxSpeed: hasPmFlag(pmFlags, 1 /* Ducked */) ? pmDuckSpeed : pmMaxSpeed,
+    ladderMod,
+    waterSpeed: pmWaterSpeed,
+    forward,
+    origin,
+    mins,
+    maxs,
+    trace
+  });
+  let wishdir = wishvel;
+  let wishspeed = lengthVec3(wishdir);
+  if (wishspeed !== 0) {
+    wishdir = normalizeVec3(wishdir);
+  }
+  if (wishspeed > pmMaxSpeed) {
+    const scale = pmMaxSpeed / wishspeed;
+    wishvel = scaleVec3(wishvel, scale);
+    wishspeed = pmMaxSpeed;
+    if (wishspeed !== 0) {
+      wishdir = normalizeVec3(wishvel);
+    }
+  }
+  wishspeed *= 0.5;
+  const ducked = hasPmFlag(pmFlags, 1 /* Ducked */);
+  if (ducked && wishspeed > pmDuckSpeed) {
+    const scale = pmDuckSpeed / wishspeed;
+    wishvel = scaleVec3(wishvel, scale);
+    wishspeed = pmDuckSpeed;
+    if (wishspeed !== 0) {
+      wishdir = normalizeVec3(wishvel);
+    }
+  }
+  velocity = applyPmoveAccelerate({ velocity, wishdir, wishspeed, accel: pmWaterAccelerate, frametime });
+  return runStepSlideMove({
+    origin,
+    velocity,
+    frametime,
+    mins,
+    maxs,
+    trace,
+    overbounce,
+    stepSize,
+    maxBumps,
+    maxClipPlanes,
+    hasTime
+  });
+}
+function buildPlanarWishVelocity(forward, right, cmd) {
+  return {
+    x: forward.x * cmd.forwardmove + right.x * cmd.sidemove,
+    y: forward.y * cmd.forwardmove + right.y * cmd.sidemove,
+    z: 0
+  };
+}
+function buildFullWishVelocity(forward, right, cmd) {
+  return {
+    x: forward.x * cmd.forwardmove + right.x * cmd.sidemove,
+    y: forward.y * cmd.forwardmove + right.y * cmd.sidemove,
+    z: forward.z * cmd.forwardmove + right.z * cmd.sidemove
+  };
+}
+function hasButton2(cmd, button) {
+  return (cmd.buttons ?? 0) & button ? true : false;
+}
+function isIdleInWater(cmd, onGround) {
+  const noMove = cmd.forwardmove === 0 && cmd.sidemove === 0;
+  const noButtons = (cmd.buttons ?? 0) & (8 /* Jump */ | 16 /* Crouch */) ? false : true;
+  return noMove && noButtons && !onGround;
+}
+function dampVerticalVelocity(velocity, gravity, frametime) {
+  let z = velocity.z;
+  const delta = gravity * frametime;
+  if (z > 0) {
+    z -= delta;
+    if (z < 0) {
+      z = 0;
+    }
+  } else {
+    z += delta;
+    if (z > 0) {
+      z = 0;
+    }
+  }
+  return { ...velocity, z };
+}
+function runStepSlideMove(params) {
+  const { origin, velocity, frametime, mins, maxs, trace, overbounce = DEFAULT_STEP_OVERBOUNCE, stepSize, maxBumps, maxClipPlanes, hasTime } = params;
+  return stepSlideMove({
+    origin,
+    velocity,
+    frametime,
+    trace,
+    mins,
+    maxs,
+    overbounce,
+    stepSize,
+    maxBumps,
+    maxClipPlanes,
+    hasTime
+  });
+}
+
+// src/pmove/special.ts
+var LADDER_TRACE_DISTANCE2 = 1;
+var WATERJUMP_FORWARD_CHECK = 40;
+var WATERJUMP_FORWARD_SPEED = 50;
+var WATERJUMP_UPWARD_SPEED = 350;
+var WATERJUMP_PM_TIME = 2048;
+var WATERJUMP_SIM_STEP = 0.1;
+var WATERJUMP_BASE_GRAVITY = 800;
+var WATERJUMP_MAX_STEPS = 50;
+var GROUND_NORMAL_THRESHOLD = 0.7;
+var WATERJUMP_STEP_TOLERANCE = 18;
+var DEFAULT_OVERBOUNCE2 = 1.01;
+var WATERJUMP_DOWN_PROBE = 2;
+function checkSpecialMovement(params) {
+  const {
+    pmFlags: initialFlags,
+    pmTime: initialPmTime,
+    waterlevel,
+    watertype,
+    gravity,
+    cmd,
+    forward,
+    origin,
+    velocity: initialVelocity,
+    mins,
+    maxs,
+    viewheight,
+    trace,
+    pointContents,
+    onGround,
+    overbounce = DEFAULT_OVERBOUNCE2,
+    stepSize = WATERJUMP_STEP_TOLERANCE,
+    maxBumps,
+    maxClipPlanes
+  } = params;
+  if (initialPmTime > 0) {
+    return { pmFlags: initialFlags, pmTime: initialPmTime, velocity: initialVelocity, performedWaterJump: false };
+  }
+  let pmFlags = removePmFlag(initialFlags, 128 /* OnLadder */);
+  let pmTime = initialPmTime;
+  let velocity = initialVelocity;
+  const flatforward = normalizeVec3({ x: forward.x, y: forward.y, z: 0 });
+  const hasForward = lengthSquaredVec3(flatforward) > 0;
+  if (waterlevel < 2 /* Waist */ && hasForward) {
+    const ladderEnd = addVec3(origin, scaleVec3(flatforward, LADDER_TRACE_DISTANCE2));
+    const ladderTrace = trace(origin, ladderEnd, mins, maxs);
+    const contents = ladderTrace.contents ?? CONTENTS_NONE;
+    if (ladderTrace.fraction < 1 && (contents & CONTENTS_LADDER) !== 0) {
+      pmFlags = addPmFlag(pmFlags, 128 /* OnLadder */);
+    }
+  }
+  if (gravity === 0) {
+    return { pmFlags, pmTime, velocity, performedWaterJump: false };
+  }
+  if (((cmd.buttons ?? 0) & 8 /* Jump */) === 0 && cmd.forwardmove <= 0) {
+    return { pmFlags, pmTime, velocity, performedWaterJump: false };
+  }
+  if (waterlevel !== 2 /* Waist */) {
+    return { pmFlags, pmTime, velocity, performedWaterJump: false };
+  }
+  if ((watertype & CONTENTS_NO_WATERJUMP) !== 0) {
+    return { pmFlags, pmTime, velocity, performedWaterJump: false };
+  }
+  if (!hasForward) {
+    return { pmFlags, pmTime, velocity, performedWaterJump: false };
+  }
+  const forwardCheckEnd = addVec3(origin, scaleVec3(flatforward, WATERJUMP_FORWARD_CHECK));
+  const forwardTrace = trace(origin, forwardCheckEnd, mins, maxs);
+  if (forwardTrace.fraction === 1 || !forwardTrace.planeNormal || forwardTrace.planeNormal.z >= GROUND_NORMAL_THRESHOLD) {
+    return { pmFlags, pmTime, velocity, performedWaterJump: false };
+  }
+  let simVelocity = {
+    x: flatforward.x * WATERJUMP_FORWARD_SPEED,
+    y: flatforward.y * WATERJUMP_FORWARD_SPEED,
+    z: WATERJUMP_UPWARD_SPEED
+  };
+  let simOrigin = origin;
+  let hasTime = true;
+  const stepCount = computeWaterJumpSteps(gravity);
+  for (let i = 0; i < stepCount; i++) {
+    simVelocity = { x: simVelocity.x, y: simVelocity.y, z: simVelocity.z - gravity * WATERJUMP_SIM_STEP };
+    if (simVelocity.z < 0) {
+      hasTime = false;
+    }
+    const move = stepSlideMove({
+      origin: simOrigin,
+      velocity: simVelocity,
+      frametime: WATERJUMP_SIM_STEP,
+      trace,
+      mins,
+      maxs,
+      overbounce,
+      stepSize,
+      maxBumps,
+      maxClipPlanes,
+      hasTime
+    });
+    simOrigin = move.origin;
+    simVelocity = move.velocity;
+  }
+  const downEnd = addVec3(simOrigin, { x: 0, y: 0, z: -WATERJUMP_DOWN_PROBE });
+  const downTrace = trace(simOrigin, downEnd, mins, maxs);
+  if (downTrace.fraction === 1 || !downTrace.planeNormal || downTrace.planeNormal.z < GROUND_NORMAL_THRESHOLD || downTrace.endpos.z < origin.z) {
+    return { pmFlags, pmTime, velocity, performedWaterJump: false };
+  }
+  if (onGround && Math.abs(origin.z - downTrace.endpos.z) <= stepSize) {
+    return { pmFlags, pmTime, velocity, performedWaterJump: false };
+  }
+  const landingWater = getWaterLevel({ origin: downTrace.endpos, mins, viewheight, pointContents });
+  if (landingWater.waterlevel >= 2 /* Waist */) {
+    return { pmFlags, pmTime, velocity, performedWaterJump: false };
+  }
+  pmFlags = addPmFlag(pmFlags, 8 /* TimeWaterJump */);
+  pmTime = WATERJUMP_PM_TIME;
+  velocity = {
+    x: flatforward.x * WATERJUMP_FORWARD_SPEED,
+    y: flatforward.y * WATERJUMP_FORWARD_SPEED,
+    z: WATERJUMP_UPWARD_SPEED
+  };
+  return { pmFlags, pmTime, velocity, performedWaterJump: true };
+}
+function computeWaterJumpSteps(gravity) {
+  if (gravity === 0) {
+    return 0;
+  }
+  const scaled = Math.floor(10 * (WATERJUMP_BASE_GRAVITY / gravity));
+  if (scaled <= 0) {
+    return 0;
+  }
+  return Math.min(WATERJUMP_MAX_STEPS, scaled);
+}
+
+// src/pmove/snap.ts
+var SNAP_OFFSETS = [0, -1, 1];
+function goodPosition(params) {
+  const { origin, mins, maxs, trace } = params;
+  const result = trace(origin, origin, mins, maxs);
+  return result.allsolid ? false : true;
+}
+function snapPosition(params) {
+  const { origin, velocity, mins, maxs, previousOrigin, trace } = params;
+  if (goodPosition({ origin, mins, maxs, trace })) {
+    return { origin: { ...origin }, velocity: { ...velocity }, resolution: "unchanged" };
+  }
+  const fix = fixStuckObjectGeneric({
+    origin,
+    mins,
+    maxs,
+    trace: (start, localMins, localMaxs, end) => trace(start, end, localMins, localMaxs)
+  });
+  if (fix.result === "fixed" || fix.result === "good-position") {
+    return { origin: fix.origin, velocity: { ...velocity }, resolution: "fixed" };
+  }
+  return { origin: { ...previousOrigin }, velocity: { ...velocity }, resolution: "reverted" };
+}
+function initialSnapPosition(params) {
+  const { origin, mins, maxs, trace } = params;
+  for (const oz of SNAP_OFFSETS) {
+    for (const oy of SNAP_OFFSETS) {
+      for (const ox of SNAP_OFFSETS) {
+        const candidate = { x: origin.x + ox, y: origin.y + oy, z: origin.z + oz };
+        if (goodPosition({ origin: candidate, mins, maxs, trace })) {
+          const snapped = ox !== 0 || oy !== 0 || oz !== 0;
+          return { origin: candidate, snapped };
+        }
+      }
+    }
+  }
+  return { origin: { ...origin }, snapped: false };
+}
+
+// src/pmove/view.ts
+function addAngles(cmdAngles, deltaAngles) {
+  return {
+    x: cmdAngles.x + deltaAngles.x,
+    y: cmdAngles.y + deltaAngles.y,
+    z: cmdAngles.z + deltaAngles.z
+  };
+}
+function clampPitch(pitch) {
+  if (pitch > 89 && pitch < 180) {
+    return 89;
+  }
+  if (pitch < 271 && pitch >= 180) {
+    return 271;
+  }
+  return pitch;
+}
+function clampViewAngles(params) {
+  const { pmFlags, cmdAngles, deltaAngles } = params;
+  let viewangles;
+  if ((pmFlags & 32 /* TimeTeleport */) !== 0) {
+    viewangles = {
+      x: 0,
+      y: cmdAngles.y + deltaAngles.y,
+      z: 0
+    };
+  } else {
+    viewangles = addAngles(cmdAngles, deltaAngles);
+    viewangles = { ...viewangles, x: clampPitch(viewangles.x) };
+  }
+  const vectors = angleVectors(viewangles);
+  return { viewangles, ...vectors };
+}
+export {
+  CONTENTS_AREAPORTAL,
+  CONTENTS_AUX,
+  CONTENTS_CURRENT_0,
+  CONTENTS_CURRENT_180,
+  CONTENTS_CURRENT_270,
+  CONTENTS_CURRENT_90,
+  CONTENTS_CURRENT_DOWN,
+  CONTENTS_CURRENT_UP,
+  CONTENTS_DEADMONSTER,
+  CONTENTS_DETAIL,
+  CONTENTS_LADDER,
+  CONTENTS_LAVA,
+  CONTENTS_MIST,
+  CONTENTS_MONSTER,
+  CONTENTS_MONSTERCLIP,
+  CONTENTS_NONE,
+  CONTENTS_NO_WATERJUMP,
+  CONTENTS_ORIGIN,
+  CONTENTS_PLAYER,
+  CONTENTS_PLAYERCLIP,
+  CONTENTS_PROJECTILE,
+  CONTENTS_PROJECTILECLIP,
+  CONTENTS_SLIME,
+  CONTENTS_SOLID,
+  CONTENTS_TRANSLUCENT,
+  CONTENTS_WATER,
+  CONTENTS_WINDOW,
+  CS_MAX_STRING_LENGTH,
+  CS_MAX_STRING_LENGTH_OLD,
+  ConfigStringIndex,
+  CvarFlags,
+  DIST_EPSILON,
+  LAST_VISIBLE_CONTENTS,
+  MASK_ALL,
+  MASK_BLOCK_SIGHT,
+  MASK_CURRENT,
+  MASK_DEADSOLID,
+  MASK_LADDER_NAV_SOLID,
+  MASK_MONSTERSOLID,
+  MASK_NAV_SOLID,
+  MASK_OPAQUE,
+  MASK_PLAYERSOLID,
+  MASK_PROJECTILE,
+  MASK_SHOT,
+  MASK_SOLID,
+  MASK_WALK_NAV_SOLID,
+  MASK_WATER,
+  MAX_CLIENTS,
+  MAX_CONFIGSTRINGS,
+  MAX_EDICTS,
+  MAX_GENERAL,
+  MAX_IMAGES,
+  MAX_ITEMS,
+  MAX_LIGHTSTYLES,
+  MAX_MODELS,
+  MAX_OSPATH,
+  MAX_QPATH,
+  MAX_SHADOW_LIGHTS,
+  MAX_SOUNDS,
+  MAX_STRING_CHARS,
+  MAX_STRING_TOKENS,
+  MAX_TOKEN_CHARS,
+  MAX_WHEEL_ITEMS,
+  MersenneTwister19937,
+  PITCH,
+  PlaneSide,
+  PlayerButton,
+  PmFlag,
+  PmType,
+  ROLL,
+  RandomGenerator,
+  SLIDEMOVE_BLOCKED_FLOOR,
+  SLIDEMOVE_BLOCKED_WALL,
+  STOP_EPSILON,
+  SURF_ALPHATEST,
+  SURF_FLOWING,
+  SURF_LIGHT,
+  SURF_N64_SCROLL_FLIP,
+  SURF_N64_SCROLL_X,
+  SURF_N64_SCROLL_Y,
+  SURF_N64_UV,
+  SURF_NODRAW,
+  SURF_NONE,
+  SURF_SKY,
+  SURF_SLICK,
+  SURF_TRANS33,
+  SURF_TRANS66,
+  SURF_WARP,
+  WaterLevel,
+  YAW,
+  ZERO_VEC3,
+  addBlendColor,
+  addContents,
+  addPmFlag,
+  addPointToBounds,
+  addVec3,
+  angleMod,
+  angleVectors,
+  applyPmoveAccelerate,
+  applyPmoveAddCurrents,
+  applyPmoveAirAccelerate,
+  applyPmoveAirMove,
+  applyPmoveFlyMove,
+  applyPmoveFriction,
+  applyPmoveWaterMove,
+  boxOnPlaneSide,
+  boxesIntersect,
+  buildAirGroundWish,
+  buildCollisionModel,
+  buildWaterWish,
+  categorizePosition,
+  checkDuckState,
+  checkJump,
+  checkSpecialMovement,
+  clampViewAngles,
+  clipBoxToBrush,
+  clipVelocityAgainstPlanes,
+  clipVelocityVec3,
+  closestPointToBox,
+  combineSurfaceFlags,
+  computePlaneSignBits,
+  computePlayerDimensions,
+  concatRotationMatrices,
+  configStringSize,
+  createDefaultTrace,
+  createEmptyBounds3,
+  createRandomGenerator,
+  crossVec3,
+  currentVectorFromContents,
+  degToRad,
+  distanceBetweenBoxesSquared,
+  dotVec3,
+  fixStuckObjectGeneric,
+  getWaterLevel,
+  goodPosition,
+  groundCurrentVelocity,
+  hasAllContents,
+  hasAnyContents,
+  hasPmFlag,
+  hasSurfaceFlags,
+  initialSnapPosition,
+  isAtLeastWaistDeep,
+  isUnderwater,
+  lengthSquaredVec3,
+  lengthVec3,
+  lerpAngle,
+  multiplyVec3,
+  negateVec3,
+  normalizeVec3,
+  perpendicularVec3,
+  planeDistanceToPoint,
+  pmoveCmdScale,
+  pointInsideBrush,
+  pointOnPlaneSide,
+  projectPointOnPlane,
+  projectSourceVec3,
+  projectSourceVec3WithUp,
+  radToDeg,
+  removeContents,
+  removePmFlag,
+  resolveSlideMove,
+  rotatePointAroundVector,
+  scaleVec3,
+  slerpVec3,
+  slideClipVelocityVec3,
+  slideMove,
+  snapPosition,
+  stepSlideMove,
+  subtractVec3,
+  testBoxInBrush,
+  vectorToAngles,
+  vectorToYaw,
+  waterCurrentVelocity
+};
+//# sourceMappingURL=index.js.map