@argila/core 0.0.0-alpha-20250607064138

package/dist/Common.test.js

@@ -0,0 +1,118 @@
+"use strict";
+import { it, expect } from "vitest";
+import {
+  angle,
+  clamp,
+  degreesToRadians,
+  distance,
+  pair,
+  radiansToDegrees,
+  unpairX,
+  unpairY,
+  random
+} from "./Common";
+it("should clamp the number value", () => {
+  const valueA = clamp(10, 2, 6);
+  const valueB = clamp(-8, -6, -2);
+  expect(valueA).toBe(6);
+  expect(valueB).toBe(-6);
+});
+it("should calc the distance between two 2d vectors", () => {
+  const valueA = distance(100, 100, 100, 100);
+  const valueB = distance(100, 100, 300, 100);
+  expect(valueA).toBe(0);
+  expect(valueB).toBe(200);
+});
+it("should pair and unpair 2 numbers", () => {
+  const numberX = 10;
+  const numberY = 123;
+  const value = pair(numberX, numberY);
+  expect(unpairX(value)).toBe(numberX);
+  expect(unpairY(value)).toBe(numberY);
+});
+it("should pair and unpair two negative numbers", () => {
+  const numberX = -1230;
+  const numberY = -123;
+  const value = pair(numberX, numberY);
+  expect(unpairX(value)).toBe(numberX);
+  expect(unpairY(value)).toBe(numberY);
+});
+it("should convert degreesToRadians", () => {
+  const value = degreesToRadians(60);
+  expect(value).toBeCloseTo(1.0472);
+});
+it("should convert degreesToRadians", () => {
+  const value = radiansToDegrees(1.0472);
+  expect(value).toBeCloseTo(60);
+});
+it("should convert degreesToRadians", () => {
+  const value = radiansToDegrees(1.0472);
+  expect(value).toBeCloseTo(60);
+});
+it("should calc the angle between two 2d vectors", () => {
+  const value = angle(10, 10, 30, 100);
+  expect(value).toBeCloseTo(1.3522);
+});
+it("should generate a random number within the range", () => {
+  const min = 5;
+  const max = 10;
+  const value = random(min, max);
+  expect(value).toBeGreaterThanOrEqual(min);
+  expect(value).toBeLessThanOrEqual(max);
+});
+it("should resample if the random number is out of range", () => {
+  const min = 0;
+  const max = 1;
+  const skew = 1;
+  const spy = vi.spyOn(global.Math, "random").mockReturnValueOnce(1.1).mockReturnValueOnce(0.5);
+  const value = random(min, max, skew);
+  expect(value).toBeGreaterThanOrEqual(min);
+  expect(value).toBeLessThanOrEqual(max);
+  spy.mockRestore();
+});
+it("should generate a random number within the range with default skew", () => {
+  const min = 0;
+  const max = 1;
+  const value = random(min, max);
+  expect(value).toBeGreaterThanOrEqual(min);
+  expect(value).toBeLessThanOrEqual(max);
+});
+it("should generate a random number with skew", () => {
+  const min = 0;
+  const max = 1;
+  const skew = 2;
+  const value = random(min, max, skew);
+  expect(value).toBeGreaterThanOrEqual(min);
+  expect(value).toBeLessThanOrEqual(max);
+});
+it("should throw an error if min is greater than or equal to max", () => {
+  expect(() => random(10, 5)).toThrow("min must be less than max");
+  expect(() => random(5, 5)).toThrow("min must be less than max");
+});
+it("should throw an error if skew is less than or equal to 0", () => {
+  expect(() => random(0, 1, 0)).toThrow("skew must be greater than 0");
+  expect(() => random(0, 1, -1)).toThrow("skew must be greater than 0");
+});
+it("should generate a random number within the range with default skew", () => {
+  const min = 0;
+  const max = 1;
+  const value = random(min, max);
+  expect(value).toBeGreaterThanOrEqual(min);
+  expect(value).toBeLessThanOrEqual(max);
+});
+it("should generate a random number within the range with skew greater than 1", () => {
+  const min = 0;
+  const max = 1;
+  const skew = 3;
+  const value = random(min, max, skew);
+  expect(value).toBeGreaterThanOrEqual(min);
+  expect(value).toBeLessThanOrEqual(max);
+});
+it("should generate a random number within the range with skew less than 1", () => {
+  const min = 0;
+  const max = 1;
+  const skew = 0.5;
+  const value = random(min, max, skew);
+  expect(value).toBeGreaterThanOrEqual(min);
+  expect(value).toBeLessThanOrEqual(max);
+});

