@gitborlando/geo 4.1.0 → 4.1.1

package/dist/index.d.ts

@@ -0,0 +1,254 @@
+interface IXY {
+    x: number;
+    y: number;
+}
+interface IRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface IRectWithCenter extends IRect {
+    centerX: number;
+    centerY: number;
+}
+
+type IAxis = {
+    widthAxis: IXY;
+    heightAxis: IXY;
+};
+declare class OBB {
+    #private;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation: number;
+    center: IXY;
+    axis: IAxis;
+    aabb: AABB;
+    vertexes: [IXY, IXY, IXY, IXY];
+    constructor(x: number, y: number, width: number, height: number, rotation: number);
+    get xy(): {
+        x: number;
+        y: number;
+    };
+    calcVertexXY: () => [{
+        x: number;
+        y: number;
+    }, {
+        x: number;
+        y: number;
+    }, {
+        x: number;
+        y: number;
+    }, {
+        x: number;
+        y: number;
+    }];
+    clone: () => OBB;
+    projectionLengthAt: (anotherAxis: IXY) => number;
+    collide: (another: OBB) => boolean;
+    static identityOBB(): OBB;
+    static fromRect(rect: IRect, rotation?: number): OBB;
+    static fromCenter(center: IXY, width: number, height: number, rotation?: number): OBB;
+    static fromAABB(aabb: AABB): OBB;
+}
+
+declare class AABB {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    constructor(minX: number, minY: number, maxX: number, maxY: number);
+    static rect(aabb: AABB): IRectWithCenter;
+    static rectTuple(aabb: AABB): readonly [number, number, number, number];
+    static collide(one: AABB, another: AABB): boolean;
+    static include(one: AABB, another: AABB): number;
+    static extend(aabb: AABB, ...expands: [number] | [number, number, number, number]): AABB;
+    static merge(...aabbList: AABB[]): AABB;
+    static fromOBB(obb: OBB): AABB;
+}
+
+declare const PI: number;
+declare const cos: (x: number) => number;
+declare const sin: (x: number) => number;
+declare const tan: (x: number) => number;
+declare const acos: (x: number) => number;
+declare const asin: (x: number) => number;
+declare const atan: (x: number) => number;
+declare const atan2: (y: number, x: number) => number;
+declare class Angle {
+    static cos(angle: number): number;
+    static sin(angle: number): number;
+    static tan(angle: number): number;
+    static acos(angle: number): number;
+    static asin(angle: number): number;
+    static atan(angle: number): number;
+    static atan2(y: number, x: number): number;
+    static angleFy(radians: number): number;
+    static radianFy(angle: number): number;
+    static normal(angle: number): number;
+    static snap(angle: number, step?: number): number;
+    static rotatePoint(ax: number, ay: number, ox: number, oy: number, angle: number): {
+        x: number;
+        y: number;
+    };
+}
+
+declare const sqrt: (x: number) => number;
+declare const abs: (x: number) => number;
+declare const min: (...values: number[]) => number;
+declare const max: (...values: number[]) => number;
+declare const round: (x: number) => number;
+declare const floor: (x: number) => number;
+declare const ceil: (x: number) => number;
+declare const random: () => number;
+declare function pow2(number: number): number;
+declare function pow3(number: number): number;
+declare function multiply(...numbers: number[]): number;
+declare function divide(a: number, b: number): number;
+declare function numberHalfFix(number: number): number;
+declare function twoDecimal(number: number): number;
+
+type IMatrix = [number, number, number, number, number, number];
+declare class Matrix {
+    static create(): IMatrix;
+    static invert(matrix: IMatrix): IMatrix;
+    static applyPoint(xy: IXY, matrix: IMatrix): {
+        x: number;
+        y: number;
+    };
+    static applyAABB(aabb: AABB, matrix: IMatrix): {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+    static invertPoint(xy: IXY, matrix: IMatrix): {
+        x: number;
+        y: number;
+    };
+    static invertAABB(aabb: AABB, matrix: IMatrix): {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+}
+
+type Point = {
+    x: number;
+    y: number;
+};
+declare function simplify(points: readonly Point[], distance: number): Point[];
+declare function simplifyPoints(points: readonly Point[], start: number, end: number, epsilon: number, newPoints?: Point[]): Point[];
+declare function pointsOnBezierCurves(points: readonly Point[], tolerance?: number, distance?: number): Point[];
+
+declare function xy_(x?: number, y?: number): {
+    x: number;
+    y: number;
+};
+declare function xy_client(e: any): {
+    x: any;
+    y: any;
+};
+declare function xy_from(xy: IXY): {
+    x: number;
+    y: number;
+};
+declare function xy_center(xy: {
+    centerX: number;
+    centerY: number;
+}): {
+    x: number;
+    y: number;
+};
+declare function xy_mutate(self: IXY, another: IXY): void;
+declare function xy_plus(self: IXY, another: IXY): {
+    x: number;
+    y: number;
+};
+declare function xy_plus_mutate(self: IXY, another: IXY): void;
+declare function xy_plus_all(...xys: IXY[]): IXY;
+declare function xy_minus(self: IXY, another: IXY): {
+    x: number;
+    y: number;
+};
+declare function xy_minus_mutate(self: IXY, another: IXY): void;
+declare function xy_multiply(self: IXY, ...numbers: number[]): {
+    x: number;
+    y: number;
+};
+declare function xy_multiply_mutate(self: IXY, ...numbers: number[]): void;
+declare function xy_divide(self: IXY, ...numbers: number[]): {
+    x: number;
+    y: number;
+};
+declare function xy_distance(self: IXY, another?: IXY): number;
+declare function xy_rotate(self: IXY, origin: IXY, rotation: number): {
+    x: number;
+    y: number;
+};
+declare function xy_dot(self: IXY, another: IXY): number;
+declare function xy_symmetric(self: IXY, origin: IXY): {
+    x: number;
+    y: number;
+};
+declare function xy_opposite(self: IXY): {
+    x: number;
+    y: number;
+};
+declare function xy_getRotation(self: IXY, another: IXY, origin: IXY): number;
+declare function xy_toArray(self: IXY): [number, number];
+declare function xy_xAxis(rotation: number): {
+    x: number;
+    y: number;
+};
+declare function xy_yAxis(rotation: number): {
+    x: number;
+    y: number;
+};
+declare class XY {
+    x: number;
+    y: number;
+    constructor(x: number, y: number);
+    plain(): {
+        x: number;
+        y: number;
+    };
+    tuple(): readonly [number, number];
+    plus(...others: IXY[]): XY;
+    minus(...others: IXY[]): XY;
+    multiply(...numbers: number[]): XY;
+    divide(...numbers: number[]): XY;
+    rotate(origin: IXY, rotation: number): XY;
+    symmetric(origin: IXY): XY;
+    ratio(another: IXY, t: number): XY;
+    getDot(another: IXY): number;
+    getDistance(another: IXY): number;
+    getAngle(another: IXY, origin: IXY): number;
+    static _(x?: number, y?: number): {
+        x: number;
+        y: number;
+    };
+    static of(x: number, y: number): XY;
+    static from(xy: IXY): XY;
+    static center(xy: {
+        centerX: number;
+        centerY: number;
+    }): XY;
+    static leftTop(e: {
+        left: number;
+        top: number;
+    }): XY;
+    static client(e: {
+        clientX: number;
+        clientY: number;
+    }): XY;
+    static tuple(arr: [number, number]): XY;
+    static xAxis(rotation: number): XY;
+    static yAxis(rotation: number): XY;
+}
+
+export { AABB, Angle, type IMatrix, type IRect, type IRectWithCenter, type IXY, Matrix, OBB, PI, type Point, XY, abs, acos, asin, atan, atan2, ceil, cos, divide, floor, max, min, multiply, numberHalfFix, pointsOnBezierCurves, pow2, pow3, random, round, simplify, simplifyPoints, sin, sqrt, tan, twoDecimal, xy_, xy_center, xy_client, xy_distance, xy_divide, xy_dot, xy_from, xy_getRotation, xy_minus, xy_minus_mutate, xy_multiply, xy_multiply_mutate, xy_mutate, xy_opposite, xy_plus, xy_plus_all, xy_plus_mutate, xy_rotate, xy_symmetric, xy_toArray, xy_xAxis, xy_yAxis };

package/dist/index.js

@@ -0,0 +1,587 @@
+// src/math.ts
+var { sqrt, abs, min, max, round, floor, ceil, random } = Math;
+function pow2(number) {
+  return Math.pow(number, 2);
+}
+function pow3(number) {
+  return Math.pow(number, 3);
+}
+function multiply(...numbers) {
+  return numbers.reduce((i, all) => all *= i, 1);
+}
+function divide(a, b) {
+  return b === 0 ? 1 : a / b;
+}
+function numberHalfFix(number) {
+  const integerPart = ~~number;
+  const floatPart = number - integerPart;
+  const halfFixed = floatPart >= 0.75 ? 1 : floatPart >= 0.25 ? 0.5 : 0;
+  return integerPart + halfFixed;
+}
+function twoDecimal(number) {
+  return Number(number.toFixed(Number.isInteger(number) ? 0 : 2));
+}
+
+// src/angle.ts
+var { PI, cos, sin, tan, acos, asin, atan, atan2 } = Math;
+var Angle = class _Angle {
+  static cos(angle) {
+    return cos(_Angle.radianFy(angle));
+  }
+  static sin(angle) {
+    return sin(_Angle.radianFy(angle));
+  }
+  static tan(angle) {
+    return tan(_Angle.radianFy(angle));
+  }
+  static acos(angle) {
+    return _Angle.angleFy(acos(_Angle.radianFy(angle)));
+  }
+  static asin(angle) {
+    return _Angle.angleFy(asin(_Angle.radianFy(angle)));
+  }
+  static atan(angle) {
+    return _Angle.angleFy(atan(_Angle.radianFy(angle)));
+  }
+  static atan2(y, x) {
+    return _Angle.angleFy(atan2(y, x));
+  }
+  static angleFy(radians) {
+    return radians * (180 / Math.PI);
+  }
+  static radianFy(angle) {
+    return angle * (Math.PI / 180);
+  }
+  static normal(angle) {
+    return (angle + 360) % 360;
+  }
+  static snap(angle, step = 90) {
+    return _Angle.normal(Math.round(angle / step) * step);
+  }
+  static rotatePoint(ax, ay, ox, oy, angle) {
+    const radian = _Angle.radianFy(angle);
+    return {
+      x: (ax - ox) * cos(radian) - (ay - oy) * sin(radian) + ox,
+      y: (ax - ox) * sin(radian) + (ay - oy) * cos(radian) + oy
+    };
+  }
+};
+
+// src/xy.ts
+function xy_(x = 0, y = 0) {
+  return { x, y };
+}
+function xy_client(e) {
+  return { x: e.clientX, y: e.clientY };
+}
+function xy_from(xy) {
+  return { x: xy.x, y: xy.y };
+}
+function xy_center(xy) {
+  return { x: xy.centerX, y: xy.centerY };
+}
+function xy_mutate(self, another) {
+  self.x = another.x;
+  self.y = another.y;
+}
+function xy_plus(self, another) {
+  return { x: self.x + another.x, y: self.y + another.y };
+}
+function xy_plus_mutate(self, another) {
+  self.x = self.x + another.x;
+  self.y = self.y + another.y;
+}
+function xy_plus_all(...xys) {
+  return xys.reduce((a, b) => xy_plus(a, b));
+}
+function xy_minus(self, another) {
+  return { x: self.x - another.x, y: self.y - another.y };
+}
+function xy_minus_mutate(self, another) {
+  self.x = self.x - another.x;
+  self.y = self.y - another.y;
+}
+function xy_multiply(self, ...numbers) {
+  const n = numbers.reduce((a, b) => a * b, 1);
+  return { x: self.x * n, y: self.y * n };
+}
+function xy_multiply_mutate(self, ...numbers) {
+  const n = numbers.reduce((a, b) => a * b, 1);
+  self.x = self.x * n;
+  self.y = self.y * n;
+}
+function xy_divide(self, ...numbers) {
+  const n = numbers.reduce((a, b) => a * b, 1);
+  return { x: self.x / n, y: self.y / n };
+}
+function xy_distance(self, another = xy_(0, 0)) {
+  return Math.sqrt((self.x - another.x) ** 2 + (self.y - another.y) ** 2);
+}
+function xy_rotate(self, origin, rotation) {
+  if (rotation === 0) return self;
+  return Angle.rotatePoint(self.x, self.y, origin.x, origin.y, rotation);
+}
+function xy_dot(self, another) {
+  return self.x * another.x + self.y * another.y;
+}
+function xy_symmetric(self, origin) {
+  return { x: 2 * origin.x - self.x, y: 2 * origin.y - self.y };
+}
+function xy_opposite(self) {
+  return { x: -self.x, y: -self.y };
+}
+function xy_getRotation(self, another, origin) {
+  return Angle.angleFy(
+    Math.atan2(self.y - origin.y, self.x - origin.x) - Math.atan2(another.y - origin.y, another.x - origin.x)
+  );
+}
+function xy_toArray(self) {
+  return [self.x, self.y];
+}
+function xy_xAxis(rotation) {
+  return { x: Angle.cos(rotation), y: Angle.sin(rotation) };
+}
+function xy_yAxis(rotation) {
+  return { x: -Angle.sin(rotation), y: Angle.cos(rotation) };
+}
+var XY = class _XY {
+  constructor(x, y) {
+    this.x = x;
+    this.y = y;
+  }
+  plain() {
+    return { x: this.x, y: this.y };
+  }
+  tuple() {
+    return [this.x, this.y];
+  }
+  plus(...others) {
+    const x = others.reduce((sum, cur) => sum + cur.x, this.x);
+    const y = others.reduce((sum, cur) => sum + cur.y, this.y);
+    return _XY.of(x, y);
+  }
+  minus(...others) {
+    const x = others.reduce((sum, cur) => sum - cur.x, this.x);
+    const y = others.reduce((sum, cur) => sum - cur.y, this.y);
+    return _XY.of(x, y);
+  }
+  multiply(...numbers) {
+    const n = numbers.reduce((a, b) => a * b, 1);
+    return _XY.of(this.x * n, this.y * n);
+  }
+  divide(...numbers) {
+    const n = numbers.reduce((a, b) => a * b, 1);
+    return _XY.of(this.x / n, this.y / n);
+  }
+  rotate(origin, rotation) {
+    if (rotation === 0) return _XY.from(this);
+    return _XY.from(Angle.rotatePoint(this.x, this.y, origin.x, origin.y, rotation));
+  }
+  symmetric(origin) {
+    return _XY.of(2 * origin.x - this.x, 2 * origin.y - this.y);
+  }
+  ratio(another, t) {
+    const x = this.x + (another.x - this.x) * t;
+    const y = this.y + (another.y - this.y) * t;
+    return _XY.of(x, y);
+  }
+  getDot(another) {
+    return this.x * another.x + this.y * another.y;
+  }
+  getDistance(another) {
+    return sqrt((this.x - another.x) ** 2 + (this.y - another.y) ** 2);
+  }
+  getAngle(another, origin) {
+    return Angle.angleFy(
+      Math.atan2(this.y - origin.y, this.x - origin.x) - Math.atan2(another.y - origin.y, another.x - origin.x)
+    );
+  }
+  static _(x = 0, y = 0) {
+    return { x, y };
+  }
+  static of(x, y) {
+    return new _XY(x, y);
+  }
+  static from(xy) {
+    if (xy instanceof _XY) return xy;
+    return _XY.of(xy.x, xy.y);
+  }
+  static center(xy) {
+    return _XY.of(xy.centerX, xy.centerY);
+  }
+  static leftTop(e) {
+    return _XY.of(e.left, e.top);
+  }
+  static client(e) {
+    return _XY.of(e.clientX, e.clientY);
+  }
+  static tuple(arr) {
+    return _XY.of(arr[0], arr[1]);
+  }
+  static xAxis(rotation) {
+    return _XY.of(Angle.cos(rotation), Angle.sin(rotation));
+  }
+  static yAxis(rotation) {
+    return _XY.of(-Angle.sin(rotation), Angle.cos(rotation));
+  }
+};
+
+// src/aabb.ts
+var AABB = class _AABB {
+  constructor(minX, minY, maxX, maxY) {
+    this.minX = minX;
+    this.minY = minY;
+    this.maxX = maxX;
+    this.maxY = maxY;
+  }
+  static rect(aabb) {
+    return {
+      x: aabb.minX,
+      y: aabb.minY,
+      width: aabb.maxX - aabb.minX,
+      height: aabb.maxY - aabb.minY,
+      centerX: aabb.minX + (aabb.maxX - aabb.minX) / 2,
+      centerY: aabb.minY + (aabb.maxY - aabb.minY) / 2
+    };
+  }
+  static rectTuple(aabb) {
+    return [
+      aabb.minX,
+      aabb.minY,
+      aabb.maxX - aabb.minX,
+      aabb.maxY - aabb.minY
+    ];
+  }
+  static collide(one, another) {
+    return one.minX <= another.maxX && one.maxX >= another.minX && one.minY <= another.maxY && one.maxY >= another.minY;
+  }
+  static include(one, another) {
+    let result = 1;
+    let [large, small] = [one, another];
+    if (one.maxX - one.minX < another.maxX - another.minX) {
+      result = 0;
+      large = another;
+      small = one;
+    }
+    const included = large.minX <= small.minX && large.maxX >= small.maxX && large.minY <= small.minY && large.maxY >= small.maxY;
+    return included ? result : -1;
+  }
+  static extend(aabb, ...expands) {
+    const { minX, minY, maxX, maxY } = aabb;
+    if (expands.length === 1) {
+      const expand = expands[0];
+      return new _AABB(minX - expand, minY - expand, maxX + expand, maxY + expand);
+    } else {
+      return new _AABB(
+        minX - expands[0],
+        minY - expands[1],
+        maxX + expands[2],
+        maxY + expands[3]
+      );
+    }
+  }
+  static merge(...aabbList) {
+    let [xMin, yMin, xMax, yMax] = [Infinity, Infinity, -Infinity, -Infinity];
+    aabbList.forEach((aabb) => {
+      xMin = min(xMin, aabb.minX);
+      yMin = min(yMin, aabb.minY);
+      xMax = max(xMax, aabb.maxX);
+      yMax = max(yMax, aabb.maxY);
+    });
+    return new _AABB(xMin, yMin, xMax, yMax);
+  }
+  static fromOBB(obb) {
+    const width = obb.projectionLengthAt(XY._(1, 0));
+    const height = obb.projectionLengthAt(XY._(0, 1));
+    return new _AABB(
+      obb.center.x - width / 2,
+      obb.center.y - height / 2,
+      obb.center.x + width / 2,
+      obb.center.y + height / 2
+    );
+  }
+};
+
+// src/matrix.ts
+var Matrix = class _Matrix {
+  static create() {
+    return [1, 0, 0, 1, 0, 0];
+  }
+  static invert(matrix) {
+    const [a, b, c, d, e, f] = matrix;
+    const invDet = 1 / (a * d - b * c);
+    return [d, -b, -c, a, c * f - d * e, b * e - a * f].map(
+      (i) => i * invDet
+    );
+  }
+  static applyPoint(xy, matrix) {
+    const { x, y } = xy;
+    const [a, b, c, d, e, f] = matrix;
+    return xy_(a * x + c * y + e, b * x + d * y + f);
+  }
+  static applyAABB(aabb, matrix) {
+    const { minX, minY, maxX, maxY } = aabb;
+    const xy1 = _Matrix.applyPoint(xy_(minX, minY), matrix);
+    const xy2 = _Matrix.applyPoint(xy_(maxX, minY), matrix);
+    const xy3 = _Matrix.applyPoint(xy_(maxX, maxY), matrix);
+    const xy4 = _Matrix.applyPoint(xy_(minX, maxY), matrix);
+    return {
+      minX: min(xy1.x, xy2.x, xy3.x, xy4.x),
+      minY: min(xy1.y, xy2.y, xy3.y, xy4.y),
+      maxX: max(xy1.x, xy2.x, xy3.x, xy4.x),
+      maxY: max(xy1.y, xy2.y, xy3.y, xy4.y)
+    };
+  }
+  static invertPoint(xy, matrix) {
+    return _Matrix.applyPoint(xy, _Matrix.invert(matrix));
+  }
+  static invertAABB(aabb, matrix) {
+    return _Matrix.applyAABB(aabb, _Matrix.invert(matrix));
+  }
+};
+
+// src/obb.ts
+var OBB = class _OBB {
+  constructor(x, y, width, height, rotation) {
+    this.x = x;
+    this.y = y;
+    this.width = width;
+    this.height = height;
+    this.rotation = rotation;
+    this.center = this.#calcCenter();
+    this.axis = this.#calcAxis();
+    this.vertexes = this.calcVertexXY();
+    this.aabb = AABB.fromOBB(this);
+  }
+  center;
+  axis;
+  aabb;
+  vertexes;
+  get xy() {
+    return xy_(this.x, this.y);
+  }
+  #calcCenter = () => {
+    const center = xy_(this.x + this.width / 2, this.y + this.height / 2);
+    return xy_rotate(center, xy_(this.x, this.y), this.rotation);
+  };
+  #calcAxis = () => {
+    const cos2 = Angle.cos(this.rotation);
+    const sin2 = Angle.sin(this.rotation);
+    const widthAxis = xy_(cos2, -sin2);
+    const heightAxis = xy_(sin2, cos2);
+    return this.axis = { widthAxis, heightAxis };
+  };
+  calcVertexXY = () => {
+    const cos2 = Angle.cos(this.rotation);
+    const sin2 = Angle.sin(this.rotation);
+    const cosWidth = cos2 * this.width;
+    const sinWidth = sin2 * this.width;
+    const cosHeight = cos2 * this.height;
+    const sinHeight = sin2 * this.height;
+    const TL = xy_(this.x, this.y);
+    const TR = xy_(this.x + cosWidth, this.y + sinWidth);
+    const BR = xy_(this.x + cosWidth - sinHeight, this.y + sinWidth + cosHeight);
+    const BL = xy_(this.x - sinHeight, this.y + cosHeight);
+    return this.vertexes = [TL, TR, BR, BL];
+  };
+  clone = () => {
+    return new _OBB(this.x, this.y, this.width, this.height, this.rotation);
+  };
+  projectionLengthAt = (anotherAxis) => {
+    const { widthAxis, heightAxis } = this.axis;
+    return Math.abs(xy_dot(widthAxis, anotherAxis)) * this.width + Math.abs(xy_dot(heightAxis, anotherAxis)) * this.height;
+  };
+  collide = (another) => {
+    const centerVector = xy_minus(this.center, another.center);
+    if (this.projectionLengthAt(another.axis.widthAxis) + another.width <= 2 * Math.abs(xy_dot(centerVector, another.axis.widthAxis)))
+      return false;
+    if (this.projectionLengthAt(another.axis.heightAxis) + another.height <= 2 * Math.abs(xy_dot(centerVector, another.axis.heightAxis)))
+      return false;
+    if (another.projectionLengthAt(this.axis.widthAxis) + this.width <= 2 * Math.abs(xy_dot(centerVector, this.axis.widthAxis)))
+      return false;
+    if (another.projectionLengthAt(this.axis.heightAxis) + this.height <= 2 * Math.abs(xy_dot(centerVector, this.axis.heightAxis)))
+      return false;
+    return true;
+  };
+  static identityOBB() {
+    return new _OBB(0, 0, 0, 0, 0);
+  }
+  static fromRect(rect, rotation = 0) {
+    const { x, y, width, height } = rect;
+    return new _OBB(x, y, width, height, rotation);
+  }
+  static fromCenter(center, width, height, rotation = 0) {
+    const dx = center.x - width / 2;
+    const dy = center.y - height / 2;
+    const xy = XY.of(dx, dy).rotate(center, rotation);
+    return new _OBB(xy.x, xy.y, width, height, rotation);
+  }
+  static fromAABB(aabb) {
+    const { minX, minY, maxX, maxY } = aabb;
+    return new _OBB(minX, minY, maxX - minX, maxY - minY, 0);
+  }
+};
+
+// src/points-of-bezier.ts
+function distance(p1, p2) {
+  return Math.sqrt(distanceSq(p1, p2));
+}
+function distanceSq(p1, p2) {
+  return Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2);
+}
+function distanceToSegmentSq(p, v, w) {
+  const l2 = distanceSq(v, w);
+  if (l2 === 0) {
+    return distanceSq(p, v);
+  }
+  let t = ((p.x - v.x) * (w.x - v.x) + (p.y - v.y) * (w.y - v.y)) / l2;
+  t = Math.max(0, Math.min(1, t));
+  return distanceSq(p, lerp(v, w, t));
+}
+function lerp(a, b, t) {
+  return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };
+}
+function flatness(points, offset) {
+  const p1 = points[offset + 0];
+  const p2 = points[offset + 1];
+  const p3 = points[offset + 2];
+  const p4 = points[offset + 3];
+  let ux = 3 * p2.x - 2 * p1.x - p4.x;
+  ux *= ux;
+  let uy = 3 * p2.y - 2 * p1.y - p4.y;
+  uy *= uy;
+  let vx = 3 * p3.x - 2 * p4.x - p1.x;
+  vx *= vx;
+  let vy = 3 * p3.y - 2 * p4.y - p1.y;
+  vy *= vy;
+  if (ux < vx) {
+    ux = vx;
+  }
+  if (uy < vy) {
+    uy = vy;
+  }
+  return ux + uy;
+}
+function getPointsOnBezierCurveWithSplitting(points, offset, tolerance, newPoints) {
+  const outPoints = newPoints || [];
+  if (flatness(points, offset) < tolerance) {
+    const p0 = points[offset + 0];
+    if (outPoints.length) {
+      const d = distance(outPoints[outPoints.length - 1], p0);
+      if (d > 1) {
+        outPoints.push(p0);
+      }
+    } else {
+      outPoints.push(p0);
+    }
+    outPoints.push(points[offset + 3]);
+  } else {
+    const t = 0.5;
+    const p1 = points[offset + 0];
+    const p2 = points[offset + 1];
+    const p3 = points[offset + 2];
+    const p4 = points[offset + 3];
+    const q1 = lerp(p1, p2, t);
+    const q2 = lerp(p2, p3, t);
+    const q3 = lerp(p3, p4, t);
+    const r1 = lerp(q1, q2, t);
+    const r2 = lerp(q2, q3, t);
+    const red = lerp(r1, r2, t);
+    getPointsOnBezierCurveWithSplitting([p1, q1, r1, red], 0, tolerance, outPoints);
+    getPointsOnBezierCurveWithSplitting([red, r2, q3, p4], 0, tolerance, outPoints);
+  }
+  return outPoints;
+}
+function simplify(points, distance2) {
+  return simplifyPoints(points, 0, points.length, distance2);
+}
+function simplifyPoints(points, start, end, epsilon, newPoints) {
+  const outPoints = newPoints || [];
+  const s = points[start];
+  const e = points[end - 1];
+  let maxDistSq = 0;
+  let maxNdx = 1;
+  for (let i = start + 1; i < end - 1; ++i) {
+    const distSq = distanceToSegmentSq(points[i], s, e);
+    if (distSq > maxDistSq) {
+      maxDistSq = distSq;
+      maxNdx = i;
+    }
+  }
+  if (Math.sqrt(maxDistSq) > epsilon) {
+    simplifyPoints(points, start, maxNdx + 1, epsilon, outPoints);
+    simplifyPoints(points, maxNdx, end, epsilon, outPoints);
+  } else {
+    if (!outPoints.length) {
+      outPoints.push(s);
+    }
+    outPoints.push(e);
+  }
+  return outPoints;
+}
+function pointsOnBezierCurves(points, tolerance = 0.15, distance2) {
+  const newPoints = [];
+  const numSegments = (points.length - 1) / 3;
+  for (let i = 0; i < numSegments; i++) {
+    const offset = i * 3;
+    getPointsOnBezierCurveWithSplitting(points, offset, tolerance, newPoints);
+  }
+  if (distance2 && distance2 > 0) {
+    return simplifyPoints(newPoints, 0, newPoints.length, distance2);
+  }
+  return newPoints;
+}
+export {
+  AABB,
+  Angle,
+  Matrix,
+  OBB,
+  PI,
+  XY,
+  abs,
+  acos,
+  asin,
+  atan,
+  atan2,
+  ceil,
+  cos,
+  divide,
+  floor,
+  max,
+  min,
+  multiply,
+  numberHalfFix,
+  pointsOnBezierCurves,
+  pow2,
+  pow3,
+  random,
+  round,
+  simplify,
+  simplifyPoints,
+  sin,
+  sqrt,
+  tan,
+  twoDecimal,
+  xy_,
+  xy_center,
+  xy_client,
+  xy_distance,
+  xy_divide,
+  xy_dot,
+  xy_from,
+  xy_getRotation,
+  xy_minus,
+  xy_minus_mutate,
+  xy_multiply,
+  xy_multiply_mutate,
+  xy_mutate,
+  xy_opposite,
+  xy_plus,
+  xy_plus_all,
+  xy_plus_mutate,
+  xy_rotate,
+  xy_symmetric,
+  xy_toArray,
+  xy_xAxis,
+  xy_yAxis
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gitborlando/geo",
-  "version": "4.1.0",
+  "version": "4.1.1",
   "description": "",
   "type": "module",
   "exports": {
@@ -9,6 +9,10 @@
       "types": "./dist/index.d.ts"
     }
   },
