brepjs 8.8.2 → 8.8.3

package/dist/Blueprint-BmbNUnGI.cjs

@@ -1,1185 +0,0 @@
-"use strict";
-const vectors = require("./vectors-CGLqemPY.cjs");
-const occtBoundary = require("./occtBoundary-Cqfsau2c.cjs");
-const shapeTypes = require("./shapeTypes-CIijJxCz.cjs");
-const faceFns = require("./faceFns-CxaLWOjc.cjs");
-const curveFns = require("./curveFns-6ovDM_sR.cjs");
-const errors = require("./errors-NNmTtM5u.cjs");
-const surfaceBuilders = require("./surfaceBuilders-CC0ZQGix.cjs");
-const helpers = require("./helpers-CRfqaW0Y.cjs");
-const vecOps = require("./vecOps-CjRL1jau.cjs");
-const result = require("./result.cjs");
-function makePlane(plane, origin) {
-  if (plane && typeof plane !== "string") {
-    return { ...plane };
-  } else {
-    return vectors.resolvePlane(plane ?? "XY", origin);
-  }
-}
-function mirror(shape, inputPlane, origin) {
-  const oc = occtBoundary.getKernel().oc;
-  const [r, gc] = shapeTypes.localGC();
-  let originVec;
-  let directionVec;
-  if (typeof inputPlane === "string") {
-    const plane = vectors.resolvePlane(inputPlane, origin);
-    originVec = plane.origin;
-    directionVec = plane.zDir;
-  } else if (inputPlane && typeof inputPlane === "object" && "origin" in inputPlane && "zDir" in inputPlane) {
-    originVec = origin ? occtBoundary.toVec3(origin) : inputPlane.origin;
-    directionVec = inputPlane.zDir;
-  } else if (inputPlane) {
-    originVec = origin ? occtBoundary.toVec3(origin) : [0, 0, 0];
-    directionVec = occtBoundary.toVec3(inputPlane);
-  } else {
-    const plane = vectors.resolvePlane("YZ", origin);
-    originVec = plane.origin;
-    directionVec = plane.zDir;
-  }
-  const mirrorAxis = r(occtBoundary.makeOcAx2(originVec, directionVec));
-  const trsf = r(new oc.gp_Trsf_1());
-  trsf.SetMirror_3(mirrorAxis);
-  const transformer = r(new oc.BRepBuilderAPI_Transform_2(shape, trsf, true));
-  const newShape = transformer.ModifiedShape(shape);
-  gc();
-  return newShape;
-}
-function isPoint2D(point) {
-  return Array.isArray(point) && point.length === 2 && typeof point[0] === "number" && typeof point[1] === "number";
-}
-function precisionRound(number, precision) {
-  const factor = Math.pow(10, precision);
-  const n = precision < 0 ? number : 0.01 / factor + number;
-  return Math.round(n * factor) / factor;
-}
-function round2(v) {
-  return Math.round(v * 100) / 100;
-}
-const reprPnt = ([x, y]) => {
-  return `(${round2(x)},${round2(y)})`;
-};
-const asFixed = (p, precision = 1e-9) => {
-  let num = p;
-  if (Math.abs(p) < precision) num = 0;
-  return num.toFixed(-Math.log10(precision));
-};
-const removeDuplicatePoints = (points, precision = 1e-9) => {
-  return Array.from(
-    new Map(
-      points.map(([p0, p1]) => [
-        `[${asFixed(p0, precision)},${asFixed(p1, precision)}]`,
-        [p0, p1]
-      ])
-    ).values()
-  );
-};
-const pnt = ([x, y]) => {
-  const oc = occtBoundary.getKernel().oc;
-  return new oc.gp_Pnt2d_3(x, y);
-};
-const direction2d = ([x, y]) => {
-  const oc = occtBoundary.getKernel().oc;
-  return new oc.gp_Dir2d_4(x, y);
-};
-const vec = ([x, y]) => {
-  const oc = occtBoundary.getKernel().oc;
-  return new oc.gp_Vec2d_4(x, y);
-};
-const axis2d = (point, direction) => {
-  const oc = occtBoundary.getKernel().oc;
-  const [r, gc] = shapeTypes.localGC();
-  const axis = new oc.gp_Ax2d_2(r(pnt(point)), r(direction2d(direction)));
-  gc();
-  return axis;
-};
-class BoundingBox2d {
-  _wrapped;
-  _deleted = false;
-  constructor(wrapped) {
-    const oc = occtBoundary.getKernel().oc;
-    this._wrapped = wrapped ?? new oc.Bnd_Box2d();
-    shapeTypes.registerForCleanup(this, this._wrapped);
-  }
-  get wrapped() {
-    if (this._deleted) throw new Error("This object has been deleted");
-    return this._wrapped;
-  }
-  delete() {
-    if (!this._deleted) {
-      this._deleted = true;
-      shapeTypes.unregisterFromCleanup(this._wrapped);
-      this._wrapped.delete();
-    }
-  }
-  /** Return a human-readable string of the form `(xMin,yMin) - (xMax,yMax)`. */
-  get repr() {
-    const [min, max] = this.bounds;
-    return `${reprPnt(min)} - ${reprPnt(max)}`;
-  }
-  /** Return the `[min, max]` corner points of the bounding box. */
-  get bounds() {
-    const xMin = { current: 0 };
-    const yMin = { current: 0 };
-    const xMax = { current: 0 };
-    const yMax = { current: 0 };
-    this.wrapped.Get(xMin, yMin, xMax, yMax);
-    return [
-      [xMin.current, yMin.current],
-      [xMax.current, yMax.current]
-    ];
-  }
-  /** Return the center point of the bounding box. */
-  get center() {
-    const [[xmin, ymin], [xmax, ymax]] = this.bounds;
-    return [xmin + (xmax - xmin) / 2, ymin + (ymax - ymin) / 2];
-  }
-  /** Return the width (x-extent) of the bounding box. */
-  get width() {
-    const [[xmin], [xmax]] = this.bounds;
-    return Math.abs(xmax - xmin);
-  }
-  /** Return the height (y-extent) of the bounding box. */
-  get height() {
-    const [[, ymin], [, ymax]] = this.bounds;
-    return Math.abs(ymax - ymin);
-  }
-  /**
-   * Return a point guaranteed to lie outside the bounding box.
-   *
-   * @param paddingPercent - Extra padding as a percentage of the box dimensions.
-   */
-  outsidePoint(paddingPercent = 1) {
-    const [min, max] = this.bounds;
-    const width = max[0] - min[0];
-    const height = max[1] - min[1];
-    return [
-      max[0] + width / 100 * paddingPercent,
-      max[1] + height / 100 * paddingPercent * 0.9
-    ];
-  }
-  /** Expand this bounding box to include `other`. */
-  add(other) {
-    this.wrapped.Add_1(other.wrapped);
-  }
-  /** Test whether this bounding box and `other` are completely disjoint. */
-  isOut(other) {
-    return this.wrapped.IsOut_4(other.wrapped);
-  }
-  /** Test whether the given point lies inside (or on the boundary of) this box. */
-  containsPoint(other) {
-    const r = shapeTypes.gcWithScope();
-    const point = r(pnt(other));
-    return !this.wrapped.IsOut_1(point);
-  }
-}
-function deserializeCurve2D(data) {
-  const oc = occtBoundary.getKernel().oc;
-  const handle = oc.GeomToolsWrapper.Read(data);
-  return new Curve2D(handle);
-}
-class Curve2D {
-  _wrapped;
-  _deleted = false;
-  _boundingBox;
-  _firstPoint = null;
-  _lastPoint = null;
-  constructor(handle) {
-    const oc = occtBoundary.getKernel().oc;
-    const inner = handle.get();
-    this._wrapped = new oc.Handle_Geom2d_Curve_2(inner);
-    this._boundingBox = null;
-    shapeTypes.registerForCleanup(this, this._wrapped);
-  }
-  get wrapped() {
-    if (this._deleted) throw new Error("This object has been deleted");
-    return this._wrapped;
-  }
-  delete() {
-    if (!this._deleted) {
-      this._deleted = true;
-      shapeTypes.unregisterFromCleanup(this._wrapped);
-      this._wrapped.delete();
-    }
-  }
-  /** Compute (and cache) the 2D bounding box of this curve. */
-  get boundingBox() {
-    if (this._boundingBox) return this._boundingBox;
-    const oc = occtBoundary.getKernel().oc;
-    const boundBox = new oc.Bnd_Box2d();
-    oc.BndLib_Add2dCurve.Add_3(this.wrapped, 1e-6, boundBox);
-    this._boundingBox = new BoundingBox2d(boundBox);
-    return this._boundingBox;
-  }
-  /** Return a human-readable representation, e.g. `LINE (0,0) - (1,1)`. */
-  get repr() {
-    return `${this.geomType} ${reprPnt(this.firstPoint)} - ${reprPnt(this.lastPoint)}`;
-  }
-  /** Access the underlying OCCT `Geom2d_Curve` (unwrapped from its handle). */
-  get innerCurve() {
-    return this.wrapped.get();
-  }
-  /** Serialize this curve to a string that can be restored with {@link deserializeCurve2D}. */
-  serialize() {
-    const oc = occtBoundary.getKernel().oc;
-    return oc.GeomToolsWrapper.Write(this.wrapped);
-  }
-  /** Evaluate the curve at the given parameter, returning the 2D point. */
-  value(parameter) {
-    const p = this.innerCurve.Value(parameter);
-    const v = [p.X(), p.Y()];
-    p.delete();
-    return v;
-  }
-  /** Return the point at the start of the curve (cached after first access). */
-  get firstPoint() {
-    if (this._firstPoint === null) {
-      this._firstPoint = this.value(this.firstParameter);
-    }
-    return this._firstPoint;
-  }
-  /** Return the point at the end of the curve (cached after first access). */
-  get lastPoint() {
-    if (this._lastPoint === null) {
-      this._lastPoint = this.value(this.lastParameter);
-    }
-    return this._lastPoint;
-  }
-  /** Return the parameter value at the start of the curve. */
-  get firstParameter() {
-    return this.innerCurve.FirstParameter();
-  }
-  /** Return the parameter value at the end of the curve. */
-  get lastParameter() {
-    return this.innerCurve.LastParameter();
-  }
-  /** Create a `Geom2dAdaptor_Curve` for algorithmic queries (caller must delete). */
-  adaptor() {
-    const oc = occtBoundary.getKernel().oc;
-    return new oc.Geom2dAdaptor_Curve_2(this.wrapped);
-  }
-  /** Return the geometric type of this curve (e.g. `LINE`, `CIRCLE`, `BSPLINE_CURVE`). */
-  get geomType() {
-    const adaptor = this.adaptor();
-    const curveType = errors.unwrap(curveFns.findCurveType(adaptor.GetType()));
-    adaptor.delete();
-    return curveType;
-  }
-  /** Create an independent deep copy of this curve. */
-  clone() {
-    const cloned = new Curve2D(this.innerCurve.Copy());
-    cloned._firstPoint = this._firstPoint;
-    cloned._lastPoint = this._lastPoint;
-    return cloned;
-  }
-  /** Reverse the orientation of this curve in place. */
-  reverse() {
-    this.innerCurve.Reverse();
-    const tmp = this._firstPoint;
-    this._firstPoint = this._lastPoint;
-    this._lastPoint = tmp;
-  }
-  distanceFromPoint(point) {
-    const oc = occtBoundary.getKernel().oc;
-    const r = shapeTypes.gcWithScope();
-    const projector = r(new oc.Geom2dAPI_ProjectPointOnCurve_2(r(pnt(point)), this.wrapped));
-    let curveToPoint;
-    try {
-      curveToPoint = projector.LowerDistance();
-    } catch {
-      curveToPoint = Infinity;
-    }
-    return Math.min(
-      curveToPoint,
-      helpers.distance2d(point, this.firstPoint),
-      helpers.distance2d(point, this.lastPoint)
-    );
-  }
-  distanceFromCurve(curve) {
-    const oc = occtBoundary.getKernel().oc;
-    const r = shapeTypes.gcWithScope();
-    let curveDistance;
-    const projector = r(
-      new oc.Geom2dAPI_ExtremaCurveCurve(
-        this.wrapped,
-        curve.wrapped,
-        this.firstParameter,
-        this.lastParameter,
-        curve.firstParameter,
-        curve.lastParameter
-      )
-    );
-    try {
-      curveDistance = projector.LowerDistance();
-    } catch {
-      curveDistance = Infinity;
-    }
-    return Math.min(
-      curveDistance,
-      this.distanceFromPoint(curve.firstPoint),
-      this.distanceFromPoint(curve.lastPoint),
-      curve.distanceFromPoint(this.firstPoint),
-      curve.distanceFromPoint(this.lastPoint)
-    );
-  }
-  /** Compute the minimum distance from this curve to a point or another curve. */
-  distanceFrom(element) {
-    if (isPoint2D(element)) {
-      return this.distanceFromPoint(element);
-    }
-    return this.distanceFromCurve(element);
-  }
-  /** Test whether a point lies on the curve within a tight tolerance (1e-9). */
-  isOnCurve(point) {
-    return this.distanceFromPoint(point) < 1e-9;
-  }
-  /**
-   * Project a point onto the curve and return its parameter value.
-   *
-   * @returns `Ok(parameter)` when the point is on the curve, or an error result otherwise.
-   */
-  parameter(point, precision = 1e-9) {
-    const oc = occtBoundary.getKernel().oc;
-    const r = shapeTypes.gcWithScope();
-    let lowerDistance;
-    let lowerDistanceParameter;
-    try {
-      const projector = r(new oc.Geom2dAPI_ProjectPointOnCurve_2(r(pnt(point)), this.wrapped));
-      lowerDistance = projector.LowerDistance();
-      lowerDistanceParameter = projector.LowerDistanceParameter();
-    } catch {
-      if (helpers.samePoint(point, this.firstPoint, precision)) return errors.ok(this.firstParameter);
-      if (helpers.samePoint(point, this.lastPoint, precision)) return errors.ok(this.lastParameter);
-      return errors.err(errors.computationError("PARAMETER_NOT_FOUND", "Failed to find parameter"));
-    }
-    if (lowerDistance > precision) {
-      return errors.err(
-        errors.computationError(
-          "POINT_NOT_ON_CURVE",
-          `Point ${reprPnt(point)} not on curve ${this.repr}, ${lowerDistance.toFixed(9)}`
-        )
-      );
-    }
-    return errors.ok(lowerDistanceParameter);
-  }
-  /**
-   * Compute the tangent vector at a parameter position or at the projection of a point.
-   *
-   * @param index - A normalized parameter (0..1) or a Point2D to project onto the curve.
-   */
-  tangentAt(index) {
-    const oc = occtBoundary.getKernel().oc;
-    const [r, gc] = shapeTypes.localGC();
-    let param;
-    if (Array.isArray(index)) {
-      param = errors.unwrap(this.parameter(index));
-    } else {
-      const paramLength = this.innerCurve.LastParameter() - this.innerCurve.FirstParameter();
-      param = paramLength * index + Number(this.innerCurve.FirstParameter());
-    }
-    const point = r(new oc.gp_Pnt2d_1());
-    const dir = r(new oc.gp_Vec2d_1());
-    this.innerCurve.D1(param, point, dir);
-    const tgtVec = [dir.X(), dir.Y()];
-    gc();
-    return tgtVec;
-  }
-  /**
-   * Split this curve at the given points or parameter values.
-   *
-   * @returns An array of sub-curves whose union covers the original curve.
-   */
-  splitAt(points, precision = 1e-9) {
-    const oc = occtBoundary.getKernel().oc;
-    const r = shapeTypes.gcWithScope();
-    let parameters = points.map((point) => {
-      if (isPoint2D(point)) return errors.unwrap(this.parameter(point, precision));
-      return point;
-    });
-    parameters = Array.from(
-      new Map(parameters.map((p) => [precisionRound(p, -Math.log10(precision)), p])).values()
-    ).sort((a, b) => a - b);
-    const firstParam = this.firstParameter;
-    const lastParam = this.lastParameter;
-    if (firstParam > lastParam) {
-      parameters.reverse();
-    }
-    if (Math.abs(parameters[0] - firstParam) < precision * 100) parameters = parameters.slice(1);
-    if (!parameters.length) return [this];
-    if (
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      Math.abs(parameters[parameters.length - 1] - lastParam) < precision * 100
-    )
-      parameters = parameters.slice(0, -1);
-    if (!parameters.length) return [this];
-    return surfaceBuilders.zip([
-      [firstParam, ...parameters],
-      [...parameters, lastParam]
-    ]).map(([first, last]) => {
-      try {
-        if (this.geomType === "BEZIER_CURVE") {
-          const curveCopy = new oc.Geom2d_BezierCurve_1(r(this.adaptor()).Bezier().get().Poles_2());
-          curveCopy.Segment(first, last);
-          return new Curve2D(new oc.Handle_Geom2d_Curve_2(curveCopy));
-        }
-        if (this.geomType === "BSPLINE_CURVE") {
-          const adapted = r(this.adaptor()).BSpline().get();
-          const curveCopy = new oc.Geom2d_BSplineCurve_1(
-            adapted.Poles_2(),
-            adapted.Knots_2(),
-            adapted.Multiplicities_2(),
-            adapted.Degree(),
-            adapted.IsPeriodic()
-          );
-          curveCopy.Segment(first, last, precision);
-          return new Curve2D(new oc.Handle_Geom2d_Curve_2(curveCopy));
-        }
-        const trimmed = new oc.Geom2d_TrimmedCurve(this.wrapped, first, last, true, true);
-        return new Curve2D(new oc.Handle_Geom2d_Curve_2(trimmed));
-      } catch (e) {
-        throw new Error(
-          `Failed to split the curve: ${e instanceof Error ? e.message : String(e)}`,
-          { cause: e }
-        );
-      }
-    });
-  }
-}
-const approximateAsBSpline = (adaptor, tolerance = 1e-4, continuity = "C0", maxSegments = 200) => {
-  const oc = occtBoundary.getKernel().oc;
-  const r = shapeTypes.gcWithScope();
-  const continuities = {
-    C0: oc.GeomAbs_Shape.GeomAbs_C0,
-    C1: oc.GeomAbs_Shape.GeomAbs_C1,
-    C2: oc.GeomAbs_Shape.GeomAbs_C2,
-    C3: oc.GeomAbs_Shape.GeomAbs_C3
-  };
-  const convert = r(
-    new oc.Geom2dConvert_ApproxCurve_2(
-      adaptor.ShallowCopy(),
-      tolerance,
-      continuities[continuity],
-      maxSegments,
-      3
-    )
-  );
-  return new Curve2D(convert.Curve());
-};
-const BSplineToBezier = (adaptor) => {
-  if (errors.unwrap(curveFns.findCurveType(adaptor.GetType())) !== "BSPLINE_CURVE")
-    result.bug("BSplineToBezier", "You can only convert a Bspline");
-  const handle = adaptor.BSpline();
-  const oc = occtBoundary.getKernel().oc;
-  const convert = new oc.Geom2dConvert_BSplineCurveToBezierCurve_1(handle);
-  function* bezierCurves() {
-    const nArcs = convert.NbArcs();
-    if (!nArcs) return;
-    for (let i = 1; i <= nArcs; i++) {
-      const arc = convert.Arc(i);
-      yield new Curve2D(arc);
-    }
-  }
-  const curves = Array.from(bezierCurves());
-  convert.delete();
-  return curves;
-};
-function approximateAsSvgCompatibleCurve(curves, options = {
-  tolerance: 1e-4,
-  continuity: "C0",
-  maxSegments: 300
-}) {
-  const r = shapeTypes.gcWithScope();
-  return curves.flatMap((curve) => {
-    const adaptor = r(curve.adaptor());
-    const curveType = errors.unwrap(curveFns.findCurveType(adaptor.GetType()));
-    if (curveType === "ELLIPSE" || curveType === "CIRCLE" && helpers.samePoint(curve.firstPoint, curve.lastPoint)) {
-      return curve.splitAt([0.5]);
-    }
-    if (["LINE", "ELLIPSE", "CIRCLE"].includes(curveType)) {
-      return curve;
-    }
-    if (curveType === "BEZIER_CURVE") {
-      const b = adaptor.Bezier().get();
-      const deg = b.Degree();
-      if ([1, 2, 3].includes(deg)) {
-        return curve;
-      }
-    }
-    if (curveType === "BSPLINE_CURVE") {
-      const c = BSplineToBezier(adaptor);
-      return approximateAsSvgCompatibleCurve(c, options);
-    }
-    const bspline = approximateAsBSpline(
-      adaptor,
-      options.tolerance,
-      options.continuity,
-      options.maxSegments
-    );
-    return approximateAsSvgCompatibleCurve(BSplineToBezier(r(bspline.adaptor())), options);
-  });
-}
-const make2dSegmentCurve = (startPoint, endPoint) => {
-  const oc = occtBoundary.getKernel().oc;
-  const [r, gc] = shapeTypes.localGC();
-  const segment = r(new oc.GCE2d_MakeSegment_1(r(pnt(startPoint)), r(pnt(endPoint)))).Value();
-  const curve = new Curve2D(segment);
-  if (!helpers.samePoint(curve.firstPoint, startPoint)) {
-    curve.reverse();
-  }
-  gc();
-  return curve;
-};
-const make2dThreePointArc = (startPoint, midPoint, endPoint) => {
-  const oc = occtBoundary.getKernel().oc;
-  const [r, gc] = shapeTypes.localGC();
-  const segment = r(
-    new oc.GCE2d_MakeArcOfCircle_4(r(pnt(startPoint)), r(pnt(midPoint)), r(pnt(endPoint)))
-  ).Value();
-  gc();
-  const curve = new Curve2D(segment);
-  if (!helpers.samePoint(curve.firstPoint, startPoint)) {
-    curve.wrapped.get().SetTrim(curve.lastParameter, curve.firstParameter, true, true);
-  }
-  return curve;
-};
-const make2dTangentArc = (startPoint, tangent, endPoint) => {
-  const oc = occtBoundary.getKernel().oc;
-  const [r, gc] = shapeTypes.localGC();
-  const segment = r(
-    new oc.GCE2d_MakeArcOfCircle_5(r(pnt(startPoint)), r(vec(tangent)), r(pnt(endPoint)))
-  ).Value();
-  gc();
-  const curve = new Curve2D(segment);
-  if (!helpers.samePoint(curve.firstPoint, startPoint)) {
-    curve.wrapped.get().SetTrim(curve.lastParameter, curve.firstParameter, true, true);
-  }
-  return curve;
-};
-const make2dCircle = (radius, center = [0, 0]) => {
-  const oc = occtBoundary.getKernel().oc;
-  const [r, gc] = shapeTypes.localGC();
-  const segment = r(new oc.GCE2d_MakeCircle_7(r(pnt(center)), radius, true)).Value();
-  gc();
-  return new Curve2D(segment);
-};
-const make2dEllipse = (majorRadius, minorRadius, xDir = [1, 0], center = [0, 0], direct = true) => {
-  const oc = occtBoundary.getKernel().oc;
-  const [r, gc] = shapeTypes.localGC();
-  const ellipse = r(new oc.gp_Elips2d_2(r(axis2d(center, xDir)), majorRadius, minorRadius, direct));
-  const segment = r(new oc.GCE2d_MakeEllipse_1(ellipse)).Value();
-  gc();
-  return new Curve2D(segment);
-};
-const make2dEllipseArc = (majorRadius, minorRadius, startAngle, endAngle, center = [0, 0], xDir, direct = true) => {
-  const oc = occtBoundary.getKernel().oc;
-  const [r, gc] = shapeTypes.localGC();
-  const ellipse = r(new oc.gp_Elips2d_2(r(axis2d(center, xDir)), majorRadius, minorRadius, true));
-  const segment = r(new oc.GCE2d_MakeArcOfEllipse_1(ellipse, startAngle, endAngle, direct)).Value();
-  gc();
-  return new Curve2D(segment);
-};
-const make2dBezierCurve = (startPoint, controls, endPoint) => {
-  const oc = occtBoundary.getKernel().oc;
-  const [r, gc] = shapeTypes.localGC();
-  const arrayOfPoints = r(new oc.TColgp_Array1OfPnt2d_2(1, controls.length + 2));
-  arrayOfPoints.SetValue(1, r(pnt(startPoint)));
-  controls.forEach((p, i) => {
-    arrayOfPoints.SetValue(i + 2, r(pnt(p)));
-  });
-  arrayOfPoints.SetValue(controls.length + 2, r(pnt(endPoint)));
-  const bezCurve = new oc.Geom2d_BezierCurve_1(arrayOfPoints);
-  gc();
-  return new Curve2D(new oc.Handle_Geom2d_Curve_2(bezCurve));
-};
-function make2dInerpolatedBSplineCurve(points, {
-  tolerance = 1e-3,
-  smoothing = null,
-  degMax = 3,
-  degMin = 1
-} = {}) {
-  const r = shapeTypes.gcWithScope();
-  const oc = occtBoundary.getKernel().oc;
-  const pnts = r(new oc.TColgp_Array1OfPnt2d_2(1, points.length));
-  points.forEach((point, index) => {
-    pnts.SetValue(index + 1, r(pnt(point)));
-  });
-  let splineBuilder;
-  if (smoothing) {
-    splineBuilder = r(
-      new oc.Geom2dAPI_PointsToBSpline_6(
-        pnts,
-        smoothing[0],
-        smoothing[1],
-        smoothing[2],
-        degMax,
-        oc.GeomAbs_Shape.GeomAbs_C2,
-        tolerance
-      )
-    );
-  } else {
-    splineBuilder = r(
-      new oc.Geom2dAPI_PointsToBSpline_2(
-        pnts,
-        degMin,
-        degMax,
-        oc.GeomAbs_Shape.GeomAbs_C2,
-        tolerance
-      )
-    );
-  }
-  if (!splineBuilder.IsDone()) {
-    return errors.err(errors.computationError("BSPLINE_2D_FAILED", "B-spline approximation failed"));
-  }
-  return errors.ok(new Curve2D(splineBuilder.Curve()));
-}
-const make2dArcFromCenter = (startPoint, endPoint, center, longArc = false) => {
-  const midChord = helpers.scalarMultiply2d(helpers.add2d(startPoint, endPoint), 0.5);
-  const orientedRadius = helpers.distance2d(center, startPoint) * (longArc ? -1 : 1);
-  const midChordDir = helpers.normalize2d(helpers.subtract2d(midChord, center));
-  return make2dThreePointArc(
-    startPoint,
-    helpers.add2d(helpers.scalarMultiply2d(midChordDir, orientedRadius), center),
-    endPoint
-  );
-};
-function round5(v) {
-  return Math.round(v * 1e5) / 1e5;
-}
-const fromPnt = (pnt2) => `${round2(pnt2.X())} ${round2(pnt2.Y())}`;
-const adaptedCurveToPathElem = (adaptor, lastPoint) => {
-  const oc = occtBoundary.getKernel().oc;
-  const r = shapeTypes.gcWithScope();
-  const curveType = errors.unwrap(curveFns.findCurveType(adaptor.GetType()));
-  const [endX, endY] = lastPoint;
-  const endpoint = `${round5(endX)} ${round5(endY)}`;
-  if (curveType === "LINE") {
-    return `L ${endpoint}`;
-  }
-  if (curveType === "BEZIER_CURVE") {
-    const bezierHandle = r(adaptor.Bezier());
-    const curve = bezierHandle.get();
-    const deg = curve.Degree();
-    if (deg === 1) {
-      return `L ${endpoint}`;
-    }
-    if (deg === 2) {
-      const pole2 = r(curve.Pole(2));
-      return `Q ${fromPnt(pole2)} ${endpoint}`;
-    }
-    if (deg === 3) {
-      const pole2 = r(curve.Pole(2));
-      const pole3 = r(curve.Pole(3));
-      const p1 = fromPnt(pole2);
-      const p2 = fromPnt(pole3);
-      return `C ${p1} ${p2} ${endpoint}`;
-    }
-  }
-  if (curveType === "CIRCLE") {
-    const curve = r(adaptor.Circle());
-    const radius = curve.Radius();
-    const p1 = adaptor.FirstParameter();
-    const p2 = adaptor.LastParameter();
-    const paramAngle = (p2 - p1) * vecOps.RAD2DEG;
-    const end = paramAngle !== 360 ? endpoint : `${round5(endX)} ${round5(endY + 1e-4)}`;
-    return `A ${radius} ${radius} 0 ${Math.abs(paramAngle) > 180 ? "1" : "0"} ${curve.IsDirect() ? "1" : "0"} ${end}`;
-  }
-  if (curveType === "ELLIPSE") {
-    const curve = r(adaptor.Ellipse());
-    const rx = curve.MajorRadius();
-    const ry = curve.MinorRadius();
-    const p1 = adaptor.FirstParameter();
-    const p2 = adaptor.LastParameter();
-    const paramAngle = (p2 - p1) * vecOps.RAD2DEG;
-    const end = paramAngle !== 360 ? endpoint : `${round5(endX)} ${round5(endY + 1e-4)}`;
-    const dir0 = r(new oc.gp_Dir2d_1());
-    const xAxis = r(curve.XAxis());
-    const xDir = r(xAxis.Direction());
-    const angle = 180 - xDir.Angle(dir0) * vecOps.RAD2DEG;
-    return `A ${round5(rx)} ${round5(ry)} ${round5(angle)} ${Math.abs(paramAngle) > 180 ? "1" : "0"} ${curve.IsDirect() ? "1" : "0"} ${end}`;
-  }
-  result.bug("adaptedCurveToPathElem", `Unsupported curve type: ${curveType}`);
-};
-const curvesBoundingBox = (curves) => {
-  const oc = occtBoundary.getKernel().oc;
-  const boundBox = new oc.Bnd_Box2d();
-  curves.forEach((c) => {
-    oc.BndLib_Add2dCurve.Add_3(c.wrapped, 1e-6, boundBox);
-  });
-  return new BoundingBox2d(boundBox);
-};
-function curvesAsEdgesOnPlane(curves, plane) {
-  const [r, gc] = shapeTypes.localGC();
-  const ax = r(occtBoundary.makeOcAx2(plane.origin, plane.zDir, plane.xDir));
-  const oc = occtBoundary.getKernel().oc;
-  const edges = curves.map((curve) => {
-    const curve3d = r(oc.GeomLib.To3d(ax, curve.wrapped));
-    const edgeBuilder = r(new oc.BRepBuilderAPI_MakeEdge_24(curve3d));
-    return shapeTypes.createEdge(edgeBuilder.Edge());
-  });
-  gc();
-  return edges;
-}
-const curvesAsEdgesOnSurface = (curves, geomSurf) => {
-  const [r, gc] = shapeTypes.localGC();
-  const oc = occtBoundary.getKernel().oc;
-  const modifiedCurves = curves.map((curve) => {
-    const edgeBuilder = r(new oc.BRepBuilderAPI_MakeEdge_30(curve.wrapped, geomSurf));
-    return shapeTypes.createEdge(edgeBuilder.Edge());
-  });
-  gc();
-  return modifiedCurves;
-};
-const transformCurves = (curves, transformation) => {
-  const oc = occtBoundary.getKernel().oc;
-  const modifiedCurves = curves.map((curve) => {
-    if (!transformation) return curve.clone();
-    return new Curve2D(oc.GeomLib.GTransform(curve.wrapped, transformation));
-  });
-  return modifiedCurves;
-};
-const stretchTransform2d = (ratio, direction, origin = [0, 0]) => {
-  const oc = occtBoundary.getKernel().oc;
-  const ax = axis2d(origin, direction);
-  const transform = new oc.gp_GTrsf2d_1();
-  transform.SetAffinity(ax, ratio);
-  ax.delete();
-  return transform;
-};
-const translationTransform2d = (translation) => {
-  const oc = occtBoundary.getKernel().oc;
-  const [r, gc] = shapeTypes.localGC();
-  const rotation = new oc.gp_Trsf2d_1();
-  rotation.SetTranslation_1(r(vec(translation)));
-  const transform = new oc.gp_GTrsf2d_2(rotation);
-  gc();
-  return transform;
-};
-const mirrorTransform2d = (centerOrDirection, origin = [0, 0], mode = "center") => {
-  const oc = occtBoundary.getKernel().oc;
-  const [r, gc] = shapeTypes.localGC();
-  const rotation = new oc.gp_Trsf2d_1();
-  if (mode === "center") {
-    rotation.SetMirror_1(r(pnt(centerOrDirection)));
-  } else {
-    rotation.SetMirror_2(r(axis2d(origin, centerOrDirection)));
-  }
-  const transform = new oc.gp_GTrsf2d_2(rotation);
-  gc();
-  return transform;
-};
-const rotateTransform2d = (angle, center = [0, 0]) => {
-  const oc = occtBoundary.getKernel().oc;
-  const [r, gc] = shapeTypes.localGC();
-  const rotation = new oc.gp_Trsf2d_1();
-  rotation.SetRotation(r(pnt(center)), angle);
-  const transform = new oc.gp_GTrsf2d_2(rotation);
-  gc();
-  return transform;
-};
-const scaleTransform2d = (scaleFactor, center = [0, 0]) => {
-  const oc = occtBoundary.getKernel().oc;
-  const [r, gc] = shapeTypes.localGC();
-  const scaling = new oc.gp_Trsf2d_1();
-  scaling.SetScale(r(pnt(center)), scaleFactor);
-  const transform = new oc.gp_GTrsf2d_2(scaling);
-  gc();
-  return transform;
-};
-function curvesAsEdgesOnFace(curves, face, scale = "original") {
-  const [r, gc] = shapeTypes.localGC();
-  const oc = occtBoundary.getKernel().oc;
-  let geomSurf = r(oc.BRep_Tool.Surface_2(face.wrapped));
-  const bounds = faceFns.uvBounds(face);
-  let transformation = null;
-  const uAxis = r(axis2d([0, 0], [0, 1]));
-  const _vAxis = r(axis2d([0, 0], [1, 0]));
-  if (scale === "original" && faceFns.faceGeomType(face) !== "PLANE") {
-    if (faceFns.faceGeomType(face) !== "CYLINDRE")
-      return errors.err(
-        errors.validationError(
-          "UNSUPPORTED_FACE_TYPE",
-          "Only planar and cylindrical faces can be unwrapped for sketching"
-        )
-      );
-    const cylinder = r(geomSurf.get().Cylinder());
-    if (!cylinder.Direct()) {
-      geomSurf = geomSurf.get().UReversed();
-    }
-    const radius = cylinder.Radius();
-    transformation = stretchTransform2d(1 / radius, [0, 1]);
-  }
-  if (scale === "bounds") {
-    transformation = r(new oc.gp_GTrsf2d_1());
-    transformation.SetAffinity(uAxis, bounds.uMax - bounds.uMin);
-    if (bounds.uMin !== 0) {
-      const trans = r(new oc.gp_GTrsf2d_1());
-      trans.SetTranslationPart(new oc.gp_XY_2(0, -bounds.uMin));
-      transformation.Multiply(trans);
-    }
-    const vTransformation = r(new oc.gp_GTrsf2d_1());
-    vTransformation.SetAffinity(_vAxis, bounds.vMax - bounds.vMin);
-    transformation.Multiply(vTransformation);
-    if (bounds.vMin !== 0) {
-      const trans = r(new oc.gp_GTrsf2d_1());
-      trans.SetTranslationPart(r(new oc.gp_XY_2(0, -bounds.vMin)));
-      transformation.Multiply(trans);
-    }
-  }
-  const modifiedCurves = transformCurves(curves, transformation);
-  const edges = curvesAsEdgesOnSurface(modifiedCurves, geomSurf);
-  gc();
-  return errors.ok(edges);
-}
-function edgeToCurve(e, face) {
-  const oc = occtBoundary.getKernel().oc;
-  const r = shapeTypes.gcWithScope();
-  const adaptor = r(new oc.BRepAdaptor_Curve2d_2(e.wrapped, face.wrapped));
-  const trimmed = new oc.Geom2d_TrimmedCurve(
-    adaptor.Curve(),
-    adaptor.FirstParameter(),
-    adaptor.LastParameter(),
-    true,
-    true
-  );
-  if (curveFns.getOrientation(e) === "backward") {
-    trimmed.Reverse();
-  }
-  return new Curve2D(new oc.Handle_Geom2d_Curve_2(trimmed));
-}
-const viewbox = (bbox, margin = 1) => {
-  const minX = bbox.bounds[0][0] - margin;
-  const minY = -bbox.bounds[1][1] - margin;
-  return `${minX} ${minY} ${bbox.width + 2 * margin} ${bbox.height + 2 * margin}`;
-};
-const asSVG = (body, boundingBox, margin = 1) => {
-  const vbox = viewbox(boundingBox, margin);
-  return `<svg version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="${vbox}" fill="none" stroke="black" stroke-width="0.6%" vector-effect="non-scaling-stroke">
-    ${body}
-</svg>`;
-};
-function assembleWire(listOfEdges) {
-  const oc = occtBoundary.getKernel().oc;
-  const builder = new oc.BRepBuilderAPI_MakeWire_1();
-  listOfEdges.forEach((e) => {
-    builder.Add_1(e.wrapped);
-  });
-  return shapeTypes.createWire(builder.Wire());
-}
-class Blueprint {
-  /** Ordered 2D curve segments that compose this blueprint. */
-  curves;
-  _boundingBox;
-  _orientation;
-  _guessedOrientation;
-  /** Create a blueprint from an ordered array of 2D curves.
-   *
-   * @throws Error if the curves array is empty.
-   */
-  constructor(curves) {
-    if (curves.length === 0) {
-      throw new Error("Blueprint requires at least one curve");
-    }
-    this.curves = curves;
-    this._boundingBox = null;
-    this._orientation = null;
-    this._guessedOrientation = null;
-  }
-  /** Release WASM resources held by the underlying curves and bounding box. */
-  delete() {
-    this.curves.forEach((c) => {
-      c.delete();
-    });
-    if (this._boundingBox) this._boundingBox.delete();
-  }
-  /** Return a deep copy of this blueprint. */
-  clone() {
-    return new Blueprint(this.curves.map((c) => c.clone()));
-  }
-  /** Return a multi-line string representation for debugging. */
-  get repr() {
-    return ["Blueprint", ...this.curves.map((c) => c.repr)].join("\n");
-  }
-  /** Compute (and cache) the axis-aligned bounding box of all curves. */
-  get boundingBox() {
-    if (!this._boundingBox) {
-      this._boundingBox = curvesBoundingBox(this.curves);
-    }
-    return this._boundingBox;
-  }
-  /** Determine the winding direction of the blueprint via the shoelace formula.
-   *
-   * @remarks Uses an approximation based on curve midpoints for non-linear
-   * segments. The result is cached after the first call.
-   */
-  get orientation() {
-    if (this._orientation) return this._orientation;
-    if (this._guessedOrientation) return this._guessedOrientation;
-    const vertices = this.curves.flatMap((c) => {
-      if (c.geomType !== "LINE") {
-        return [c.firstPoint, c.value(0.5)];
-      }
-      return [c.firstPoint];
-    });
-    const approximateArea = vertices.map((v1, i) => {
-      const v2 = vertices[(i + 1) % vertices.length];
-      return (v2[0] - v1[0]) * (v2[1] + v1[1]);
-    }).reduce((a, b) => a + b, 0);
-    this._guessedOrientation = approximateArea > 0 ? "clockwise" : "counterClockwise";
-    return this._guessedOrientation;
-  }
-  /**
-   * Stretch the blueprint along a direction by a given ratio.
-   *
-   * @param ratio - Stretch factor (1 = unchanged).
-   * @param direction - Unit direction vector to stretch along.
-   * @param origin - Fixed point of the stretch (defaults to the origin).
-   * @returns A new stretched Blueprint.
-   */
-  stretch(ratio, direction, origin = [0, 0]) {
-    const curves = transformCurves(this.curves, stretchTransform2d(ratio, direction, origin));
-    return new Blueprint(curves);
-  }
-  /**
-   * Uniformly scale the blueprint around a center point.
-   *
-   * @param scaleFactor - Scale multiplier (>1 enlarges, <1 shrinks).
-   * @param center - Center of scaling (defaults to the bounding box center).
-   * @returns A new scaled Blueprint.
-   */
-  scale(scaleFactor, center) {
-    const centerPoint = center || this.boundingBox.center;
-    const curves = transformCurves(this.curves, scaleTransform2d(scaleFactor, centerPoint));
-    return new Blueprint(curves);
-  }
-  /**
-   * Rotate the blueprint by an angle in degrees.
-   *
-   * @param angle - Rotation angle in degrees (positive = counter-clockwise).
-   * @param center - Center of rotation (defaults to the origin).
-   * @returns A new rotated Blueprint.
-   */
-  rotate(angle, center) {
-    const curves = transformCurves(this.curves, rotateTransform2d(angle * vecOps.DEG2RAD, center));
-    return new Blueprint(curves);
-  }
-  translate(xDistOrPoint, yDist = 0) {
-    const translationVector = isPoint2D(xDistOrPoint) ? xDistOrPoint : [xDistOrPoint, yDist];
-    const curves = transformCurves(this.curves, translationTransform2d(translationVector));
-    return new Blueprint(curves);
-  }
-  /**
-   * Mirror the blueprint across a point or plane.
-   *
-   * @param centerOrDirection - Mirror center (center mode) or plane normal (plane mode).
-   * @param origin - Origin for plane-mode mirroring.
-   * @param mode - `'center'` for point symmetry, `'plane'` for reflection across an axis.
-   * @returns A new mirrored Blueprint.
-   */
-  mirror(centerOrDirection, origin = [0, 0], mode = "center") {
-    const curves = transformCurves(this.curves, mirrorTransform2d(centerOrDirection, origin, mode));
-    return new Blueprint(curves);
-  }
-  /**
-   * Project this 2D blueprint onto a 3D plane, producing a wire and metadata.
-   *
-   * @param inputPlane - Named plane (`"XY"`, `"XZ"`, etc.) or a custom Plane.
-   * @param origin - Origin offset; a number sets the offset along the plane normal.
-   * @returns Sketch data containing the projected wire and default orientation.
-   */
-  sketchOnPlane(inputPlane, origin) {
-    const plane = inputPlane && typeof inputPlane !== "string" ? { ...inputPlane } : makePlane(inputPlane, origin);
-    const edges = curvesAsEdgesOnPlane(this.curves, plane);
-    const wire = assembleWire(edges);
-    return {
-      wire,
-      defaultOrigin: plane.origin,
-      defaultDirection: plane.zDir
-    };
-  }
-  /**
-   * Map this 2D blueprint onto a 3D face's UV surface.
-   *
-   * @param face - Target face to project onto.
-   * @param scaleMode - How UV coordinates are interpreted (`'original'`, `'bounds'`, or `'native'`).
-   * @returns Sketch data containing the wire mapped onto the face.
-   */
-  sketchOnFace(face, scaleMode) {
-    const oc = occtBoundary.getKernel().oc;
-    const edges = errors.unwrap(curvesAsEdgesOnFace(this.curves, face, scaleMode));
-    const wire = assembleWire(edges);
-    oc.BRepLib.BuildCurves3d_2(wire.wrapped);
-    const wireFixer = new oc.ShapeFix_Wire_2(wire.wrapped, face.wrapped, 1e-9);
-    wireFixer.FixEdgeCurves();
-    wireFixer.delete();
-    return { wire, baseFace: face };
-  }
-  /**
-   * Create a face on a target face's surface defined by this blueprint's profile.
-   *
-   * @param face - The face whose surface the sub-face lies on.
-   * @param origin - Optional UV origin offset (defaults to the face center).
-   * @returns A new Face bounded by the blueprint's profile.
-   */
-  subFace(face, origin) {
-    const originPoint = origin || [...faceFns.faceCenter(face)];
-    const originVec3 = occtBoundary.toVec3(originPoint);
-    const sketch = this.translate(faceFns.uvCoordinates(face, originVec3)).sketchOnFace(face, "original");
-    return errors.unwrap(surfaceBuilders.makeFace(sketch.wire));
-  }
-  /**
-   * Cut a prism-shaped hole through a solid along a face using this blueprint.
-   *
-   * @param shape - The solid to punch through.
-   * @param face - The face on which the hole profile is placed.
-   * @param options - Optional hole parameters.
-   * @param options.height - Hole depth; `null` (default) cuts through the entire solid.
-   * @param options.origin - UV origin on the face for the blueprint placement.
-   * @param options.draftAngle - Taper angle in degrees (0 = straight hole).
-   * @returns The modified shape with the hole removed.
-   */
-  punchHole(shape, face, {
-    height = null,
-    origin = null,
-    draftAngle = 0
-  } = {}) {
-    const oc = occtBoundary.getKernel().oc;
-    const gc = shapeTypes.gcWithScope();
-    const foundFace = errors.unwrap(helpers.getSingleFace(face, shape));
-    const hole = this.subFace(foundFace, origin);
-    const maker = gc(
-      new oc.BRepFeat_MakeDPrism_1(
-        shape.wrapped,
-        hole.wrapped,
-        foundFace.wrapped,
-        draftAngle * vecOps.DEG2RAD,
-        0,
-        false
-      )
-    );
-    if (height) {
-      maker.Perform_1(height);
-    } else {
-      maker.PerformThruAll();
-    }
-    return errors.unwrap(faceFns.cast(maker.Shape()));
-  }
-  /** Convert the blueprint to an SVG path `d` attribute string. */
-  toSVGPathD() {
-    const r = shapeTypes.gcWithScope();
-    const bp = this.clone().mirror([1, 0], [0, 0], "plane");
-    const compatibleCurves = approximateAsSvgCompatibleCurve(bp.curves);
-    const path = compatibleCurves.flatMap((c) => {
-      return adaptedCurveToPathElem(r(c.adaptor()), c.lastPoint);
-    });
-    const [startX, startY] = bp.curves[0].firstPoint;
-    return `M ${round5(startX)} ${round5(startY)} ${path.join(" ")}${bp.isClosed() ? " Z" : ""}`;
-  }
-  /** Wrap the SVG path data in a `<path>` element string. */
-  toSVGPath() {
-    return `<path d="${this.toSVGPathD()}" />`;
-  }
-  /**
-   * Compute the SVG `viewBox` attribute for this blueprint.
-   *
-   * @param margin - Extra padding around the bounding box in drawing units.
-   */
-  toSVGViewBox(margin = 1) {
-    return viewbox(this.boundingBox, margin);
-  }
-  /** Return the SVG path `d` strings for this blueprint as an array. */
-  toSVGPaths() {
-    return [this.toSVGPathD()];
-  }
-  /**
-   * Render a complete SVG document string for this blueprint.
-   *
-   * @param margin - Extra padding around the bounding box in drawing units.
-   */
-  toSVG(margin = 1) {
-    return asSVG(this.toSVGPath(), this.boundingBox, margin);
-  }
-  /** Get the start point of the first curve. */
-  get firstPoint() {
-    return this.curves[0].firstPoint;
-  }
-  /** Get the end point of the last curve. */
-  get lastPoint() {
-    return this.curves[this.curves.length - 1].lastPoint;
-  }
-  /**
-   * Test whether a 2D point lies inside this closed blueprint.
-   *
-   * Uses ray-casting (intersection counting) against a segment from the point
-   * to a location guaranteed to be outside the bounding box.
-   *
-   * @remarks Returns `false` for points on the boundary.
-   * @returns `true` if the point is strictly inside the blueprint.
-   */
-  isInside(point) {
-    if (!this.boundingBox.containsPoint(point)) return false;
-    const oc = occtBoundary.getKernel().oc;
-    const intersector = new oc.Geom2dAPI_InterCurveCurve_1();
-    try {
-      const segment = make2dSegmentCurve(point, this.boundingBox.outsidePoint());
-      let crossCounts = 0;
-      const onCurve = this.curves.find((c) => c.isOnCurve(point));
-      if (onCurve) return false;
-      this.curves.forEach((c) => {
-        if (c.boundingBox.isOut(segment.boundingBox)) return;
-        intersector.Init_1(segment.wrapped, c.wrapped, 1e-9);
-        crossCounts += Number(intersector.NbPoints());
-      });
-      return !!(crossCounts % 2);
-    } finally {
-      intersector.delete();
-    }
-  }
-  /** Check whether the first and last points coincide (the profile is closed). */
-  isClosed() {
-    return helpers.samePoint(this.firstPoint, this.lastPoint);
-  }
-  /**
-   * Test whether this blueprint's curves intersect with another blueprint's curves.
-   *
-   * @remarks Uses bounding-box pre-filtering for early rejection.
-   */
-  intersects(other) {
-    if (this.boundingBox.isOut(other.boundingBox)) return false;
-    const oc = occtBoundary.getKernel().oc;
-    const intersector = new oc.Geom2dAPI_InterCurveCurve_1();
-    try {
-      for (const myCurve of this.curves) {
-        for (const otherCurve of other.curves) {
-          if (myCurve.boundingBox.isOut(otherCurve.boundingBox)) continue;
-          intersector.Init_1(myCurve.wrapped, otherCurve.wrapped, 1e-9);
-          if (intersector.NbPoints() || intersector.NbSegments()) return true;
-        }
-      }
-      return false;
-    } finally {
-      intersector.delete();
-    }
-  }
-}
-exports.Blueprint = Blueprint;
-exports.BoundingBox2d = BoundingBox2d;
-exports.Curve2D = Curve2D;
-exports.approximateAsBSpline = approximateAsBSpline;
-exports.approximateAsSvgCompatibleCurve = approximateAsSvgCompatibleCurve;
-exports.asSVG = asSVG;
-exports.axis2d = axis2d;
-exports.deserializeCurve2D = deserializeCurve2D;
-exports.edgeToCurve = edgeToCurve;
-exports.isPoint2D = isPoint2D;
-exports.make2dArcFromCenter = make2dArcFromCenter;
-exports.make2dBezierCurve = make2dBezierCurve;
-exports.make2dCircle = make2dCircle;
-exports.make2dEllipse = make2dEllipse;
-exports.make2dEllipseArc = make2dEllipseArc;
-exports.make2dInerpolatedBSplineCurve = make2dInerpolatedBSplineCurve;
-exports.make2dSegmentCurve = make2dSegmentCurve;
-exports.make2dTangentArc = make2dTangentArc;
-exports.make2dThreePointArc = make2dThreePointArc;
-exports.makePlane = makePlane;
-exports.mirror = mirror;
-exports.removeDuplicatePoints = removeDuplicatePoints;
-exports.viewbox = viewbox;