package/dist/Event.d.ts

@@ -0,0 +1,10 @@
+export default class Event<T> {
+    name: string;
+    listeners: Set<(arg: T) => void>;
+    constructor(name: string);
+    fire(arg: T): void;
+    on(callback: (arg: T) => void): void;
+    off(callback: (arg: T) => void): void;
+    destroy(): void;
+}
+//# sourceMappingURL=Event.d.ts.map

package/dist/Event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Event.d.ts","sourceRoot":"","sources":["../src/Event.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,OAAO,KAAK,CAAC,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,CAAC,CAAC;gBAErB,IAAI,EAAE,MAAM;IAKxB,IAAI,CAAC,GAAG,EAAE,CAAC,GAAG,IAAI;IAMlB,EAAE,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,GAAG,IAAI;IAIpC,GAAG,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,GAAG,IAAI;IAIrC,OAAO,IAAI,IAAI;CAGf"}

package/dist/Event.js

@@ -0,0 +1,23 @@
+"use strict";
+export default class Event {
+  name;
+  listeners;
+  constructor(name) {
+    this.name = name;
+    this.listeners = /* @__PURE__ */ new Set();
+  }
+  fire(arg) {
+    for (const callback of this.listeners) {
+      callback(arg);
+    }
+  }
+  on(callback) {
+    this.listeners.add(callback);
+  }
+  off(callback) {
+    this.listeners.delete(callback);
+  }
+  destroy() {
+    this.listeners.clear();
+  }
+}

package/dist/Event.test.js

@@ -0,0 +1,72 @@
+"use strict";
+import { describe, it, expect } from "vitest";
+import Event from "./Event";
+describe("listener register", () => {
+  const event = new Event("hit");
+  event.on(() => {
+  });
+  event.on(() => {
+  });
+  it("should register the 2 listeners", () => {
+    expect(event.listeners.size).toBe(2);
+  });
+});
+describe("listener remove", () => {
+  const event = new Event("hit");
+  let calledInsideEvent = "banana";
+  const handleEvent = () => {
+    calledInsideEvent = "apple";
+  };
+  const handleEventTwo = () => {
+    calledInsideEvent = "pineapple";
+  };
+  event.on(handleEvent);
+  event.on(handleEventTwo);
+  event.off(handleEventTwo);
+  event.fire({ health: 100 });
+  it("should remove 1 listener", () => {
+    expect(event.listeners.size).toBe(1);
+  });
+  it("should remove the right listener", () => {
+    expect(calledInsideEvent).toBe("apple");
+  });
+});
+describe("fire event", () => {
+  const event = new Event("hit");
+  let count = 0;
+  event.on(() => {
+    count++;
+  });
+  event.on(() => {
+    count++;
+  });
+  event.fire({ health: 100 });
+  let maxHealth = 0;
+  event.on((data) => {
+    maxHealth += data.health;
+  });
+  event.fire({ health: 100 });
+  event.fire({ health: 20 });
+  event.fire({ health: 30 });
+  it("should fire the event two times", () => {
+    expect(count).toBe(8);
+  });
+  it("should fire the event with data", () => {
+    expect(maxHealth).toBe(150);
+  });
+});
+describe("destroy", () => {
+  const event = new Event("hit");
+  event.on(() => {
+  });
+  event.on(() => {
+  });
+  event.on(() => {
+  });
+  event.on(() => {
+  });
+  event.destroy();
+  it("should destroy all listeners", () => {
+    expect(event.listeners.size).toBe(0);
+  });
+});

