@argila/core 0.0.0-alpha-20250607064138

package/dist/Canvas.js

@@ -0,0 +1,311 @@
+"use strict";
+import { v4 as uuidv4 } from "uuid";
+import Input from "./systems/Input";
+export default class Canvas {
+  static id = uuidv4();
+  static list = /* @__PURE__ */ new Map();
+  static resizeObserver = null;
+  /**
+   * Creates a new canvas configuration
+   * @param options Canvas configuration options
+   * @returns The created canvas configuration
+   * @throws Error if a canvas with the same ID already exists
+   */
+  static create(options) {
+    const element = options.element || document.createElement("canvas");
+    const ctx = element.getContext("2d", { alpha: true });
+    if (!ctx) {
+      throw new Error("Failed to get 2D context from canvas element");
+    }
+    const canvas = {
+      element,
+      ctx,
+      dpr: typeof window !== "undefined" ? window.devicePixelRatio || 1 : 1,
+      windowResizeCallback: () => {
+        Canvas.autoResize(options.id);
+      },
+      lastWidth: element.width,
+      clear: true,
+      width: 800,
+      height: 800,
+      autoHeight: true,
+      autoWidth: true,
+      lastHeight: element.height,
+      clearColor: "rgba(0, 0, 0, 0)",
+      isVisible: true,
+      ...options
+    };
+    if (Canvas.list.has(options.id)) {
+      throw Error(`Already exists a canvas with the id ${options.id}`);
+    }
+    Canvas.list.set(options.id, canvas);
+    Canvas.autoResize(options.id);
+    canvas.element.setAttribute("id", options.id);
+    canvas.lastWidth = canvas.width;
+    canvas.lastHeight = canvas.height;
+    if (canvas.autoWidth === true || canvas.autoHeight === true) {
+      if (typeof window !== "undefined") {
+        window.addEventListener("resize", canvas.windowResizeCallback);
+        if (typeof ResizeObserver !== "undefined" && !Canvas.resizeObserver) {
+          Canvas.resizeObserver = new ResizeObserver((entries) => {
+            for (const entry of entries) {
+              const canvasElement = entry.target;
+              const canvasId = canvasElement.getAttribute("id");
+              if (canvasId) {
+                Canvas.autoResize(canvasId);
+              }
+            }
+          });
+        }
+        if (Canvas.resizeObserver) {
+          Canvas.resizeObserver.observe(canvas.element);
+        }
+      }
+    }
+    canvas.element.addEventListener("webglcontextlost", (event) => {
+      event.preventDefault();
+      if (canvas.contextLostCallback) {
+        canvas.contextLostCallback(event);
+      }
+    });
+    canvas.element.addEventListener("webglcontextrestored", (event) => {
+      if (canvas.contextRestoredCallback) {
+        canvas.contextRestoredCallback(event);
+      }
+      Canvas.fixDPI(options.id);
+    });
+    Input.setupCanvasEventListeners(options.id);
+    return canvas;
+  }
+  /**
+   * Retrieves a canvas configuration by its ID
+   * @param id The canvas ID
+   * @returns The canvas configuration or undefined if not found
+   */
+  static get(id) {
+    return Canvas.list.get(id);
+  }
+  /**
+   * Updates canvas properties
+   * @param id The canvas ID
+   * @param options Options to update
+   */
+  static set(id, options) {
+    const canvas = Canvas.get(id);
+    if (canvas) {
+      Canvas.list.set(id, { ...canvas, ...options });
+      if (options.width !== void 0 || options.height !== void 0) {
+        Canvas.fixDPI(id);
+      }
+    }
+  }
+  /**
+   * Sets the clear color for a canvas
+   * @param id The canvas ID
+   * @param clearColor The color to set
+   */
+  static setClearColor(id, clearColor) {
+    const canvas = Canvas.get(id);
+    if (canvas) {
+      canvas.clearColor = clearColor;
+    }
+  }
+  /**
+   * Executes a callback for each canvas
+   * @param callback Function to execute for each canvas
+   */
+  static forEach(callback) {
+    Canvas.list.forEach((canvas) => {
+      callback(canvas);
+    });
+  }
+  /**
+   * Automatically resizes a canvas based on its parent element or window
+   * @param id The canvas ID
+   */
+  static autoResize(id) {
+    const canvas = Canvas.get(id);
+    if (!canvas) {
+      return;
+    }
+    const rootNode = canvas.element.getRootNode();
+    const shadowHost = rootNode instanceof ShadowRoot ? rootNode.host : null;
+    if (!canvas.element.parentElement && !shadowHost) {
+      if (canvas.autoWidth) {
+        canvas.width = typeof window !== "undefined" ? window.innerWidth : canvas.width;
+      }
+      if (canvas.autoHeight) {
+        canvas.height = typeof window !== "undefined" ? window.innerHeight : canvas.height;
+      }
+      Canvas.fixDPI(id);
+      return;
+    }
+    const parent = canvas.element.parentElement || shadowHost;
+    if (parent) {
+      const width = parent.offsetWidth;
+      const height = parent.offsetHeight;
+      let needsUpdate = false;
+      if (canvas.autoWidth && canvas.width !== width) {
+        canvas.width = width;
+        needsUpdate = true;
+      }
+      if (canvas.autoHeight && canvas.height !== height) {
+        canvas.height = height;
+        needsUpdate = true;
+      }
+      if (needsUpdate) {
+        Canvas.fixDPI(id);
+      }
+    }
+  }
+  /**
+   * Appends a canvas to a container
+   * @param id The canvas ID
+   * @param containerId The container ID or element
+   */
+  static append(id, containerId) {
+    const canvas = Canvas.get(id);
+    if (!canvas) {
+      return;
+    }
+    if (typeof containerId === "string") {
+      const container = document.getElementById(containerId);
+      if (container) {
+        container.appendChild(canvas.element);
+      } else {
+        console.warn(`Container with ID ${containerId} not found`);
+        return;
+      }
+    } else {
+      containerId.appendChild(canvas.element);
+    }
+    if (canvas.autoWidth === true || canvas.autoHeight === true) {
+      Canvas.autoResize(id);
+    }
+  }
+  /**
+   * Fixes the device pixel ratio for a canvas
+   * @param id The canvas ID
+   */
+  static fixDPI(id) {
+    const canvas = Canvas.get(id);
+    if (!canvas) {
+      return;
+    }
+    canvas.dpr = typeof window !== "undefined" ? window.devicePixelRatio || 1 : 1;
+    canvas.element.style.width = `${canvas.width}px`;
+    canvas.element.style.height = `${canvas.height}px`;
+    canvas.element.setAttribute(
+      "width",
+      (canvas.width * canvas.dpr).toString()
+    );
+    canvas.element.setAttribute(
+      "height",
+      (canvas.height * canvas.dpr).toString()
+    );
+    canvas.ctx.scale(canvas.dpr, canvas.dpr);
+  }
+  /**
+   * Handles canvas resize events
+   * @param id The canvas ID
+   */
+  static onResize(id) {
+    const canvas = Canvas.get(id);
+    if (!canvas) {
+      return;
+    }
+    if (canvas.lastWidth !== canvas.width || canvas.lastHeight !== canvas.height) {
+      canvas.lastWidth = canvas.width;
+      canvas.lastHeight = canvas.height;
+      if (canvas.onResize) {
+        canvas.onResize();
+      }
+    }
+  }
+  /**
+   * Destroys a canvas
+   * @param id The canvas ID
+   */
+  static destroy(id) {
+    const canvas = Canvas.get(id);
+    if (!canvas) {
+      return;
+    }
+    if (canvas.autoWidth === true || canvas.autoHeight === true) {
+      if (typeof window !== "undefined") {
+        window.removeEventListener("resize", canvas.windowResizeCallback);
+        if (Canvas.resizeObserver) {
+          Canvas.resizeObserver.unobserve(canvas.element);
+        }
+      }
+    }
+    if (canvas.element.parentElement) {
+      canvas.element.parentElement.removeChild(canvas.element);
+    }
+    Canvas.list.delete(id);
+  }
+  /**
+   * Clears all canvases
+   */
+  static clear() {
+    Canvas.list.forEach((canvas) => {
+      if (canvas.clear) {
+        canvas.ctx.clearRect(0, 0, canvas.width, canvas.height);
+      }
+      if (canvas.clearColor) {
+        canvas.ctx.fillStyle = canvas.clearColor;
+        canvas.ctx.fillRect(0, 0, canvas.width, canvas.height);
+      }
+    });
+  }
+  /**
+   * Destroys all canvases
+   */
+  static destroyAll() {
+    Canvas.list.forEach((canvas) => {
+      Canvas.destroy(canvas.id);
+    });
+    Canvas.list.clear();
+    if (Canvas.resizeObserver) {
+      Canvas.resizeObserver.disconnect();
+      Canvas.resizeObserver = null;
+    }
+  }
+  /**
+   * Checks if a canvas is visible in the viewport
+   * @param id The canvas ID
+   * @returns True if the canvas is visible
+   */
+  static isVisible(id) {
+    const canvas = Canvas.get(id);
+    if (!canvas) {
+      return false;
+    }
+    const rect = canvas.element.getBoundingClientRect();
+    return rect.top < window.innerHeight && rect.bottom > 0 && rect.left < window.innerWidth && rect.right > 0;
+  }
+  /**
+   * Updates visibility status for all canvases
+   */
+  static updateVisibility() {
+    Canvas.list.forEach((canvas, id) => {
+      canvas.isVisible = Canvas.isVisible(id);
+    });
+  }
+  /**
+   * Resizes a canvas to specific dimensions
+   * @param id The canvas ID
+   * @param width New width
+   * @param height New height
+   */
+  static resize(id, width, height) {
+    const canvas = Canvas.get(id);
+    if (!canvas) {
+      return;
+    }
+    canvas.width = width;
+    canvas.height = height;
+    Canvas.fixDPI(id);
+    Canvas.onResize(id);
+  }
+}

