brepjs 12.8.2 → 12.9.1

package/dist/topology.js

@@ -1,104 +1,105 @@
-import { h, d, a, f, e, c, x, y, i, z, A, B, C, v } from "./shapeFns-FDuKkrDR.js";
-import { a as a2, b, d as d2, e as e2, f as f2, g, c as c2, j, k, l, m, n, o, p, q, r, s, t, u, v as v2, w, x as x2, y as y2, z as z2, A as A2, B as B2, C as C2, D, E, F, G, H, I, J, K, L, M, N, O, P, Q } from "./topology-C7x98OVn.js";
-import { k as k2, j as j2 } from "./booleanFns-BCTjYZAg.js";
-import { h as h2, e as e3, b as b2, i as i2, f as f3, j as j3, d as d3, c as c3, a as a3, k as k3, l as l2, g as g2, m as m2, o as o2 } from "./curveFns-mROFhiuG.js";
-import { l as l3, c as c4, m as m3, j as j4, d as d4, e as e4, f as f4, q as q2, r as r2, g as g3, k as k4, s as s2, i as i3, n as n2, o as o3, p as p2, t as t2, w as w2, u as u2, h as h3 } from "./faceFns-B8GnxjdY.js";
-import { c as c5, b as b3, e as e5, d as d5, f as f5 } from "./meshFns-nQjK38EC.js";
+import { g, b, i } from "./shapeFns-BJbua5kT.js";
+import { d, e, f, g as g2, j, k, c, l, o, p, q, u, v, w, x, y, z, A, B, C, D, E, F, G, H, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y } from "./topology-D6LeuhI_.js";
+import { h, g as g3 } from "./booleanFns-Br2KdGJq.js";
+import { i as i2, h as h2, a, j as j2, c as c2, k as k2, f as f2, d as d2, e as e2, l as l2, g as g4, b as b2, m, o as o2 } from "./curveFns-1u0oZ0u0.js";
+import { l as l3, c as c3, m as m2, j as j3, d as d3, e as e3, f as f3, q as q2, r, g as g5, k as k3, s, i as i3, n, o as o3, p as p2, t, w as w2, u as u2, h as h3 } from "./faceFns-DGMp47Os.js";
+import { c as c4, b as b3, e as e4, d as d4, f as f4 } from "./meshFns-CtUl9fGY.js";
+import { f as f5, d as d5, b as b4, e as e5, c as c5, i as i4, j as j4, k as k4, l as l4, m as m3, v as v2 } from "./topologyQueryFns-De439iBP.js";
 export {
-  a2 as addHoles,
-  b as adjacentFaces,
-  h2 as approximateCurve,
+  d as addHoles,
+  e as adjacentFaces,
+  i2 as approximateCurve,
   l3 as asTopo,
-  d2 as autoHeal,
-  e2 as bezier,
-  f2 as box,
-  g as bsplineApprox,
-  c4 as cast,
-  c2 as chamferDistAngleShape,
-  j as circle,
-  m3 as classifyPointOnFace,
-  c5 as clearMeshCache,
-  k as compound,
-  l as cone,
+  f as autoHeal,
+  g2 as bezier,
+  j as box,
+  k as bsplineApprox,
+  c3 as cast,
+  c as chamferDistAngleShape,
+  l as circle,
+  m2 as classifyPointOnFace,
+  c4 as clearMeshCache,
+  o as compound,
+  p as cone,
   b3 as createMeshCache,
-  e3 as curveEndPoint,
-  b2 as curveIsClosed,
-  i2 as curveIsPeriodic,
-  f3 as curveLength,
-  j3 as curvePeriod,
-  d3 as curvePointAt,
-  c3 as curveStartPoint,
-  a3 as curveTangentAt,
-  k2 as cutAll,
-  m as cylinder,
-  j4 as deserializeShape,
-  d4 as downcast,
-  n as edgesOfFace,
-  o as ellipse,
-  p as ellipseArc,
-  q as ellipsoid,
-  e5 as exportIGES,
-  d5 as exportSTEP,
-  f5 as exportSTL,
-  r as face,
-  e4 as faceCenter,
-  f4 as faceGeomType,
+  h2 as curveEndPoint,
+  a as curveIsClosed,
+  j2 as curveIsPeriodic,
+  c2 as curveLength,
+  k2 as curvePeriod,
+  f2 as curvePointAt,
+  d2 as curveStartPoint,
+  e2 as curveTangentAt,
+  h as cutAll,
+  q as cylinder,
+  j3 as deserializeShape,
+  d3 as downcast,
+  u as edgesOfFace,
+  v as ellipse,
+  w as ellipseArc,
+  x as ellipsoid,
+  e4 as exportIGES,
+  d4 as exportSTEP,
+  f4 as exportSTL,
+  y as face,
+  e3 as faceCenter,
+  f3 as faceGeomType,
   q2 as faceOrientation,
-  s as facesOfEdge,
-  t as filledFace,
-  r2 as flipFaceOrientation,
-  k3 as flipOrientation,
-  j2 as fuseAll,
-  h as getBounds,
-  l2 as getCurveType,
-  d as getEdges,
-  a as getFaces,
-  f as getHashCode,
-  g2 as getOrientation,
-  g3 as getSurfaceType,
-  e as getVertices,
-  c as getWires,
-  u as healFace,
-  v2 as healSolid,
-  w as healWire,
-  x2 as helix,
-  k4 as innerWires,
-  m2 as interpolateCurve,
-  x as invalidateShapeCache,
-  s2 as isCompSolid,
-  y as isEqualShape,
+  z as facesOfEdge,
+  A as filledFace,
+  r as flipFaceOrientation,
+  l2 as flipOrientation,
+  g3 as fuseAll,
+  f5 as getBounds,
+  g4 as getCurveType,
+  d5 as getEdges,
+  b4 as getFaces,
+  g as getHashCode,
+  b2 as getOrientation,
+  g5 as getSurfaceType,
+  e5 as getVertices,
+  c5 as getWires,
+  B as healFace,
+  C as healSolid,
+  D as healWire,
+  E as helix,
+  k3 as innerWires,
+  m as interpolateCurve,
+  i4 as invalidateShapeCache,
+  s as isCompSolid,
+  b as isEqualShape,
   i as isSameShape,
-  z as iterEdges,
-  A as iterFaces,
+  j4 as iterEdges,
+  k4 as iterFaces,
   i3 as iterTopo,
-  B as iterVertices,
-  C as iterWires,
-  y2 as line,
-  n2 as normalAt,
-  z2 as offsetFace,
+  l4 as iterVertices,
+  m3 as iterWires,
+  F as line,
+  n as normalAt,
+  G as offsetFace,
   o2 as offsetWire2D,
   o3 as outerWire,
   p2 as pointOnSurface,
-  A2 as polygon,
-  t2 as projectPointOnFace,
-  B2 as sewShells,
+  H as polygon,
+  t as projectPointOnFace,
+  J as sewShells,
   w2 as shapeType,
-  C2 as sharedEdges,
-  D as solid,
-  E as sphere,
-  F as subFace,
-  G as tangentArc,
-  H as threePointArc,
-  I as toBufferGeometryData,
-  J as toGroupedBufferGeometryData,
-  K as toLineGeometryData,
-  L as torus,
+  K as sharedEdges,
+  L as solid,
+  M as sphere,
+  N as subFace,
+  O as tangentArc,
+  P as threePointArc,
+  Q as toBufferGeometryData,
+  R as toGroupedBufferGeometryData,
+  S as toLineGeometryData,
+  T as torus,
   u2 as uvBounds,
   h3 as uvCoordinates,
-  M as vertex,
-  v as vertexPosition,
-  N as verticesOfEdge,
-  O as wire,
-  P as wireLoop,
-  Q as wiresOfFace
+  U as vertex,
+  v2 as vertexPosition,
+  V as verticesOfEdge,
+  W as wire,
+  X as wireLoop,
+  Y as wiresOfFace
 };