package/dist/LinkedList.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Represents a node in a linked list.
+ */
+export declare class LinkedNode<T> {
+    prev: LinkedNode<T> | null;
+    next: LinkedNode<T> | null;
+    data: T;
+    /**
+     * Creates a new LinkedNode.
+     * @param data - The data to store in the node.
+     */
+    constructor(data: T);
+}
+/**
+ * Represents a doubly linked list.
+ */
+export default class LinkedList<T> {
+    head: LinkedNode<T> | null;
+    tail: LinkedNode<T> | null;
+    length: number;
+    /**
+     * Adds a new node with the given data to the end of the list.
+     * @param data - The data to add to the list.
+     */
+    push(data: T): void;
+    /**
+     * Removes and returns the data from the last node in the list.
+     * @returns The data from the last node, or null if the list is empty.
+     */
+    pop(): T | null;
+    /**
+     * Removes the specified node from the list.
+     * @param node - The node to remove.
+     * @throws Will throw an error if the node is null or undefined.
+     */
+    remove(node: LinkedNode<T>): void;
+    /**
+     * Finds and returns the first node containing the specified data.
+     * @param data - The data to find in the list.
+     * @returns The node containing the data, or null if no such node exists.
+     */
+    find(data: T): LinkedNode<T> | null;
+}
+//# sourceMappingURL=LinkedList.d.ts.map

package/dist/LinkedList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LinkedList.d.ts","sourceRoot":"","sources":["../src/LinkedList.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,UAAU,CAAC,CAAC;IAEvB,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAQ;IAElC,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAQ;IAElC,IAAI,EAAE,CAAC,CAAC;IAER;;;OAGG;gBACS,IAAI,EAAE,CAAC;CAIpB;AAED;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,UAAU,CAAC,CAAC;IAE/B,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAQ;IAElC,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAQ;IAElC,MAAM,SAAK;IAEX;;;OAGG;IACH,IAAI,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI;IAkBnB;;;OAGG;IACH,GAAG,IAAI,CAAC,GAAG,IAAI;IAaf;;;;OAIG;IACH,MAAM,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI;IAwCjC;;;;OAIG;IACH,IAAI,CAAC,IAAI,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI;CAcpC"}

package/dist/LinkedList.js

@@ -0,0 +1,95 @@
+"use strict";
+export class LinkedNode {
+  // Previous node in the list
+  prev = null;
+  // Next node in the list
+  next = null;
+  // Data stored in the node
+  data;
+  /**
+   * Creates a new LinkedNode.
+   * @param data - The data to store in the node.
+   */
+  constructor(data) {
+    this.data = data;
+  }
+}
+export default class LinkedList {
+  // First node in the list
+  head = null;
+  // Last node in the list
+  tail = null;
+  // Number of nodes in the list
+  length = 0;
+  /**
+   * Adds a new node with the given data to the end of the list.
+   * @param data - The data to add to the list.
+   */
+  push(data) {
+    const node = new LinkedNode(data);
+    if (this.tail) {
+      node.prev = this.tail;
+      this.tail.next = node;
+      this.tail = node;
+    } else {
+      this.head = this.tail = node;
+    }
+    this.length++;
+  }
+  /**
+   * Removes and returns the data from the last node in the list.
+   * @returns The data from the last node, or null if the list is empty.
+   */
+  pop() {
+    if (!this.tail) {
+      return null;
+    }
+    const data = this.tail.data;
+    this.remove(this.tail);
+    return data;
+  }
+  /**
+   * Removes the specified node from the list.
+   * @param node - The node to remove.
+   * @throws Will throw an error if the node is null or undefined.
+   */
+  remove(node) {
+    if (!node) {
+      throw new Error("Node to be removed is null or undefined");
+    }
+    const prev = node.prev;
+    const next = node.next;
+    if (this.head === node) {
+      this.head = next;
+    }
+    if (this.tail === node) {
+      this.tail = prev;
+    }
+    if (prev) {
+      prev.next = next;
+    }
+    if (next) {
+      next.prev = prev;
+    }
+    if (this.length === 1) {
+      this.head = this.tail = null;
+    }
+    node.prev = node.next = null;
+    this.length--;
+  }
+  /**
+   * Finds and returns the first node containing the specified data.
+   * @param data - The data to find in the list.
+   * @returns The node containing the data, or null if no such node exists.
+   */
+  find(data) {
+    let current = this.head;
+    while (current) {
+      if (current.data === data) {
+        return current;
+      }
+      current = current.next;
+    }
+    return null;
+  }
+}