package/dist/Canvas.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Canvas.test.d.ts.map

package/dist/Canvas.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Canvas.test.d.ts","sourceRoot":"","sources":["../src/Canvas.test.ts"],"names":[],"mappings":""}

package/dist/Canvas.test.js

@@ -0,0 +1,311 @@
+"use strict";
+import {
+  describe,
+  it,
+  expect,
+  beforeEach,
+  afterEach,
+  beforeAll,
+  afterAll,
+  vi
+} from "vitest";
+import Canvas from "./Canvas";
+describe("Canvas", () => {
+  let canvasConfig;
+  const originalOffsetHeight = Object.getOwnPropertyDescriptor(
+    HTMLElement.prototype,
+    "offsetHeight"
+  );
+  const originalOffsetWidth = Object.getOwnPropertyDescriptor(
+    HTMLElement.prototype,
+    "offsetWidth"
+  );
+  beforeAll(() => {
+    Object.defineProperty(HTMLElement.prototype, "offsetHeight", {
+      configurable: true,
+      value: 800
+    });
+    Object.defineProperty(HTMLElement.prototype, "offsetWidth", {
+      configurable: true,
+      value: 600
+    });
+    Element.prototype.getBoundingClientRect = vi.fn(() => ({
+      top: 10,
+      right: 110,
+      bottom: 110,
+      left: 10,
+      width: 100,
+      height: 100,
+      x: 10,
+      y: 10,
+      toJSON: vi.fn()
+    }));
+    global.ResizeObserver = vi.fn().mockImplementation(() => ({
+      observe: vi.fn(),
+      unobserve: vi.fn(),
+      disconnect: vi.fn()
+    }));
+  });
+  beforeEach(() => {
+    vi.stubGlobal("innerWidth", 1024);
+    vi.stubGlobal("innerHeight", 768);
+  });
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+  afterAll(() => {
+    if (originalOffsetHeight) {
+      Object.defineProperty(
+        HTMLElement.prototype,
+        "offsetHeight",
+        originalOffsetHeight
+      );
+    }
+    if (originalOffsetWidth) {
+      Object.defineProperty(
+        HTMLElement.prototype,
+        "offsetWidth",
+        originalOffsetWidth
+      );
+    }
+  });
+  beforeEach(() => {
+    canvasConfig = {
+      id: "testCanvas",
+      width: 500,
+      height: 500,
+      autoWidth: false,
+      autoHeight: false,
+      clear: true,
+      clearColor: "#ffffff"
+    };
+  });
+  afterEach(() => {
+    Canvas.destroyAll();
+  });
+  it("should create a new canvas", () => {
+    const canvas = Canvas.create(canvasConfig);
+    expect(canvas).toBeDefined();
+    expect(Canvas.list.has(canvasConfig.id)).toBe(true);
+  });
+  it("should get an existing canvas by id", () => {
+    Canvas.create(canvasConfig);
+    const canvas = Canvas.get(canvasConfig.id);
+    expect(canvas).toBeDefined();
+    expect(canvas?.id).toBe(canvasConfig.id);
+  });
+  it("should set properties of an existing canvas", () => {
+    Canvas.create(canvasConfig);
+    Canvas.set(canvasConfig.id, { width: 600 });
+    const canvas = Canvas.get(canvasConfig.id);
+    expect(canvas?.width).toBe(600);
+  });
+  it("should set the clear color of an existing canvas", () => {
+    Canvas.create(canvasConfig);
+    Canvas.setClearColor(canvasConfig.id, "#000000");
+    const canvas = Canvas.get(canvasConfig.id);
+    expect(canvas?.clearColor).toBe("#000000");
+  });
+  it("should call the callback for each canvas", () => {
+    Canvas.create(canvasConfig);
+    const callback = vi.fn();
+    Canvas.forEach(callback);
+    expect(callback).toHaveBeenCalled();
+  });
+  it("should auto resize the canvas", () => {
+    canvasConfig.autoWidth = true;
+    canvasConfig.autoHeight = true;
+    Canvas.create(canvasConfig);
+    const canvas = Canvas.get(canvasConfig.id);
+    const parentElement = document.createElement("div");
+    document.body.appendChild(parentElement);
+    if (canvas?.element) {
+      parentElement.appendChild(canvas.element);
+    }
+    Canvas.autoResize(canvasConfig.id);
+    expect(canvas?.width).toBe(600);
+    expect(canvas?.height).toBe(800);
+  });
+  it("should append the canvas to a container", () => {
+    const container = document.createElement("div");
+    container.id = "container";
+    document.body.appendChild(container);
+    Canvas.create(canvasConfig);
+    Canvas.append(canvasConfig.id, "container");
+    const canvas = Canvas.get(canvasConfig.id);
+    expect(container.contains(canvas.element)).toBe(true);
+  });
+  it("should log warning when appending to non-existent container", () => {
+    const consoleSpy = vi.spyOn(console, "warn");
+    Canvas.create(canvasConfig);
+    Canvas.append(canvasConfig.id, "nonExistentContainer");
+    expect(consoleSpy).toHaveBeenCalledWith(
+      "Container with ID nonExistentContainer not found"
+    );
+  });
+  it("should fix the DPI of the canvas", () => {
+    Canvas.create(canvasConfig);
+    const canvas = Canvas.get(canvasConfig.id);
+    Canvas.fixDPI(canvasConfig.id);
+    if (canvas) {
+      expect(canvas.element.width).toBe(canvas.width * canvas.dpr);
+    }
+    if (canvas?.dpr !== void 0) {
+      expect(canvas.element.height).toBe(canvas.height * canvas.dpr);
+    }
+  });
+  it("should call onResize if dimensions change", () => {
+    const onResize = vi.fn();
+    canvasConfig.onResize = onResize;
+    Canvas.create(canvasConfig);
+    const canvas = Canvas.get(canvasConfig.id);
+    canvas.width = 600;
+    canvas.height = 600;
+    Canvas.onResize(canvasConfig.id);
+    expect(onResize).toHaveBeenCalled();
+  });
+  it("should destroy a canvas", () => {
+    Canvas.create(canvasConfig);
+    Canvas.destroy(canvasConfig.id);
+    expect(Canvas.list.has(canvasConfig.id)).toBe(false);
+  });
+  it("should clear all canvases", () => {
+    Canvas.create(canvasConfig);
+    const canvas = Canvas.get(canvasConfig.id);
+    Canvas.clear();
+    expect(canvas?.ctx.fillStyle).toBe(canvas?.clearColor);
+  });
+  it("should destroy all canvases", () => {
+    Canvas.create(canvasConfig);
+    Canvas.destroyAll();
+    expect(Canvas.list.size).toBe(0);
+  });
+  it("should not create a canvas with duplicate id", () => {
+    Canvas.create(canvasConfig);
+    expect(() => Canvas.create(canvasConfig)).toThrow(
+      `Already exists a canvas with the id ${canvasConfig.id}`
+    );
+  });
+  it("should not resize if autoWidth and autoHeight are false", () => {
+    canvasConfig.autoWidth = false;
+    canvasConfig.autoHeight = false;
+    Canvas.create(canvasConfig);
+    const canvas = Canvas.get(canvasConfig.id);
+    const initialWidth = canvas?.width;
+    const initialHeight = canvas?.height;
+    Canvas.autoResize(canvasConfig.id);
+    expect(canvas?.width).toBe(initialWidth);
+    expect(canvas?.height).toBe(initialHeight);
+  });
+  it("should not call onResize if dimensions do not change", () => {
+    const onResize = vi.fn();
+    canvasConfig.onResize = onResize;
+    Canvas.create(canvasConfig);
+    Canvas.onResize(canvasConfig.id);
+    expect(onResize).not.toHaveBeenCalled();
+  });
+  it("should remove canvas from DOM on destroy", () => {
+    Canvas.create(canvasConfig);
+    const canvas = Canvas.get(canvasConfig.id);
+    document.body.appendChild(canvas.element);
+    Canvas.destroy(canvasConfig.id);
+    expect(document.body.contains(canvas.element)).toBe(false);
+  });
+  it("should clear canvas with specified clear color", () => {
+    canvasConfig.clearColor = "#ff0000";
+    Canvas.create(canvasConfig);
+    const canvas = Canvas.get(canvasConfig.id);
+    Canvas.clear();
+    expect(canvas?.ctx.fillStyle).toBe(canvas?.clearColor);
+  });
+  it("should not clear canvas if clear is false", () => {
+    canvasConfig.clear = false;
+    Canvas.create(canvasConfig);
+    const canvas = Canvas.get(canvasConfig.id);
+    const clearRectSpy = vi.spyOn(canvas.ctx, "clearRect");
+    Canvas.clear();
+    expect(clearRectSpy).not.toHaveBeenCalled();
+  });
+  it("should handle window resize event", () => {
+    canvasConfig.autoWidth = true;
+    canvasConfig.autoHeight = true;
+    Canvas.create(canvasConfig);
+    const canvas = Canvas.get(canvasConfig.id);
+    window.dispatchEvent(new Event("resize"));
+    expect(canvas?.width).toBe(1024);
+    expect(canvas?.height).toBe(768);
+  });
+  it("should not throw error if trying to destroy non-existent canvas", () => {
+    expect(() => Canvas.destroy("nonExistentCanvas")).not.toThrow();
+  });
+  it("should not throw error if trying to get non-existent canvas", () => {
+    expect(Canvas.get("nonExistentCanvas")).toBeUndefined();
+  });
+  it("should not throw error if trying to set properties on non-existent canvas", () => {
+    expect(() => Canvas.set("nonExistentCanvas", { width: 600 })).not.toThrow();
+  });
+  it("should not throw error if trying to set clear color on non-existent canvas", () => {
+    expect(
+      () => Canvas.setClearColor("nonExistentCanvas", "#000000")
+    ).not.toThrow();
+  });
+  it("should not throw error if trying to append non-existent canvas", () => {
+    expect(() => Canvas.append("nonExistentCanvas", "container")).not.toThrow();
+  });
+  it("should not throw error if trying to fix DPI on non-existent canvas", () => {
+    expect(() => Canvas.fixDPI("nonExistentCanvas")).not.toThrow();
+  });
+  it("should not throw error if trying to call onResize on non-existent canvas", () => {
+    expect(() => Canvas.onResize("nonExistentCanvas")).not.toThrow();
+  });
+  it("should check if canvas is visible in viewport", () => {
+    Canvas.create(canvasConfig);
+    expect(Canvas.isVisible(canvasConfig.id)).toBe(true);
+  });
+  it("should update visibility status for all canvases", () => {
+    Canvas.create(canvasConfig);
+    Canvas.updateVisibility();
+    const canvas = Canvas.get(canvasConfig.id);
+    expect(canvas?.isVisible).toBe(true);
+  });
+  it("should resize canvas to specific dimensions", () => {
+    Canvas.create(canvasConfig);
+    Canvas.resize(canvasConfig.id, 800, 600);
+    const canvas = Canvas.get(canvasConfig.id);
+    expect(canvas?.width).toBe(800);
+    expect(canvas?.height).toBe(600);
+  });
+  it("should handle context loss and restoration", () => {
+    const contextLostCallback = vi.fn();
+    const contextRestoredCallback = vi.fn();
+    canvasConfig.contextLostCallback = contextLostCallback;
+    canvasConfig.contextRestoredCallback = contextRestoredCallback;
+    Canvas.create(canvasConfig);
+    const canvas = Canvas.get(canvasConfig.id);
+    canvas?.element.dispatchEvent(new Event("webglcontextlost"));
+    expect(contextLostCallback).toHaveBeenCalled();
+    canvas?.element.dispatchEvent(new Event("webglcontextrestored"));
+    expect(contextRestoredCallback).toHaveBeenCalled();
+  });
+  it("should throw an error if context cannot be created", () => {
+    const originalGetContext = HTMLCanvasElement.prototype.getContext;
+    HTMLCanvasElement.prototype.getContext = vi.fn().mockReturnValue(null);
+    expect(() => Canvas.create(canvasConfig)).toThrow(
+      "Failed to get 2D context from canvas element"
+    );
+    HTMLCanvasElement.prototype.getContext = originalGetContext;
+  });
+  it("should setup ResizeObserver if available", () => {
+    canvasConfig.autoWidth = true;
+    Canvas.create(canvasConfig);
+    expect(global.ResizeObserver).toHaveBeenCalled();
+  });
+  it("should update canvas when set() is called with width or height", () => {
+    Canvas.create(canvasConfig);
+    const fixDPISpy = vi.spyOn(Canvas, "fixDPI");
+    Canvas.set(canvasConfig.id, { width: 700 });
+    const canvas = Canvas.get(canvasConfig.id);
+    expect(fixDPISpy).toHaveBeenCalledWith(canvasConfig.id);
+    expect(canvas?.width).toBe(700);
+  });
+});