package/dist/topologyQueryFns-De439iBP.js

@@ -0,0 +1,119 @@
+import { g as getKernel, c as castShape, a as getShapeKind } from "./shapeTypes-CAEAyk8j.js";
+import { i as iterTopo, d as downcast } from "./faceFns-DGMp47Os.js";
+import { u as unwrap } from "./result-DtuwWSUD.js";
+const topoCache = /* @__PURE__ */ new WeakMap();
+function getOrCreateCache(shape) {
+  let entry = topoCache.get(shape.wrapped);
+  if (!entry) {
+    entry = {};
+    topoCache.set(shape.wrapped, entry);
+  }
+  return entry;
+}
+function getCacheEntry(shape) {
+  return topoCache.get(shape.wrapped);
+}
+function invalidateShapeCache(shape) {
+  topoCache.delete(shape.wrapped);
+}
+function getEdges(shape) {
+  const cache = getOrCreateCache(shape);
+  if (cache.edges) return cache.edges;
+  const edges = Array.from(iterTopo(shape.wrapped, "edge")).map(
+    (e) => castShape(unwrap(downcast(e)))
+  );
+  cache.edges = edges;
+  return edges;
+}
+function getFaces(shape) {
+  const cache = getOrCreateCache(shape);
+  if (cache.faces) return cache.faces;
+  const faces = Array.from(iterTopo(shape.wrapped, "face")).map(
+    (e) => castShape(unwrap(downcast(e)))
+  );
+  cache.faces = faces;
+  return faces;
+}
+function getWires(shape) {
+  const cache = getOrCreateCache(shape);
+  if (cache.wires) return cache.wires;
+  const wires = Array.from(iterTopo(shape.wrapped, "wire")).map(
+    (e) => castShape(unwrap(downcast(e)))
+  );
+  cache.wires = wires;
+  return wires;
+}
+function getVertices(shape) {
+  const cache = getOrCreateCache(shape);
+  if (cache.vertices) return cache.vertices;
+  const vertices = Array.from(iterTopo(shape.wrapped, "vertex")).map(
+    (e) => castShape(unwrap(downcast(e)))
+  );
+  cache.vertices = vertices;
+  return vertices;
+}
+function* iterEdges(shape) {
+  for (const e of iterTopo(shape.wrapped, "edge")) {
+    yield castShape(unwrap(downcast(e)));
+  }
+}
+function* iterFaces(shape) {
+  for (const f of iterTopo(shape.wrapped, "face")) {
+    yield castShape(unwrap(downcast(f)));
+  }
+}
+function* iterWires(shape) {
+  for (const w of iterTopo(shape.wrapped, "wire")) {
+    yield castShape(unwrap(downcast(w)));
+  }
+}
+function* iterVertices(shape) {
+  for (const v of iterTopo(shape.wrapped, "vertex")) {
+    yield castShape(unwrap(downcast(v)));
+  }
+}
+function getBounds(shape) {
+  const cache = getOrCreateCache(shape);
+  if (cache.bounds) return cache.bounds;
+  const { min, max } = getKernel().boundingBox(shape.wrapped);
+  const bounds = {
+    xMin: min[0],
+    xMax: max[0],
+    yMin: min[1],
+    yMax: max[1],
+    zMin: min[2],
+    zMax: max[2]
+  };
+  cache.bounds = bounds;
+  return bounds;
+}
+function describe(shape) {
+  return {
+    kind: getShapeKind(shape),
+    faceCount: getFaces(shape).length,
+    edgeCount: getEdges(shape).length,
+    wireCount: getWires(shape).length,
+    vertexCount: getVertices(shape).length,
+    valid: getKernel().isValid(shape.wrapped),
+    bounds: getBounds(shape)
+  };
+}
+function vertexPosition(vertex) {
+  return getKernel().vertexPosition(vertex.wrapped);
+}
+export {
+  getOrCreateCache as a,
+  getFaces as b,
+  getWires as c,
+  getEdges as d,
+  getVertices as e,
+  getBounds as f,
+  getCacheEntry as g,
+  describe as h,
+  invalidateShapeCache as i,
+  iterEdges as j,
+  iterFaces as k,
+  iterVertices as l,
+  iterWires as m,
+  vertexPosition as v
+};

