@gitborlando/geo 4.1.0 → 5.1.0

package/src/obb.ts

@@ -1,7 +1,7 @@
 import { AABB } from './aabb'
 import { Angle } from './angle'
 import { IRect, IXY } from './types'
-import { XY, xy_, xy_dot, xy_minus, xy_rotate } from './xy'
+import { XY } from './xy'
 
 type IAxis = { widthAxis: IXY; heightAxis: IXY }
 
@@ -25,19 +25,18 @@ export class OBB {
   }
 
   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 cos = Angle.cos(this.rotation)
-    const sin = Angle.sin(this.rotation)
-    const widthAxis = xy_(cos, -sin)
-    const heightAxis = xy_(sin, cos)
+    const { cos, sin } = Angle.cosSin(this.rotation)
+    const widthAxis = XY.$(cos, -sin)
+    const heightAxis = XY.$(sin, cos)
     return (this.axis = { widthAxis, heightAxis })
   }
 
@@ -48,10 +47,10 @@ export class OBB {
     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)
+    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])
   }
 
@@ -59,34 +58,34 @@ export class OBB {
     return new OBB(this.x, this.y, this.width, this.height, this.rotation)
   }
 
-  projectionLengthAt = (anotherAxis: IXY) => {
+  projectAt = (anotherAxis: IXY) => {
     const { widthAxis, heightAxis } = this.axis
     return (
-      Math.abs(xy_dot(widthAxis, anotherAxis)) * this.width +
-      Math.abs(xy_dot(heightAxis, anotherAxis)) * this.height
+      Math.abs(XY.dot(widthAxis, anotherAxis)) * this.width +
+      Math.abs(XY.dot(heightAxis, anotherAxis)) * this.height
     )
   }
 
   collide = (another: OBB) => {
-    const centerVector = xy_minus(this.center, another.center)
+    const centerVector = XY.vector(this.center, another.center)
     if (
-      this.projectionLengthAt(another.axis.widthAxis) + another.width <=
-      2 * Math.abs(xy_dot(centerVector, another.axis.widthAxis))
+      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))
+      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))
+      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))
+      another.projectAt(this.axis.heightAxis) + this.height <=
+      2 * Math.abs(XY.dot(centerVector, this.axis.heightAxis))
     )
       return false
     return true
@@ -104,7 +103,7 @@ export class OBB {
   static fromCenter(center: IXY, width: number, height: number, 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)
   }
 

package/src/xy.ts

@@ -1,108 +1,13 @@
 import { Angle } from './angle'
-import { sqrt } from './math'
 import { IXY } from './types'
 
