@holoscript/std 2.1.0 → 6.0.3

package/dist/chunk-7HVUYGPS.js

@@ -0,0 +1,679 @@
+// src/types.ts
+function vec2(x = 0, y = 0) {
+  return { x, y };
+}
+function vec3(x = 0, y = 0, z = 0) {
+  return { x, y, z };
+}
+function vec4(x = 0, y = 0, z = 0, w = 0) {
+  return { x, y, z, w };
+}
+function quat(x = 0, y = 0, z = 0, w = 1) {
+  return { x, y, z, w };
+}
+function transform(position = vec3(), rotation = quat(), scale = vec3(1, 1, 1)) {
+  return { position, rotation, scale };
+}
+function rgb(r, g, b) {
+  return { r, g, b };
+}
+function rgba(r, g, b, a = 1) {
+  return { r, g, b, a };
+}
+function hsl(h, s, l) {
+  return { h, s, l };
+}
+function aabb(min = vec3(), max = vec3()) {
+  return { min, max };
+}
+function ray(origin, direction) {
+  return { origin, direction };
+}
+function vec3ToArray(v) {
+  return [v.x, v.y, v.z];
+}
+function arrayToVec3(arr) {
+  return { x: arr[0] || 0, y: arr[1] || 0, z: arr[2] || 0 };
+}
+function quatToArray(q) {
+  return [q.x, q.y, q.z, q.w];
+}
+function arrayToQuat(arr) {
+  return { x: arr[0] || 0, y: arr[1] || 0, z: arr[2] || 0, w: arr[3] ?? 1 };
+}
+function parseColor(color) {
+  if (typeof color === "string") {
+    if (color.startsWith("#")) {
+      const hex = color.slice(1);
+      if (hex.length === 3) {
+        return {
+          r: parseInt(hex[0] + hex[0], 16) / 255,
+          g: parseInt(hex[1] + hex[1], 16) / 255,
+          b: parseInt(hex[2] + hex[2], 16) / 255,
+          a: 1
+        };
+      } else if (hex.length === 6) {
+        return {
+          r: parseInt(hex.slice(0, 2), 16) / 255,
+          g: parseInt(hex.slice(2, 4), 16) / 255,
+          b: parseInt(hex.slice(4, 6), 16) / 255,
+          a: 1
+        };
+      } else if (hex.length === 8) {
+        return {
+          r: parseInt(hex.slice(0, 2), 16) / 255,
+          g: parseInt(hex.slice(2, 4), 16) / 255,
+          b: parseInt(hex.slice(4, 6), 16) / 255,
+          a: parseInt(hex.slice(6, 8), 16) / 255
+        };
+      }
+    }
+    const namedColors = {
+      white: { r: 1, g: 1, b: 1, a: 1 },
+      black: { r: 0, g: 0, b: 0, a: 1 },
+      red: { r: 1, g: 0, b: 0, a: 1 },
+      green: { r: 0, g: 1, b: 0, a: 1 },
+      blue: { r: 0, g: 0, b: 1, a: 1 },
+      yellow: { r: 1, g: 1, b: 0, a: 1 },
+      cyan: { r: 0, g: 1, b: 1, a: 1 },
+      magenta: { r: 1, g: 0, b: 1, a: 1 }
+    };
+    return namedColors[color.toLowerCase()] || { r: 1, g: 1, b: 1, a: 1 };
+  }
+  if (typeof color === "number") {
+    return {
+      r: (color >> 16 & 255) / 255,
+      g: (color >> 8 & 255) / 255,
+      b: (color & 255) / 255,
+      a: 1
+    };
+  }
+  if ("h" in color) {
+    const { h, s, l } = color;
+    const c = (1 - Math.abs(2 * l - 1)) * s;
+    const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+    const m = l - c / 2;
+    let r = 0, g = 0, b = 0;
+    if (h < 60) {
+      r = c;
+      g = x;
+    } else if (h < 120) {
+      r = x;
+      g = c;
+    } else if (h < 180) {
+      g = c;
+      b = x;
+    } else if (h < 240) {
+      g = x;
+      b = c;
+    } else if (h < 300) {
+      r = x;
+      b = c;
+    } else {
+      r = c;
+      b = x;
+    }
+    return { r: r + m, g: g + m, b: b + m, a: 1 };
+  }
+  if ("a" in color) {
+    return color;
+  }
+  return { ...color, a: 1 };
+}
+function colorToHex(color) {
+  const r = Math.round(color.r * 255).toString(16).padStart(2, "0");
+  const g = Math.round(color.g * 255).toString(16).padStart(2, "0");
+  const b = Math.round(color.b * 255).toString(16).padStart(2, "0");
+  return `#${r}${g}${b}`;
+}
+
+// src/math.ts
+var PI = Math.PI;
+var TAU = Math.PI * 2;
+var HALF_PI = Math.PI / 2;
+var DEG_TO_RAD = Math.PI / 180;
+var RAD_TO_DEG = 180 / Math.PI;
+var EPSILON = 1e-6;
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+function inverseLerp(a, b, value) {
+  return (value - a) / (b - a);
+}
+function remap(value, inMin, inMax, outMin, outMax) {
+  return lerp(outMin, outMax, inverseLerp(inMin, inMax, value));
+}
+function smoothstep(edge0, edge1, x) {
+  const t = clamp((x - edge0) / (edge1 - edge0), 0, 1);
+  return t * t * (3 - 2 * t);
+}
+function smootherstep(edge0, edge1, x) {
+  const t = clamp((x - edge0) / (edge1 - edge0), 0, 1);
+  return t * t * t * (t * (t * 6 - 15) + 10);
+}
+function degToRad(degrees) {
+  return degrees * DEG_TO_RAD;
+}
+function radToDeg(radians) {
+  return radians * RAD_TO_DEG;
+}
+function mod(n, m) {
+  return (n % m + m) % m;
+}
+function fract(x) {
+  return x - Math.floor(x);
+}
+function sign(x) {
+  return x > 0 ? 1 : x < 0 ? -1 : 0;
+}
+function step(edge, x) {
+  return x < edge ? 0 : 1;
+}
+var vec2Math = {
+  add: (a, b) => ({ x: a.x + b.x, y: a.y + b.y }),
+  sub: (a, b) => ({ x: a.x - b.x, y: a.y - b.y }),
+  mul: (a, s) => ({ x: a.x * s, y: a.y * s }),
+  div: (a, s) => ({ x: a.x / s, y: a.y / s }),
+  dot: (a, b) => a.x * b.x + a.y * b.y,
+  length: (v) => Math.sqrt(v.x * v.x + v.y * v.y),
+  lengthSq: (v) => v.x * v.x + v.y * v.y,
+  normalize: (v) => {
+    const len = vec2Math.length(v);
+    return len > 0 ? vec2Math.div(v, len) : { x: 0, y: 0 };
+  },
+  distance: (a, b) => vec2Math.length(vec2Math.sub(a, b)),
+  lerp: (a, b, t) => ({
+    x: lerp(a.x, b.x, t),
+    y: lerp(a.y, b.y, t)
+  }),
+  rotate: (v, angle) => {
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    return { x: v.x * c - v.y * s, y: v.x * s + v.y * c };
+  },
+  angle: (v) => Math.atan2(v.y, v.x),
+  angleBetween: (a, b) => {
+    return Math.acos(clamp(vec2Math.dot(vec2Math.normalize(a), vec2Math.normalize(b)), -1, 1));
+  }
+};
+var vec3Math = {
+  zero: () => vec3(0, 0, 0),
+  one: () => vec3(1, 1, 1),
+  up: () => vec3(0, 1, 0),
+  down: () => vec3(0, -1, 0),
+  forward: () => vec3(0, 0, -1),
+  back: () => vec3(0, 0, 1),
+  left: () => vec3(-1, 0, 0),
+  right: () => vec3(1, 0, 0),
+  add: (a, b) => ({ x: a.x + b.x, y: a.y + b.y, z: a.z + b.z }),
+  sub: (a, b) => ({ x: a.x - b.x, y: a.y - b.y, z: a.z - b.z }),
+  mul: (a, s) => ({ x: a.x * s, y: a.y * s, z: a.z * s }),
+  div: (a, s) => ({ x: a.x / s, y: a.y / s, z: a.z / s }),
+  mulVec: (a, b) => ({ x: a.x * b.x, y: a.y * b.y, z: a.z * b.z }),
+  dot: (a, b) => a.x * b.x + a.y * b.y + a.z * b.z,
+  cross: (a, b) => ({
+    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
+  }),
+  length: (v) => Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z),
+  lengthSq: (v) => v.x * v.x + v.y * v.y + v.z * v.z,
+  normalize: (v) => {
+    const len = vec3Math.length(v);
+    return len > EPSILON ? vec3Math.div(v, len) : vec3(0, 0, 0);
+  },
+  distance: (a, b) => vec3Math.length(vec3Math.sub(a, b)),
+  distanceSq: (a, b) => vec3Math.lengthSq(vec3Math.sub(a, b)),
+  lerp: (a, b, t) => ({
+    x: lerp(a.x, b.x, t),
+    y: lerp(a.y, b.y, t),
+    z: lerp(a.z, b.z, t)
+  }),
+  slerp: (a, b, t) => {
+    const dot = clamp(vec3Math.dot(a, b), -1, 1);
+    const theta = Math.acos(dot) * t;
+    const relative = vec3Math.normalize(vec3Math.sub(b, vec3Math.mul(a, dot)));
+    return vec3Math.add(vec3Math.mul(a, Math.cos(theta)), vec3Math.mul(relative, Math.sin(theta)));
+  },
+  negate: (v) => ({ x: -v.x, y: -v.y, z: -v.z }),
+  abs: (v) => ({ x: Math.abs(v.x), y: Math.abs(v.y), z: Math.abs(v.z) }),
+  min: (a, b) => ({
+    x: Math.min(a.x, b.x),
+    y: Math.min(a.y, b.y),
+    z: Math.min(a.z, b.z)
+  }),
+  max: (a, b) => ({
+    x: Math.max(a.x, b.x),
+    y: Math.max(a.y, b.y),
+    z: Math.max(a.z, b.z)
+  }),
+  clamp: (v, min, max) => ({
+    x: clamp(v.x, min.x, max.x),
+    y: clamp(v.y, min.y, max.y),
+    z: clamp(v.z, min.z, max.z)
+  }),
+  floor: (v) => ({
+    x: Math.floor(v.x),
+    y: Math.floor(v.y),
+    z: Math.floor(v.z)
+  }),
+  ceil: (v) => ({
+    x: Math.ceil(v.x),
+    y: Math.ceil(v.y),
+    z: Math.ceil(v.z)
+  }),
+  round: (v) => ({
+    x: Math.round(v.x),
+    y: Math.round(v.y),
+    z: Math.round(v.z)
+  }),
+  reflect: (v, normal) => {
+    const dot = vec3Math.dot(v, normal);
+    return vec3Math.sub(v, vec3Math.mul(normal, 2 * dot));
+  },
+  project: (v, onto) => {
+    const dot = vec3Math.dot(v, onto);
+    const lenSq = vec3Math.lengthSq(onto);
+    return vec3Math.mul(onto, dot / lenSq);
+  },
+  angle: (a, b) => {
+    const dot = vec3Math.dot(vec3Math.normalize(a), vec3Math.normalize(b));
+    return Math.acos(clamp(dot, -1, 1));
+  },
+  equals: (a, b, epsilon = EPSILON) => {
+    return Math.abs(a.x - b.x) < epsilon && Math.abs(a.y - b.y) < epsilon && Math.abs(a.z - b.z) < epsilon;
+  }
+};
+var quatMath = {
+  identity: () => quat(0, 0, 0, 1),
+  fromAxisAngle: (axis, angle) => {
+    const halfAngle = angle / 2;
+    const s = Math.sin(halfAngle);
+    const normalized = vec3Math.normalize(axis);
+    return {
+      x: normalized.x * s,
+      y: normalized.y * s,
+      z: normalized.z * s,
+      w: Math.cos(halfAngle)
+    };
+  },
+  fromEuler: (euler) => {
+    const { x, y, z } = euler;
+    const c1 = Math.cos(degToRad(x) / 2);
+    const c2 = Math.cos(degToRad(y) / 2);
+    const c3 = Math.cos(degToRad(z) / 2);
+    const s1 = Math.sin(degToRad(x) / 2);
+    const s2 = Math.sin(degToRad(y) / 2);
+    const s3 = Math.sin(degToRad(z) / 2);
+    return {
+      x: s1 * c2 * c3 + c1 * s2 * s3,
+      y: c1 * s2 * c3 - s1 * c2 * s3,
+      z: c1 * c2 * s3 + s1 * s2 * c3,
+      w: c1 * c2 * c3 - s1 * s2 * s3
+    };
+  },
+  toEuler: (q) => {
+    const sinr_cosp = 2 * (q.w * q.x + q.y * q.z);
+    const cosr_cosp = 1 - 2 * (q.x * q.x + q.y * q.y);
+    const x = Math.atan2(sinr_cosp, cosr_cosp);
+    const sinp = 2 * (q.w * q.y - q.z * q.x);
+    let y;
+    if (Math.abs(sinp) >= 1) {
+      y = Math.PI / 2 * Math.sign(sinp);
+    } else {
+      y = Math.asin(sinp);
+    }
+    const siny_cosp = 2 * (q.w * q.z + q.x * q.y);
+    const cosy_cosp = 1 - 2 * (q.y * q.y + q.z * q.z);
+    const z = Math.atan2(siny_cosp, cosy_cosp);
+    return {
+      x: radToDeg(x),
+      y: radToDeg(y),
+      z: radToDeg(z)
+    };
+  },
+  multiply: (a, b) => ({
+    x: a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y,
+    y: a.w * b.y - a.x * b.z + a.y * b.w + a.z * b.x,
+    z: a.w * b.z + a.x * b.y - a.y * b.x + a.z * b.w,
+    w: a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z
+  }),
+  conjugate: (q) => ({ x: -q.x, y: -q.y, z: -q.z, w: q.w }),
+  inverse: (q) => {
+    const lenSq = q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w;
+    return {
+      x: -q.x / lenSq,
+      y: -q.y / lenSq,
+      z: -q.z / lenSq,
+      w: q.w / lenSq
+    };
+  },
+  normalize: (q) => {
+    const len = Math.sqrt(q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w);
+    return { x: q.x / len, y: q.y / len, z: q.z / len, w: q.w / len };
+  },
+  dot: (a, b) => a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w,
+  slerp: (a, b, t) => {
+    let dot = quatMath.dot(a, b);
+    let bAdjusted = b;
+    if (dot < 0) {
+      bAdjusted = { x: -b.x, y: -b.y, z: -b.z, w: -b.w };
+      dot = -dot;
+    }
+    if (dot > 0.9995) {
+      return quatMath.normalize({
+        x: lerp(a.x, bAdjusted.x, t),
+        y: lerp(a.y, bAdjusted.y, t),
+        z: lerp(a.z, bAdjusted.z, t),
+        w: lerp(a.w, bAdjusted.w, t)
+      });
+    }
+    const theta0 = Math.acos(dot);
+    const theta = theta0 * t;
+    const sinTheta = Math.sin(theta);
+    const sinTheta0 = Math.sin(theta0);
+    const s0 = Math.cos(theta) - dot * sinTheta / sinTheta0;
+    const s1 = sinTheta / sinTheta0;
+    return {
+      x: a.x * s0 + bAdjusted.x * s1,
+      y: a.y * s0 + bAdjusted.y * s1,
+      z: a.z * s0 + bAdjusted.z * s1,
+      w: a.w * s0 + bAdjusted.w * s1
+    };
+  },
+  rotateVec3: (q, v) => {
+    const qv = { x: q.x, y: q.y, z: q.z };
+    const uv = vec3Math.cross(qv, v);
+    const uuv = vec3Math.cross(qv, uv);
+    return vec3Math.add(v, vec3Math.add(vec3Math.mul(uv, 2 * q.w), vec3Math.mul(uuv, 2)));
+  },
+  lookAt: (forward, up = vec3(0, 1, 0)) => {
+    const f = vec3Math.normalize(forward);
+    const r = vec3Math.normalize(vec3Math.cross(up, f));
+    const u = vec3Math.cross(f, r);
+    const trace = r.x + u.y + f.z;
+    let q;
+    if (trace > 0) {
+      const s = 0.5 / Math.sqrt(trace + 1);
+      q = {
+        w: 0.25 / s,
+        x: (u.z - f.y) * s,
+        y: (f.x - r.z) * s,
+        z: (r.y - u.x) * s
+      };
+    } else if (r.x > u.y && r.x > f.z) {
+      const s = 2 * Math.sqrt(1 + r.x - u.y - f.z);
+      q = {
+        w: (u.z - f.y) / s,
+        x: 0.25 * s,
+        y: (u.x + r.y) / s,
+        z: (f.x + r.z) / s
+      };
+    } else if (u.y > f.z) {
+      const s = 2 * Math.sqrt(1 + u.y - r.x - f.z);
+      q = {
+        w: (f.x - r.z) / s,
+        x: (u.x + r.y) / s,
+        y: 0.25 * s,
+        z: (f.y + u.z) / s
+      };
+    } else {
+      const s = 2 * Math.sqrt(1 + f.z - r.x - u.y);
+      q = {
+        w: (r.y - u.x) / s,
+        x: (f.x + r.z) / s,
+        y: (f.y + u.z) / s,
+        z: 0.25 * s
+      };
+    }
+    return quatMath.normalize(q);
+  }
+};
+var aabbMath = {
+  contains: (aabb2, point) => {
+    return point.x >= aabb2.min.x && point.x <= aabb2.max.x && point.y >= aabb2.min.y && point.y <= aabb2.max.y && point.z >= aabb2.min.z && point.z <= aabb2.max.z;
+  },
+  intersects: (a, b) => {
+    return a.min.x <= b.max.x && a.max.x >= b.min.x && a.min.y <= b.max.y && a.max.y >= b.min.y && a.min.z <= b.max.z && a.max.z >= b.min.z;
+  },
+  center: (aabb2) => vec3Math.mul(vec3Math.add(aabb2.min, aabb2.max), 0.5),
+  size: (aabb2) => vec3Math.sub(aabb2.max, aabb2.min),
+  expand: (aabb2, point) => ({
+    min: vec3Math.min(aabb2.min, point),
+    max: vec3Math.max(aabb2.max, point)
+  }),
+  merge: (a, b) => ({
+    min: vec3Math.min(a.min, b.min),
+    max: vec3Math.max(a.max, b.max)
+  })
+};
+var perm = new Uint8Array(512);
+for (let i = 0; i < 256; i++) perm[i] = perm[i + 256] = i;
+for (let i = 255; i > 0; i--) {
+  const j = Math.floor(Math.random() * (i + 1));
+  [perm[i], perm[j]] = [perm[j], perm[i]];
+  perm[i + 256] = perm[i];
+}
+function fade(t) {
+  return t * t * t * (t * (t * 6 - 15) + 10);
+}
+function grad(hash, x, y, z) {
+  const h = hash & 15;
+  const u = h < 8 ? x : y;
+  const v = h < 4 ? y : h === 12 || h === 14 ? x : z;
+  return ((h & 1) === 0 ? u : -u) + ((h & 2) === 0 ? v : -v);
+}
+var noise = {
+  /**
+   * 3D Perlin noise (-1 to 1)
+   */
+  perlin3d: (x, y, z) => {
+    const X = Math.floor(x) & 255;
+    const Y = Math.floor(y) & 255;
+    const Z = Math.floor(z) & 255;
+    x -= Math.floor(x);
+    y -= Math.floor(y);
+    z -= Math.floor(z);
+    const u = fade(x);
+    const v = fade(y);
+    const w = fade(z);
+    const A = perm[X] + Y;
+    const AA = perm[A] + Z;
+    const AB = perm[A + 1] + Z;
+    const B = perm[X + 1] + Y;
+    const BA = perm[B] + Z;
+    const BB = perm[B + 1] + Z;
+    return lerp(
+      lerp(
+        lerp(grad(perm[AA], x, y, z), grad(perm[BA], x - 1, y, z), u),
+        lerp(grad(perm[AB], x, y - 1, z), grad(perm[BB], x - 1, y - 1, z), u),
+        v
+      ),
+      lerp(
+        lerp(grad(perm[AA + 1], x, y, z - 1), grad(perm[BA + 1], x - 1, y, z - 1), u),
+        lerp(grad(perm[AB + 1], x, y - 1, z - 1), grad(perm[BB + 1], x - 1, y - 1, z - 1), u),
+        v
+      ),
+      w
+    );
+  },
+  /**
+   * 2D Perlin noise (-1 to 1)
+   */
+  perlin2d: (x, y) => {
+    return noise.perlin3d(x, y, 0);
+  },
+  /**
+   * Fractal Brownian Motion (fBm)
+   */
+  fbm: (x, y, z, octaves = 6, lacunarity = 2, gain = 0.5) => {
+    let value = 0;
+    let amplitude = 1;
+    let frequency = 1;
+    let maxValue = 0;
+    for (let i = 0; i < octaves; i++) {
+      value += amplitude * noise.perlin3d(x * frequency, y * frequency, z * frequency);
+      maxValue += amplitude;
+      amplitude *= gain;
+      frequency *= lacunarity;
+    }
+    return value / maxValue;
+  },
+  /**
+   * Simplex-like noise (approximation using perlin)
+   */
+  simplex: (x, y) => {
+    return noise.perlin2d(x * 1.2, y * 1.2);
+  },
+  /**
+   * Worley/Cellular noise
+   */
+  worley: (x, y, z) => {
+    const xi = Math.floor(x);
+    const yi = Math.floor(y);
+    const zi = Math.floor(z);
+    let minDist = Infinity;
+    for (let i = -1; i <= 1; i++) {
+      for (let j = -1; j <= 1; j++) {
+        for (let k = -1; k <= 1; k++) {
+          const cellX = xi + i;
+          const cellY = yi + j;
+          const cellZ = zi + k;
+          const hash = perm[perm[perm[cellX & 255] + cellY & 255] + cellZ & 255];
+          const px = cellX + hash / 255;
+          const py = cellY + hash * 7 % 255 / 255;
+          const pz = cellZ + hash * 13 % 255 / 255;
+          const dist = (x - px) * (x - px) + (y - py) * (y - py) + (z - pz) * (z - pz);
+          minDist = Math.min(minDist, dist);
+        }
+      }
+    }
+    return Math.sqrt(minDist);
+  }
+};
+var random = {
+  /**
+   * Random float between 0 and 1
+   */
+  float: () => Math.random(),
+  /**
+   * Random float in range [min, max)
+   */
+  range: (min, max) => min + Math.random() * (max - min),
+  /**
+   * Random integer in range [min, max]
+   */
+  int: (min, max) => Math.floor(min + Math.random() * (max - min + 1)),
+  /**
+   * Random boolean with probability
+   */
+  bool: (probability = 0.5) => Math.random() < probability,
+  /**
+   * Random element from array
+   */
+  pick: (array) => array[Math.floor(Math.random() * array.length)],
+  /**
+   * Shuffle array (Fisher-Yates)
+   */
+  shuffle: (array) => {
+    const result = [...array];
+    for (let i = result.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [result[i], result[j]] = [result[j], result[i]];
+    }
+    return result;
+  },
+  /**
+   * Random Vec3 in unit sphere
+   */
+  insideUnitSphere: () => {
+    const theta = Math.random() * TAU;
+    const phi = Math.acos(2 * Math.random() - 1);
+    const r = Math.cbrt(Math.random());
+    return {
+      x: r * Math.sin(phi) * Math.cos(theta),
+      y: r * Math.sin(phi) * Math.sin(theta),
+      z: r * Math.cos(phi)
+    };
+  },
+  /**
+   * Random Vec3 on unit sphere surface
+   */
+  onUnitSphere: () => {
+    const theta = Math.random() * TAU;
+    const phi = Math.acos(2 * Math.random() - 1);
+    return {
+      x: Math.sin(phi) * Math.cos(theta),
+      y: Math.sin(phi) * Math.sin(theta),
+      z: Math.cos(phi)
+    };
+  },
+  /**
+   * Random Vec2 in unit circle
+   */
+  insideUnitCircle: () => {
+    const theta = Math.random() * TAU;
+    const r = Math.sqrt(Math.random());
+    return {
+      x: r * Math.cos(theta),
+      y: r * Math.sin(theta)
+    };
+  },
+  /**
+   * Seeded random number generator
+   */
+  seeded: (seed) => {
+    let s = seed;
+    return () => {
+      s = s * 1103515245 + 12345 & 2147483647;
+      return s / 2147483647;
+    };
+  }
+};
+
+export {
+  vec2,
+  vec3,
+  vec4,
+  quat,
+  transform,
+  rgb,
+  rgba,
+  hsl,
+  aabb,
+  ray,
+  vec3ToArray,
+  arrayToVec3,
+  quatToArray,
+  arrayToQuat,
+  parseColor,
+  colorToHex,
+  PI,
+  TAU,
+  HALF_PI,
+  DEG_TO_RAD,
+  RAD_TO_DEG,
+  EPSILON,
+  clamp,
+  lerp,
+  inverseLerp,
+  remap,
+  smoothstep,
+  smootherstep,
+  degToRad,
+  radToDeg,
+  mod,
+  fract,
+  sign,
+  step,
+  vec2Math,
+  vec3Math,
+  quatMath,
+  aabbMath,
+  noise,
+  random
+};
+//# sourceMappingURL=chunk-7HVUYGPS.js.map