@thi.ng/geom 7.0.1 → 8.0.1

package/transform-vertices.js

@@ -1,57 +1,55 @@
 import { defmulti } from "@thi.ng/defmulti/defmulti";
-import { ComplexPolygon } from "./api/complex-polygon.js";
-import { Cubic } from "./api/cubic.js";
-import { Line } from "./api/line.js";
 import { Path } from "./api/path.js";
-import { Points, Points3 } from "./api/points.js";
+import { Points } from "./api/points.js";
 import { Polygon } from "./api/polygon.js";
 import { Polyline } from "./api/polyline.js";
-import { Quad } from "./api/quad.js";
-import { Quadratic } from "./api/quadratic.js";
-import { Triangle } from "./api/triangle.js";
 import { asPolygon } from "./as-polygon.js";
 import { asPolyline } from "./as-polyline.js";
-import { __copyAttribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
+import { __ensureNoArc } from "./internal/error.js";
 import {
   __segmentTransformer,
-  __transformedShapePoints as tx,
-  __transformedShapePoints3 as tx3
+  __transformedPointsWith
 } from "./internal/transform.js";
 const transformVertices = defmulti(
   __dispatch,
   {
-    circle: "rect",
-    ellipse: "circle"
+    arc: "$aspolyline",
+    circle: "$aspoly",
+    complexpoly: "group",
+    ellipse: "$aspoly",
+    group3: "group",
+    bpatch: "points",
+    cubic: "points",
+    cubic3: "points",
+    line: "points",
+    line3: "points",
+    path3: "path",
+    points3: "points",
+    poly: "points",
+    poly3: "points",
+    polyline: "points",
+    polyline3: "points",
+    quad: "points",
+    quad3: "points",
+    quadratic: "points",
+    quadratic3: "points",
+    rect: "$aspoly",
+    tri: "points",
+    tri3: "points"
   },
   {
-    arc: ($, fn) => transformVertices(asPolyline($)[0], fn),
-    complexpoly: ($, fn) => new ComplexPolygon(
-      transformVertices($.boundary, fn),
-      $.children.map((child) => transformVertices(child, fn))
-    ),
-    cubic: tx(Cubic),
+    $aspoly: ($, fn) => transformVertices(asPolygon($)[0], fn),
+    $aspolyline: ($, fn) => transformVertices(asPolyline($)[0], fn),
+    extra: ($) => $,
     group: ($, fn) => $.copyTransformed((x) => transformVertices(x, fn)),
-    line: tx(Line),
-    path: ($, fn) => {
-      const $transformSegments = __segmentTransformer(
-        (geo) => transformVertices(geo, fn),
-        fn
-      );
-      return new Path(
-        $transformSegments($.segments),
-        $.subPaths.map($transformSegments),
-        __copyAttribs($)
-      );
-    },
-    points: tx(Points),
-    points3: tx3(Points3),
-    poly: tx(Polygon),
-    polyline: tx(Polyline),
-    quad: tx(Quad),
-    quadratic: tx(Quadratic),
-    rect: ($, fn) => transformVertices(asPolygon($)[0], fn),
-    tri: tx(Triangle)
+    path: ($, fn) => $.copyTransformed(
+      __segmentTransformer((geo) => {
+        __ensureNoArc(geo);
+        return transformVertices(geo, fn);
+      }, fn)
+    ),
+    points: ($, fn) => $.copyTransformed((pts) => __transformedPointsWith(pts, fn))
   }
 );
 export {

package/transform.d.ts

@@ -1,6 +1,23 @@
 import type { MultiFn2 } from "@thi.ng/defmulti";
-import type { IShape } from "@thi.ng/geom-api";
 import type { ReadonlyMat } from "@thi.ng/matrices";
+import type { IShape, IShape2, IShape3 } from "./api.js";
+import type { Arc } from "./api/arc.js";
+import type { Circle } from "./api/circle.js";
+import type { Ellipse } from "./api/ellipse.js";
+import { Path } from "./api/path.js";
+import { Quad } from "./api/quad.js";
+import type { Rect } from "./api/rect.js";
+/**
+ * Function overrides for {@link transform}.
+ */
+export type TransformFn = {
+    (shape: Arc, mat: ReadonlyMat): Path;
+    (shape: Circle, mat: ReadonlyMat): Path;
+    (shape: Ellipse, mat: ReadonlyMat): Path;
+    (shape: Rect, mat: ReadonlyMat): Quad;
+    <T extends IShape2>(shape: T, mat: ReadonlyMat): T;
+    <T extends IShape3>(shape: T, mat: ReadonlyMat): T;
+} & MultiFn2<IShape, ReadonlyMat, IShape>;
 /**
  * Transforms given shape with provided matrix.
  *
@@ -18,26 +35,37 @@ import type { ReadonlyMat } from "@thi.ng/matrices";
  * Currently implemented for:
  *
  * - {@link Arc}
+ * - {@link BPatch}
  * - {@link Circle}
  * - {@link ComplexPolygon}
  * - {@link Cubic}
+ * - {@link Cubic3}
  * - {@link Ellipse}
+ * - {@link Extra}
  * - {@link Group}
+ * - {@link Group3}
  * - {@link Line}
+ * - {@link Line3}
  * - {@link Path}
+ * - {@link Path3}
  * - {@link Points}
  * - {@link Points3}
  * - {@link Polygon}
+ * - {@link Polygon3}
  * - {@link Polyline}
+ * - {@link Polyline3}
  * - {@link Quad}
+ * - {@link Quad3}
  * - {@link Quadratic}
+ * - {@link Quadratic3}
  * - {@link Ray}
  * - {@link Rect}
  * - {@link Text}
  * - {@link Triangle}
+ * - {@link Triangle3}
  *
  * @param shape
  * @param mat
  */
-export declare const transform: MultiFn2<IShape, ReadonlyMat, IShape>;
+export declare const transform: TransformFn;
 //# sourceMappingURL=transform.d.ts.map

package/transform.js

@@ -1,60 +1,74 @@
 import { defmulti } from "@thi.ng/defmulti/defmulti";
-import { mulV } from "@thi.ng/matrices/mulv";
-import { ComplexPolygon } from "./api/complex-polygon.js";
-import { Cubic } from "./api/cubic.js";
-import { Line } from "./api/line.js";
+import { mulV23, mulV344 } from "@thi.ng/matrices/mulv";
 import { Path } from "./api/path.js";
-import { Points, Points3 } from "./api/points.js";
-import { Polygon } from "./api/polygon.js";
-import { Polyline } from "./api/polyline.js";
+import { Path3 } from "./api/path3.js";
+import { Points } from "./api/points.js";
+import { Points3 } from "./api/points3.js";
 import { Quad } from "./api/quad.js";
-import { Quadratic } from "./api/quadratic.js";
 import { Text } from "./api/text.js";
-import { Triangle } from "./api/triangle.js";
 import { asPath } from "./as-path.js";
 import { __copyAttribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
+import { __ensureNoArc } from "./internal/error.js";
 import {
   __segmentTransformer,
-  __transformedShape as tx,
-  __transformedShape3 as tx3
+  __transformedPoints
 } from "./internal/transform.js";
 import { vertices } from "./vertices.js";
 const transform = defmulti(
   __dispatch,
   {
-    circle: "arc",
-    ellipse: "circle"
+    arc: "$aspath",
+    circle: "$aspath",
+    complexpoly: "group",
+    bpatch: "points",
+    cubic: "points",
+    cubic3: "points3",
+    ellipse: "$aspath",
+    group3: "group",
+    line: "points",
+    line3: "points3",
+    poly: "points",
+    poly3: "points3",
+    polyline: "points",
+    polyline3: "points3",
+    quad: "points",
+    quad3: "points3",
+    quadratic: "points",
+    quadratic3: "points3",
+    tri: "points",
+    tri3: "points3"
   },
   {
-    arc: ($, mat) => transform(asPath($), mat),
-    complexpoly: ($, mat) => new ComplexPolygon(
-      transform($.boundary, mat),
-      $.children.map((child) => transform(child, mat))
-    ),
-    cubic: tx(Cubic),
+    $aspath: ($, mat) => transform(asPath($), mat),
+    extra: ($) => $,
     group: ($, mat) => $.copyTransformed((x) => transform(x, mat)),
-    line: tx(Line),
-    path: ($, mat) => {
-      const $transformSegments = __segmentTransformer(
-        (geo) => transform(geo, mat),
-        (p) => mulV([], mat, p)
-      );
-      return new Path(
-        $transformSegments($.segments),
-        $.subPaths.map($transformSegments),
-        __copyAttribs($)
-      );
-    },
-    points: tx(Points),
-    points3: tx3(Points3),
-    poly: tx(Polygon),
-    polyline: tx(Polyline),
-    quad: tx(Quad),
-    quadratic: tx(Quadratic),
-    rect: ($, mat) => transform(new Quad(vertices($), __copyAttribs($)), mat),
-    text: ($, mat) => new Text(mulV([], mat, $.pos), $.body, __copyAttribs($)),
-    tri: tx(Triangle)
+    path: ($, mat) => $.copyTransformed(
+      __segmentTransformer(
+        (geo) => {
+          __ensureNoArc(geo);
+          return transform(geo, mat);
+        },
+        (p) => mulV23([], mat, p)
+      )
+    ),
+    path3: ($, mat) => $.copyTransformed(
+      __segmentTransformer(
+        (geo) => {
+          __ensureNoArc(geo);
+          return transform(geo, mat);
+        },
+        (p) => mulV344([], mat, p)
+      )
+    ),
+    points: ($, mat) => $.copyTransformed(
+      (points) => __transformedPoints(points, mat, mulV23)
+    ),
+    points3: ($, mat) => $.copyTransformed(
+      (points) => __transformedPoints(points, mat, mulV344)
+    ),
+    rect: ($, mat) => transform(new Quad(vertices($), __copyAttribs($.attribs)), mat),
+    text: ($, mat) => new Text(mulV23([], mat, $.pos), $.body, __copyAttribs($.attribs))
   }
 );
 export {

package/translate.d.ts

@@ -1,6 +1,12 @@
 import type { MultiFn2 } from "@thi.ng/defmulti";
-import type { IShape } from "@thi.ng/geom-api";
 import type { ReadonlyVec } from "@thi.ng/vectors";
+import type { IShape } from "./api.js";
+/**
+ * Function overrides for {@link translate}.
+ */
+export type TranslateFn = {
+    <T extends IShape>(shape: T, offset: ReadonlyVec): T;
+} & MultiFn2<IShape, ReadonlyVec, IShape>;
 /**
  * Translates given shape by given `offset` vector.
  *
@@ -9,11 +15,15 @@ import type { ReadonlyVec } from "@thi.ng/vectors";
  *
  * - {@link AABB}
  * - {@link Arc}
+ * - {@link BPatch}
  * - {@link Circle}
  * - {@link ComplexPolygon}
  * - {@link Cubic}
+ * - {@link Cubic3}
  * - {@link Ellipse}
+ * - {@link Extra}
  * - {@link Group}
+ * - {@link Group3}
  * - {@link Line}
  * - {@link Path}
  * - {@link Points}
@@ -31,5 +41,5 @@ import type { ReadonlyVec } from "@thi.ng/vectors";
  * @param shape
  * @param offset
  */
-export declare const translate: MultiFn2<IShape, ReadonlyVec, IShape>;
+export declare const translate: TranslateFn;
 //# sourceMappingURL=translate.d.ts.map

package/translate.js

@@ -1,80 +1,79 @@
 import { defmulti } from "@thi.ng/defmulti/defmulti";
-import { add2, add3 } from "@thi.ng/vectors/add";
+import { add, add2, add3 } from "@thi.ng/vectors/add";
 import { set2, set3 } from "@thi.ng/vectors/set";
 import { AABB } from "./api/aabb.js";
 import { Circle } from "./api/circle.js";
-import { ComplexPolygon } from "./api/complex-polygon.js";
-import { Cubic } from "./api/cubic.js";
 import { Ellipse } from "./api/ellipse.js";
-import { Line } from "./api/line.js";
-import { Path } from "./api/path.js";
-import { Points, Points3 } from "./api/points.js";
-import { Polygon } from "./api/polygon.js";
-import { Polyline } from "./api/polyline.js";
-import { Quad } from "./api/quad.js";
-import { Quadratic } from "./api/quadratic.js";
 import { Ray } from "./api/ray.js";
+import { Ray3 } from "./api/ray3.js";
 import { Rect } from "./api/rect.js";
 import { Sphere } from "./api/sphere.js";
 import { Text } from "./api/text.js";
-import { Triangle } from "./api/triangle.js";
 import { __copyAttribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
 import { __segmentTransformer } from "./internal/transform.js";
-import { __translatedShape as tx } from "./internal/translate.js";
 const translate = defmulti(
   __dispatch,
-  {},
+  {
+    bpatch: "points",
+    cubic: "points",
+    cubic3: "points3",
+    complexpoly: "group",
+    group3: "group",
+    line: "points",
+    line3: "points3",
+    path3: "path",
+    poly: "points",
+    poly3: "points3",
+    polyline: "points",
+    polyline3: "points3",
+    quad: "points",
+    quad3: "points3",
+    quadratic: "points",
+    quadratic3: "points3",
+    tri: "points",
+    tri3: "points3"
+  },
   {
     aabb: ($, delta) => new AABB(
       add3([], $.pos, delta),
       set3([], $.size),
-      __copyAttribs($)
+      __copyAttribs($.attribs)
     ),
     arc: ($, delta) => {
       const a = $.copy();
       add2(null, a.pos, delta);
       return a;
     },
-    circle: ($, delta) => new Circle(add2([], $.pos, delta), $.r, __copyAttribs($)),
-    complexpoly: ($, delta) => new ComplexPolygon(
-      translate($.boundary, delta),
-      $.children.map((child) => translate(child, delta))
-    ),
-    cubic: tx(Cubic),
+    circle: ($, delta) => new Circle(add2([], $.pos, delta), $.r, __copyAttribs($.attribs)),
     ellipse: ($, delta) => new Ellipse(
       add2([], $.pos, delta),
       set2([], $.r),
-      __copyAttribs($)
+      __copyAttribs($.attribs)
     ),
+    extra: ($) => $,
     group: ($, delta) => $.copyTransformed((x) => translate(x, delta)),
-    line: tx(Line),
-    path: ($, delta) => {
-      const $translateSegments = __segmentTransformer(
+    path: ($, delta) => $.copyTransformed(
+      __segmentTransformer(
         (geo) => translate(geo, delta),
-        (p) => add2([], p, delta)
-      );
-      return new Path(
-        $translateSegments($.segments),
-        $.subPaths.map($translateSegments),
-        __copyAttribs($)
-      );
-    },
-    points: tx(Points),
-    points3: tx(Points3),
-    poly: tx(Polygon),
-    polyline: tx(Polyline),
-    quad: tx(Quad),
-    quadratic: tx(Quadratic),
-    ray: ($, delta) => new Ray(add2([], $.pos, delta), $.dir, __copyAttribs($)),
+        (p) => add([], p, delta)
+      )
+    ),
+    points: ($, delta) => $.copyTransformed(
+      (points) => points.map((x) => add2([], x, delta))
+    ),
+    points3: ($, delta) => $.copyTransformed(
+      (points) => points.map((x) => add3([], x, delta))
+    ),
+    ray: ($, delta) => new Ray(add2([], $.pos, delta), $.dir, __copyAttribs($.attribs)),
+    ray3: ($, delta) => new Ray3(add3([], $.pos, delta), $.dir, __copyAttribs($.attribs)),
     rect: ($, delta) => new Rect(
       add2([], $.pos, delta),
       set2([], $.size),
-      __copyAttribs($)
+      __copyAttribs($.attribs)
     ),
-    sphere: ($, delta) => new Sphere(add3([], $.pos, delta), $.r, __copyAttribs($)),
-    text: ($, delta) => new Text(add2([], $.pos, delta), $.body, __copyAttribs($)),
-    tri: tx(Triangle)
+    sphere: ($, delta) => new Sphere(add3([], $.pos, delta), $.r, __copyAttribs($.attribs)),
+    text: ($, delta) => new Text(add2([], $.pos, delta), $.body, __copyAttribs($.attribs))
   }
 );
 export {

package/triangle.d.ts

@@ -1,4 +1,4 @@
-import type { Attribs } from "@thi.ng/geom-api";
+import type { Attribs } from "./api.js";
 import type { Vec } from "@thi.ng/vectors";
 import { Triangle } from "./api/triangle.js";
 export declare function triangle(a: Vec, b: Vec, c: Vec, attribs?: Attribs): Triangle;

package/triangle3.d.ts

@@ -0,0 +1,6 @@
+import type { Attribs } from "./api.js";
+import type { Vec } from "@thi.ng/vectors";
+import { Triangle3 } from "./api/triangle3.js";
+export declare function triangle3(a: Vec, b: Vec, c: Vec, attribs?: Attribs): Triangle3;
+export declare function triangle3(pts: Iterable<Vec>, attribs?: Attribs): Triangle3;
+//# sourceMappingURL=triangle3.d.ts.map

package/triangle3.js

@@ -0,0 +1,8 @@
+import { Triangle3 } from "./api/triangle3.js";
+import { __pclike } from "./internal/pclike.js";
+function triangle3(...args) {
+  return __pclike(Triangle3, args);
+}
+export {
+  triangle3
+};

package/union.d.ts

@@ -1,5 +1,14 @@
 import type { MultiFn2 } from "@thi.ng/defmulti";
-import type { IShape } from "@thi.ng/geom-api";
+import type { IShape } from "./api.js";
+import { AABB } from "./api/aabb.js";
+import { Rect } from "./api/rect.js";
+/**
+ * Function overrides for {@link union}.
+ */
+export type UnionFn = {
+    (a: AABB, b: AABB): AABB;
+    (a: Rect, b: Rect): Rect;
+} & MultiFn2<IShape, IShape, IShape>;
 /**
  * Computes shape "union" of given 2 shapes.
  *
@@ -10,5 +19,5 @@ import type { IShape } from "@thi.ng/geom-api";
  * @param a
  * @param b
  */
-export declare const union: MultiFn2<IShape, IShape, IShape[]>;
+export declare const union: UnionFn;
 //# sourceMappingURL=union.d.ts.map

package/union.js

@@ -5,14 +5,13 @@ import { __unionBounds } from "./internal/bounds.js";
 import { __dispatch } from "./internal/dispatch.js";
 const union = defmulti(
   __dispatch,
-  {},
   {
-    aabb: (a, b) => [
-      new AABB(...__unionBounds(a.pos, a.size, b.pos, b.size))
-    ],
-    rect: (a, b) => [
-      new Rect(...__unionBounds(a.pos, a.size, b.pos, b.size))
-    ]
+    rect: "aabb"
+  },
+  {
+    aabb: (a, b) => new a.constructor(
+      ...__unionBounds(a.pos, a.size, b.pos, b.size)
+    )
   }
 );
 export {

package/unmap-point.d.ts

@@ -1,5 +1,5 @@
 import type { MultiFn2O } from "@thi.ng/defmulti";
-import type { IShape } from "@thi.ng/geom-api";
+import type { IShape } from "./api.js";
 import type { ReadonlyVec, Vec } from "@thi.ng/vectors";
 /**
  * Projects given point `uv` (normalized coords) into the target space defined

package/vertices.d.ts

@@ -1,11 +1,10 @@
 import type { MultiFn1O } from "@thi.ng/defmulti";
-import type { IShape } from "@thi.ng/geom-api";
-import { type SamplingOpts } from "@thi.ng/geom-api/sample";
 import type { Vec } from "@thi.ng/vectors";
+import type { IShape, SamplingOpts } from "./api.js";
 /**
  * Extracts/samples vertices from given shape's boundary and returns them as
  * array. Some shapes also support
- * [`SamplingOpts`](https://docs.thi.ng/umbrella/geom-api/interfaces/SamplingOpts.html).
+ * [`SamplingOpts`](https://docs.thi.ng/umbrella/geom-resample/interfaces/SamplingOpts.html).
  *
  * @remarks
  * The given sampling options (if any) can also be overridden per shape using
@@ -21,6 +20,7 @@ import type { Vec } from "@thi.ng/vectors";
  * - {@link ComplexPolygon}
  * - {@link Cubic}
  * - {@link Ellipse}
+ * - {@link Extra}
  * - {@link Group}
  * - {@link Line}
  * - {@link Path}

package/vertices.js

@@ -1,8 +1,9 @@
+import { peek } from "@thi.ng/arrays/peek";
 import { isArray } from "@thi.ng/checks/is-array";
 import { isNumber } from "@thi.ng/checks/is-number";
 import { defmulti } from "@thi.ng/defmulti/defmulti";
-import { DEFAULT_SAMPLES } from "@thi.ng/geom-api/sample";
 import { sample as _arcVertices } from "@thi.ng/geom-arc/sample";
+import { DEFAULT_SAMPLES } from "@thi.ng/geom-resample/api";
 import { resample } from "@thi.ng/geom-resample/resample";
 import { sampleCubic } from "@thi.ng/geom-splines/cubic-sample";
 import { sampleQuadratic } from "@thi.ng/geom-splines/quadratic-sample";
@@ -16,15 +17,23 @@ import { ComplexPolygon } from "./api/complex-polygon.js";
 import { Polygon } from "./api/polygon.js";
 import { __dispatch } from "./internal/dispatch.js";
 import { __circleOpts, __sampleAttribs } from "./internal/vertices.js";
-import { peek } from "@thi.ng/arrays/peek";
 const vertices = defmulti(
   __dispatch,
   {
-    line: "polyline",
     bpatch: "points",
+    cubic3: "cubic",
+    group3: "group",
+    line: "polyline",
+    line3: "polyline",
+    path3: "path",
     points3: "points",
+    poly3: "poly",
+    polyline3: "polyline",
     quad: "poly",
-    tri: "poly"
+    quad3: "poly",
+    quadratic3: "quadratic",
+    tri: "poly",
+    tri3: "poly"
   },
   {
     // e +----+ h
@@ -100,6 +109,7 @@ const vertices = defmulti(
       }
       return buf;
     },
+    extra: () => [],
     group: ($, opts) => {
       opts = __sampleAttribs(opts, $.attribs);
       return $.children.reduce(

package/volume.d.ts

@@ -1,5 +1,5 @@
 import type { MultiFn1 } from "@thi.ng/defmulti";
-import type { IShape } from "@thi.ng/geom-api";
+import type { IShape } from "./api.js";
 /**
  * Returns the volume of given 3D shape. Returns 0 for all others.
  *

package/warp-points.d.ts

@@ -1,16 +1,47 @@
-import type { IShape } from "@thi.ng/geom-api";
 import type { ReadonlyVec, Vec } from "@thi.ng/vectors/api";
+import type { IShape } from "./api.js";
 import type { BPatch } from "./api/bpatch.js";
 import type { Rect } from "./api/rect.js";
 /**
- * Transfers/remaps points (in world space) given in relation to `src` shape to
- * be relative to the space of `dest` shape. Writes results to `out` (or creates
- * new array).
+ * Transfers/remaps point `p` (in world space) given in relation to `src` shape
+ * to be relative to the space of `dest` shape. Writes results to `out` (or
+ * creates new vector).
  *
  * @remarks
  * The type of `src` must be supported by {@link mapPoint}. The type of `dest`
  * must be supported by {@link unmapPoint}.
  *
+ * @example
+ * ```ts tangle:../export/warp-point.ts
+ * import { rect, warpPoint } from "@thi.ng/geom";
+ *
+ * const p = [1075, -1975];
+ *
+ * // source rect [1000,-2000] .. [1100,-1900]
+ * const src = rect([1000,-2000], 100);
+ *
+ * // destination rect [0,0] .. [0.5,0.5]
+ * const dest = rect(0.5);
+ *
+ * // map `p` into the space of `dest` via `src`
+ * console.log(warpPoint(p, dest, src));
+ * // [ 0.375, 0.125 ]
+ * ```
+ *
+ * @param p
+ * @param dest
+ * @param src
+ * @param out
+ */
+export declare const warpPoint: (p: ReadonlyVec, dest: IShape, src: IShape, out?: Vec) => Vec;
+/**
+ * Array version of {@link warpPoint}, transferring all points in the array from
+ * world space to the local space of `dest` via the local space of `src`.
+ *
+ * @remarks
+ * Note: Different arg orderThe type of `src` must be supported by {@link mapPoint}. The type of `dest`
+ * must be supported by {@link unmapPoint}.
+ *
  * @param pts
  * @param dest
  * @param src

package/warp-points.js

@@ -2,6 +2,7 @@ import { bounds2 } from "@thi.ng/geom-poly-utils/bounds";
 import { mapPoint } from "./map-point.js";
 import { rectFromMinMax } from "./rect.js";
 import { unmapPoint } from "./unmap-point.js";
+const warpPoint = (p, dest, src, out) => unmapPoint(dest, mapPoint(src, p), out);
 const warpPoints = (pts, dest, src, out = []) => {
   for (let n = pts.length, i = 0; i < n; i++) {
     out.push(unmapPoint(dest, mapPoint(src, pts[i])));
@@ -16,6 +17,7 @@ const warpPointsBPatch = (pts, dest, src, out = []) => {
   return out;
 };
 export {
+  warpPoint,
   warpPoints,
   warpPointsBPatch
 };