package/dist/Common.d.ts

@@ -0,0 +1,11 @@
+export declare function clamp(n: number, min: number, max: number): number;
+export declare function distance(ax: number, ay: number, bx: number, by: number): number;
+export declare function pair(x: number, y: number): number;
+export declare function unpairX(z: number): number;
+export declare function unpairY(z: number): number;
+export declare function degreesToRadians(degrees: number): number;
+export declare function radiansToDegrees(radians: number): number;
+export declare function angle(ax: number, ay: number, bx: number, by: number): number;
+export declare function random(min?: number, max?: number, skew?: number): number;
+export declare function randomInt(min: number, max: number): number;
+//# sourceMappingURL=Common.d.ts.map

package/dist/Common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Common.d.ts","sourceRoot":"","sources":["../src/Common.ts"],"names":[],"mappings":"AAAA,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAEjE;AAED,wBAAgB,QAAQ,CACtB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,GACT,MAAM,CAER;AAGD,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAIjD;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAKzC;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAKzC;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAI5E;AAGD,wBAAgB,MAAM,CACpB,GAAG,GAAE,MAAU,EACf,GAAG,GAAE,MAAU,EACf,IAAI,GAAE,MAAU,GACf,MAAM,CA2BR;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAE1D"}

package/dist/Common.js