-export function xy_(x: number = 0, y: number = 0) {
-  return { x, y }
-}
-
-export function xy_client(e: any) {
-  return { x: e.clientX, y: e.clientY }
-}
-
-export function xy_from(xy: IXY) {
-  return { x: xy.x, y: xy.y }
-}
-
-export function xy_center(xy: { centerX: number; centerY: number }) {
-  return { x: xy.centerX, y: xy.centerY }
-}
-
-export function xy_mutate(self: IXY, another: IXY) {
-  self.x = another.x
-  self.y = another.y
-}
-
-export function xy_plus(self: IXY, another: IXY) {
-  return { x: self.x + another.x, y: self.y + another.y }
-}
-export function xy_plus_mutate(self: IXY, another: IXY) {
-  self.x = self.x + another.x
-  self.y = self.y + another.y
-}
-export function xy_plus_all(...xys: IXY[]) {
-  return xys.reduce((a, b) => xy_plus(a, b))
-}
-
-export function xy_minus(self: IXY, another: IXY) {
-  return { x: self.x - another.x, y: self.y - another.y }
-}
-export function xy_minus_mutate(self: IXY, another: IXY) {
-  self.x = self.x - another.x
-  self.y = self.y - another.y
-}
-
-export function xy_multiply(self: IXY, ...numbers: number[]) {
-  const n = numbers.reduce((a, b) => a * b, 1)
-  return { x: self.x * n, y: self.y * n }
-}
-export function xy_multiply_mutate(self: IXY, ...numbers: number[]) {
-  const n = numbers.reduce((a, b) => a * b, 1)
-  self.x = self.x * n
-  self.y = self.y * n
-}
-
-export function xy_divide(self: IXY, ...numbers: number[]) {
-  const n = numbers.reduce((a, b) => a * b, 1)
-  return { x: self.x / n, y: self.y / n }
-}
-
-export function xy_distance(self: IXY, another: IXY = xy_(0, 0)) {
-  return Math.sqrt((self.x - another.x) ** 2 + (self.y - another.y) ** 2)
-}
-
-export function xy_rotate(self: IXY, origin: IXY, rotation: number) {
-  if (rotation === 0) return self
-  return Angle.rotatePoint(self.x, self.y, origin.x, origin.y, rotation)
-}
-
-export function xy_dot(self: IXY, another: IXY) {
-  return self.x * another.x + self.y * another.y
-}
-
-export function xy_symmetric(self: IXY, origin: IXY) {
-  return { x: 2 * origin.x - self.x, y: 2 * origin.y - self.y }
-}
-
-export function xy_opposite(self: IXY) {
-  return { x: -self.x, y: -self.y }
-}
-
-export function xy_getRotation(self: IXY, another: IXY, origin: IXY) {
-  return Angle.angleFy(
-    Math.atan2(self.y - origin.y, self.x - origin.x) -
-      Math.atan2(another.y - origin.y, another.x - origin.x),
-  )
-}
-
-export function xy_toArray(self: IXY) {
-  return [self.x, self.y] as [number, number]
-}
-
-export function xy_xAxis(rotation: number) {
-  return { x: Angle.cos(rotation), y: Angle.sin(rotation) }
-}
-
-export function xy_yAxis(rotation: number) {
-  return { x: -Angle.sin(rotation), y: Angle.cos(rotation) }
-}
-
 export class XY {
   constructor(
     public x: number,
     public y: number,
   ) {}
-  plain() {
+
+  $() {
     return { x: this.x, y: this.y }
   }
 
@@ -111,91 +16,107 @@ export class XY {
   }
 
   plus(...others: IXY[]) {
-    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: number) {
+    this.x += num
+    this.y += num
+    return this
   }
 
   minus(...others: IXY[]) {
-    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: number[]) {
     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: number) {
+    this.x *= num
+    this.y *= num
+    return this
   }
 
   divide(...numbers: number[]) {
     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: IXY, rotation: number) {
-    if (rotation === 0) return XY.from(this)
-    return XY.from(Angle.rotatePoint(this.x, this.y, origin.x, origin.y, rotation))
-  }
-
-  symmetric(origin: IXY) {
-    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
   }
 
-  ratio(another: IXY, t: number) {
-    const x = this.x + (another.x - this.x) * t
-    const y = this.y + (another.y - this.y) * t
-    return XY.of(x, y)
+  static $(x = 0, y = 0) {
+    return { x, y }
   }
 
-  getDot(another: IXY) {
-    return this.x * another.x + this.y * another.y
+  static of(xy: IXY) {
+    return new XY(xy.x, xy.y)
   }
 
-  getDistance(another: IXY) {
-    return sqrt((this.x - another.x) ** 2 + (this.y - another.y) ** 2)
+  static from(x: number, y: number) {
+    return new XY(x, y)
   }
 
-  getAngle(another: IXY, origin: IXY) {
-    return Angle.angleFy(
-      Math.atan2(this.y - origin.y, this.x - origin.x) -
-        Math.atan2(another.y - origin.y, another.x - origin.x),
-    )
+  static center(wh: { width: number; height: number }) {
+    return new XY(wh.width / 2, wh.height / 2)
   }
 
-  static _(x: number = 0, y: number = 0) {
-    return { x, y }
+  static leftTop(e: { left: number; top: number }) {
+    return new XY(e.left, e.top)
   }
 
-  static of(x: number, y: number) {
-    return new XY(x, y)
+  static client(e: { clientX: number; clientY: number }) {
+    return new XY(e.clientX, e.clientY)
   }
 
-  static from(xy: IXY) {
-    if (xy instanceof XY) return xy
-    return XY.of(xy.x, xy.y)
+  static xAxis(rotation: number = 0) {
+    const { cos, sin } = Angle.cosSin(rotation)
+    return new XY(cos, sin)
   }
 
-  static center(xy: { centerX: number; centerY: number }) {
-    return XY.of(xy.centerX, xy.centerY)
+  static yAxis(rotation: number = 0) {
+    const { cos, sin } = Angle.cosSin(rotation)
+    return new XY(-sin, cos)
   }
 
-  static leftTop(e: { left: number; top: number }) {
-    return XY.of(e.left, e.top)
+  static dot(self: IXY, another: IXY) {
+    return self.x * another.x + self.y * another.y
   }
 
-  static client(e: { clientX: number; clientY: number }) {
-    return XY.of(e.clientX, e.clientY)
+  static distance(self: IXY, another: IXY) {
+    return Math.hypot(self.x - another.x, self.y - another.y)
   }
 
-  static tuple(arr: [number, number]) {
-    return XY.of(arr[0], arr[1])
+  static vector(self: IXY, another: IXY) {
+    return new XY(self.x - another.x, self.y - another.y)
   }
 
-  static xAxis(rotation: number) {
-    return XY.of(Angle.cos(rotation), Angle.sin(rotation))
+  static symmetric(self: IXY, origin = XY.$()) {
+    return new XY(2 * origin.x - self.x, 2 * origin.y - self.y)
   }
 
-  static yAxis(rotation: number) {
-    return XY.of(-Angle.sin(rotation), Angle.cos(rotation))
+  static lerp(self: IXY, origin: IXY, t: number) {
+    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),
+    )
   }
 }

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/src/__test__/aabb.test.ts

@@ -1,84 +0,0 @@
-// 测试轴对齐包围盒功能
-
-import { describe, expect, it } from 'vitest'
-import { AABB } from '../aabb'
-import { OBB } from '../obb'
-
-describe('AABB', () => {
-  it('should create AABB correctly', () => {
-    const aabb = new AABB(0, 0, 10, 10)
-    expect(aabb.minX).toBe(0)
-    expect(aabb.minY).toBe(0)
-    expect(aabb.maxX).toBe(10)
-    expect(aabb.maxY).toBe(10)
-  })
-
-  it('should convert to rect correctly', () => {
-    const aabb = new AABB(5, 10, 15, 25)
-    const rect = AABB.rect(aabb)
-    expect(rect.x).toBe(5)
-    expect(rect.y).toBe(10)
-    expect(rect.width).toBe(10)
-    expect(rect.height).toBe(15)
-    expect(rect.centerX).toBe(10)
-    expect(rect.centerY).toBe(17.5)
-  })
-
-  it('should detect collision correctly', () => {
-    const aabb1 = new AABB(0, 0, 10, 10)
-    const aabb2 = new AABB(5, 5, 15, 15)
-    const aabb3 = new AABB(20, 20, 30, 30)
-
-    expect(AABB.collide(aabb1, aabb2)).toBe(true)
-    expect(AABB.collide(aabb1, aabb3)).toBe(false)
-  })
-
-  it('should detect inclusion correctly', () => {
-    const large = new AABB(0, 0, 20, 20)
-    const small = new AABB(5, 5, 15, 15)
-    const outside = new AABB(25, 25, 35, 35)
-
-    expect(AABB.include(large, small)).toBe(1) // large包含small
-    expect(AABB.include(small, large)).toBe(0) // small被large包含
-    expect(AABB.include(large, outside)).toBe(-1) // 不包含
-  })
-
-  it('should expand correctly with single value', () => {
-    const aabb = new AABB(5, 5, 15, 15)
-    const expanded = AABB.extend(aabb, 2)
-    expect(expanded.minX).toBe(3)
-    expect(expanded.minY).toBe(3)
-    expect(expanded.maxX).toBe(17)
-    expect(expanded.maxY).toBe(17)
-  })
-
-  it('should expand correctly with four values', () => {
-    const aabb = new AABB(5, 5, 15, 15)
-    const expanded = AABB.extend(aabb, 1, 2, 3, 4)
-    expect(expanded.minX).toBe(4)
-    expect(expanded.minY).toBe(3)
-    expect(expanded.maxX).toBe(18)
-    expect(expanded.maxY).toBe(19)
-  })
-
-  it('should merge multiple AABBs correctly', () => {
-    const aabb1 = new AABB(0, 0, 5, 5)
-    const aabb2 = new AABB(10, 10, 15, 15)
-    const aabb3 = new AABB(-5, -5, 0, 0)
-
-    const merged = AABB.merge(aabb1, aabb2, aabb3)
-    expect(merged.minX).toBe(-5)
-    expect(merged.minY).toBe(-5)
-    expect(merged.maxX).toBe(15)
-    expect(merged.maxY).toBe(15)
-  })
-
-  it('should create from OBB correctly', () => {
-    const obb = new OBB(0, 0, 10, 20, 0)
-    const aabb = AABB.fromOBB(obb)
-    expect(aabb.minX).toBe(0)
-    expect(aabb.minY).toBe(0)
-    expect(aabb.maxX).toBe(10)
-    expect(aabb.maxY).toBe(20)
-  })
-})

package/src/__test__/angle.test.ts

@@ -1,58 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { Angle, PI } from '../angle'
-
-describe('Angle', () => {
-  it('should export PI constant correctly', () => {
-    expect(PI).toBe(Math.PI)
-  })
-
-  it('should calculate cosine correctly', () => {
-    expect(Angle.cos(0)).toBe(1)
-    expect(Angle.cos(90)).toBeCloseTo(0, 10)
-    expect(Angle.cos(180)).toBeCloseTo(-1, 10)
-  })
-
-  it('should calculate sine correctly', () => {
-    expect(Angle.sin(0)).toBe(0)
-    expect(Angle.sin(90)).toBeCloseTo(1, 10)
-    expect(Angle.sin(180)).toBeCloseTo(0, 10)
-  })
-
-  it('should calculate tangent correctly', () => {
-    expect(Angle.tan(0)).toBe(0)
-    expect(Angle.tan(45)).toBeCloseTo(1, 10)
-  })
-
-  it('should convert radians to degrees correctly', () => {
-    expect(Angle.angleFy(Math.PI)).toBe(180)
-    expect(Angle.angleFy(Math.PI / 2)).toBe(90)
-    expect(Angle.angleFy(0)).toBe(0)
-  })
-
-  it('should convert degrees to radians correctly', () => {
-    expect(Angle.radianFy(180)).toBe(Math.PI)
-    expect(Angle.radianFy(90)).toBe(Math.PI / 2)
-    expect(Angle.radianFy(0)).toBe(0)
-  })
-
-  it('should normalize angles correctly', () => {
-    expect(Angle.normal(370)).toBe(10)
-    expect(Angle.normal(-10)).toBe(350)
-    expect(Angle.normal(0)).toBe(0)
-  })
-
-  it('should snap angles to steps correctly', () => {
-    expect(Angle.snap(45)).toBe(90) // 45度四舍五入到90度
-    expect(Angle.snap(80)).toBe(90)
-    expect(Angle.snap(120)).toBe(90)
-    expect(Angle.snap(135)).toBe(180)
-    expect(Angle.snap(0)).toBe(0)
-    expect(Angle.snap(30)).toBe(0) // 30度四舍五入到0度
-  })
-
-  it('should rotate point correctly', () => {
-    const result = Angle.rotatePoint(1, 0, 0, 0, 90)
-    expect(result.x).toBeCloseTo(0, 10)
-    expect(result.y).toBeCloseTo(1, 10)
-  })
-})

package/src/__test__/index.test.ts

@@ -1,85 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import * as Geo from '../index'
-
-describe('Index exports', () => {
-  it('should export all modules correctly', () => {
-    // 验证AABB相关导出
-    expect(typeof Geo.AABB).toBe('function')
-
-    // 验证Angle相关导出
-    expect(typeof Geo.Angle).toBe('function')
-    expect(typeof Geo.PI).toBe('number')
-
-    // 验证数学函数导出
-    expect(typeof Geo.sqrt).toBe('function')
-    expect(typeof Geo.abs).toBe('function')
-    expect(typeof Geo.pow2).toBe('function')
-    expect(typeof Geo.pow3).toBe('function')
-    expect(typeof Geo.multiply).toBe('function')
-    expect(typeof Geo.divide).toBe('function')
-    expect(typeof Geo.numberHalfFix).toBe('function')
-
-    // 验证Matrix相关导出
-    expect(typeof Geo.Matrix).toBe('function')
-
-    // 验证OBB相关导出
-    expect(typeof Geo.OBB).toBe('function')
-
-    // 验证贝塞尔曲线相关导出
-    expect(typeof Geo.pointsOnBezierCurves).toBe('function')
-    expect(typeof Geo.simplify).toBe('function')
-    expect(typeof Geo.simplifyPoints).toBe('function')
-
-    // 验证XY相关导出
-    expect(typeof Geo.xy_).toBe('function')
-    expect(typeof Geo.xy_client).toBe('function')
-    expect(typeof Geo.xy_from).toBe('function')
-    expect(typeof Geo.xy_plus).toBe('function')
-    expect(typeof Geo.xy_minus).toBe('function')
-    expect(typeof Geo.xy_multiply).toBe('function')
-    expect(typeof Geo.xy_divide).toBe('function')
-    expect(typeof Geo.xy_distance).toBe('function')
-    expect(typeof Geo.xy_dot).toBe('function')
-    expect(typeof Geo.XY).toBe('function')
-  })
-
-  it('should export type interfaces', () => {
-    // 验证可以使用导出的类型
-    const point: Geo.IXY = { x: 10, y: 20 }
-    const rect: Geo.IRect = { x: 0, y: 0, width: 100, height: 50 }
-    const rectWithCenter: Geo.IRectWithCenter = {
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 50,
-      centerX: 50,
-      centerY: 25,
-    }
-
-    expect(point.x).toBe(10)
-    expect(rect.width).toBe(100)
-    expect(rectWithCenter.centerX).toBe(50)
-  })
-
-  it('should allow creating instances from exported classes', () => {
-    // 测试能够创建实例
-    const aabb = new Geo.AABB(0, 0, 10, 10)
-    const obb = new Geo.OBB(0, 0, 10, 10, 0)
-    const xy = new Geo.XY(5, 5)
-
-    expect(aabb.minX).toBe(0)
-    expect(obb.width).toBe(10)
-    expect(xy.x).toBe(5)
-  })
-
-  it('should allow using static methods from exported classes', () => {
-    // 测试静态方法
-    const matrix = Geo.Matrix.create()
-    const normalizedAngle = Geo.Angle.normal(370)
-    const distance = Geo.xy_distance({ x: 0, y: 0 }, { x: 3, y: 4 })
-
-    expect(matrix).toEqual([1, 0, 0, 1, 0, 0])
-    expect(normalizedAngle).toBe(10)
-    expect(distance).toBe(5)
-  })
-})