@thi.ng/geom 7.0.1 → 8.0.0

package/points3.d.ts

@@ -0,0 +1,5 @@
+import type { Attribs } from "./api.js";
+import type { Vec } from "@thi.ng/vectors";
+import { Points3 } from "./api/points3.js";
+export declare const points3: (pts?: Iterable<Vec>, attribs?: Attribs) => Points3;
+//# sourceMappingURL=points3.d.ts.map

package/points3.js

@@ -0,0 +1,5 @@
+import { Points3 } from "./api/points3.js";
+const points3 = (pts, attribs) => new Points3(pts, attribs);
+export {
+  points3
+};

package/polygon.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 { Polygon } from "./api/polygon.js";
 export declare const polygon: (pts?: Iterable<Vec>, attribs?: Attribs) => Polygon;
@@ -9,7 +9,6 @@ export declare const polygon: (pts?: Iterable<Vec>, attribs?: Attribs) => Polygo
  * @param n
  * @param profile
  * @param attribs
- * @returns
  */
 export declare const star: (r: number, n: number, profile: number[], attribs?: Attribs) => Polygon;
 /**
@@ -21,10 +20,12 @@ export declare const star: (r: number, n: number, profile: number[], attribs?: A
  * vertex will be inset to 50% of the base radius.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/star-with-centroid.ts
  * import { starWithCentroid } from "@thi.ng/geom";
  *
- * starWithCentroid([100,200], 50, 5, [1, 0.5])
+ * console.log(
+ *   starWithCentroid([100,200], 50, 5, [1, 0.5])
+ * );
  * // Polygon {
  * //   points: [
  * //     [150.000, 200.000],
@@ -47,7 +48,6 @@ export declare const star: (r: number, n: number, profile: number[], attribs?: A
  * @param n
  * @param profile
  * @param attribs
- * @returns
  */
 export declare const starWithCentroid: (pos: Vec, r: number, n: number, profile: number[], attribs?: Attribs) => Polygon;
 //# sourceMappingURL=polygon.d.ts.map

package/polygon3.d.ts

@@ -0,0 +1,5 @@
+import type { Attribs } from "./api.js";
+import type { Vec } from "@thi.ng/vectors";
+import { Polygon3 } from "./api/polygon3.js";
+export declare const polygon3: (pts?: Iterable<Vec>, attribs?: Attribs) => Polygon3;
+//# sourceMappingURL=polygon3.d.ts.map

package/polygon3.js

@@ -0,0 +1,5 @@
+import { Polygon3 } from "./api/polygon3.js";
+const polygon3 = (pts, attribs) => new Polygon3(pts, attribs);
+export {
+  polygon3
+};

package/polyline.d.ts

@@ -1,7 +1,7 @@
-import type { Attribs } from "@thi.ng/geom-api";
+import type { Attribs } from "./api.js";
 import type { ReadonlyVec, Vec } from "@thi.ng/vectors";
 import { Polyline } from "./api/polyline.js";
-export declare const polyline: (pts: Iterable<Vec>, attribs?: Attribs) => Polyline;
+export declare const polyline: (pts?: Iterable<Vec>, attribs?: Attribs) => Polyline;
 /**
  * Creates a polyline spiral from given params. The number of twists is defined
  * by the angle range. Resolution depends on angle range and number of steps.

package/polyline3.d.ts

@@ -0,0 +1,5 @@
+import type { Attribs } from "./api.js";
+import type { Vec } from "@thi.ng/vectors";
+import { Polyline3 } from "./api/polyline3.js";
+export declare const polyline3: (pts: Iterable<Vec>, attribs?: Attribs) => Polyline3;
+//# sourceMappingURL=polyline3.d.ts.map

package/polyline3.js

@@ -0,0 +1,5 @@
+import { Polyline3 } from "./api/polyline3.js";
+const polyline3 = (pts, attribs) => new Polyline3(pts, attribs);
+export {
+  polyline3
+};

package/proximity.d.ts

@@ -1,11 +1,13 @@
-import type { IShape } from "@thi.ng/geom-api";
 import type { ReadonlyVec } from "@thi.ng/vectors";
+import type { IShape } from "./api.js";
 /**
  * Computes {@link closestPoint} on `shape` to `p`, and if successful, returns
- * eucledian distance between that point and `p`.
+ * the distance between that point and `p`, using optionally given `dist`ance
+ * function (by default uses Eucledian distance).
  *
  * @param shape
  * @param p
+ * @param dist
  */