@@ -0,0 +1,64 @@
+"use strict";
+export function clamp(n, min, max) {
+  return Math.min(Math.max(n, min), max);
+}
+export function distance(ax, ay, bx, by) {
+  return Math.hypot(bx - ax, by - ay);
+}
+export function pair(x, y) {
+  const xx = x >= 0 ? x * 2 : x * -2 - 1;
+  const yy = y >= 0 ? y * 2 : y * -2 - 1;
+  return xx >= yy ? xx * xx + xx + yy : yy * yy + xx;
+}
+export function unpairX(z) {
+  const sqrtz = Math.sqrt(z) >> 0;
+  const sqz = sqrtz * sqrtz;
+  const result1 = z - sqz >= sqrtz ? sqrtz : z - sqz;
+  return result1 % 2 === 0 ? result1 / 2 : (result1 + 1) / -2;
+}
+export function unpairY(z) {
+  const sqrtz = Math.sqrt(z) >> 0;
+  const sqz = sqrtz * sqrtz;
+  const result1 = z - sqz >= sqrtz ? z - sqz - sqrtz : sqrtz;
+  return result1 % 2 === 0 ? result1 / 2 : (result1 + 1) / -2;
+}
+export function degreesToRadians(degrees) {
+  return degrees * Math.PI / 180;
+}
+export function radiansToDegrees(radians) {
+  return radians * 180 / Math.PI;
+}
+export function angle(ax, ay, bx, by) {
+  const cy = by - ay;
+  const cx = bx - ax;
+  return Math.atan2(cy, cx);
+}
+export function random(min = 0, max = 1, skew = 1) {
+  if (min >= max) {
+    throw new Error("min must be less than max");
+  }
+  if (skew <= 0) {
+    throw new Error("skew must be greater than 0");
+  }
+  let u = 0;
+  let v = 0;
+  while (u === 0) {
+    u = crypto.getRandomValues(new Uint32Array(1))[0] / 4294967295;
+  }
+  while (v === 0) {
+    v = crypto.getRandomValues(new Uint32Array(1))[0] / 4294967295;
+  }
+  let num = Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
+  num = num / 10 + 0.5;
+  if (num > 1 || num < 0) {
+    return random(min, max, skew);
+  } else {
+    num = Math.pow(num, skew);
+    num *= max - min;
+    num += min;
+  }
+  return num;
+}
+export function randomInt(min, max) {
+  return Math.floor(random(min, max));
+}