package/dist/topologyQueryFns-fz5kz5e1.cjs

@@ -0,0 +1,118 @@
+"use strict";
+const shapeTypes = require("./shapeTypes-owrg2MNK.cjs");
+const faceFns = require("./faceFns-BAKkZG6D.cjs");
+const result = require("./result-DJAAj1yb.cjs");
+const topoCache = /* @__PURE__ */ new WeakMap();
+function getOrCreateCache(shape) {
+  let entry = topoCache.get(shape.wrapped);
+  if (!entry) {
+    entry = {};
+    topoCache.set(shape.wrapped, entry);
+  }
+  return entry;
+}
+function getCacheEntry(shape) {
+  return topoCache.get(shape.wrapped);
+}
+function invalidateShapeCache(shape) {
+  topoCache.delete(shape.wrapped);
+}
+function getEdges(shape) {
+  const cache = getOrCreateCache(shape);
+  if (cache.edges) return cache.edges;
+  const edges = Array.from(faceFns.iterTopo(shape.wrapped, "edge")).map(
+    (e) => shapeTypes.castShape(result.unwrap(faceFns.downcast(e)))
+  );
+  cache.edges = edges;
+  return edges;
+}
+function getFaces(shape) {
+  const cache = getOrCreateCache(shape);
+  if (cache.faces) return cache.faces;
+  const faces = Array.from(faceFns.iterTopo(shape.wrapped, "face")).map(
+    (e) => shapeTypes.castShape(result.unwrap(faceFns.downcast(e)))
+  );
+  cache.faces = faces;
+  return faces;
+}
+function getWires(shape) {
+  const cache = getOrCreateCache(shape);
+  if (cache.wires) return cache.wires;
+  const wires = Array.from(faceFns.iterTopo(shape.wrapped, "wire")).map(
+    (e) => shapeTypes.castShape(result.unwrap(faceFns.downcast(e)))
+  );
+  cache.wires = wires;
+  return wires;
+}
+function getVertices(shape) {
+  const cache = getOrCreateCache(shape);
+  if (cache.vertices) return cache.vertices;
+  const vertices = Array.from(faceFns.iterTopo(shape.wrapped, "vertex")).map(
+    (e) => shapeTypes.castShape(result.unwrap(faceFns.downcast(e)))
+  );
+  cache.vertices = vertices;
+  return vertices;
+}
+function* iterEdges(shape) {
+  for (const e of faceFns.iterTopo(shape.wrapped, "edge")) {
+    yield shapeTypes.castShape(result.unwrap(faceFns.downcast(e)));
+  }
+}
+function* iterFaces(shape) {
+  for (const f of faceFns.iterTopo(shape.wrapped, "face")) {
+    yield shapeTypes.castShape(result.unwrap(faceFns.downcast(f)));
+  }
+}
+function* iterWires(shape) {
+  for (const w of faceFns.iterTopo(shape.wrapped, "wire")) {
+    yield shapeTypes.castShape(result.unwrap(faceFns.downcast(w)));
+  }
+}
+function* iterVertices(shape) {
+  for (const v of faceFns.iterTopo(shape.wrapped, "vertex")) {
+    yield shapeTypes.castShape(result.unwrap(faceFns.downcast(v)));
+  }
+}
+function getBounds(shape) {
+  const cache = getOrCreateCache(shape);
+  if (cache.bounds) return cache.bounds;
+  const { min, max } = shapeTypes.getKernel().boundingBox(shape.wrapped);
+  const bounds = {
+    xMin: min[0],
+    xMax: max[0],
+    yMin: min[1],
+    yMax: max[1],
+    zMin: min[2],
+    zMax: max[2]
+  };
+  cache.bounds = bounds;
+  return bounds;
+}
+function describe(shape) {
+  return {
+    kind: shapeTypes.getShapeKind(shape),
+    faceCount: getFaces(shape).length,
+    edgeCount: getEdges(shape).length,
+    wireCount: getWires(shape).length,
+    vertexCount: getVertices(shape).length,
+    valid: shapeTypes.getKernel().isValid(shape.wrapped),
+    bounds: getBounds(shape)
+  };
+}
+function vertexPosition(vertex) {
+  return shapeTypes.getKernel().vertexPosition(vertex.wrapped);
+}
+exports.describe = describe;
+exports.getBounds = getBounds;
+exports.getCacheEntry = getCacheEntry;
+exports.getEdges = getEdges;
+exports.getFaces = getFaces;
+exports.getOrCreateCache = getOrCreateCache;
+exports.getVertices = getVertices;
+exports.getWires = getWires;
+exports.invalidateShapeCache = invalidateShapeCache;
+exports.iterEdges = iterEdges;
+exports.iterFaces = iterFaces;
+exports.iterVertices = iterVertices;
+exports.iterWires = iterWires;
+exports.vertexPosition = vertexPosition;