-export declare const proximity: (shape: IShape, p: ReadonlyVec) => number | undefined;
+export declare const proximity: (shape: IShape, p: ReadonlyVec, dist?: import("@thi.ng/vectors").DistanceFn) => number | undefined;
 //# sourceMappingURL=proximity.d.ts.map

package/proximity.js

@@ -1,6 +1,6 @@
-import { dist } from "@thi.ng/vectors/dist";
+import { dist as $dist } from "@thi.ng/vectors/dist";
 import { closestPoint } from "./closest-point.js";
-const proximity = (shape, p) => {
+const proximity = (shape, p, dist = $dist) => {
   const q = closestPoint(shape, p);
   return q ? dist(p, q) : void 0;
 };

package/quad.d.ts

@@ -1,11 +1,6 @@
-import type { Attribs } from "@thi.ng/geom-api";
-import { type ReadonlyVec, type Vec } from "@thi.ng/vectors/api";
-import type { Plane } from "./api/plane.js";
+import type { Attribs } from "./api.js";
+import type { Vec } from "@thi.ng/vectors";
 import { Quad } from "./api/quad.js";
-import { Quad3 } from "./api/quad3.js";
 export declare function quad(a: Vec, b: Vec, c: Vec, d: Vec, attribs?: Attribs): Quad;
 export declare function quad(pts: Iterable<Vec>, attribs?: Attribs): Quad;
-export declare function quad3(a: Vec, b: Vec, c: Vec, d: Vec, attribs?: Attribs): Quad;
-export declare function quad3(pts: Iterable<Vec>, attribs?: Attribs): Quad;
-export declare const quadOnPlane: (plane: Plane, pos: ReadonlyVec, size: number | ReadonlyVec, attribs?: Attribs) => Quad3;
 //# sourceMappingURL=quad.d.ts.map

package/quad.js

@@ -1,36 +1,8 @@
-import { isNumber } from "@thi.ng/checks/is-number";
-import { closestPointPlane } from "@thi.ng/geom-closest-point/plane";
-import { alignmentQuat } from "@thi.ng/matrices/alignment-quat";
-import { mulVQ } from "@thi.ng/matrices/mulv";
-import { add3 } from "@thi.ng/vectors/add";
-import { Z3 } from "@thi.ng/vectors/api";
 import { Quad } from "./api/quad.js";
-import { Quad3 } from "./api/quad3.js";
-import { __argAttribs } from "./internal/args.js";
 import { __pclike } from "./internal/pclike.js";
 function quad(...args) {
   return __pclike(Quad, args);
 }
-function quad3(...args) {
-  const attr = __argAttribs(args);
-  return new Quad3(args.length === 1 ? args[0] : args, attr);
-}
-const quadOnPlane = (plane, pos, size, attribs) => {
-  pos = closestPointPlane(pos, plane.normal, plane.w);
-  const [w, h] = isNumber(size) ? [size, size] : size;
-  const q = alignmentQuat(Z3, plane.normal);
-  return new Quad3(
-    [
-      [-w, -h, 0],
-      [w, -h, 0],
-      [w, h, 0],
-      [-w, h, 0]
-    ].map((p) => add3(null, mulVQ(null, q, p), pos)),
-    attribs
-  );
-};
 export {
-  quad,
-  quad3,
-  quadOnPlane
+  quad
 };

package/quad3.d.ts

@@ -0,0 +1,8 @@
+import type { Attribs } from "./api.js";
+import { type ReadonlyVec, type Vec } from "@thi.ng/vectors/api";
+import type { Plane } from "./api/plane.js";
+import { Quad3 } from "./api/quad3.js";
+export declare function quad3(a: Vec, b: Vec, c: Vec, d: Vec, attribs?: Attribs): Quad3;
+export declare function quad3(pts: Iterable<Vec>, attribs?: Attribs): Quad3;
+export declare const quadOnPlane: (plane: Plane, pos: ReadonlyVec, size: number | ReadonlyVec, attribs?: Attribs) => Quad3;
+//# sourceMappingURL=quad3.d.ts.map

package/quad3.js

@@ -0,0 +1,30 @@
+import { isNumber } from "@thi.ng/checks/is-number";
+import { closestPointPlane } from "@thi.ng/geom-closest-point/plane";
+import { alignmentQuat } from "@thi.ng/matrices/alignment-quat";
+import { mulVQ } from "@thi.ng/matrices/mulv";
+import { add3 } from "@thi.ng/vectors/add";
+import { Z3 } from "@thi.ng/vectors/api";
+import { Quad3 } from "./api/quad3.js";
+import { __argAttribs } from "./internal/args.js";
+function quad3(...args) {
+  const attr = __argAttribs(args);
+  return new Quad3(args.length === 1 ? args[0] : args, attr);
+}
+const quadOnPlane = (plane, pos, size, attribs) => {
+  pos = closestPointPlane(pos, plane.normal, plane.w);
+  const [w, h] = isNumber(size) ? [size, size] : size;
+  const q = alignmentQuat(Z3, plane.normal);
+  return new Quad3(
+    [
+      [-w, -h, 0],
+      [w, -h, 0],
+      [w, h, 0],
+      [-w, h, 0]
+    ].map((p) => add3(null, mulVQ(null, q, p), pos)),
+    attribs
+  );
+};
+export {
+  quad3,
+  quadOnPlane
+};

package/quadratic.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 { Quadratic } from "./api/quadratic.js";
 export declare function quadratic(a: Vec, b: Vec, c: Vec, attribs?: Attribs): Quadratic;

package/quadratic3.d.ts

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

package/quadratic3.js

@@ -0,0 +1,11 @@
+import { quadraticFromLine as _line } from "@thi.ng/geom-splines/quadratic-line";
+import { Quadratic3 } from "./api/quadratic3.js";
+import { __pclike } from "./internal/pclike.js";
+function quadratic3(...args) {
+  return __pclike(Quadratic3, args);
+}
+const quadraticFromLine3 = (a, b, attribs) => new Quadratic3(_line(a, b), attribs);
+export {
+  quadratic3,
+  quadraticFromLine3
+};

package/ray.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 { Ray } from "./api/ray.js";
 export declare const ray: (pos: Vec, dir: Vec, attribs?: Attribs, normalize?: boolean) => Ray;

package/ray.js

@@ -1,6 +1,6 @@
-import { normalize as _norm } from "@thi.ng/vectors/normalize";
+import { normalize2 } from "@thi.ng/vectors/normalize";
 import { Ray } from "./api/ray.js";
-const ray = (pos, dir, attribs, normalize = true) => new Ray(pos, normalize ? _norm(null, dir) : dir, attribs);
+const ray = (pos, dir, attribs, normalize = true) => new Ray(pos, normalize ? normalize2(null, dir) : dir, attribs);
 export {
   ray
 };

package/ray3.d.ts

@@ -0,0 +1,5 @@
+import type { Attribs } from "./api.js";
+import type { Vec } from "@thi.ng/vectors";
+import { Ray3 } from "./api/ray3.js";
+export declare const ray3: (pos: Vec, dir: Vec, attribs?: Attribs, normalize?: boolean) => Ray3;
+//# sourceMappingURL=ray3.d.ts.map

package/ray3.js

@@ -0,0 +1,6 @@
+import { normalize3 } from "@thi.ng/vectors/normalize";
+import { Ray3 } from "./api/ray3.js";
+const ray3 = (pos, dir, attribs, normalize = true) => new Ray3(pos, normalize ? normalize3(null, dir) : dir, attribs);
+export {
+  ray3
+};

package/rect.d.ts

@@ -1,4 +1,4 @@
-import type { Attribs } from "@thi.ng/geom-api";
+import type { Attribs } from "./api.js";
 import { type ReadonlyVec, type Vec } from "@thi.ng/vectors/api";
 import type { Circle } from "./api/circle.js";
 import type { Polygon } from "./api/polygon.js";

package/resample.d.ts

@@ -1,27 +1,68 @@
 import type { MultiFn2 } from "@thi.ng/defmulti";
-import type { IShape, SamplingOpts } from "@thi.ng/geom-api";
+import type { IShape, IShape2, IShape3, SamplingOpts } from "./api.js";
+import type { ComplexPolygon } from "./api/complex-polygon.js";
+import type { Cubic } from "./api/cubic.js";
+import type { Cubic3 } from "./api/cubic3.js";
+import type { Group } from "./api/group.js";
+import type { Line } from "./api/line.js";
+import type { Line3 } from "./api/line3.js";
+import type { Polygon } from "./api/polygon.js";
+import type { Polygon3 } from "./api/polygon3.js";
+import type { Polyline } from "./api/polyline.js";
+import type { Polyline3 } from "./api/polyline3.js";
+import type { Quad3 } from "./api/quad3.js";
+import type { Quadratic } from "./api/quadratic.js";
+import type { Quadratic3 } from "./api/quadratic3.js";
 /**
- * Resamples given 2D shape with given options and returns result as polygon (if
+ * Function overrides for {@link resample}.
+ */
+export type ResampleFn = {
+    (shape: ComplexPolygon, opts: number | Partial<SamplingOpts>): ComplexPolygon;
+    (shape: Cubic, opts: number | Partial<SamplingOpts>): Polyline;
+    (shape: Cubic3, opts: number | Partial<SamplingOpts>): Polyline3;
+    (shape: Group, opts: number | Partial<SamplingOpts>): Group;
+    (shape: Line, opts: number | Partial<SamplingOpts>): Polyline;
+    (shape: Line3, opts: number | Partial<SamplingOpts>): Polyline3;
+    (shape: Polyline, opts: number | Partial<SamplingOpts>): Polyline;
+    (shape: Polyline3, opts: number | Partial<SamplingOpts>): Polyline3;
+    (shape: Quadratic, opts: number | Partial<SamplingOpts>): Polyline;
+    (shape: Quadratic3, opts: number | Partial<SamplingOpts>): Polyline3;
+    (shape: Quad3, opts: number | Partial<SamplingOpts>): Polygon3;
+    (shape: IShape2, opts: number | Partial<SamplingOpts>): Polygon;
+    (shape: IShape3, opts: number | Partial<SamplingOpts>): IShape3;
+} & MultiFn2<IShape, number | Partial<SamplingOpts>, IShape>;
+/**
+ * Resamples given shape with given options and returns result as polygon (if
  * closed) or polyline (if open).
  *
  * @remarks
  * If the shape has a `__samples` attribute, it will be removed in the result to
- * avoid recursive application.
+ * ensure idempotent behavior.
  *
  * Currently implemented for:
  *
+ * - {@link Arc}
  * - {@link Circle}
  * - {@link ComplexPolygon}
+ * - {@link Cubic}
+ * - {@link Cubic3}
  * - {@link Ellipse}
  * - {@link Line}
+ * - {@link Line3}
  * - {@link Polygon}
+ * - {@link Polygon3}
  * - {@link Polyline}
+ * - {@link Polyline3}
  * - {@link Quad}
+ * - {@link Quad3}
+ * - {@link Quadratic}
+ * - {@link Quadratic3}
  * - {@link Rect}
  * - {@link Triangle}
+ * - {@link Triangle3}
  *
  * @param shape
  * @param opts
  */
-export declare const resample: MultiFn2<IShape, number | Partial<SamplingOpts>, IShape>;
+export declare const resample: ResampleFn;
 //# sourceMappingURL=resample.d.ts.map

package/resample.js

@@ -1,29 +1,39 @@
 import { defmulti } from "@thi.ng/defmulti/defmulti";
 import { resample as _resample } from "@thi.ng/geom-resample/resample";
-import { ComplexPolygon } from "./api/complex-polygon.js";
-import { Polygon } from "./api/polygon.js";
-import { Polyline } from "./api/polyline.js";
 import { asPolygon } from "./as-polygon.js";
-import { __copyAttribsNoSamples as __attribs } from "./internal/copy.js";
+import { asPolyline } from "./as-polyline.js";
 import { __dispatch } from "./internal/dispatch.js";
 const resample = defmulti(
   __dispatch,
   {
-    ellipse: "circle",
-    line: "polyline",
-    quad: "poly",
-    tri: "poly",
-    rect: "circle"
+    arc: "$aspolyline",
+    circle: "$aspoly",
+    complexpoly: "group",
+    cubic: "$aspolyline",
+    cubic3: "$aspolyline",
+    ellipse: "$aspoly",
+    line: "$aspolyline",
+    line3: "$aspolyline",
+    poly3: "poly",
+    polyline3: "polyline",
+    quad: "$aspoly",
+    quad3: "$aspoly",
+    quadratic: "$aspolyline",
+    quadratic3: "$aspolyline",
+    rect: "$aspoly",
+    tri: "$aspoly",
+    tri3: "$aspoly"
   },
   {
-    circle: ($, opts) => asPolygon($, opts)[0],
-    complexpoly: ($, opts) => new ComplexPolygon(
-      resample($.boundary, opts),
-      $.children.map((child) => resample(child, opts)),
-      __attribs($)
+    $aspoly: ($, opts) => asPolygon($, opts)[0],
+    $aspolyline: ($, opts) => asPolyline($, opts)[0],
+    group: ($, opts) => $.copyTransformed((child) => resample(child, opts)),
+    poly: ($, opts) => $.copyTransformed(
+      (points) => _resample(points, opts, true, true)
     ),
-    poly: ($, opts) => new Polygon(_resample($.points, opts, true, true), __attribs($)),
-    polyline: ($, opts) => new Polyline(_resample($.points, opts, false, true), __attribs($))
+    polyline: ($, opts) => $.copyTransformed(
+      (points) => _resample(points, opts, false, true)
+    )
   }
 );
 export {

package/rotate-around-axis.d.ts

@@ -0,0 +1,33 @@
+import type { MultiFn3 } from "@thi.ng/defmulti";
+import type { ReadonlyVec } from "@thi.ng/vectors";
+import type { IShape3 } from "./api.js";
+export type RotateAroundAxisFn = {
+    <T extends IShape3>(shape: T, axis: ReadonlyVec, theta: number): T;
+} & MultiFn3<IShape3, ReadonlyVec, number, IShape3>;
+/**
+ * Rotates given 3D shape by `theta` (in radians) around `axis`.
+ *
+ * @remarks
+ * Currently implemented for:
+ *
+ * - {@link Cubic3}
+ * - {@link Group3}
+ * - {@link Polygon3}
+ * - {@link Polyline3}
+ * - {@link Line3}
+ * - {@link Path3}
+ * - {@link Points3}
+ * - {@link Quad3}
+ * - {@link Quadratic3}
+ * - {@link Ray3}
+ * - {@link Triangle3}
+ *
+ * @param shape
+ * @param axis
+ * @param theta
+ */
+export declare const rotateAroundAxis: RotateAroundAxisFn;
+export declare const rotateX: (shape: IShape3, theta: number) => IShape3;
+export declare const rotateY: (shape: IShape3, theta: number) => IShape3;
+export declare const rotateZ: (shape: IShape3, theta: number) => IShape3;
+//# sourceMappingURL=rotate-around-axis.d.ts.map

package/rotate-around-axis.js

@@ -0,0 +1,57 @@
+import { defmulti } from "@thi.ng/defmulti/defmulti";
+import { mulV33 } from "@thi.ng/matrices/mulv";
+import { rotationAroundAxis33 } from "@thi.ng/matrices/rotation-around-axis";
+import { X3, Y3, Z3 } from "@thi.ng/vectors/api";
+import { rotateAroundAxis3 } from "@thi.ng/vectors/rotate-around-axis";
+import { Ray3 } from "./api/ray3.js";
+import { __copyAttribs } from "./internal/copy.js";
+import { __dispatch } from "./internal/dispatch.js";
+import { __segmentTransformer } from "./internal/transform.js";
+const rotateAroundAxis = defmulti(
+  __dispatch,
+  {
+    cubic3: "points3",
+    line3: "points3",
+    poly3: "points3",
+    polyline3: "points3",
+    quad3: "points3",
+    quadratic3: "points3",
+    tri3: "points3"
+  },
+  {
+    group3: ($, axis, theta) => $.copyTransformed(
+      (x) => rotateAroundAxis(x, axis, theta)
+    ),
+    path3: ($, axis, theta) => {
+      const mat = rotationAroundAxis33([], axis, theta);
+      return $.copyTransformed(
+        __segmentTransformer(
+          (geo) => rotateAroundAxis(geo, axis, theta),
+          (p) => mulV33([], mat, p)
+        )
+      );
+    },
+    points3: ($, axis, theta) => {
+      const mat = rotationAroundAxis33([], axis, theta);
+      return $.copyTransformed(
+        (points) => points.map((p) => mulV33([], mat, p))
+      );
+    },
+    ray3: ($, axis, theta) => {
+      return new Ray3(
+        rotateAroundAxis3([], $.pos, axis, theta),
+        rotateAroundAxis3([], $.dir, axis, theta),
+        __copyAttribs($.attribs)
+      );
+    }
+  }
+);
+const rotateX = (shape, theta) => rotateAroundAxis(shape, X3, theta);
+const rotateY = (shape, theta) => rotateAroundAxis(shape, Y3, theta);
+const rotateZ = (shape, theta) => rotateAroundAxis(shape, Z3, theta);
+export {
+  rotateAroundAxis,
+  rotateX,
+  rotateY,
+  rotateZ
+};

package/rotate.d.ts

@@ -1,5 +1,16 @@
 import type { MultiFn2 } from "@thi.ng/defmulti";
-import type { IShape } from "@thi.ng/geom-api";
+import type { IShape2 } from "./api.js";
+import type { Arc } from "./api/arc.js";
+import type { Ellipse } from "./api/ellipse.js";
+import type { Path } from "./api/path.js";
+import type { Polygon } from "./api/polygon.js";
+import type { Rect } from "./api/rect.js";
+export type RotateFn = {
+    (shape: Arc, theta: number): Path;
+    (shape: Ellipse, theta: number): Path;
+    (shape: Rect, theta: number): Polygon;
+    <T extends IShape2>(shape: T, theta: number): T;
+} & MultiFn2<IShape2, number, IShape2>;
 /**
  * Rotates given 2D shape by `theta` (in radians).
  *
@@ -7,10 +18,12 @@ import type { IShape } from "@thi.ng/geom-api";
  * Currently implemented for:
  *
  * - {@link Arc}
+ * - {@link BPatch}
  * - {@link Circle}
  * - {@link ComplexPolygon}
  * - {@link Cubic}
  * - {@link Ellipse}
+ * - {@link Extra}
  * - {@link Group}
  * - {@link Line}
  * - {@link Path}
@@ -27,5 +40,5 @@ import type { IShape } from "@thi.ng/geom-api";
  * @param shape
  * @param theta
  */
-export declare const rotate: MultiFn2<IShape, number, IShape>;
+export declare const rotate: RotateFn;
 //# sourceMappingURL=rotate.d.ts.map

package/rotate.js

@@ -1,68 +1,70 @@
 import { defmulti } from "@thi.ng/defmulti/defmulti";
+import { mulV22 } from "@thi.ng/matrices/mulv";
+import { rotation22 } from "@thi.ng/matrices/rotation";
 import { rotate as $rotate } from "@thi.ng/vectors/rotate";
 import { Circle } from "./api/circle.js";
-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 } 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 { Text } from "./api/text.js";
-import { Triangle } from "./api/triangle.js";
 import { asPath } from "./as-path.js";
 import { asPolygon } from "./as-polygon.js";
 import { __copyAttribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
-import { __rotatedShape as tx } from "./internal/rotate.js";
+import { __ensureNoArc } from "./internal/error.js";
 import { __segmentTransformer } from "./internal/transform.js";
 const rotate = defmulti(
   __dispatch,
-  {},
   {
-    arc: ($, theta) => {
-      const a = $.copy();
-      $rotate(null, a.pos, theta);
-      return a;
-    },
-    circle: ($, theta) => new Circle($rotate([], $.pos, theta), $.r, __copyAttribs($)),
-    complexpoly: ($, theta) => new ComplexPolygon(
-      rotate($.boundary, theta),
-      $.children.map((child) => rotate(child, theta))
+    arc: "$aspath",
+    bpatch: "points",
+    complexpoly: "group",
+    cubic: "points",
+    ellipse: "$aspath",
+    line: "points",
+    poly: "points",
+    polyline: "points",
+    quad: "points",
+    quadratic: "points",
+    rect: "$aspoly",
+    tri: "points"
+  },
+  {
+    $aspath: ($, theta) => rotate(asPath($), theta),
+    $aspoly: ($, theta) => rotate(asPolygon($)[0], theta),
+    circle: ($, theta) => new Circle(
+      $rotate([], $.pos, theta),
+      $.r,
+      __copyAttribs($.attribs)
     ),
-    cubic: tx(Cubic),
-    ellipse: ($, theta) => rotate(asPath($), theta),
+    extra: ($) => $,
     group: ($, theta) => $.copyTransformed((x) => rotate(x, theta)),
-    line: tx(Line),
     path: ($, theta) => {
-      const $rotateSegments = __segmentTransformer(
-        (geo) => rotate(geo, theta),
-        (p) => $rotate([], p, theta)
-      );
-      return new Path(
-        $rotateSegments($.segments),
-        $.subPaths.map($rotateSegments),
-        __copyAttribs($)
+      const mat = rotation22([], theta);
+      return $.copyTransformed(
+        __segmentTransformer(
+          (geo) => {
+            __ensureNoArc(geo);
+            return rotate(geo, theta);
+          },
+          (p) => mulV22([], mat, p)
+        )
       );
     },
-    points: tx(Points),
-    poly: tx(Polygon),
-    polyline: tx(Polyline),
-    quad: tx(Quad),
-    quadratic: tx(Quadratic),
-    ray: ($, theta) => {
-      return new Ray(
-        $rotate([], $.pos, theta),
-        $rotate([], $.dir, theta),
-        __copyAttribs($)
+    points: ($, theta) => {
+      const mat = rotation22([], theta);
+      return $.copyTransformed(
+        (points) => points.map((p) => mulV22([], mat, p))
       );
     },
-    rect: ($, theta) => rotate(asPolygon($)[0], theta),
-    text: ($, theta) => new Text($rotate([], $.pos, theta), $.body, __copyAttribs($)),
-    tri: tx(Triangle)
+    ray: ($, theta) => new Ray(
+      $rotate([], $.pos, theta),
+      $rotate([], $.dir, theta),
+      __copyAttribs($.attribs)
+    ),
+    text: ($, theta) => new Text(
+      $rotate([], $.pos, theta),
+      $.body,
+      __copyAttribs($.attribs)
+    )
   }
 );
 export {