+  "files": [
+    "dist",
+    "src"
+  ],
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"

package/.github/workflows/publish.yml

@@ -1,36 +0,0 @@
-name: 发布包
-
-on:
-  push:
-    branches:
-      - main
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: 检出代码
-        uses: actions/checkout@v4
-
-      - name: 设置 Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-          registry-url: 'https://registry.npmjs.org'
-
-      - name: 安装 pnpm
-        uses: pnpm/action-setup@v2
-        with:
-          version: 8
-
-      - name: 安装依赖
-        run: pnpm install
-
-      - name: 构建项目
-        run: pnpm build
-
-      - name: 发布到 npm
-        run: pnpm publish --no-git-checks
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.github/workflows/release.yml.txt

@@ -1,44 +0,0 @@
-name: Release
-
-on:
-  push:
-    branches:
-      - main
-
-jobs:
-  release:
-    name: Release
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: 20
-
-      - name: Setup PNPM
-        uses: pnpm/action-setup@v2
-        with:
-          version: 8
-
-      - name: Install Dependencies
-        run: pnpm install
-
-      # 添加构建步骤
-      - name: Build Packages
-        run: pnpm build
-
-      - name: Create Release Pull Request or Publish
-        id: changeset
-        uses: changesets/action@v1
-        with:
-          publish: pnpm changeset publish
-          commit: 'chore: version packages'
-          title: 'chore: version packages'
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.husky/pre-commit