package/dist/{types-CWDdqcrq.js → types-CcKqsmd0.js}

@@ -19,7 +19,7 @@ function resolveDirection(d) {
   return d;
 }
 export {
-  toVec3 as a,
+  toVec2 as a,
   resolveDirection as r,
-  toVec2 as t
+  toVec3 as t
 };

package/dist/utils/precisionRound.d.ts

@@ -4,4 +4,8 @@
  * @param precision - Number of decimal places (may be negative for rounding to tens, hundreds, etc.).
  */
 export default function precisionRound(number: number, precision: number): number;
+/** Round a number to 2 decimal places. */
+export declare function round2(v: number): number;
+/** Round a number to 5 decimal places. */
+export declare function round5(v: number): number;
 //# sourceMappingURL=precisionRound.d.ts.map

package/dist/utils/precisionRound.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"precisionRound.d.ts","sourceRoot":"","sources":["../../src/utils/precisionRound.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAIhF"}
+{"version":3,"file":"precisionRound.d.ts","sourceRoot":"","sources":["../../src/utils/precisionRound.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAIhF;AAED,0CAA0C;AAC1C,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAExC;AAED,0CAA0C;AAC1C,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAExC"}

package/dist/utils/vec2d.d.ts

@@ -44,6 +44,11 @@ export declare const polarAngle2d: ([x0, y0]: Point2D, [x1, y1]?: Point2D) => nu
  * ```
  */
 export declare const rotate2d: (point: Point2D, angle: number, center?: Point2D) => Point2D;
+/**
+ * Normalize a 2D vector to unit length.
+ * Returns `[0, 0]` for zero-length vectors (within epsilon).
+ */
+export declare function normalize2d([x, y]: Point2D): Point2D;
 /** Convert polar coordinates (r, theta) to a Cartesian Point2D. */
 export declare const polarToCartesian: (r: number, theta: number) => Point2D;
 /**

package/dist/utils/vec2d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vec2d.d.ts","sourceRoot":"","sources":["../../src/utils/vec2d.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,6DAA6D;AAC7D,MAAM,MAAM,OAAO,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAMvC,iEAAiE;AACjE,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAE3C,8EAA8E;AAC9E,eAAO,MAAM,gBAAgB,OAAO,CAAC;AAErC,wDAAwD;AACxD,eAAO,MAAM,eAAe,WAAO,CAAC;AAMpC,qEAAqE;AACrE,eAAO,MAAM,SAAS,GACpB,UAAU,OAAO,EACjB,UAAU,OAAO,EACjB,kBAA2B,KAC1B,OAEF,CAAC;AAEF,yCAAyC;AACzC,eAAO,MAAM,KAAK,GAAI,UAAU,OAAO,EAAE,UAAU,OAAO,KAAG,OAE5D,CAAC;AAEF,oDAAoD;AACpD,eAAO,MAAM,UAAU,GAAI,UAAU,OAAO,EAAE,UAAU,OAAO,KAAG,OAEjE,CAAC;AAEF,wCAAwC;AACxC,eAAO,MAAM,gBAAgB,GAAI,UAAU,OAAO,EAAE,QAAQ,MAAM,KAAG,OAEpE,CAAC;AAEF,+FAA+F;AAC/F,eAAO,MAAM,UAAU,GAAI,UAAU,OAAO,EAAE,WAAU,OAAgB,KAAG,MAE1E,CAAC;AAEF,oFAAoF;AACpF,eAAO,MAAM,gBAAgB,GAAI,UAAU,OAAO,EAAE,WAAU,OAAgB,KAAG,MAEhF,CAAC;AAEF,0EAA0E;AAC1E,wBAAgB,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,GAAG,MAAM,CAE3E;AAED,iDAAiD;AACjD,wBAAgB,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,GAAG,MAAM,CAEzE;AAED,oEAAoE;AACpE,eAAO,MAAM,OAAO,GAAI,UAAU,OAAO,EAAE,WAAU,OAAgB,KAAG,MAEvE,CAAC;AAEF,+EAA+E;AAC/E,eAAO,MAAM,YAAY,GAAI,UAAU,OAAO,EAAE,WAAU,OAAgB,KAAG,MAE5E,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,OAAO,EAAE,OAAO,MAAM,EAAE,SAAQ,OAAgB,KAAG,OAclF,CAAC;AAEF,mEAAmE;AACnE,eAAO,MAAM,gBAAgB,GAAI,GAAG,MAAM,EAAE,OAAO,MAAM,KAAG,OAI3D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,QAAQ,OAAO,KAAG,CAAC,MAAM,EAAE,MAAM,CAIjE,CAAC"}
+{"version":3,"file":"vec2d.d.ts","sourceRoot":"","sources":["../../src/utils/vec2d.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,6DAA6D;AAC7D,MAAM,MAAM,OAAO,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAMvC,iEAAiE;AACjE,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAE3C,8EAA8E;AAC9E,eAAO,MAAM,gBAAgB,OAAO,CAAC;AAErC,wDAAwD;AACxD,eAAO,MAAM,eAAe,WAAO,CAAC;AAMpC,qEAAqE;AACrE,eAAO,MAAM,SAAS,GACpB,UAAU,OAAO,EACjB,UAAU,OAAO,EACjB,kBAA2B,KAC1B,OAEF,CAAC;AAEF,yCAAyC;AACzC,eAAO,MAAM,KAAK,GAAI,UAAU,OAAO,EAAE,UAAU,OAAO,KAAG,OAE5D,CAAC;AAEF,oDAAoD;AACpD,eAAO,MAAM,UAAU,GAAI,UAAU,OAAO,EAAE,UAAU,OAAO,KAAG,OAEjE,CAAC;AAEF,wCAAwC;AACxC,eAAO,MAAM,gBAAgB,GAAI,UAAU,OAAO,EAAE,QAAQ,MAAM,KAAG,OAEpE,CAAC;AAEF,+FAA+F;AAC/F,eAAO,MAAM,UAAU,GAAI,UAAU,OAAO,EAAE,WAAU,OAAgB,KAAG,MAE1E,CAAC;AAEF,oFAAoF;AACpF,eAAO,MAAM,gBAAgB,GAAI,UAAU,OAAO,EAAE,WAAU,OAAgB,KAAG,MAEhF,CAAC;AAEF,0EAA0E;AAC1E,wBAAgB,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,GAAG,MAAM,CAE3E;AAED,iDAAiD;AACjD,wBAAgB,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,GAAG,MAAM,CAEzE;AAED,oEAAoE;AACpE,eAAO,MAAM,OAAO,GAAI,UAAU,OAAO,EAAE,WAAU,OAAgB,KAAG,MAEvE,CAAC;AAEF,+EAA+E;AAC/E,eAAO,MAAM,YAAY,GAAI,UAAU,OAAO,EAAE,WAAU,OAAgB,KAAG,MAE5E,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,OAAO,EAAE,OAAO,MAAM,EAAE,SAAQ,OAAgB,KAAG,OAclF,CAAC;AAEF;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAGpD;AAED,mEAAmE;AACnE,eAAO,MAAM,gBAAgB,GAAI,GAAG,MAAM,EAAE,OAAO,MAAM,KAAG,OAI3D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,QAAQ,OAAO,KAAG,CAAC,MAAM,EAAE,MAAM,CAIjE,CAAC"}

package/dist/{vecOps-ZDdZWbwT.js → vecOps-LTN--A58.js}

@@ -74,20 +74,20 @@ export {
   DEG2RAD as D,
   HASH_CODE_MAX as H,
   RAD2DEG as R,
-  vecAngle as a,
-  vecCross as b,
-  vecDistance as c,
+  vecAdd as a,
+  vecScale as b,
+  vecNormalize as c,
   vecDot as d,
-  vecEquals as e,
-  vecIsZero as f,
-  vecLength as g,
-  vecLengthSq as h,
-  vecNegate as i,
-  vecNormalize as j,
-  vecProjectToPlane as k,
-  vecRepr as l,
-  vecRotate as m,
-  vecScale as n,
-  vecSub as o,
-  vecAdd as v
+  vecCross as e,
+  vecSub as f,
+  vecRotate as g,
+  vecDistance as h,
+  vecIsZero as i,
+  vecAngle as j,
+  vecEquals as k,
+  vecLengthSq as l,
+  vecNegate as m,
+  vecProjectToPlane as n,
+  vecRepr as o,
+  vecLength as v
 };

package/dist/{vectors-D_IiZx0q.cjs → vectors-C8N_QeEX.cjs}

@@ -1,7 +1,7 @@
 "use strict";
 const types = require("./types-CA_xrgDq.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
-const result = require("./result-fAX0OZzI.cjs");
+const result = require("./result-DJAAj1yb.cjs");
 function createPlane(origin, xDirection = null, normal = [0, 0, 1]) {
   const zDir = vecOps.vecNormalize(normal);
   if (vecOps.vecIsZero(zDir)) throw new Error("Plane normal must be non-zero");
@@ -58,6 +58,13 @@ function resolvePlane(input, origin) {
   }
   return input;
 }
+function makePlane(plane, origin) {
+  if (plane && typeof plane !== "string") {
+    return { ...plane };
+  } else {
+    return resolvePlane(plane ?? "XY", origin);
+  }
+}
 function planeToWorld(plane, local) {
   const [u, v] = local;
   return vecOps.vecAdd(vecOps.vecAdd(plane.origin, vecOps.vecScale(plane.xDir, u)), vecOps.vecScale(plane.yDir, v));
@@ -74,6 +81,7 @@ function pivotPlane(plane, angleDeg, axis = [1, 0, 0]) {
 }
 exports.createNamedPlane = createNamedPlane;
 exports.createPlane = createPlane;
+exports.makePlane = makePlane;
 exports.pivotPlane = pivotPlane;
 exports.planeToWorld = planeToWorld;
 exports.resolvePlane = resolvePlane;

package/dist/{vectors-Bx8wkNui.js → vectors-DTREgnVp.js}

@@ -1,6 +1,6 @@
-import { a as toVec3 } from "./types-CWDdqcrq.js";
-import { j as vecNormalize, f as vecIsZero, b as vecCross, v as vecAdd, n as vecScale, m as vecRotate, D as DEG2RAD } from "./vecOps-ZDdZWbwT.js";
-import { e as err, z as validationError, o as ok } from "./result-BaSD1fqR.js";
+import { t as toVec3 } from "./types-CcKqsmd0.js";
+import { c as vecNormalize, i as vecIsZero, e as vecCross, a as vecAdd, b as vecScale, g as vecRotate, D as DEG2RAD } from "./vecOps-LTN--A58.js";
+import { e as err, v as validationError, o as ok } from "./result-DtuwWSUD.js";
 function createPlane(origin, xDirection = null, normal = [0, 0, 1]) {
   const zDir = vecNormalize(normal);
   if (vecIsZero(zDir)) throw new Error("Plane normal must be non-zero");
@@ -57,6 +57,13 @@ function resolvePlane(input, origin) {
   }
   return input;
 }
+function makePlane(plane, origin) {
+  if (plane && typeof plane !== "string") {
+    return { ...plane };
+  } else {
+    return resolvePlane(plane ?? "XY", origin);
+  }
+}
 function planeToWorld(plane, local) {
   const [u, v] = local;
   return vecAdd(vecAdd(plane.origin, vecScale(plane.xDir, u)), vecScale(plane.yDir, v));
@@ -72,10 +79,11 @@ function pivotPlane(plane, angleDeg, axis = [1, 0, 0]) {
   return { origin: plane.origin, xDir: newXDir, yDir: newYDir, zDir: newZDir };
 }
 export {
-  createPlane as a,
-  planeToWorld as b,
-  createNamedPlane as c,
-  pivotPlane as p,
+  createNamedPlane as a,
+  pivotPlane as b,
+  createPlane as c,
+  makePlane as m,
+  planeToWorld as p,
   resolvePlane as r,
   translatePlane as t
 };

package/dist/vectors.cjs

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const types = require("./types-CA_xrgDq.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
-const vectors = require("./vectors-D_IiZx0q.cjs");
+const vectors = require("./vectors-C8N_QeEX.cjs");
 exports.resolveDirection = types.resolveDirection;
 exports.toVec2 = types.toVec2;
 exports.toVec3 = types.toVec3;

package/dist/vectors.js

@@ -1,31 +1,31 @@
-import { r, t, a } from "./types-CWDdqcrq.js";
-import { D, R, v, a as a2, b, c, d, e, f, g, h, i, j, k, l, m, n, o } from "./vecOps-ZDdZWbwT.js";
-import { c as c2, a as a3, p, r as r2, t as t2 } from "./vectors-Bx8wkNui.js";
+import { r, a, t } from "./types-CcKqsmd0.js";
+import { D, R, a as a2, j, e, h, d, k, i, v, l, m, c, n, o, g, b, f } from "./vecOps-LTN--A58.js";
+import { a as a3, c as c2, b as b2, r as r2, t as t2 } from "./vectors-DTREgnVp.js";
 export {
   D as DEG2RAD,
   R as RAD2DEG,
-  c2 as createNamedPlane,
-  a3 as createPlane,
-  p as pivotPlane,
+  a3 as createNamedPlane,
+  c2 as createPlane,
+  b2 as pivotPlane,
   r as resolveDirection,
   r2 as resolvePlane,
-  t as toVec2,
-  a as toVec3,
+  a as toVec2,
+  t as toVec3,
   t2 as translatePlane,
-  v as vecAdd,
-  a2 as vecAngle,
-  b as vecCross,
-  c as vecDistance,
+  a2 as vecAdd,
+  j as vecAngle,
+  e as vecCross,
+  h as vecDistance,
   d as vecDot,
-  e as vecEquals,
-  f as vecIsZero,
-  g as vecLength,
-  h as vecLengthSq,
-  i as vecNegate,
-  j as vecNormalize,
-  k as vecProjectToPlane,
-  l as vecRepr,
-  m as vecRotate,
-  n as vecScale,
-  o as vecSub
+  k as vecEquals,
+  i as vecIsZero,
+  v as vecLength,
+  l as vecLengthSq,
+  m as vecNegate,
+  c as vecNormalize,
+  n as vecProjectToPlane,
+  o as vecRepr,
+  g as vecRotate,
+  b as vecScale,
+  f as vecSub
 };