package/dist/LinkedList.test.d.ts

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

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

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

package/dist/LinkedList.test.js

@@ -0,0 +1,197 @@
+"use strict";
+import LinkedList, { LinkedNode } from "./LinkedList";
+describe("LinkedList", () => {
+  let list;
+  let node1;
+  let node2;
+  let node3;
+  beforeEach(() => {
+    list = new LinkedList();
+    node1 = new LinkedNode("node1");
+    node2 = new LinkedNode("node2");
+    node3 = new LinkedNode("node3");
+  });
+  test("push should add nodes to the list", () => {
+    list.push(node1.data);
+    expect(list.head?.data).toBe(node1.data);
+    expect(list.tail?.data).toBe(node1.data);
+    expect(list.length).toBe(1);
+    list.push(node2.data);
+    expect(list.head?.data).toBe(node1.data);
+    expect(list.tail?.data).toBe(node2.data);
+    expect(list.length).toBe(2);
+    list.push(node3.data);
+    expect(list.head?.data).toBe(node1.data);
+    expect(list.tail?.data).toBe(node3.data);
+    expect(list.length).toBe(3);
+  });
+  test("pop should remove the last node from the list", () => {
+    list.push(node1.data);
+    list.push(node2.data);
+    list.push(node3.data);
+    list.pop();
+    expect(list.tail?.data).toBe(node2.data);
+    expect(list.length).toBe(2);
+    list.pop();
+    expect(list.tail?.data).toBe(node1.data);
+    expect(list.length).toBe(1);
+    list.pop();
+    expect(list.tail).toBeNull();
+    expect(list.head).toBeNull();
+    expect(list.length).toBe(0);
+  });
+  test("remove should remove a specific node from the list", () => {
+    list.push(node1.data);
+    list.push(node2.data);
+    list.push(node3.data);
+    const nodeToRemove = list.find(node2.data);
+    if (nodeToRemove) {
+      list.remove(nodeToRemove);
+    }
+    expect(list.head?.data).toBe(node1.data);
+    expect(list.tail?.data).toBe(node3.data);
+    expect(list.length).toBe(2);
+    expect(list.head?.next?.data).toBe(node3.data);
+    expect(list.tail?.prev?.data).toBe(node1.data);
+    const nodeToRemove2 = list.find(node1.data);
+    if (nodeToRemove2) {
+      list.remove(nodeToRemove2);
+    }
+    expect(list.head?.data).toBe(node3.data);
+    expect(list.tail?.data).toBe(node3.data);
+    expect(list.length).toBe(1);
+    const nodeToRemove3 = list.find(node3.data);
+    if (nodeToRemove3) {
+      list.remove(nodeToRemove3);
+    }
+    expect(list.head).toBeNull();
+    expect(list.tail).toBeNull();
+    expect(list.length).toBe(0);
+  });
+  test("push should handle multiple nodes correctly", () => {
+    const nodes = Array.from(
+      { length: 1e3 },
+      (_, i) => new LinkedNode(`node${i}`)
+    );
+    nodes.forEach((node) => list.push(node.data));
+    expect(list.length).toBe(1e3);
+    expect(list.head?.data).toBe(nodes[0].data);
+    expect(list.tail?.data).toBe(nodes[999].data);
+  });
+  test("pop should handle multiple nodes correctly", () => {
+    const nodes = Array.from(
+      { length: 1e3 },
+      (_, i) => new LinkedNode(`node${i}`)
+    );
+    nodes.forEach((node) => list.push(node.data));
+    for (let i = 999; i >= 0; i--) {
+      list.pop();
+      expect(list.length).toBe(i);
+      if (i > 0) {
+        expect(list.tail?.data).toBe(nodes[i - 1].data);
+      } else {
+        expect(list.tail).toBeNull();
+        expect(list.head).toBeNull();
+      }
+    }
+  });
+  test("remove should handle multiple nodes correctly", () => {
+    const nodes = Array.from(
+      { length: 1e3 },
+      (_, i) => new LinkedNode(`node${i}`)
+    );
+    nodes.forEach((node) => list.push(node.data));
+    nodes.forEach((node, i) => {
+      const nodeToRemove = list.find(node.data);
+      if (nodeToRemove) {
+        list.remove(nodeToRemove);
+      }
+      expect(list.length).toBe(999 - i);
+      if (i < 999) {
+        expect(list.head?.data).toBe(nodes[i + 1].data);
+      } else {
+        expect(list.head).toBeNull();
+        expect(list.tail).toBeNull();
+      }
+    });
+  });
+  test("remove should handle head and tail correctly", () => {
+    list.push(node1.data);
+    list.push(node2.data);
+    list.push(node3.data);
+    const nodeToRemove = list.find(node1.data);
+    if (nodeToRemove) {
+      list.remove(nodeToRemove);
+    }
+    expect(list.head?.data).toBe(node2.data);
+    expect(list.tail?.data).toBe(node3.data);
+    expect(list.length).toBe(2);
+    const nodeToRemove2 = list.find(node3.data);
+    if (nodeToRemove2) {
+      list.remove(nodeToRemove2);
+    }
+    expect(list.head?.data).toBe(node2.data);
+    expect(list.tail?.data).toBe(node2.data);
+    expect(list.length).toBe(1);
+    const nodeToRemove3 = list.find(node2.data);
+    if (nodeToRemove3) {
+      list.remove(nodeToRemove3);
+    }
+    expect(list.head).toBeNull();
+    expect(list.tail).toBeNull();
+    expect(list.length).toBe(0);
+  });
+  test("push and pop should handle stress test", () => {
+    const nodes = Array.from(
+      { length: 1e4 },
+      (_, i) => new LinkedNode(`node${i}`)
+    );
+    nodes.forEach((node) => list.push(node.data));
+    expect(list.length).toBe(1e4);
+    nodes.forEach(() => list.pop());
+    expect(list.length).toBe(0);
+    expect(list.head).toBeNull();
+    expect(list.tail).toBeNull();
+  });
+  test("find should return the correct node", () => {
+    list.push(node1.data);
+    list.push(node2.data);
+    list.push(node3.data);
+    expect(list.find("node1")?.data).toBe("node1");
+    expect(list.find("node2")?.data).toBe("node2");
+    expect(list.find("node3")?.data).toBe("node3");
+    expect(list.find("nonexistent")).toBeNull();
+  });
+  test("remove should throw an error if node is null or undefined", () => {
+    expect(() => list.remove(null)).toThrow(
+      "Node to be removed is null or undefined"
+    );
+    expect(() => list.remove(void 0)).toThrow(
+      "Node to be removed is null or undefined"
+    );
+  });
+  test("pop should return the correct data", () => {
+    list.push(node1.data);
+    list.push(node2.data);
+    list.push(node3.data);
+    expect(list.pop()).toBe("node3");
+    expect(list.pop()).toBe("node2");
+    expect(list.pop()).toBe("node1");
+    expect(list.pop()).toBeNull();
+  });
+  test("find should handle an empty list", () => {
+    expect(list.find("node1")).toBeNull();
+  });
+  test("push should handle a single node", () => {
+    list.push(node1.data);
+    expect(list.head).toBe(list.tail);
+    expect(list.length).toBe(1);
+  });
+  test("pop should handle a single node", () => {
+    list.push(node1.data);
+    expect(list.pop()).toBe("node1");
+    expect(list.head).toBeNull();
+    expect(list.tail).toBeNull();
+    expect(list.length).toBe(0);
+  });
+});

