@gitborlando/geo 4.1.1 → 5.1.0

package/dist/index.js

@@ -1,50 +1,20 @@
-// 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));
+    return Math.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)));
+    return Math.sin(_Angle.radianFy(angle));
   }
-  static asin(angle) {
-    return _Angle.angleFy(asin(_Angle.radianFy(angle)));
+  static cosSin(angle) {
+    const radians = _Angle.radianFy(angle);
+    return { cos: Math.cos(radians), sin: Math.sin(radians) };
   }
-  static atan(angle) {
-    return _Angle.angleFy(atan(_Angle.radianFy(angle)));
+  static tan(angle) {
+    return Math.tan(_Angle.radianFy(angle));
   }
   static atan2(y, x) {
-    return _Angle.angleFy(atan2(y, x));
+    return _Angle.angleFy(Math.atan2(y, x));
   }
   static angleFy(radians) {
     return radians * (180 / Math.PI);
@@ -53,176 +23,117 @@ var Angle = class _Angle {
     return angle * (Math.PI / 180);
   }
   static normal(angle) {
-    return (angle + 360) % 360;
+    return (angle % 360 + 360) % 360;
+  }
+  static minor(angle) {
+    return Math.min(angle, 360 - angle);
   }
   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
-    };
+  static sweep(v1, v2 = XY.xAxis(), clockwise = false) {
+    const dot = v1.x * v2.x + v1.y * v2.y;
+    const det = v1.x * v2.y - v1.y * v2.x;
+    return _Angle.normal(_Angle.atan2(det, dot) * (clockwise ? 1 : -1));
   }
 };
 
 // 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);
+    this.x = others.reduce((sum, cur) => sum + cur.x, this.x);
+    this.y = others.reduce((sum, cur) => sum + cur.y, this.y);
+    return this;
+  }
+  plusNum(num) {
+    this.x += num;
+    this.y += num;
+    return this;
   }
   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);
+    this.x = others.reduce((sum, cur) => sum - cur.x, this.x);
+    this.y = others.reduce((sum, cur) => sum - cur.y, this.y);
+    return this;
   }
   multiply(...numbers) {
     const n = numbers.reduce((a, b) => a * b, 1);
-    return _XY.of(this.x * n, this.y * n);
+    this.x *= n;
+    this.y *= n;
+    return this;
+  }
+  multiplyNum(num) {
+    this.x *= num;
+    this.y *= num;
+    return this;
   }
   divide(...numbers) {
     const n = numbers.reduce((a, b) => a * b, 1);
-    return _XY.of(this.x / n, this.y / n);
+    this.x /= n;
+    this.y /= n;
+    return this;
   }
   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);