@@ -1,3 +0,0 @@
-#!/usr/bin/env sh
-
-npx pretty-quick --staged

package/.vscode/settings.json

@@ -1,3 +0,0 @@
-{
-  "cSpell.words": ["aabb"]
-}

package/tsconfig.json

@@ -1,31 +0,0 @@
-{
-  "compilerOptions": {
-    "baseUrl": "./",
-    "target": "ESNext",
-    "useDefineForClassFields": true,
-    "lib": ["ESNext", "DOM", "DOM.Iterable"],
-    "module": "ESNext",
-    "skipLibCheck": true,
-    /* Bundler mode */
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true,
-    "isolatedModules": true,
-    "moduleDetection": "force",
-    "noEmit": true,
-    "jsx": "react-jsx",
-    /* Linting */
-    "strict": true,
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "noFallthroughCasesInSwitch": false
-  },
-  "include": [
-    "packages",
-    "src",
-    "tsup.config.ts",
-    "vitest.config.ts",
-    "src/__test__"
-  ]
-}

package/tsup.config.ts

@@ -1,10 +0,0 @@
-import { defineConfig } from 'tsup'
-
-export default defineConfig({
-  entry: ['src/index.ts'],
-  outDir: 'dist',
-  format: ['esm'],
-  dts: true,
-  splitting: true,
-  clean: true,
-})

package/vitest.config.ts

@@ -1,8 +0,0 @@
-import { defineConfig } from 'vitest/config'
-
-export default defineConfig({
-  test: {
-    environment: 'node',
-    globals: true,
-  },
-})