package/dist/Vector3.d.ts

@@ -0,0 +1,104 @@
+interface IVector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+/**
+ * Class representing a 3D vector and operations on it.
+ */
+export default class Vector3 {
+    private static vectors;
+    private static vectorPool;
+    /**
+     * Creates a new vector and stores it in the map.
+     * @param entity - The entity identifier.
+     * @param x - The x component of the vector.
+     * @param y - The y component of the vector.
+     * @param z - The z component of the vector.
+     * @returns The unique ID of the created vector.
+     */
+    static create(entity: string, x: number, y: number, z: number): string;
+    /**
+     * Retrieves a vector by its entity identifier.
+     * @param entity - The entity identifier.
+     * @returns The vector associated with the entity, or undefined if not found.
+     */
+    static get(entity: string): IVector3 | undefined;
+    /**
+     * Validates if a vector exists.
+     * @param vector - The vector to validate.
+     * @throws Will throw an error if the vector is not found.
+     */
+    private static validateVector;
+    /**
+     * Sets the components of a vector.
+     * @param entity - The entity identifier.
+     * @param x - The new x component.
+     * @param y - The new y component.
+     * @param z - The new z component.
+     */
+    static set(entity: string, x: number, y: number, z: number): void;
+    /**
+     * Adds values to the components of a vector.
+     * @param entity - The entity identifier.
+     * @param x - The value to add to the x component.
+     * @param y - The value to add to the y component.
+     * @param z - The value to add to the z component.
+     */
+    static add(entity: string, x: number, y: number, z: number): void;
+    /**
+     * Subtracts values from the components of a vector.
+     * @param entity - The entity identifier.
+     * @param x - The value to subtract from the x component.
+     * @param y - The value to subtract from the y component.
+     * @param z - The value to subtract from the z component.
+     */
+    static subtract(entity: string, x: number, y: number, z: number): void;
+    /**
+     * Multiplies the components of a vector by given values.
+     * @param entity - The entity identifier.
+     * @param x - The value to multiply the x component by.
+     * @param y - The value to multiply the y component by.
+     * @param z - The value to multiply the z component by.
+     */
+    static multiply(entity: string, x: number, y: number, z: number): void;
+    /**
+     * Divides the components of a vector by given values.
+     * @param entity - The entity identifier.
+     * @param x - The value to divide the x component by.
+     * @param y - The value to divide the y component by.
+     * @param z - The value to divide the z component by.
+     * @throws Will throw an error if any of the values are zero.
+     */
+    static divide(entity: string, x: number, y: number, z: number): void;
+    /**
+     * Calculates the magnitude (length) of a vector.
+     * @param entity - The entity identifier.
+     * @returns The magnitude of the vector.
+     */
+    static magnitude(entity: string): number;
+    /**
+     * Normalizes the vector to have a magnitude of 1.
+     * @param entity - The entity identifier.
+     * @throws Will throw an error if the vector is a zero vector.
+     */
+    static normalize(entity: string): void;
+    /**
+     * Calculates the dot product of two vectors.
+     * @param entity1 - The first entity identifier.
+     * @param entity2 - The second entity identifier.
+     * @returns The dot product of the two vectors.
+     */
+    static dotProduct(entity1: string, entity2: string): number;
+    /**
+     * Removes a vector from the map and returns it to the pool.
+     * @param entity - The entity identifier.
+     */
+    static destroy(entity: string): void;
+    /**
+     * Clears all vectors from the map and returns them to the pool.
+     */
+    static clear(): void;
+}
+export {};
+//# sourceMappingURL=Vector3.d.ts.map