+    const { cos, sin } = Angle.cosSin(rotation);
+    const dx = this.x - origin.x;
+    const dy = this.y - origin.y;
+    this.x = dx * cos - dy * sin + origin.x;
+    this.y = dx * sin + dy * cos + origin.y;
+    return this;
+  }
+  static $(x = 0, y = 0) {
+    return { x, 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);
+  static of(xy) {
+    return new _XY(xy.x, xy.y);
   }
-  getDot(another) {
-    return this.x * another.x + this.y * another.y;
+  static from(x, y) {
+    return new _XY(x, y);
   }
-  getDistance(another) {
-    return sqrt((this.x - another.x) ** 2 + (this.y - another.y) ** 2);
+  static center(wh) {
+    return new _XY(wh.width / 2, wh.height / 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 leftTop(e) {
+    return new _XY(e.left, e.top);
   }
-  static of(x, y) {
-    return new _XY(x, y);
+  static client(e) {
+    return new _XY(e.clientX, e.clientY);
   }
-  static from(xy) {
-    if (xy instanceof _XY) return xy;
-    return _XY.of(xy.x, xy.y);
+  static xAxis(rotation = 0) {
+    const { cos, sin } = Angle.cosSin(rotation);
+    return new _XY(cos, sin);
   }
-  static center(xy) {
-    return _XY.of(xy.centerX, xy.centerY);
+  static yAxis(rotation = 0) {
+    const { cos, sin } = Angle.cosSin(rotation);
+    return new _XY(-sin, cos);
   }
-  static leftTop(e) {
-    return _XY.of(e.left, e.top);
+  static dot(self, another) {
+    return self.x * another.x + self.y * another.y;
   }
-  static client(e) {
-    return _XY.of(e.clientX, e.clientY);
+  static distance(self, another) {
+    return Math.hypot(self.x - another.x, self.y - another.y);
   }
-  static tuple(arr) {
-    return _XY.of(arr[0], arr[1]);
+  static vector(self, another) {
+    return new _XY(self.x - another.x, self.y - another.y);
   }
-  static xAxis(rotation) {
-    return _XY.of(Angle.cos(rotation), Angle.sin(rotation));
+  static symmetric(self, origin = _XY.$()) {
+    return new _XY(2 * origin.x - self.x, 2 * origin.y - self.y);
   }
-  static yAxis(rotation) {
-    return _XY.of(-Angle.sin(rotation), Angle.cos(rotation));
+  static lerp(self, origin, t) {
+    const distance = _XY.distance(self, origin);
+    return new _XY(
+      self.x + (self.x - origin.x) * (t / distance),
+      self.y + (self.y - origin.y) * (t / distance)
+    );
   }
 };
 
@@ -252,6 +163,29 @@ var AABB = class _AABB {
       aabb.maxY - aabb.minY
     ];
   }
+  static update(aabb, minX, minY, maxX, maxY) {
+    aabb.minX = minX;
+    aabb.minY = minY;
+    aabb.maxX = maxX;
+    aabb.maxY = maxY;
+    return aabb;
+  }
+  static updateFromRect(aabb, rect) {
+    return _AABB.update(
+      aabb,
+      rect.x,
+      rect.y,
+      rect.x + rect.width,
+      rect.y + rect.height
+    );
+  }
+  static shift(aabb, delta) {
+    aabb.minX += delta.x;
+    aabb.minY += delta.y;
+    aabb.maxX += delta.x;
+    aabb.maxY += delta.y;
+    return aabb;
+  }
   static collide(one, another) {
     return one.minX <= another.maxX && one.maxX >= another.minX && one.minY <= another.maxY && one.maxY >= another.minY;
   }
@@ -280,19 +214,24 @@ var AABB = class _AABB {
       );
     }
   }
-  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);
-    });
+  static merge(aabbList) {
+    if (Array.isArray(aabbList)) {
+      if (aabbList.length === 0) return new _AABB(0, 0, 0, 0);
+    } else {
+      if (aabbList.size === 0) return new _AABB(0, 0, 0, 0);
+    }
+    let xMin = Infinity, yMin = Infinity, xMax = -Infinity, yMax = -Infinity;
+    for (const aabb of aabbList) {
+      xMin = Math.min(xMin, aabb.minX);
+      yMin = Math.min(yMin, aabb.minY);
+      xMax = Math.max(xMax, aabb.maxX);
+      yMax = Math.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));
+    const width = obb.projectAt(XY.$(1, 0));
+    const height = obb.projectAt(XY.$(0, 1));
     return new _AABB(
       obb.center.x - width / 2,
       obb.center.y - height / 2,
@@ -300,46 +239,25 @@ var AABB = class _AABB {
       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));
+  static updateFromOBB(aabb, obb) {
+    const width = obb.projectAt(XY.$(1, 0));
+    const height = obb.projectAt(XY.$(0, 1));
+    aabb.minX = obb.center.x - width / 2;
+    aabb.minY = obb.center.y - height / 2;
+    aabb.maxX = obb.center.x + width / 2;
+    aabb.maxY = obb.center.y + height / 2;
+    return aabb;
   }
 };
 
+// src/misc.ts
+function twoDecimal(number) {
+  return Number(number.toFixed(Number.isInteger(number) ? 0 : 2));
+}
+function minMax(val, min, max) {
+  return Math.min(Math.max(val, min), max);
+}
+
 // src/obb.ts
 var OBB = class _OBB {
   constructor(x, y, width, height, rotation) {
@@ -358,48 +276,47 @@ var OBB = class _OBB {
   aabb;
   vertexes;
   get xy() {
-    return xy_(this.x, this.y);
+    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);
+    const center = XY.center(this);
+    return center.rotate(this.xy, 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);
+    const { cos, sin } = Angle.cosSin(this.rotation);
+    const widthAxis = XY.$(cos, -sin);
+    const heightAxis = XY.$(sin, cos);
     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);
+    const cos = Angle.cos(this.rotation);
+    const sin = Angle.sin(this.rotation);
+    const cosWidth = cos * this.width;
+    const sinWidth = sin * this.width;
+    const cosHeight = cos * this.height;
+    const sinHeight = sin * 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) => {
+  projectAt = (anotherAxis) => {
     const { widthAxis, heightAxis } = this.axis;
-    return Math.abs(xy_dot(widthAxis, anotherAxis)) * this.width + Math.abs(xy_dot(heightAxis, anotherAxis)) * this.height;
+    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)))
+    const centerVector = XY.vector(this.center, another.center);
+    if (this.projectAt(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)))
+    if (this.projectAt(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)))
+    if (another.projectAt(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)))
+    if (another.projectAt(this.axis.heightAxis) + this.height <= 2 * Math.abs(XY.dot(centerVector, this.axis.heightAxis)))
       return false;
     return true;
   };
@@ -413,7 +330,7 @@ var OBB = class _OBB {
   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);
+    const xy = XY.from(dx, dy).rotate(center, rotation);
     return new _OBB(xy.x, xy.y, width, height, rotation);
   }
   static fromAABB(aabb) {
@@ -421,167 +338,11 @@ var OBB = class _OBB {
     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
+  minMax,
+  twoDecimal
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gitborlando/geo",
-  "version": "4.1.1",
+  "version": "5.1.0",
   "description": "",
   "type": "module",
   "exports": {