@litecanvas/utils/dist/math.js

Utilities to help build litecanvas games

(() => {
  var __defProp = Object.defineProperty;
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };

  // src/_global.js
  globalThis.utils = globalThis.utils || {};
  globalThis.utils.global = (overrides = true) => {
    for (const key in globalThis.utils) {
      if ("global" === key) continue;
      if (overrides || globalThis[key] === void 0) {
        globalThis[key] = globalThis.utils[key];
      }
    }
  };

  // src/math/index.js
  var index_exports = {};
  __export(index_exports, {
    advance: () => advance_default,
    diff: () => diff_default,
    dist: () => dist_default,
    fract: () => fract_default,
    lerpAngle: () => lerp_angle_default,
    mag: () => mag_default,
    mean: () => mean_default,
    median: () => median_default,
    mod: () => mod_default,
    sum: () => sum_default,
    wave: () => wave_default
  });

  // src/math/diff.js
  var diff_default = (a, b) => Math.abs(b - a) || 0;

  // src/math/wave.js
  var wave_default = (lower, higher, t, fn = Math.sin) => lower + (fn(t) + 1) / 2 * (higher - lower);

  // src/math/fract.js
  var fract_default = (value) => value % 1 || 0;

  // src/vector/index.js
  var PI2 = 2 * Math.PI;

  // src/math/advance.js
  var advance_default = advance = (position, velocity, acceleration, deltaTime = 1) => {
    if (acceleration) {
      velocity.x += acceleration.x * deltaTime;
      velocity.y += acceleration.y * deltaTime;
    }
    position.x += velocity.x * deltaTime;
    position.y += velocity.y * deltaTime;
  };

  // src/math/mod.js
  var mod_default = (a, b) => (b + a % b) % b;

  // src/math/dist.js
  var dist_default = (x1, y1, x2, y2) => {
    return Math.hypot(x2 - x1, y2 - y1);
  };

  // src/math/mag.js
  var mag_default = (x, y) => {
    return Math.hypot(x, y);
  };

  // src/math/sum.js
  var sum_default = (values) => {
    let result = 0;
    for (let i = 0; i < values.length; i++) {
      result += values[i];
    }
    return result;
  };

  // src/math/mean.js
  var mean_default = (values) => {
    return sum_default(values) / values.length;
  };

  // src/math/median.js
  var median_default = (...values) => {
    const sorted = values.sort((a, b) => a - b);
    const middle = Math.floor(sorted.length / 2);
    if (sorted.length % 2 === 0) {
      return (sorted[middle - 1] + sorted[middle]) / 2;
    }
    return sorted[middle];
  };

  // src/math/lerp-angle.js
  var lerp_angle_default = (start, end, amount) => {
    let dif = (end - start) % 360;
    if (dif > 180) {
      dif -= 360;
    } else if (dif < -180) {
      dif += 360;
    }
    return start + dif * amount;
  };

  // src/math/_web.js
  globalThis.utils = Object.assign(globalThis.utils || {}, index_exports);
})();