package/dist/Vector3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Vector3.d.ts","sourceRoot":"","sources":["../src/Vector3.ts"],"names":[],"mappings":"AAGA,UAAU,QAAQ;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,OAAO;IAE1B,OAAO,CAAC,MAAM,CAAC,OAAO,CAAgD;IAEtE,OAAO,CAAC,MAAM,CAAC,UAAU,CAA0C;IAEnE;;;;;;;OAOG;WACW,MAAM,CAClB,MAAM,EAAE,MAAM,EACd,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,MAAM;IAoBT;;;;OAIG;WACW,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS;IAKvD;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,cAAc;IAM7B;;;;;;OAMG;WACW,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IASxE;;;;;;OAMG;WACW,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IASxE;;;;;;OAMG;WACW,QAAQ,CACpB,MAAM,EAAE,MAAM,EACd,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,IAAI;IASP;;;;;;OAMG;WACW,QAAQ,CACpB,MAAM,EAAE,MAAM,EACd,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,IAAI;IASP;;;;;;;OAOG;WACW,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAa3E;;;;OAIG;WACW,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAW/C;;;;OAIG;WACW,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAc7C;;;;;OAKG;WACW,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM;IAalE;;;OAGG;WACW,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAQ3C;;OAEG;WACW,KAAK,IAAI,IAAI;CAM5B"}