@itwin/rpcinterface-full-stack-tests 4.0.0-dev.6 → 4.0.0-dev.8

package/lib/dist/bundled-tests.js

@@ -183333,9 +183333,9 @@ class Geometry {
         return 2 - ((-axis - 1) % 3);
     }
     /** Return the AxisOrder for which axisIndex is the first named axis.
-     * * `axisIndex===0`returns AxisOrder.XYZ
-     * * `axisIndex===1`returns AxisOrder.YZX
-     * * `axisIndex===2`returns AxisOrder.ZXY
+     * * `axisIndex === 0` returns `AxisOrder.XYZ`
+     * * `axisIndex === 1` returns `AxisOrder.YZX`
+     * * `axisIndex === 2` returns `AxisOrder.ZXY`
      */
     static axisIndexToRightHandedAxisOrder(axisIndex) {
         if (axisIndex === 0)
@@ -183347,7 +183347,9 @@ class Geometry {
         return Geometry.axisIndexToRightHandedAxisOrder(Geometry.cyclic3dAxis(axisIndex));
     }
     /** Return the largest absolute distance from a to either of b0 or b1 */
-    static maxAbsDiff(a, b0, b1) { return Math.max(Math.abs(a - b0), Math.abs(a - b1)); }
+    static maxAbsDiff(a, b0, b1) {
+        return Math.max(Math.abs(a - b0), Math.abs(a - b1));
+    }
     /** Return the largest absolute absolute value among x,y,z */
     static maxAbsXYZ(x, y, z) {
         return Geometry.maxXYZ(Math.abs(x), Math.abs(y), Math.abs(z));
@@ -183392,19 +183394,33 @@ class Geometry {
         return q;
     }
     /** Return the hypotenuse `sqrt(x*x + y*y)`. This is much faster than `Math.hypot(x,y)`. */
-    static hypotenuseXY(x, y) { return Math.sqrt(x * x + y * y); }
+    static hypotenuseXY(x, y) {
+        return Math.sqrt(x * x + y * y);
+    }
     /** Return the squared `hypotenuse (x*x + y*y)`. */
-    static hypotenuseSquaredXY(x, y) { return x * x + y * y; }
+    static hypotenuseSquaredXY(x, y) {
+        return x * x + y * y;
+    }
     /** Return the square of x */
-    static square(x) { return x * x; }
+    static square(x) {
+        return x * x;
+    }
     /** Return the hypotenuse `sqrt(x*x + y*y + z*z)`. This is much faster than `Math.hypot(x,y,z)`. */
-    static hypotenuseXYZ(x, y, z) { return Math.sqrt(x * x + y * y + z * z); }
+    static hypotenuseXYZ(x, y, z) {
+        return Math.sqrt(x * x + y * y + z * z);
+    }
     /** Return the squared hypotenuse `(x*x + y*y + z*z)`. This is much faster than `Math.hypot(x,y,z)`. */
-    static hypotenuseSquaredXYZ(x, y, z) { return x * x + y * y + z * z; }
+    static hypotenuseSquaredXYZ(x, y, z) {
+        return x * x + y * y + z * z;
+    }
     /** Return the (full 4d) hypotenuse `sqrt(x*x + y*y + z*z + w*w)`. This is much faster than `Math.hypot(x,y,z,w)`. */
-    static hypotenuseXYZW(x, y, z, w) { return Math.sqrt(x * x + y * y + z * z + w * w); }
+    static hypotenuseXYZW(x, y, z, w) {
+        return Math.sqrt(x * x + y * y + z * z + w * w);
+    }
     /** Return the squared hypotenuse `(x*x + y*y + z*z+w*w)`. This is much faster than `Math.hypot(x,y,z)`. */
-    static hypotenuseSquaredXYZW(x, y, z, w) { return x * x + y * y + z * z + w * w; }
+    static hypotenuseSquaredXYZW(x, y, z, w) {
+        return x * x + y * y + z * z + w * w;
+    }
     /**
      * Return the distance between xy points given as numbers.
      * @param x0 x coordinate of point 0
@@ -194261,6 +194277,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "NewtonEvaluatorRtoRD": () => (/* reexport safe */ _numerics_Newton__WEBPACK_IMPORTED_MODULE_51__.NewtonEvaluatorRtoRD),
 /* harmony export */   "NullGeometryHandler": () => (/* reexport safe */ _geometry3d_GeometryHandler__WEBPACK_IMPORTED_MODULE_8__.NullGeometryHandler),
 /* harmony export */   "NumberArray": () => (/* reexport safe */ _geometry3d_PointHelpers__WEBPACK_IMPORTED_MODULE_23__.NumberArray),
+/* harmony export */   "OffsetMeshOptions": () => (/* reexport safe */ _polyface_PolyfaceQuery__WEBPACK_IMPORTED_MODULE_116__.OffsetMeshOptions),
 /* harmony export */   "OffsetOptions": () => (/* reexport safe */ _curve_internalContexts_PolygonOffsetContext__WEBPACK_IMPORTED_MODULE_79__.OffsetOptions),
 /* harmony export */   "Order2Bezier": () => (/* reexport safe */ _numerics_BezierPolynomials__WEBPACK_IMPORTED_MODULE_49__.Order2Bezier),
 /* harmony export */   "Order3Bezier": () => (/* reexport safe */ _numerics_BezierPolynomials__WEBPACK_IMPORTED_MODULE_49__.Order3Bezier),
@@ -197272,11 +197289,12 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "CurveCurve": () => (/* binding */ CurveCurve)
 /* harmony export */ });
-/* harmony import */ var _CurveCollection__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./CurveCollection */ "../../core/geometry/lib/esm/curve/CurveCollection.js");
-/* harmony import */ var _CurveCurveIntersectXY__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./CurveCurveIntersectXY */ "../../core/geometry/lib/esm/curve/CurveCurveIntersectXY.js");
-/* harmony import */ var _CurveCurveIntersectXYZ__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./CurveCurveIntersectXYZ */ "../../core/geometry/lib/esm/curve/CurveCurveIntersectXYZ.js");
-/* harmony import */ var _CurvePrimitive__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./CurvePrimitive */ "../../core/geometry/lib/esm/curve/CurvePrimitive.js");
-/* harmony import */ var _CurveCurveCloseApproachXY__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./CurveCurveCloseApproachXY */ "../../core/geometry/lib/esm/curve/CurveCurveCloseApproachXY.js");
+/* harmony import */ var _Geometry__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../Geometry */ "../../core/geometry/lib/esm/Geometry.js");
+/* harmony import */ var _CurveCollection__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./CurveCollection */ "../../core/geometry/lib/esm/curve/CurveCollection.js");
+/* harmony import */ var _CurveCurveCloseApproachXY__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./CurveCurveCloseApproachXY */ "../../core/geometry/lib/esm/curve/CurveCurveCloseApproachXY.js");
+/* harmony import */ var _CurveCurveIntersectXY__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./CurveCurveIntersectXY */ "../../core/geometry/lib/esm/curve/CurveCurveIntersectXY.js");
+/* harmony import */ var _CurveCurveIntersectXYZ__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./CurveCurveIntersectXYZ */ "../../core/geometry/lib/esm/curve/CurveCurveIntersectXYZ.js");
+/* harmony import */ var _CurvePrimitive__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./CurvePrimitive */ "../../core/geometry/lib/esm/curve/CurvePrimitive.js");
 /*---------------------------------------------------------------------------------------------
 * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
 * See LICENSE.md in the project root for license terms and full copyright notice.
@@ -197289,6 +197307,7 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+
 /**
  * `CurveCurve` has static method for various computations that work on a pair of curves or curve collections.
  * @public
@@ -197296,17 +197315,18 @@ __webpack_require__.r(__webpack_exports__);
 class CurveCurve {
     /**
      * Return xy intersections of 2 curves.
-     * @param geometryA second geometry
+     * @param geometryA first geometry
      * @param extendA true to allow geometryA to extend
      * @param geometryB second geometry
      * @param extendB true to allow geometryB to extend
+     * @param tolerance optional distance tolerance for coincidence
      */
-    static intersectionXYPairs(geometryA, extendA, geometryB, extendB) {
-        const handler = new _CurveCurveIntersectXY__WEBPACK_IMPORTED_MODULE_0__.CurveCurveIntersectXY(undefined, geometryA, extendA, geometryB, extendB);
-        if (geometryB instanceof _CurvePrimitive__WEBPACK_IMPORTED_MODULE_1__.CurvePrimitive) {
+    static intersectionXYPairs(geometryA, extendA, geometryB, extendB, tolerance = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.smallMetricDistance) {
+        const handler = new _CurveCurveIntersectXY__WEBPACK_IMPORTED_MODULE_1__.CurveCurveIntersectXY(undefined, geometryA, extendA, geometryB, extendB, tolerance);
+        if (geometryB instanceof _CurvePrimitive__WEBPACK_IMPORTED_MODULE_2__.CurvePrimitive) {
             geometryA.dispatchToGeometryHandler(handler);
         }
-        else if (geometryB instanceof _CurveCollection__WEBPACK_IMPORTED_MODULE_2__.CurveCollection) {
+        else if (geometryB instanceof _CurveCollection__WEBPACK_IMPORTED_MODULE_3__.CurveCollection) {
             const allCurves = geometryB.collectCurvePrimitives();
             for (const child of allCurves) {
                 handler.resetGeometry(geometryA, false, child, false);
@@ -197317,13 +197337,14 @@ class CurveCurve {
     }
     /**
      * Return xy intersections of 2 projected curves
-     * @param geometryA second geometry
+     * @param geometryA first geometry
      * @param extendA true to allow geometryA to extend
      * @param geometryB second geometry
      * @param extendB true to allow geometryB to extend
+     * @param tolerance optional distance tolerance for coincidence
      */
-    static intersectionProjectedXYPairs(worldToLocal, geometryA, extendA, geometryB, extendB) {
-        const handler = new _CurveCurveIntersectXY__WEBPACK_IMPORTED_MODULE_0__.CurveCurveIntersectXY(worldToLocal, geometryA, extendA, geometryB, extendB);
+    static intersectionProjectedXYPairs(worldToLocal, geometryA, extendA, geometryB, extendB, tolerance = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.smallMetricDistance) {
+        const handler = new _CurveCurveIntersectXY__WEBPACK_IMPORTED_MODULE_1__.CurveCurveIntersectXY(worldToLocal, geometryA, extendA, geometryB, extendB, tolerance);
         geometryA.dispatchToGeometryHandler(handler);
         return handler.grabPairedResults();
     }
@@ -197332,25 +197353,26 @@ class CurveCurve {
      *  * Implemented for combinations of LineSegment3d, LineString3d, Arc3d.
      *  * Not Implemented for bspline and bezier curves.
      * @beta
-     * @param geometryA second geometry
+     * @param geometryA first geometry
      * @param extendA true to allow geometryA to extend
      * @param geometryB second geometry
      * @param extendB true to allow geometryB to extend
      */
     static intersectionXYZ(geometryA, extendA, geometryB, extendB) {
-        const handler = new _CurveCurveIntersectXYZ__WEBPACK_IMPORTED_MODULE_3__.CurveCurveIntersectXYZ(geometryA, extendA, geometryB, extendB);
+        const handler = new _CurveCurveIntersectXYZ__WEBPACK_IMPORTED_MODULE_4__.CurveCurveIntersectXYZ(geometryA, extendA, geometryB, extendB);
         geometryA.dispatchToGeometryHandler(handler);
         return handler.grabResults();
     }
     /**
      * Return xy intersections of 2 curves.
-     * @param geometryA second geometry
+     * @param geometryA first geometry
      * @param extendA true to allow geometryA to extend
      * @param geometryB second geometry
      * @param extendB true to allow geometryB to extend
+     * @param tolerance optional distance tolerance for coincidence
      */
-    static allIntersectionsAmongPrimitivesXY(primitives) {
-        const handler = new _CurveCurveIntersectXY__WEBPACK_IMPORTED_MODULE_0__.CurveCurveIntersectXY(undefined, undefined, false, undefined, false);
+    static allIntersectionsAmongPrimitivesXY(primitives, tolerance = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.smallMetricDistance) {
+        const handler = new _CurveCurveIntersectXY__WEBPACK_IMPORTED_MODULE_1__.CurveCurveIntersectXY(undefined, undefined, false, undefined, false, tolerance);
         for (let i = 0; i < primitives.length; i++) {
             const geometryA = primitives[i];
             for (let j = i + 1; j < primitives.length; j++) {
@@ -197362,11 +197384,11 @@ class CurveCurve {
     }
     /**
      * Return xy close approaches of 2 projected curves
-     * @param geometryA second geometry
+     * @param geometryA first geometry
      * @param geometryB second geometry
      */
     static closeApproachProjectedXYPairs(geometryA, geometryB, maxDistance) {
-        const handler = new _CurveCurveCloseApproachXY__WEBPACK_IMPORTED_MODULE_4__.CurveCurveCloseApproachXY(geometryA, geometryB);
+        const handler = new _CurveCurveCloseApproachXY__WEBPACK_IMPORTED_MODULE_5__.CurveCurveCloseApproachXY(geometryA, geometryB);
         handler.maxDistanceToAccept = maxDistance;
         geometryA.dispatchToGeometryHandler(handler);
         return handler.grabPairedResults();
@@ -198135,8 +198157,8 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "CurveLocationDetailArrayPair": () => (/* binding */ CurveLocationDetailArrayPair)
 /* harmony export */ });
 /* harmony import */ var _bspline_BSplineCurve__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ../bspline/BSplineCurve */ "../../core/geometry/lib/esm/bspline/BSplineCurve.js");
-/* harmony import */ var _Geometry__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../Geometry */ "../../core/geometry/lib/esm/Geometry.js");
-/* harmony import */ var _geometry3d_CoincidentGeometryOps__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../geometry3d/CoincidentGeometryOps */ "../../core/geometry/lib/esm/geometry3d/CoincidentGeometryOps.js");
+/* harmony import */ var _Geometry__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../Geometry */ "../../core/geometry/lib/esm/Geometry.js");
+/* harmony import */ var _geometry3d_CoincidentGeometryOps__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../geometry3d/CoincidentGeometryOps */ "../../core/geometry/lib/esm/geometry3d/CoincidentGeometryOps.js");
 /* harmony import */ var _geometry3d_GeometryHandler__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../geometry3d/GeometryHandler */ "../../core/geometry/lib/esm/geometry3d/GeometryHandler.js");
 /* harmony import */ var _geometry3d_GrowableFloat64Array__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../geometry3d/GrowableFloat64Array */ "../../core/geometry/lib/esm/geometry3d/GrowableFloat64Array.js");
 /* harmony import */ var _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../geometry3d/Matrix3d */ "../../core/geometry/lib/esm/geometry3d/Matrix3d.js");
@@ -198161,14 +198183,12 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
-// import { Arc3d } from "./Arc3d";
 
 
 
 
 
 
-// import { LineString3d } from "./LineString3d";
 
 
 
@@ -198221,8 +198241,9 @@ class CurveCurveIntersectXY extends _geometry3d_GeometryHandler__WEBPACK_IMPORTE
      * @param extendA flag to enable using extension of geometryA.
      * @param geometryB second curve for intersection.  Saved for reference by specific handler methods.
      * @param extendB flag for extension of geometryB.
+     * @param tolerance optional distance tolerance for coincidence
      */
-    constructor(worldToLocal, _geometryA, extendA, geometryB, extendB) {
+    constructor(worldToLocal, _geometryA, extendA, geometryB, extendB, tolerance = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.smallMetricDistance) {
         super();
         // this.geometryA = _geometryA;
         this._extendA = extendA;
@@ -198235,7 +198256,7 @@ class CurveCurveIntersectXY extends _geometry3d_GeometryHandler__WEBPACK_IMPORTE
             if (!this._worldToLocalAffine)
                 this._worldToLocalPerspective = worldToLocal.clone();
         }
-        this._coincidentGeometryContext = _geometry3d_CoincidentGeometryOps__WEBPACK_IMPORTED_MODULE_3__.CoincidentGeometryQuery.create();
+        this._coincidentGeometryContext = _geometry3d_CoincidentGeometryOps__WEBPACK_IMPORTED_MODULE_4__.CoincidentGeometryQuery.create(tolerance);
         this.reinitialize();
     }
     reinitialize() {
@@ -198254,13 +198275,15 @@ class CurveCurveIntersectXY extends _geometry3d_GeometryHandler__WEBPACK_IMPORTE
             return false;
         return true;
     }
-    // Test the fraction by strict parameter, but allow physical (metric) test at ends.
-    acceptFractionOnLine(extend0, fraction, extend1, pointA, pointB) {
+    /** Test the fraction by strict parameter, but allow toleranced distance test at ends.
+     * @param tolerance optional distance tolerance to check proximity to start/end point
+     */
+    acceptFractionOnLine(extend0, fraction, extend1, pointA, pointB, tolerance = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.smallMetricDistance) {
         if (!extend0 && fraction < 0) {
-            return _Geometry__WEBPACK_IMPORTED_MODULE_4__.Geometry.isSmallMetricDistance(fraction * pointA.distanceXY(pointB));
+            return _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.isDistanceWithinTol(fraction * pointA.distanceXY(pointB), tolerance);
         }
         else if (!extend1 && fraction > 1.0)
-            return _Geometry__WEBPACK_IMPORTED_MODULE_4__.Geometry.isSmallMetricDistance((fraction - 1.0) * pointA.distanceXY(pointB));
+            return _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.isDistanceWithinTol((fraction - 1.0) * pointA.distanceXY(pointB), tolerance);
         return true;
     }
     /**
@@ -198275,7 +198298,7 @@ class CurveCurveIntersectXY extends _geometry3d_GeometryHandler__WEBPACK_IMPORTE
         return result;
     }
     sameCurveAndFraction(cp, fraction, detail) {
-        return cp === detail.curve && _Geometry__WEBPACK_IMPORTED_MODULE_4__.Geometry.isAlmostEqualNumber(fraction, detail.fraction);
+        return cp === detail.curve && _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.isAlmostEqualNumber(fraction, detail.fraction);
     }
     /** compute intersection of two line segments.
      * filter by extension rules.
@@ -198287,14 +198310,14 @@ class CurveCurveIntersectXY extends _geometry3d_GeometryHandler__WEBPACK_IMPORTE
         let globalFractionA1, globalFractionB1;
         const isInterval = intervalDetails !== undefined && intervalDetails.detailA.hasFraction1 && intervalDetails.detailB.hasFraction1;
         if (isInterval) {
-            globalFractionA = _Geometry__WEBPACK_IMPORTED_MODULE_4__.Geometry.interpolate(fractionA0, intervalDetails.detailA.fraction, fractionA1);
-            globalFractionB = _Geometry__WEBPACK_IMPORTED_MODULE_4__.Geometry.interpolate(fractionB0, intervalDetails.detailB.fraction, fractionB1);
-            globalFractionA1 = _Geometry__WEBPACK_IMPORTED_MODULE_4__.Geometry.interpolate(fractionA0, intervalDetails.detailA.fraction1, fractionA1);
-            globalFractionB1 = _Geometry__WEBPACK_IMPORTED_MODULE_4__.Geometry.interpolate(fractionB0, intervalDetails.detailB.fraction1, fractionB1);
+            globalFractionA = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.interpolate(fractionA0, intervalDetails.detailA.fraction, fractionA1);
+            globalFractionB = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.interpolate(fractionB0, intervalDetails.detailB.fraction, fractionB1);
+            globalFractionA1 = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.interpolate(fractionA0, intervalDetails.detailA.fraction1, fractionA1);
+            globalFractionB1 = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.interpolate(fractionB0, intervalDetails.detailB.fraction1, fractionB1);
         }
         else {
-            globalFractionA = globalFractionA1 = _Geometry__WEBPACK_IMPORTED_MODULE_4__.Geometry.interpolate(fractionA0, localFractionA, fractionA1);
-            globalFractionB = globalFractionB1 = _Geometry__WEBPACK_IMPORTED_MODULE_4__.Geometry.interpolate(fractionB0, localFractionB, fractionB1);
+            globalFractionA = globalFractionA1 = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.interpolate(fractionA0, localFractionA, fractionA1);
+            globalFractionB = globalFractionB1 = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.interpolate(fractionB0, localFractionB, fractionB1);
         }
         // ignore duplicate of most recent point .  ..
         const numPrevious = this._results.length;
@@ -198356,8 +198379,8 @@ class CurveCurveIntersectXY extends _geometry3d_GeometryHandler__WEBPACK_IMPORTE
             this.recordPointWithLocalFractions(overlap.detailA.fraction, cpA, fractionA0, fractionA1, overlap.detailB.fraction, cpB, fractionB0, fractionB1, reversed, overlap);
         }
         else if (_numerics_Polynomials__WEBPACK_IMPORTED_MODULE_6__.SmallSystem.lineSegment3dXYTransverseIntersectionUnbounded(pointA0, pointA1, pointB0, pointB1, uv)) {
-            if (this.acceptFractionOnLine(extendA0, uv.x, extendA1, pointA0, pointA1)
-                && this.acceptFractionOnLine(extendB0, uv.y, extendB1, pointB0, pointB1)) {
+            if (this.acceptFractionOnLine(extendA0, uv.x, extendA1, pointA0, pointA1, this._coincidentGeometryContext.tolerance)
+                && this.acceptFractionOnLine(extendB0, uv.y, extendB1, pointB0, pointB1, this._coincidentGeometryContext.tolerance)) {
                 this.recordPointWithLocalFractions(uv.x, cpA, fractionA0, fractionA1, uv.y, cpB, fractionB0, fractionB1, reversed);
             }
         }
@@ -198415,9 +198438,9 @@ class CurveCurveIntersectXY extends _geometry3d_GeometryHandler__WEBPACK_IMPORTE
             const data = arc.toTransformedPoint4d(this._worldToLocalPerspective);
             const pointA0H = this._worldToLocalPerspective.multiplyPoint3d(pointA0, 1);
             const pointA1H = this._worldToLocalPerspective.multiplyPoint3d(pointA1, 1);
-            const alpha = _Geometry__WEBPACK_IMPORTED_MODULE_4__.Geometry.tripleProductPoint4dXYW(pointA0H, pointA1H, data.center);
-            const beta = _Geometry__WEBPACK_IMPORTED_MODULE_4__.Geometry.tripleProductPoint4dXYW(pointA0H, pointA1H, data.vector0);
-            const gamma = _Geometry__WEBPACK_IMPORTED_MODULE_4__.Geometry.tripleProductPoint4dXYW(pointA0H, pointA1H, data.vector90);
+            const alpha = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.tripleProductPoint4dXYW(pointA0H, pointA1H, data.center);
+            const beta = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.tripleProductPoint4dXYW(pointA0H, pointA1H, data.vector0);
+            const gamma = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.tripleProductPoint4dXYW(pointA0H, pointA1H, data.vector90);
             const cosines = new _geometry3d_GrowableFloat64Array__WEBPACK_IMPORTED_MODULE_7__.GrowableFloat64Array(2);
             const sines = new _geometry3d_GrowableFloat64Array__WEBPACK_IMPORTED_MODULE_7__.GrowableFloat64Array(2);
             const radians = new _geometry3d_GrowableFloat64Array__WEBPACK_IMPORTED_MODULE_7__.GrowableFloat64Array(2);
@@ -198439,9 +198462,9 @@ class CurveCurveIntersectXY extends _geometry3d_GeometryHandler__WEBPACK_IMPORTE
                 pointA0Local = this._worldToLocalAffine.multiplyPoint3d(pointA0);
                 pointA1Local = this._worldToLocalAffine.multiplyPoint3d(pointA1);
             }
-            const alpha = _Geometry__WEBPACK_IMPORTED_MODULE_4__.Geometry.tripleProductXYW(pointA0Local, 1, pointA1Local, 1, data.center, 1);
-            const beta = _Geometry__WEBPACK_IMPORTED_MODULE_4__.Geometry.tripleProductXYW(pointA0Local, 1, pointA1Local, 1, data.vector0, 0);
-            const gamma = _Geometry__WEBPACK_IMPORTED_MODULE_4__.Geometry.tripleProductXYW(pointA0Local, 1, pointA1Local, 1, data.vector90, 0);
+            const alpha = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.tripleProductXYW(pointA0Local, 1, pointA1Local, 1, data.center, 1);
+            const beta = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.tripleProductXYW(pointA0Local, 1, pointA1Local, 1, data.vector0, 0);
+            const gamma = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.tripleProductXYW(pointA0Local, 1, pointA1Local, 1, data.vector90, 0);
             const cosines = new _geometry3d_GrowableFloat64Array__WEBPACK_IMPORTED_MODULE_7__.GrowableFloat64Array(2);
             const sines = new _geometry3d_GrowableFloat64Array__WEBPACK_IMPORTED_MODULE_7__.GrowableFloat64Array(2);
             const radians = new _geometry3d_GrowableFloat64Array__WEBPACK_IMPORTED_MODULE_7__.GrowableFloat64Array(2);
@@ -198666,8 +198689,8 @@ class CurveCurveIntersectXY extends _geometry3d_GeometryHandler__WEBPACK_IMPORTE
                     let bezierBFraction = r;
                     bezierB.fractionToPoint4d(bezierBFraction, this._xyzwB);
                     const segmentAFraction = _numerics_Polynomials__WEBPACK_IMPORTED_MODULE_6__.SmallSystem.lineSegment3dHXYClosestPointUnbounded(this._xyzwA0, this._xyzwA1, this._xyzwB);
-                    if (segmentAFraction && _Geometry__WEBPACK_IMPORTED_MODULE_4__.Geometry.isIn01WithTolerance(segmentAFraction, intervalTolerance)) {
-                        let bezierAFraction = _Geometry__WEBPACK_IMPORTED_MODULE_4__.Geometry.interpolate(f0, segmentAFraction, f1);
+                    if (segmentAFraction && _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.isIn01WithTolerance(segmentAFraction, intervalTolerance)) {
+                        let bezierAFraction = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.interpolate(f0, segmentAFraction, f1);
                         const xyMatchingFunction = new BezierBezierIntersectionXYRRToRRD(bezierA, bezierB);
                         const newtonSearcher = new _numerics_Newton__WEBPACK_IMPORTED_MODULE_0__.Newton2dUnboundedWithDerivative(xyMatchingFunction);
                         newtonSearcher.setUV(bezierAFraction, bezierBFraction);
@@ -212656,6 +212679,44 @@ class Angle {
         const uDotV = ux * vx + uy * vy + uz * vz;
         return Math.atan2(_Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.crossProductMagnitude(ux, uy, uz, vx, vy, vz), uDotV);
     }
+    /**
+     * * Returns the angle between two vectors, with the vectors given as xyz components, and an up vector to resolve angle to a full 2PI range.
+     * * The returned angle is (-PI < radians <= PI) or (0 <= radians < 2 * PI)
+     * * The angle is in the plane of the U and V vectors.
+     * * The upVector determines a positive side of the plane but need not be strictly perpendicular to the plane.
+     *
+     * @param ux x component of vector u
+     * @param uy y component of vector u
+     * @param uz z component of vector u
+     * @param vx x component of vector v
+     * @param vy y component of vector v
+     * @param vz z component of vector v
+     * @param upVectorX x component of vector to positive side of plane.
+     * @param upVectorY y component of vector to positive side of plane.
+     * @param upVectorZ z component of vector to positive side of plane.
+     * @param adjustToAllPositive if true, return strictly non-negative sweep (0 <= radians < 2*PI).  If false, return signed (-PI < radians <= PI)
+     */
+    static orientedRadiansBetweenVectorsXYZ(ux, uy, uz, vx, vy, vz, upVectorX, upVectorY, upVectorZ, adjustToPositive = false) {
+        const uDotV = ux * vx + uy * vy + uz * vz;
+        const wx = uy * vz - uz * vy;
+        const wy = uz * vx - ux * vz;
+        const wz = ux * vy - uy * vx;
+        const upDotW = upVectorX * wx + upVectorY * wy + upVectorZ * wz;
+        const crossMagnitude = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.hypotenuseXYZ(wx, wy, wz);
+        if (upDotW < 0.0) {
+            if (adjustToPositive) {
+                // The turn is greater than 180 degrees.  Take a peculiarly oriented atan2 to get the excess-180 part as addition to PI.
+                // This gives the smoothest numerical transition passing PI.
+                return Math.PI + Math.atan2(crossMagnitude, -uDotV);
+            }
+            else {
+                return -Math.atan2(crossMagnitude, uDotV);
+            }
+        }
+        else {
+            return Math.atan2(crossMagnitude, uDotV);
+        }
+    }
     /**
      * Add a multiple of a full circle angle (360 degrees, 2PI) in place.
      * @param multiple multiplier factor
@@ -213483,6 +213544,9 @@ class CoincidentGeometryQuery {
     constructor(tolerance = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.smallMetricDistance) {
         this._tolerance = tolerance;
     }
+    get tolerance() {
+        return this._tolerance;
+    }
     static create(tolerance = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.smallMetricDistance) {
         return new CoincidentGeometryQuery(tolerance);
     }
@@ -218032,6 +218096,7 @@ __webpack_require__.r(__webpack_exports__);
 
 
 /* eslint-disable @itwin/prefer-get */
+// cSpell:words XXYZ YXYZ ZXYZ
 /**
  * PackedMatrix3dOps contains static methods for matrix operations where the matrix is a Float64Array.
  * * The Float64Array contains the matrix entries in row-major order
@@ -218659,7 +218724,8 @@ class Matrix3d {
         return undefined;
     }
     /**
-     * Construct a rigid matrix using vectorA and its 2 perpendicular.
+     * Construct a rigid matrix (orthogonal matrix with +1 determinant) using vectorA and its 2 perpendicular.
+     * * If axisOrder is not passed then `AxisOrder = AxisOrder.ZXY` is used as default.
      * * This function internally uses createPerpendicularVectorFavorXYPlane and createRigidFromColumns.
      */
     static createRigidHeadsUp(vectorA, axisOrder = _Geometry__WEBPACK_IMPORTED_MODULE_0__.AxisOrder.ZXY, result) {
@@ -218671,7 +218737,7 @@ class Matrix3d {
         }
         return Matrix3d.createIdentity(result);
     }
-    /** Return the matrix for rotation of `angle` around `axis` */
+    /** Return the matrix for rotation of `angle` around desired `axis` */
     static createRotationAroundVector(axis, angle, result) {
         // Rodriguez formula (matrix form), https://mathworld.wolfram.com/RodriguesRotationFormula.html
         const c = angle.cos();
@@ -218685,7 +218751,7 @@ class Matrix3d {
         }
         return undefined;
     }
-    /** Returns a rotation of specified angle around an axis
+    /** Returns a rotation of specified angle around one of the main axis (X,Y,Z).
      * @param axisIndex index of axis (AxisIndex.X, AxisIndex.Y, AxisIndex.Z) kept fixed by the rotation.
      * @param angle angle of rotation
      * @param result optional result matrix.
@@ -218708,14 +218774,33 @@ class Matrix3d {
         return myResult;
     }
     /**
-   * Replace current columns Ui and Uj with (c*Ui - s*Uj) and (c*Uj + s*Ui).
-   * * There is no checking for i,j being 0,1,2.
-   * * This is used in compute intensive inner loops
-   * @param i first row index. **must be 0,1,2** (unchecked)
-   * @param j second row index. **must be 0,1,2** (unchecked)
-   * @param c fist coefficient
-   * @param s second coefficient
-   */
+     * Replace current rows Ui and Uj with (c*Ui + s*Uj) and (c*Uj - s*Ui).
+     * * There is no checking for i,j being 0,1,2.
+     * @param i first row index.  **must be 0,1,2** (unchecked)
+     * @param j second row index. **must be 0,1,2** (unchecked)
+     * @param c fist coefficient
+     * @param s second coefficient
+     */
+    applyGivensRowOp(i, j, c, s) {
+        let ii = 3 * i;
+        let jj = 3 * j;
+        const limit = ii + 3;
+        for (; ii < limit; ii++, jj++) {
+            const a = this.coffs[ii];
+            const b = this.coffs[jj];
+            this.coffs[ii] = a * c + b * s;
+            this.coffs[jj] = -a * s + b * c;
+        }
+    }
+    /**
+     * Replace current columns Ui and Uj with (c*Ui + s*Uj) and (c*Uj - s*Ui).
+     * * There is no checking for i,j being 0,1,2.
+     * * This is used in compute intensive inner loops
+     * @param i first row index. **must be 0,1,2** (unchecked)
+     * @param j second row index. **must be 0,1,2** (unchecked)
+     * @param c fist coefficient
+     * @param s second coefficient
+     */
     applyGivensColumnOp(i, j, c, s) {
         const limit = i + 9;
         for (; i < limit; i += 3, j += 3) {
@@ -218726,12 +218811,12 @@ class Matrix3d {
         }
     }
     /**
-   * Create a matrix from column vectors.
-   * ```
-   * equation
-   * \begin{bmatrix}U_x & V_x & W_x \\ U_y & V_y & W_y \\ U_z & V_z & W_z \end{bmatrix}
-   * ```
-   */
+     * Create a matrix from column vectors.
+     * ```
+     * equation
+     * \begin{bmatrix}U_x & V_x & W_x \\ U_y & V_y & W_y \\ U_z & V_z & W_z \end{bmatrix}
+     * ```
+     */
     static createColumns(vectorU, vectorV, vectorW, result) {
         return Matrix3d.createRowValues(vectorU.x, vectorV.x, vectorW.x, vectorU.y, vectorV.y, vectorW.y, vectorU.z, vectorV.z, vectorW.z, result);
     }
@@ -218748,8 +218833,9 @@ class Matrix3d {
      * * ColumnX points in the rightVector direction
      * * ColumnY points in the upVector direction
      * * ColumnZ is a unit cross product of ColumnX and ColumnY.
-     * * Optionally rotate the standard cube by 45 degrees ccw around Y to bring its left or right vertical edge to center.
-     * * Optionally rotate the standard cube by 35.264 degrees ccw around X (isometric rotation).
+     * * Optionally rotate by 45 degrees around `upVector` to bring its left or right vertical edge to center.
+     * * Optionally rotate by arctan(1/sqrt(2)) ~ 35.264 degrees around `rightVector` to bring the top or bottom
+     * horizontal edge of the view to the center (for isometric views).
      * * This is expected to be used with various principal unit vectors that are perpendicular to each other.
      * * STANDARD TOP VIEW: createViewedAxes(Vector3d.unitX(), Vector3d.unitY(), 0, 0)
      * * STANDARD FRONT VIEW: createViewedAxes(Vector3d.unitX(), Vector3d.unitZ(), 0, 0)
@@ -218757,16 +218843,20 @@ class Matrix3d {
      * * STANDARD RIGHT VIEW: createViewedAxes(Vector3d.unitY(), Vector3d.unitZ(), 0, 0)
      * * STANDARD LEFT VIEW: createViewedAxes(Vector3d.unitY(-1), Vector3d.unitZ(), 0, 0)
      * * STANDARD BOTTOM VIEW: createViewedAxes(Vector3d.unitX(), Vector3d.unitY(-1), 0, 0)
+     * * STANDARD ISO VIEW: createViewedAxes(Vector3d.unitX(), Vector3d.unitZ(), -1, 1)
+     * * STANDARD RIGHT ISO VIEW: createViewedAxes(Vector3d.unitX(), Vector3d.unitZ(), 1, 1)
+     * * Front, right, back, left, top, and bottom standard views are views from faces of the cube
+     * and iso and right iso standard views are views from corners of the cube.
      * * Note: createViewedAxes is column-based so always returns local to world
      *
      * @param rightVector ColumnX of the returned matrix. Expected to be perpendicular to upVector.
      * @param upVector ColumnY of the returned matrix. Expected to be perpendicular to rightVector.
-     * @param leftNoneRight Specifies the ccw rotation around Y axis. Normally one of "-1", "0", and "1", where
-     * "-1" indicates rotation by 45 degrees to bring the left vertical edge to center, "0" means no rotation,
+     * @param leftNoneRight Specifies the ccw rotation around `upVector` axis. Normally one of "-1", "0", and "1",
+     * where "-1" indicates rotation by 45 degrees to bring the left vertical edge to center, "0" means no rotation,
      * and "1" indicates rotation by 45 degrees to bring the right vertical edge to center. Other numbers are
      * used as multiplier for this 45 degree rotation.
-     * @param topNoneBottom Specifies the ccw rotation around X axis. Normally one of "-1", "0", and "1", where
-     * "-1" indicates isometric rotation (35.264 degrees) to bring the bottom upward, "0" means no rotation,
+     * @param topNoneBottom Specifies the ccw rotation around `rightVector` axis. Normally one of "-1", "0", and "1",
+     * where "-1" indicates isometric rotation (35.264 degrees) to bring the bottom upward, "0" means no rotation,
      * and "1" indicates isometric rotation (35.264 degrees) to bring the top downward. Other numbers are
      * used as multiplier for the 35.264 degree rotation.
      * @returns matrix = [rightVector, upVector, rightVector cross upVector] with the applied rotations specified
@@ -218804,9 +218894,11 @@ class Matrix3d {
      * * Default is TOP view (`local X = world X`, `local Y = world Y`, `local Z = world Z`).
      * * To change view from the TOP to one of the other 7 standard views, we need to multiply "world data" to
      * the corresponding matrix1 provided by `createStandardWorldToView(index, false)` and then
-     * `matrix1.multiply(world data)` will returns "local data".
+     * `matrix1.multiply(world data)` will return "local data".
      * * To change view back to the TOP, we need to multiply "local data" to the corresponding matrix2 provided
      * by `createStandardWorldToView(index, true)` and then `matrix2.multiply(local data)` will returns "world data".
+     * * Note: No matter how you rotate the world axis, local X is always pointing right, local Y is always pointing up,
+     * and local Z is always pointing toward you.
      *
      * @param index standard view index `StandardViewIndex.Top, Bottom, Left, Right, Front, Back, Iso, RightIso`
      * @param invert if false (default), the return matrix is world to local (view) and if true, the the return
@@ -218815,343 +218907,182 @@ class Matrix3d {
      */
     static createStandardWorldToView(index, invert = false, result) {
         switch (index) {
-            // start with TOP view, ccw rotation by 180 degrees around X
+            // Start with TOP view, ccw rotation by 180 degrees around X
             case _Geometry__WEBPACK_IMPORTED_MODULE_0__.StandardViewIndex.Bottom:
                 result = Matrix3d.createRowValues(1, 0, 0, 0, -1, 0, 0, 0, -1);
                 break;
-            // start with TOP view, ccw rotation by -90 degrees around X and by 90 degrees around Z
+            // Start with TOP view, ccw rotation by -90 degrees around X and by 90 degrees around Z
             case _Geometry__WEBPACK_IMPORTED_MODULE_0__.StandardViewIndex.Left:
                 result = Matrix3d.createRowValues(0, -1, 0, 0, 0, 1, -1, 0, 0);
                 break;
-            // start with TOP view, ccw rotation by -90 degrees around X and by -90 degrees around Z
+            // Start with TOP view, ccw rotation by -90 degrees around X and by -90 degrees around Z
             case _Geometry__WEBPACK_IMPORTED_MODULE_0__.StandardViewIndex.Right:
                 result = Matrix3d.createRowValues(0, 1, 0, 0, 0, 1, 1, 0, 0);
                 break;
-            // start with TOP view, ccw rotation by -90 degrees around X
+            // Start with TOP view, ccw rotation by -90 degrees around X
             case _Geometry__WEBPACK_IMPORTED_MODULE_0__.StandardViewIndex.Front:
                 result = Matrix3d.createRowValues(1, 0, 0, 0, 0, 1, 0, -1, 0);
                 break;
-            // start with TOP view, ccw rotation by -90 degrees around X and by 180 degrees around Z
+            // Start with TOP view, ccw rotation by -90 degrees around X and by 180 degrees around Z
             case _Geometry__WEBPACK_IMPORTED_MODULE_0__.StandardViewIndex.Back:
                 result = Matrix3d.createRowValues(-1, 0, 0, 0, 0, 1, 0, 1, 0);
                 break;
+            /**
+             * Isometric view
+             * Start with FRONT view, ccw rotation by -45 degrees around Y and by arctan(1/sqrt(2)) ~ 35.264 degrees around X
+             * cos(45) = 1/sqrt(2) = 0.70710678118 and sin(45) = 1/sqrt(2) = 0.70710678118
+             * cos(35.264) = 2/sqrt(6) = 0.81649658092 and sin(35.264) = 1/sqrt(3) = 0.57735026919
+             * More info: https://en.wikipedia.org/wiki/Isometric_projection
+             */
             case _Geometry__WEBPACK_IMPORTED_MODULE_0__.StandardViewIndex.Iso:
-                // start with FRONT view, ccw rotation by -45 degrees around Y and by 35.264 degrees around X
                 result = Matrix3d.createRowValues(0.707106781186548, -0.70710678118654757, 0.00000000000000000, 0.408248290463863, 0.40824829046386302, 0.81649658092772603, -0.577350269189626, -0.57735026918962573, 0.57735026918962573);
                 break;
+            // Start with FRONT view, ccw rotation by 45 degrees around Y and by 35.264 degrees around X
             case _Geometry__WEBPACK_IMPORTED_MODULE_0__.StandardViewIndex.RightIso:
                 result = Matrix3d.createRowValues(0.707106781186548, 0.70710678118654757, 0.00000000000000000, -0.408248290463863, 0.40824829046386302, 0.81649658092772603, 0.577350269189626, -0.57735026918962573, 0.57735026918962573);
                 break;
-            case _Geometry__WEBPACK_IMPORTED_MODULE_0__.StandardViewIndex.Top: // no rotation
+            // no rotation
+            case _Geometry__WEBPACK_IMPORTED_MODULE_0__.StandardViewIndex.Top:
             default:
                 result = Matrix3d.createIdentity(result);
         }
         if (invert)
-            result.transposeInPlace();
+            result.transposeInPlace(); // matrix is rigid so transpose and inverse are the same
         return result;
     }
-    /*
-    // this implementation has problems distinguishing failure (normalize) from small angle.
-    public getAxisAndAngleOfRotation(): { axis: Vector3d, angle: Angle, error: boolean } {
-  
-      const result = { axis: Vector3d.unitZ(), angle: Angle.createRadians(0), error: true };
-      if (this.isIdentity) {
-        result.error = false;
-        return result;
-      }
-      if (!this.isRigid())
-        return result;
-      const QMinusI = this.clone();
-      QMinusI.coffs[0] -= 1.0;
-      QMinusI.coffs[4] -= 1.0;
-      QMinusI.coffs[8] -= 1.0;
-      // Each column of (Q - I) is the motion of the corresponding axis vector
-      // during the rotation.
-      // Only one of the three axes can really be close to the rotation axis.
-      const delta0 = QMinusI.columnX();
-      const delta1 = QMinusI.columnY();
-      const delta2 = QMinusI.columnZ();
-      const cross01 = delta0.crossProduct(delta1);
-      const cross12 = delta1.crossProduct(delta2);
-      const cross20 = delta2.crossProduct(delta0);
-  
-      const aa01 = cross01.magnitudeSquared();
-      const aa12 = cross12.magnitudeSquared();
-      const aa20 = cross20.magnitudeSquared();
-  
-      const cross = cross01.clone(); // This will end up as the biggest cross product
-      const v0 = delta0.clone();  // This will end up as one of the two largest delta vectors
-      let aaMax = aa01;
-      if (aa12 > aaMax) {
-        cross.setFrom(cross12);
-        aaMax = aa12;
-        v0.setFrom(delta1);
-      }
-      if (aa20 > aaMax) {
-        cross.setFrom(cross20);
-        aaMax = aa20;
-        v0.setFrom(delta2);
-      }
-  
-      if (aaMax === 0.0) {
-        // The vectors did not move.  Just accept the zero rotation, with error flag set.
-        return result;
-      }
-  
-      v0.normalizeInPlace();
-      // V0 is a unit vector perpendicular to the rotation axis.
-      // Rotate it.   Its image V1 is also a unit vector, and the angle from V0 to V1 is the quat angle.
-      // CrossProduct is axis vector times sine of angle.
-      // Dot Product is cosine of angle.
-      // V2 is zero in 180 degree case, so we use the Cross from the search as the axis
-      //   as direction, being careful to keep sine positive.
-      const v1 = this.multiplyVector(v0);
-      const v2 = v0.crossProduct(v1);
-      const sine = v2.magnitude();
-      if (v2.dotProduct(cross) < 0.0)
-        cross.scaleInPlace(-1.0);
-      const cosine = v0.dotProduct(v1);
-      result.angle.setRadians(Math.atan2(sine, cosine));
-      result.axis.setFrom(cross);
-      result.error = !result.axis.tryNormalizeInPlace();
-      return result
+    /**
+     * Apply (in place) a jacobi update that zeros out this.at(i,j).
+     * @param i row index of zeroed member
+     * @param j column index of zeroed member
+     * @param k other row/column index (different from i and j)
+     * @param leftEigenVectors a matrix that its columns will be filled by eigenvectors of this Matrix3d
+     * (allocated by caller, computed and filled by this function)
+     */
+    applyFastSymmetricJacobiUpdate(i, j, k, leftEigenVectors) {
+        const indexII = 4 * i;
+        const indexJJ = 4 * j;
+        const indexIJ = 3 * i + j;
+        const indexIK = 3 * i + k;
+        const indexJK = 3 * j + k;
+        const dotUU = this.coffs[indexII];
+        const dotVV = this.coffs[indexJJ];
+        const dotUV = this.coffs[indexIJ];
+        const jacobi = _Angle__WEBPACK_IMPORTED_MODULE_1__.Angle.trigValuesToHalfAngleTrigValues(dotUU - dotVV, 2.0 * dotUV);
+        if (Math.abs(dotUV) < 1.0e-15 * (dotUU + dotVV))
+            return 0.0;
+        const c = jacobi.c;
+        const s = jacobi.s;
+        const cc = c * c;
+        const ss = s * s;
+        const sc2 = 2.0 * c * s;
+        this.coffs[indexII] = cc * dotUU + sc2 * dotUV + ss * dotVV;
+        this.coffs[indexJJ] = ss * dotUU - sc2 * dotUV + cc * dotVV;
+        this.coffs[indexIJ] = 0.0;
+        const a = this.coffs[indexIK];
+        const b = this.coffs[indexJK];
+        this.coffs[indexIK] = a * c + b * s;
+        this.coffs[indexJK] = -s * a + c * b;
+        this.coffs[3 * j + i] = 0.0;
+        this.coffs[3 * k + i] = this.coffs[indexIK];
+        this.coffs[3 * k + j] = this.coffs[indexJK];
+        leftEigenVectors.applyGivensColumnOp(i, j, c, s);
+        return Math.abs(dotUV);
+    }
+    /**
+     * Factor this (symmetrized) as a product U * lambda * UT where U is orthogonal, lambda is diagonal.
+     * The upper triangle is mirrored to lower triangle to enforce symmetry.
+     * @param leftEigenvectors a matrix that its columns will be filled by eigenvectors of this Matrix3d
+     * (allocated by caller, computed and filled by this function)
+     * @param lambda a vector that its entries will be filled by eigenvalues of this Matrix3d
+     * (allocated by caller, computed and filled by this function)
+     */
+    fastSymmetricEigenvalues(leftEigenvectors, lambda) {
+        const matrix = this.clone();
+        leftEigenvectors.setIdentity();
+        const tolerance = 1.0e-12 * this.sumSquares();
+        for (let iteration = 0; iteration < 7; iteration++) {
+            const sum = matrix.applyFastSymmetricJacobiUpdate(0, 1, 2, leftEigenvectors)
+                + matrix.applyFastSymmetricJacobiUpdate(0, 2, 1, leftEigenvectors)
+                + matrix.applyFastSymmetricJacobiUpdate(1, 2, 0, leftEigenvectors);
+            // console.log("symmetric sum", sum);
+            // console.log ("sum", sum);
+            if (sum < tolerance) {
+                // console.log("symmetric iterations", iteration);
+                lambda.set(matrix.at(0, 0), matrix.at(1, 1), matrix.at(2, 2));
+                return true;
+            }
+        }
+        return false;
     }
-  */
     /**
      * Compute the (unit vector) axis and angle of rotation.
+     * * math details can be found at docs/learning/geometry/Angle.md
      * @returns Returns axis and angle of rotation with result.ok === true when the conversion succeeded.
      */
     getAxisAndAngleOfRotation() {
         const trace = this.coffs[0] + this.coffs[4] + this.coffs[8];
-        // trace = (xx + yy * zz) * (1-c) + 3 * c = 1 + 2c ==> c = (trace-1) / 2
-        const skewXY = this.coffs[3] - this.coffs[1]; // == 2sz
-        const skewYZ = this.coffs[7] - this.coffs[5]; // == 2sx
-        const skewZX = this.coffs[2] - this.coffs[6]; // == 2sy
-        const c = (trace - 1.0) / 2.0;
-        const s = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.hypotenuseXYZ(skewXY, skewYZ, skewZX) / 2.0;
-        const e = c * c + s * s - 1.0;
+        const skewXY = this.coffs[3] - this.coffs[1]; // 2*z*sin
+        const skewYZ = this.coffs[7] - this.coffs[5]; // 2*y*sin
+        const skewZX = this.coffs[2] - this.coffs[6]; // 2*x*sin
+        // trace = (m00^2 + m11^2 + m22^2) * (1-cos) + 3cos = (1-cos) + 3cos = 1 + 2cos ==> cos = (trace-1) / 2
+        const c = (trace - 1.0) / 2.0; // cosine
+        const s = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.hypotenuseXYZ(skewXY, skewYZ, skewZX) / 2.0; // sine
+        const e = c * c + s * s - 1.0; // s^2 + c^2 = 1
+        // if s^2 + c^2 != 1 then we have a bad matrix so return false
         if (Math.abs(e) > _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.smallAngleRadians) {
-            // the sine and cosine are not a unit circle point.   bad matrix . ..
             return { axis: _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(0, 0, 1), angle: _Angle__WEBPACK_IMPORTED_MODULE_1__.Angle.createRadians(0), ok: false };
         }
+        // sin is close to 0 then we got to special cases (angle 0 or 180) which needs to be handled differently
         if (Math.abs(s) < _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.smallAngleRadians) {
-            // There is no significant skew.
-            // The matrix is symmetric
-            // So it has simple eigenvalues -- either (1,1,1) or (1,-1,-1).
-            if (c > 0) // no rotation
+            if (c > 0) // sin = 0 and cos = 1 so angle = 0 (i.e., no rotation)
                 return { axis: _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(0, 0, 1), angle: _Angle__WEBPACK_IMPORTED_MODULE_1__.Angle.createRadians(0), ok: true };
-            // 180 degree flip around some axis ?
-            // Look for the simple case of a principal rotation ...
-            // look for a pair of (-1) entries on the diagonal ...
+            /**
+             * If sin = 0 and cos = -1 then angle = 180 (i.e., 180 degree rotation around some axis)
+             * then the rotation matrix becomes
+             *                                 2x^2-1  2xy      2xz
+             *                                 2xy     2y^2-1   2yz
+             *                                 2xz     2yz      2z^2-1
+             * Note that the matrix is symmetric.
+             * If rotation is around one the standard basis then non-diagonal entries become 0 and we
+             * have one 1 and two -1s on the diagonal.
+             * If rotation is around an axis other than standard basis, then the axis is the eigenvector
+             * of the rotation matrix with eigenvalue = 1.
+             */
             const axx = this.coffs[0];
             const ayy = this.coffs[4];
             const azz = this.coffs[8];
-            const theta180 = _Angle__WEBPACK_IMPORTED_MODULE_1__.Angle.createDegrees(180);
-            // Look for principal axis flips as a special case . ..
+            // Look for a pair of "-1" entries on the diagonal (for rotation around the basis X,Y,Z axis)
             if (_Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.isAlmostEqualNumber(-1.0, ayy) && _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.isAlmostEqualNumber(-1, azz)) {
-                // rotate around
-                return { axis: _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(1, 0, 0), angle: theta180, ok: true };
+                return { axis: _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(1, 0, 0), angle: _Angle__WEBPACK_IMPORTED_MODULE_1__.Angle.createDegrees(180), ok: true };
             }
             else if (_Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.isAlmostEqualNumber(-1.0, axx) && _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.isAlmostEqualNumber(-1, azz)) {
-                return { axis: _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(0, 1, 0), angle: theta180, ok: true };
+                return { axis: _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(0, 1, 0), angle: _Angle__WEBPACK_IMPORTED_MODULE_1__.Angle.createDegrees(180), ok: true };
             }
             else if (_Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.isAlmostEqualNumber(-1.0, axx) && _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.isAlmostEqualNumber(-1, ayy)) {
-                return { axis: _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(0, 0, 1), angle: theta180, ok: true };
+                return { axis: _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(0, 0, 1), angle: _Angle__WEBPACK_IMPORTED_MODULE_1__.Angle.createDegrees(180), ok: true };
             }
-            // 180 degree flip around some other axis ...
-            // eigenvalues will have 1.0 once, -1.0 twice.
-            // These cases look for each place (x,y,z) that the 1.0 might appear.
-            // But fastSymmetricEigenvalues reliably always seems to put the 1.0 as the x eigenvalue.
-            // so only the getColumn(0) return seems reachable in unit tests.
+            // Look for eigenvector with eigenvalue = 1
             const eigenvectors = Matrix3d.createIdentity();
             const eigenvalues = _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(0, 0, 0);
             if (this.fastSymmetricEigenvalues(eigenvectors, eigenvalues)) {
                 for (let axisIndex = 0; axisIndex < 2; axisIndex++) {
                     const lambda = eigenvalues.at(axisIndex);
                     if (_Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.isAlmostEqualNumber(1, lambda))
-                        return { axis: eigenvectors.getColumn(axisIndex), angle: theta180, ok: true };
+                        return { axis: eigenvectors.getColumn(axisIndex), angle: _Angle__WEBPACK_IMPORTED_MODULE_1__.Angle.createDegrees(180), ok: true };
                 }
-                // Don't know if this can be reached ....
+                // if no eigenvalue = 1 was found return false
                 return { axis: _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(0, 0, 1), angle: _Angle__WEBPACK_IMPORTED_MODULE_1__.Angle.createRadians(0), ok: false };
             }
+            // if no axis was found return false
             return { axis: _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(0, 0, 1), angle: _Angle__WEBPACK_IMPORTED_MODULE_1__.Angle.createRadians(0), ok: false };
         }
+        // good matrix and non-zero sine
         const a = 1.0 / (2.0 * s);
-        const result = { axis: _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(skewYZ * a, skewZX * a, skewXY * a), angle: _Angle__WEBPACK_IMPORTED_MODULE_1__.Angle.createAtan2(s, c), ok: true };
-        return result;
-    }
-    /**
-     * Returns a matrix that rotates from vectorA to vectorB.
-     */
-    static createRotationVectorToVector(vectorA, vectorB, result) {
-        return this.createPartialRotationVectorToVector(vectorA, 1.0, vectorB, result);
-    }
-    /**
-     * Return a matrix that rotates a fraction of the angular sweep from vectorA to vectorB.
-     * @param vectorA initial vector position
-     * @param fraction fractional rotation.  1.0 is "all the way"
-     * @param vectorB final vector position
-     * @param result optional result matrix.
-     */
-    static createPartialRotationVectorToVector(vectorA, fraction, vectorB, result) {
-        let upVector = vectorA.unitCrossProduct(vectorB);
-        if (upVector) { // the usual case --
-            return Matrix3d.createRotationAroundVector(upVector, _Angle__WEBPACK_IMPORTED_MODULE_1__.Angle.createRadians(fraction * vectorA.planarAngleTo(vectorB, upVector).radians));
-        }
-        // fail if either vector is zero ...
-        if (_Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.isSmallMetricDistance(vectorA.magnitude())
-            || _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.isSmallMetricDistance(vectorB.magnitude()))
-            return undefined;
-        // nonzero but aligned vectors ...
-        if (vectorA.dotProduct(vectorB) > 0.0)
-            return Matrix3d.createIdentity(result);
-        // nonzero opposing vectors ..
-        upVector = Matrix3d.createPerpendicularVectorFavorPlaneContainingZ(vectorA, upVector);
-        return Matrix3d.createRotationAroundVector(upVector, _Angle__WEBPACK_IMPORTED_MODULE_1__.Angle.createRadians(fraction * Math.PI));
-    }
-    /** Create a 90 degree rotation around a principal axis */
-    static create90DegreeRotationAroundAxis(axisIndex) {
-        axisIndex = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.cyclic3dAxis(axisIndex);
-        if (axisIndex === 0) {
-            const retVal = Matrix3d.createRowValues(1, 0, 0, 0, 0, -1, 0, 1, 0);
-            retVal.setupInverseTranspose();
-            return retVal;
-        }
-        else if (axisIndex === 1) {
-            const retVal = Matrix3d.createRowValues(0, 0, 1, 0, 1, 0, -1, 0, 0);
-            retVal.setupInverseTranspose();
-            return retVal;
-        }
-        else {
-            const retVal = Matrix3d.createRowValues(0, -1, 0, 1, 0, 0, 0, 0, 1);
-            retVal.setupInverseTranspose();
-            return retVal;
-        }
-    }
-    /** Return (a copy of) the X column */
-    columnX(result) { return _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(this.coffs[0], this.coffs[3], this.coffs[6], result); }
-    /** Return (a copy of)the Y column */
-    columnY(result) { return _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(this.coffs[1], this.coffs[4], this.coffs[7], result); }
-    /** Return (a copy of)the Z column */
-    columnZ(result) { return _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(this.coffs[2], this.coffs[5], this.coffs[8], result); }
-    /** Return the X column magnitude squared */
-    columnXMagnitudeSquared() { return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.hypotenuseSquaredXYZ(this.coffs[0], this.coffs[3], this.coffs[6]); }
-    /** Return the Y column magnitude squared */
-    columnYMagnitudeSquared() { return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.hypotenuseSquaredXYZ(this.coffs[1], this.coffs[4], this.coffs[7]); }
-    /** Return the Z column magnitude squared */
-    columnZMagnitudeSquared() { return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.hypotenuseSquaredXYZ(this.coffs[2], this.coffs[5], this.coffs[8]); }
-    /** Return the X column magnitude */
-    columnXMagnitude() { return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.hypotenuseXYZ(this.coffs[0], this.coffs[3], this.coffs[6]); }
-    /** Return the Y column magnitude */
-    columnYMagnitude() { return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.hypotenuseXYZ(this.coffs[1], this.coffs[4], this.coffs[7]); }
-    /** Return the Z column magnitude */
-    columnZMagnitude() { return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.hypotenuseXYZ(this.coffs[2], this.coffs[5], this.coffs[8]); }
-    /** Return magnitude of columnX cross columnY. */
-    columnXYCrossProductMagnitude() {
-        return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.crossProductMagnitude(this.coffs[0], this.coffs[3], this.coffs[6], this.coffs[1], this.coffs[4], this.coffs[7]);
-    }
-    /** Return the X row magnitude d */
-    rowXMagnitude() { return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.hypotenuseXYZ(this.coffs[0], this.coffs[1], this.coffs[2]); }
-    /** Return the Y row magnitude  */
-    rowYMagnitude() { return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.hypotenuseXYZ(this.coffs[3], this.coffs[4], this.coffs[5]); }
-    /** Return the Z row magnitude  */
-    rowZMagnitude() { return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.hypotenuseXYZ(this.coffs[6], this.coffs[7], this.coffs[8]); }
-    /** Return the dot product of column X with column Y */
-    /** Return the dot product of column X with column Y */
-    columnXDotColumnY() {
-        return this.coffs[0] * this.coffs[1]
-            + this.coffs[3] * this.coffs[4]
-            + this.coffs[6] * this.coffs[7];
-    }
-    /**
-     * Dot product of an indexed column with a vector given as x,y,z
-     * @param columnIndex index of column.  Must be 0,1,2
-     * @param x x component of vector
-     * @param y y component of vector
-     * @param z z component of vector
-     */
-    columnDotXYZ(columnIndex, x, y, z) {
-        return this.coffs[columnIndex] * x + this.coffs[columnIndex + 3] * y + this.coffs[columnIndex + 6] * z;
-    }
-    /** Return (a copy of) the X row */
-    rowX(result) { return _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(this.coffs[0], this.coffs[1], this.coffs[2], result); }
-    /** Return (a copy of) the Y row */
-    rowY(result) { return _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(this.coffs[3], this.coffs[4], this.coffs[5], result); }
-    /** Return (a copy of) the Z row */
-    rowZ(result) { return _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(this.coffs[6], this.coffs[7], this.coffs[8], result); }
-    /** Return the dot product of the vector parameter with the X column. */
-    dotColumnX(vector) { return vector.x * this.coffs[0] + vector.y * this.coffs[3] + vector.z * this.coffs[6]; }
-    /** Return the dot product of the vector parameter with the Y column. */
-    dotColumnY(vector) { return vector.x * this.coffs[1] + vector.y * this.coffs[4] + vector.z * this.coffs[7]; }
-    /** Return the dot product of the vector parameter with the Z column. */
-    dotColumnZ(vector) { return vector.x * this.coffs[2] + vector.y * this.coffs[5] + vector.z * this.coffs[8]; }
-    /** Return the dot product of the vector parameter with the X row. */
-    dotRowX(vector) { return vector.x * this.coffs[0] + vector.y * this.coffs[1] + vector.z * this.coffs[2]; }
-    /** Return the dot product of the vector parameter with the Y row. */
-    dotRowY(vector) { return vector.x * this.coffs[3] + vector.y * this.coffs[4] + vector.z * this.coffs[5]; }
-    /** Return the dot product of the vector parameter with the Z row. */
-    dotRowZ(vector) { return vector.x * this.coffs[6] + vector.y * this.coffs[7] + vector.z * this.coffs[8]; }
-    // cSpell:words XXYZ YXYZ ZXYZ XYZAs Eigen
-    /** Return the dot product of the x,y,z with the X row. */
-    dotRowXXYZ(x, y, z) { return x * this.coffs[0] + y * this.coffs[1] + z * this.coffs[2]; }
-    /** Return the dot product of the x,y,z with the Y row. */
-    dotRowYXYZ(x, y, z) { return x * this.coffs[3] + y * this.coffs[4] + z * this.coffs[5]; }
-    /** Return the dot product of the x,y,z with the Z row. */
-    dotRowZXYZ(x, y, z) { return x * this.coffs[6] + y * this.coffs[7] + z * this.coffs[8]; }
-    /** Return the (vector) cross product of the Z column with the vector parameter. */
-    columnZCrossVector(vector, result) {
-        return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.crossProductXYZXYZ(this.coffs[2], this.coffs[5], this.coffs[8], vector.x, vector.y, vector.z, result);
-    }
-    /*
-     * Replace current rows Ui Uj with (c*Ui - s*Uj) and (c*Uj + s*Ui).
-     * @param i first row index.  must be 0,1,2 (unchecked)
-     * @param j second row index. must be 0,1,2 (unchecked)
-     * @param c fist coefficient
-     * @param s second coefficient
-     */
-    applyGivensRowOp(i, j, c, s) {
-        let ii = 3 * i;
-        let jj = 3 * j;
-        const limit = ii + 3;
-        for (; ii < limit; ii++, jj++) {
-            const a = this.coffs[ii];
-            const b = this.coffs[jj];
-            this.coffs[ii] = a * c + b * s;
-            this.coffs[jj] = -a * s + b * c;
-        }
-    }
-    /**
-     * create a rigid coordinate frame column z parallel to (_x_,_y_,_z_) and column x in the xy plane.
-     * * column z points from origin to x,y,z
-     * * column x is perpendicular and in the xy plane
-     * * column y is perpendicular to both.  It is the "up" vector on the view plane.
-     * * Multiplying a world vector times the transpose of this matrix transforms into the view xy
-     * * Multiplying the matrix times the an in-view vector transforms the vector to world.
-     * @param x eye x coordinate
-     * @param y eye y coordinate
-     * @param z eye z coordinate
-     * @param result
-     */
-    static createRigidViewAxesZTowardsEye(x, y, z, result) {
-        result = Matrix3d.createIdentity(result);
-        const rxy = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.hypotenuseXY(x, y);
-        if (_Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.isSmallMetricDistance(rxy)) {
-            // special case for top or bottom view.
-            if (z < 0.0)
-                result.scaleColumnsInPlace(1.0, -1, -1.0);
-        }
-        else {
-            //      const d = Geometry.hypotenuseSquaredXYZ(x, y, z);
-            const c = x / rxy;
-            const s = y / rxy;
-            result.setRowValues(-s, 0, c, c, 0, s, 0, 1, 0);
-            if (z !== 0.0) {
-                const r = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.hypotenuseXYZ(x, y, z);
-                const s1 = z / r;
-                const c1 = rxy / r;
-                result.applyGivensColumnOp(1, 2, c1, -s1);
-            }
-        }
+        const result = {
+            axis: _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(skewYZ * a, skewZX * a, skewXY * a),
+            angle: _Angle__WEBPACK_IMPORTED_MODULE_1__.Angle.createAtan2(s, c),
+            ok: true,
+        };
         return result;
     }
     /** Rotate so columns i and j become perpendicular */
@@ -219183,8 +219114,7 @@ class Matrix3d {
     factorPerpendicularColumns(matrixC, matrixU) {
         matrixC.setFrom(this);
         matrixU.setIdentity();
-        const ss = this.sumSquares();
-        const tolerance = 1.0e-12 * ss;
+        const tolerance = 1.0e-12 * this.sumSquares();
         for (let iteration = 0; iteration < 7; iteration++) {
             const sum = matrixC.applyJacobiColumnRotation(0, 1, matrixU)
                 + matrixC.applyJacobiColumnRotation(0, 2, matrixU)
@@ -219275,8 +219205,7 @@ class Matrix3d {
         matrix.coffs[3] = matrix.coffs[1];
         matrix.coffs[6] = matrix.coffs[2];
         matrix.coffs[7] = matrix.coffs[5];
-        const ss = this.sumSquares();
-        const tolerance = 1.0e-12 * ss;
+        const tolerance = 1.0e-12 * this.sumSquares();
         for (let iteration = 0; iteration < 7; iteration++) {
             const sum = leftEigenvectors.applySymmetricJacobi(0, 1, matrix)
                 + leftEigenvectors.applySymmetricJacobi(0, 2, matrix)
@@ -219291,68 +219220,174 @@ class Matrix3d {
         }
         return false;
     }
-    /** Apply (in place a jacobi update that zeros out this.at(i,j).
-     *
+    /**
+     * Return a matrix that rotates a fraction of the angular sweep from vectorA to vectorB.
+     * @param vectorA initial vector position
+     * @param fraction fractional rotation (1 means rotate all the way)
+     * @param vectorB final vector position
+     * @param result optional result matrix.
      */
-    applyFastSymmetricJacobiUpdate(i, // row index of zeroed member
-    j, // column index of zeroed member
-    k, // other row/column index (different from i and j)
-    leftEigenVectors) {
-        const indexII = 4 * i;
-        const indexJJ = 4 * j;
-        const indexIJ = 3 * i + j;
-        const indexIK = 3 * i + k;
-        const indexJK = 3 * j + k;
-        const dotUU = this.coffs[indexII];
-        const dotVV = this.coffs[indexJJ];
-        const dotUV = this.coffs[indexIJ];
-        const jacobi = _Angle__WEBPACK_IMPORTED_MODULE_1__.Angle.trigValuesToHalfAngleTrigValues(dotUU - dotVV, 2.0 * dotUV);
-        if (Math.abs(dotUV) < 1.0e-15 * (dotUU + dotVV))
-            return 0.0;
-        const c = jacobi.c;
-        const s = jacobi.s;
-        const cc = c * c;
-        const ss = s * s;
-        const sc2 = 2.0 * c * s;
-        this.coffs[indexII] = cc * dotUU + sc2 * dotUV + ss * dotVV;
-        this.coffs[indexJJ] = ss * dotUU - sc2 * dotUV + cc * dotVV;
-        this.coffs[indexIJ] = 0.0;
-        const a = this.coffs[indexIK];
-        const b = this.coffs[indexJK];
-        this.coffs[indexIK] = a * c + b * s;
-        this.coffs[indexJK] = -s * a + c * b;
-        this.coffs[3 * j + i] = 0.0;
-        this.coffs[3 * k + i] = this.coffs[indexIK];
-        this.coffs[3 * k + j] = this.coffs[indexJK];
-        leftEigenVectors.applyGivensColumnOp(i, j, c, s);
-        return Math.abs(dotUV);
+    static createPartialRotationVectorToVector(vectorA, fraction, vectorB, result) {
+        let upVector = vectorA.unitCrossProduct(vectorB);
+        // the usual case (both vectors and also their cross product is non-zero)
+        if (upVector) {
+            return Matrix3d.createRotationAroundVector(upVector, _Angle__WEBPACK_IMPORTED_MODULE_1__.Angle.createRadians(fraction * vectorA.planarAngleTo(vectorB, upVector).radians));
+        }
+        // if either vector is zero
+        if (_Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.isSmallMetricDistance(vectorA.magnitude())
+            || _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.isSmallMetricDistance(vectorB.magnitude()))
+            return undefined;
+        // aligned vectors (cross product = 0, dot product > 0)
+        if (vectorA.dotProduct(vectorB) > 0.0)
+            return Matrix3d.createIdentity(result);
+        // opposing vectors (cross product = 0, dot product < 0)
+        upVector = Matrix3d.createPerpendicularVectorFavorPlaneContainingZ(vectorA, upVector);
+        return Matrix3d.createRotationAroundVector(upVector, _Angle__WEBPACK_IMPORTED_MODULE_1__.Angle.createRadians(fraction * Math.PI));
+    }
+    /** Returns a matrix that rotates from vectorA to vectorB. */
+    static createRotationVectorToVector(vectorA, vectorB, result) {
+        return this.createPartialRotationVectorToVector(vectorA, 1.0, vectorB, result);
+    }
+    /** Create a 90 degree rotation around a principal axis */
+    static create90DegreeRotationAroundAxis(axisIndex) {
+        axisIndex = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.cyclic3dAxis(axisIndex);
+        if (axisIndex === 0) {
+            const retVal = Matrix3d.createRowValues(1, 0, 0, 0, 0, -1, 0, 1, 0);
+            retVal.setupInverseTranspose();
+            return retVal;
+        }
+        else if (axisIndex === 1) {
+            const retVal = Matrix3d.createRowValues(0, 0, 1, 0, 1, 0, -1, 0, 0);
+            retVal.setupInverseTranspose();
+            return retVal;
+        }
+        else {
+            const retVal = Matrix3d.createRowValues(0, -1, 0, 1, 0, 0, 0, 0, 1);
+            retVal.setupInverseTranspose();
+            return retVal;
+        }
+    }
+    /** Return (a copy of) the X column */
+    columnX(result) {
+        return _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(this.coffs[0], this.coffs[3], this.coffs[6], result);
+    }
+    /** Return (a copy of) the Y column */
+    columnY(result) {
+        return _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(this.coffs[1], this.coffs[4], this.coffs[7], result);
+    }
+    /** Return (a copy of) the Z column */
+    columnZ(result) {
+        return _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(this.coffs[2], this.coffs[5], this.coffs[8], result);
+    }
+    /** Return the X column magnitude squared */
+    columnXMagnitudeSquared() {
+        return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.hypotenuseSquaredXYZ(this.coffs[0], this.coffs[3], this.coffs[6]);
+    }
+    /** Return the Y column magnitude squared */
+    columnYMagnitudeSquared() {
+        return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.hypotenuseSquaredXYZ(this.coffs[1], this.coffs[4], this.coffs[7]);
+    }
+    /** Return the Z column magnitude squared */
+    columnZMagnitudeSquared() {
+        return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.hypotenuseSquaredXYZ(this.coffs[2], this.coffs[5], this.coffs[8]);
+    }
+    /** Return the X column magnitude */
+    columnXMagnitude() {
+        return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.hypotenuseXYZ(this.coffs[0], this.coffs[3], this.coffs[6]);
+    }
+    /** Return the Y column magnitude */
+    columnYMagnitude() {
+        return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.hypotenuseXYZ(this.coffs[1], this.coffs[4], this.coffs[7]);
+    }
+    /** Return the Z column magnitude */
+    columnZMagnitude() {
+        return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.hypotenuseXYZ(this.coffs[2], this.coffs[5], this.coffs[8]);
+    }
+    /** Return magnitude of columnX cross columnY. */
+    columnXYCrossProductMagnitude() {
+        return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.crossProductMagnitude(this.coffs[0], this.coffs[3], this.coffs[6], this.coffs[1], this.coffs[4], this.coffs[7]);
+    }
+    /** Return the X row magnitude */
+    rowXMagnitude() {
+        return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.hypotenuseXYZ(this.coffs[0], this.coffs[1], this.coffs[2]);
+    }
+    /** Return the Y row magnitude  */
+    rowYMagnitude() {
+        return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.hypotenuseXYZ(this.coffs[3], this.coffs[4], this.coffs[5]);
+    }
+    /** Return the Z row magnitude  */
+    rowZMagnitude() {
+        return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.hypotenuseXYZ(this.coffs[6], this.coffs[7], this.coffs[8]);
+    }
+    /** Return the dot product of column X with column Y */
+    columnXDotColumnY() {
+        return this.coffs[0] * this.coffs[1]
+            + this.coffs[3] * this.coffs[4]
+            + this.coffs[6] * this.coffs[7];
     }
     /**
-     * Factor this (symmetrized) as a product U * lambda * UT where U is orthogonal, lambda is diagonal.
-     * The upper triangle is mirrored to lower triangle to enforce symmetry.
-     * @param matrixC (allocate by caller, computed here)
-     * @param factor  (allocate by caller, computed here)
+     * Dot product of an indexed column with a vector given as x,y,z
+     * @param columnIndex index of column. Must be 0,1,2.
+     * @param x x component of vector
+     * @param y y component of vector
+     * @param z z component of vector
      */
-    fastSymmetricEigenvalues(leftEigenvectors, lambda) {
-        const matrix = this.clone();
-        leftEigenvectors.setIdentity();
-        const ss = this.sumSquares();
-        const tolerance = 1.0e-12 * ss;
-        for (let iteration = 0; iteration < 7; iteration++) {
-            const sum = matrix.applyFastSymmetricJacobiUpdate(0, 1, 2, leftEigenvectors)
-                + matrix.applyFastSymmetricJacobiUpdate(0, 2, 1, leftEigenvectors)
-                + matrix.applyFastSymmetricJacobiUpdate(1, 2, 0, leftEigenvectors);
-            // console.log("symmetric sum", sum);
-            // console.log ("   sum", sum);
-            if (sum < tolerance) {
-                // console.log("symmetric iterations", iteration);
-                lambda.set(matrix.at(0, 0), matrix.at(1, 1), matrix.at(2, 2));
-                return true;
-            }
-        }
-        return false;
+    columnDotXYZ(columnIndex, x, y, z) {
+        return this.coffs[columnIndex] * x + this.coffs[columnIndex + 3] * y + this.coffs[columnIndex + 6] * z;
+    }
+    /** Return (a copy of) the X row */
+    rowX(result) {
+        return _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(this.coffs[0], this.coffs[1], this.coffs[2], result);
+    }
+    /** Return (a copy of) the Y row */
+    rowY(result) {
+        return _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(this.coffs[3], this.coffs[4], this.coffs[5], result);
+    }
+    /** Return (a copy of) the Z row */
+    rowZ(result) {
+        return _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(this.coffs[6], this.coffs[7], this.coffs[8], result);
     }
-    /** Install data from xyz parts of Point4d  (w part of Point4d ignored) */
+    /** Return the dot product of the vector parameter with the X column. */
+    dotColumnX(vector) {
+        return vector.x * this.coffs[0] + vector.y * this.coffs[3] + vector.z * this.coffs[6];
+    }
+    /** Return the dot product of the vector parameter with the Y column. */
+    dotColumnY(vector) {
+        return vector.x * this.coffs[1] + vector.y * this.coffs[4] + vector.z * this.coffs[7];
+    }
+    /** Return the dot product of the vector parameter with the Z column. */
+    dotColumnZ(vector) {
+        return vector.x * this.coffs[2] + vector.y * this.coffs[5] + vector.z * this.coffs[8];
+    }
+    /** Return the dot product of the vector parameter with the X row. */
+    dotRowX(vector) {
+        return vector.x * this.coffs[0] + vector.y * this.coffs[1] + vector.z * this.coffs[2];
+    }
+    /** Return the dot product of the vector parameter with the Y row. */
+    dotRowY(vector) {
+        return vector.x * this.coffs[3] + vector.y * this.coffs[4] + vector.z * this.coffs[5];
+    }
+    /** Return the dot product of the vector parameter with the Z row. */
+    dotRowZ(vector) {
+        return vector.x * this.coffs[6] + vector.y * this.coffs[7] + vector.z * this.coffs[8];
+    }
+    /** Return the dot product of the x,y,z with the X row. */
+    dotRowXXYZ(x, y, z) {
+        return x * this.coffs[0] + y * this.coffs[1] + z * this.coffs[2];
+    }
+    /** Return the dot product of the x,y,z with the Y row. */
+    dotRowYXYZ(x, y, z) {
+        return x * this.coffs[3] + y * this.coffs[4] + z * this.coffs[5];
+    }
+    /** Return the dot product of the x,y,z with the Z row. */
+    dotRowZXYZ(x, y, z) {
+        return x * this.coffs[6] + y * this.coffs[7] + z * this.coffs[8];
+    }
+    /** Return the cross product of the Z column with the vector parameter. */
+    columnZCrossVector(vector, result) {
+        return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.crossProductXYZXYZ(this.coffs[2], this.coffs[5], this.coffs[8], vector.x, vector.y, vector.z, result);
+    }
+    /** Set data from xyz parts of Point4d  (w part of Point4d ignored) */
     setColumnsPoint4dXYZ(vectorU, vectorV, vectorW) {
         this.inverseState = InverseMatrixState.unknown;
         this.setRowValues(vectorU.x, vectorV.x, vectorW.x, vectorU.y, vectorV.y, vectorW.y, vectorU.z, vectorV.z, vectorW.z);
@@ -219376,16 +219411,22 @@ class Matrix3d {
             this.coffs[index + 6] = 0.0;
         }
     }
-    /** Set all columns of the matrix. Any undefined vector is zeros. */
+    /**
+     * Set all columns of the matrix. Any undefined vector is zeros.
+     * @param vectorX values for column 0
+     * @param vectorY values for column 1
+     * @param vectorZ optional values for column 2 (it's optional in case column 2 is 000, which is a
+     * projection onto the xy-plane)
+     */
     setColumns(vectorX, vectorY, vectorZ) {
         this.setColumn(0, vectorX);
         this.setColumn(1, vectorY);
         this.setColumn(2, vectorZ);
     }
     /**
-     * set entries in one row of the matrix.
-     * @param rowIndex row index. this is interpreted cyclically.
-     * @param value x,yz, values for row.  If undefined, zeros are installed.
+     * Set entries in one row of the matrix.
+     * @param rowIndex row index. This is interpreted cyclically (using Geometry.cyclic3dAxis).
+     * @param value x,y,z values for row.
      */
     setRow(rowIndex, value) {
         const index = 3 * _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.cyclic3dAxis(rowIndex);
@@ -219394,21 +219435,26 @@ class Matrix3d {
         this.coffs[index + 2] = value.z;
         this.inverseState = InverseMatrixState.unknown;
     }
-    /** Return a (copy of) a column of the matrix.
-     * @param i column index.  This is corrected to 012 by Geometry.cyclic3dAxis.
+    /**
+     * Return (a copy of) a column of the matrix.
+     * @param i column index. This is interpreted cyclically (using Geometry.cyclic3dAxis).
+     * @param result optional preallocated result.
      */
     getColumn(columnIndex, result) {
         const index = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.cyclic3dAxis(columnIndex);
         return _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(this.coffs[index], this.coffs[index + 3], this.coffs[index + 6], result);
     }
-    /** Return a (copy of) a row of the matrix.
-     * @param i row index.  This is corrected to 012 by Geometry.cyclic3dAxis.
+    /**
+     * Return a (copy of) a row of the matrix.
+     * @param i row index. This is interpreted cyclically (using Geometry.cyclic3dAxis).
+     * @param result optional preallocated result.
      */
     getRow(columnIndex, result) {
         const index = 3 * _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.cyclic3dAxis(columnIndex);
         return _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(this.coffs[index], this.coffs[index + 1], this.coffs[index + 2], result);
     }
-    /** Create a matrix from row vectors.
+    /**
+     * Create a matrix from row vectors.
      * ```
      * equation
      * \begin{bmatrix}U_x & U_y & U_z \\ V_x & V_y & V_z \\ W_x & W_y & W_z \end{bmatrix}
@@ -219417,13 +219463,18 @@ class Matrix3d {
     static createRows(vectorU, vectorV, vectorW, result) {
         return Matrix3d.createRowValues(vectorU.x, vectorU.y, vectorU.z, vectorV.x, vectorV.y, vectorV.z, vectorW.x, vectorW.y, vectorW.z, result);
     }
-    /** Create a matrix that scales along a specified direction.
-     * * The scale factor can be negative.
-     *  * A scale of -1.0 (negative one) is a mirror across the plane perpendicular to the vector.
+    /**
+     * Create a matrix that scales along a specified `direction`. This means if you multiply the returned matrix
+     * by a `vector`, you get `directional scale` of that `vector`. Suppose `plane` is the plane perpendicular
+     * to the `direction`. When scale = 0, `directional scale` is projection of the `vector` to the `plane`.
+     * When scale = 1, `directional scale` is the `vector` itself. When scale = -1, `directional scale` is
+     * mirror of the `vector` across the `plane`. In general, When scale != 0, the result is computed by first
+     * projecting the `vector` to the `plane`, then translating that projection along the `direction` (if scale > 0)
+     * or in opposite direction (if scale < 0).
      * ```
      * equation
-     * \text{The matrix is } I - (s-1) U U^T
-     * \\ \text{with }U\text{ being the unit vector in the direction of the input vector.}
+     * \text{The matrix is } I + (s-1) D D^T
+     * \\ \text{with }D\text{ being the normalized direction vector and }s\text{ being the scale.}
      * ```
      */
     static createDirectionalScale(direction, scale, result) {
@@ -219432,19 +219483,13 @@ class Matrix3d {
             const x = unit.x;
             const y = unit.y;
             const z = unit.z;
-            const a = (scale - 1);
+            const a = scale - 1;
             return Matrix3d.createRowValues(1 + a * x * x, a * x * y, a * x * z, a * y * x, 1 + a * y * y, a * y * z, a * z * x, a * z * y, 1 + a * z * z, result);
         }
         return Matrix3d.createUniformScale(scale);
     }
-    /* Create a matrix with the indicated column in the (normalized) direction, and the other two columns perpendicular. All columns are normalized.
-     * * The direction vector is normalized and appears in column axisIndex
-     * * If the direction vector is not close to Z, the "next" column ((axisIndex + 1) mod 3) will be in the XY plane in the direction of (direction cross Z)
-     * * If the direction vector is close to Z, the "next" column ((axisIndex + 1) mode 3) will be in the direction of (direction cross Y)
-    */
-    // static create1Vector(direction: Vector3d, axisIndex: number): Matrix3d;
-    // static createFromXYVectors(vectorX: Vector3d, vectorY: Vector3d, axisIndex: number): Matrix3d;
-    /** Multiply the matrix * vector, treating the vector is a column vector on the right.
+    /**
+     * Multiply `matrix * vector`, treating the vector is a column vector on the right.
      * ```
      * equation
      * \matrixXY{A}\columnSubXYZ{U}
@@ -219455,36 +219500,38 @@ class Matrix3d {
         const x = vectorU.x;
         const y = vectorU.y;
         const z = vectorU.z;
-        return _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create((this.coffs[0] * x + this.coffs[1] * y + this.coffs[2] * z), (this.coffs[3] * x + this.coffs[4] * y + this.coffs[5] * z), (this.coffs[6] * x + this.coffs[7] * y + this.coffs[8] * z), result);
+        return _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Vector3d.create(this.coffs[0] * x + this.coffs[1] * y + this.coffs[2] * z, this.coffs[3] * x + this.coffs[4] * y + this.coffs[5] * z, this.coffs[6] * x + this.coffs[7] * y + this.coffs[8] * z, result);
     }
-    /** Multiply matrix * vector for each array member, i.e. the vector is a column vector on the right.
-     * @return the vector result
+    /**
+     * Multiply `matrix * vector` in place for vector in the array, i.e. treating the vector is a column
+     * vector on the right.
+     * * Each `vector` is updated to be `matrix * vector`
      */
     multiplyVectorArrayInPlace(data) {
         for (const v of data)
-            v.set((this.coffs[0] * v.x + this.coffs[1] * v.y + this.coffs[2] * v.z), (this.coffs[3] * v.x + this.coffs[4] * v.y + this.coffs[5] * v.z), (this.coffs[6] * v.x + this.coffs[7] * v.y + this.coffs[8] * v.z));
+            v.set(this.coffs[0] * v.x + this.coffs[1] * v.y + this.coffs[2] * v.z, this.coffs[3] * v.x + this.coffs[4] * v.y + this.coffs[5] * v.z, this.coffs[6] * v.x + this.coffs[7] * v.y + this.coffs[8] * v.z);
     }
-    /** compute `origin - matrix * vector` */
+    /** Compute `origin - matrix * vector` */
     static xyzMinusMatrixTimesXYZ(origin, matrix, vector, result) {
         const x = vector.x;
         const y = vector.y;
         const z = vector.z;
         return _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Point3d.create(origin.x - (matrix.coffs[0] * x + matrix.coffs[1] * y + matrix.coffs[2] * z), origin.y - (matrix.coffs[3] * x + matrix.coffs[4] * y + matrix.coffs[5] * z), origin.z - (matrix.coffs[6] * x + matrix.coffs[7] * y + matrix.coffs[8] * z), result);
     }
-    /** compute  `origin + matrix * vector`  using only the xy parts of the inputs. */
+    /** Compute `origin + matrix * vector`  using only the xy parts of the inputs. */
     static xyPlusMatrixTimesXY(origin, matrix, vector, result) {
         const x = vector.x;
         const y = vector.y;
         return _Point2dVector2d__WEBPACK_IMPORTED_MODULE_3__.Point2d.create(origin.x + matrix.coffs[0] * x + matrix.coffs[1] * y, origin.y + matrix.coffs[3] * x + matrix.coffs[4] * y, result);
     }
-    /** compute  `origin + matrix * vector`  using all xyz parts of the inputs. */
+    /** Compute `origin + matrix * vector`  using all xyz parts of the inputs. */
     static xyzPlusMatrixTimesXYZ(origin, matrix, vector, result) {
         const x = vector.x;
         const y = vector.y;
         const z = vector.z;
         return _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Point3d.create(origin.x + matrix.coffs[0] * x + matrix.coffs[1] * y + matrix.coffs[2] * z, origin.y + matrix.coffs[3] * x + matrix.coffs[4] * y + matrix.coffs[5] * z, origin.z + matrix.coffs[6] * x + matrix.coffs[7] * y + matrix.coffs[8] * z, result);
     }
-    /** compute  `origin + matrix * vector`  using all xyz parts of the inputs. */
+    /** Updates vector to be `origin + matrix * vector` using all xyz parts of the inputs. */
     static xyzPlusMatrixTimesXYZInPlace(origin, matrix, vector) {
         const x = vector.x;
         const y = vector.y;
@@ -219493,61 +219540,72 @@ class Matrix3d {
         vector.y = origin.y + matrix.coffs[3] * x + matrix.coffs[4] * y + matrix.coffs[5] * z;
         vector.z = origin.z + matrix.coffs[6] * x + matrix.coffs[7] * y + matrix.coffs[8] * z;
     }
-    /** compute `origin + matrix * vector` where the final vector is given as direct x,y,z coordinates */
+    /** Compute `origin + matrix * vector` where the final vector is given as direct x,y,z coordinates */
     static xyzPlusMatrixTimesCoordinates(origin, matrix, x, y, z, result) {
         return _Point3dVector3d__WEBPACK_IMPORTED_MODULE_2__.Point3d.create(origin.x + matrix.coffs[0] * x + matrix.coffs[1] * y + matrix.coffs[2] * z, origin.y + matrix.coffs[3] * x + matrix.coffs[4] * y + matrix.coffs[5] * z, origin.z + matrix.coffs[6] * x + matrix.coffs[7] * y + matrix.coffs[8] * z, result);
     }
     /**
      * Treat the 3x3 matrix and origin as upper 3x4 part of a 4x4 matrix, with 0001 as the final row.
-     * Multiply times point with coordinates `[x,y,z,w]`
+     * Multiply the 4x4 matrix by `[x,y,z,w]`
+     * ```
+     * equation
+     * \begin{bmatrix}M_0 & M_1 & M_2 & Ox \\ M_3 & M_4 & M_5 & Oy \\ M_6 & M_7 & M_8 & Oz \\ 0 & 0 & 0 & 1\end{bmatrix} * \begin{bmatrix}x \\ y \\ z \\ w\end{bmatrix}
+     * ```
      * @param origin translation part (xyz in column 3)
      * @param matrix matrix part (leading 3x3)
      * @param x x part of multiplied point
      * @param y y part of multiplied point
      * @param z z part of multiplied point
      * @param w w part of multiplied point
-     * @param result optional result.
+     * @param result optional preallocated result.
      */
     static xyzPlusMatrixTimesWeightedCoordinates(origin, matrix, x, y, z, w, result) {
-        return _geometry4d_Point4d__WEBPACK_IMPORTED_MODULE_4__.Point4d.create(w * origin.x + matrix.coffs[0] * x + matrix.coffs[1] * y + matrix.coffs[2] * z, w * origin.y + matrix.coffs[3] * x + matrix.coffs[4] * y + matrix.coffs[5] * z, w * origin.z + matrix.coffs[6] * x + matrix.coffs[7] * y + matrix.coffs[8] * z, w, result);
+        return _geometry4d_Point4d__WEBPACK_IMPORTED_MODULE_4__.Point4d.create(matrix.coffs[0] * x + matrix.coffs[1] * y + matrix.coffs[2] * z + origin.x * w, matrix.coffs[3] * x + matrix.coffs[4] * y + matrix.coffs[5] * z + origin.y * w, matrix.coffs[6] * x + matrix.coffs[7] * y + matrix.coffs[8] * z + origin.z * w, w, result);
     }
     /**
      * Treat the 3x3 matrix and origin as upper 3x4 part of a 4x4 matrix, with 0001 as the final row.
-     * Multiply times point with coordinates `[x,y,z,w]`
+     * Multiply the 4x4 matrix by `[x,y,z,w]`
+     * ```
+     * equation
+     * \begin{bmatrix}M_0 & M_1 & M_2 & Ox \\ M_3 & M_4 & M_5 & Oy \\ M_6 & M_7 & M_8 & Oz \\ 0 & 0 & 0 & 1\end{bmatrix} * \begin{bmatrix}x \\ y \\ z \\ w\end{bmatrix}
+     * ```
      * @param origin translation part (xyz in column 3)
      * @param matrix matrix part (leading 3x3)
      * @param x x part of multiplied point
      * @param y y part of multiplied point
      * @param z z part of multiplied point
      * @param w w part of multiplied point
-     * @param result optional result.
+     * @param result optional preallocated result.
      */
     static xyzPlusMatrixTimesWeightedCoordinatesToFloat64Array(origin, matrix, x, y, z, w, result) {
         if (!result)
             result = new Float64Array(4);
-        result[0] = w * origin.x + matrix.coffs[0] * x + matrix.coffs[1] * y + matrix.coffs[2] * z;
-        result[1] = w * origin.y + matrix.coffs[3] * x + matrix.coffs[4] * y + matrix.coffs[5] * z;
-        result[2] = w * origin.z + matrix.coffs[6] * x + matrix.coffs[7] * y + matrix.coffs[8] * z;
+        result[0] = matrix.coffs[0] * x + matrix.coffs[1] * y + matrix.coffs[2] * z + origin.x * w;
+        result[1] = matrix.coffs[3] * x + matrix.coffs[4] * y + matrix.coffs[5] * z + origin.y * w;
+        result[2] = matrix.coffs[6] * x + matrix.coffs[7] * y + matrix.coffs[8] * z + origin.z * w;
         result[3] = w;
         return result;
     }
     /**
-     * Treat the 3x3 matrix and origin as upper 3x4 part of a 4x4 matrix, with 0001 as the final row.
-     * Multiply times point with coordinates `[x,y,z,w]`
+     * Treat the 3x3 matrix and origin as a 3x4 matrix.
+     * * Multiply the 3x4 matrix by `[x,y,z,1]`
+     * ```
+     * equation
+     * \begin{bmatrix}M_0 & M_1 & M_2 & Ox \\ M_3 & M_4 & M_5 & Oy \\ M_6 & M_7 & M_8 & Oz\end{bmatrix} * \begin{bmatrix}x \\ y \\ z \\ 1\end{bmatrix}
+     * ```
      * @param origin translation part (xyz in column 3)
      * @param matrix matrix part (leading 3x3)
      * @param x x part of multiplied point
      * @param y y part of multiplied point
      * @param z z part of multiplied point
-     * @param w w part of multiplied point
-     * @param result optional result.
+     * @param result optional preallocated result.
      */
     static xyzPlusMatrixTimesCoordinatesToFloat64Array(origin, matrix, x, y, z, result) {
         if (!result)
             result = new Float64Array(3);
-        result[0] = origin.x + matrix.coffs[0] * x + matrix.coffs[1] * y + matrix.coffs[2] * z;
-        result[1] = origin.y + matrix.coffs[3] * x + matrix.coffs[4] * y + matrix.coffs[5] * z;
-        result[2] = origin.z + matrix.coffs[6] * x + matrix.coffs[7] * y + matrix.coffs[8] * z;
+        result[0] = matrix.coffs[0] * x + matrix.coffs[1] * y + matrix.coffs[2] * z + origin.x;
+        result[1] = matrix.coffs[3] * x + matrix.coffs[4] * y + matrix.coffs[5] * z + origin.y;
+        result[2] = matrix.coffs[6] * x + matrix.coffs[7] * y + matrix.coffs[8] * z + origin.z;
         return result;
     }
     /**
@@ -219567,9 +219625,9 @@ class Matrix3d {
         const x = vector.x;
         const y = vector.y;
         const z = vector.z;
-        result.x = (this.coffs[0] * x + this.coffs[3] * y + this.coffs[6] * z);
-        result.y = (this.coffs[1] * x + this.coffs[4] * y + this.coffs[7] * z);
-        result.z = (this.coffs[2] * x + this.coffs[5] * y + this.coffs[8] * z);
+        result.x = this.coffs[0] * x + this.coffs[3] * y + this.coffs[6] * z;
+        result.y = this.coffs[1] * x + this.coffs[4] * y + this.coffs[7] * z;
+        result.z = this.coffs[2] * x + this.coffs[5] * y + this.coffs[8] * z;
         return result;
     }
     /** Multiply the matrix * (x,y,z), i.e. the vector (x,y,z) is a column vector on the right.
@@ -220097,7 +220155,7 @@ class Matrix3d {
      * @param scaleX scale factor for column x
      * @param scaleY scale factor for column y
      * @param scaleZ scale factor for column z
-     * @param result optional result.
+     * @param result optional preallocated result.
      */
     scaleColumns(scaleX, scaleY, scaleZ, result) {
         return Matrix3d.createRowValues(this.coffs[0] * scaleX, this.coffs[1] * scaleY, this.coffs[2] * scaleZ, this.coffs[3] * scaleX, this.coffs[4] * scaleY, this.coffs[5] * scaleZ, this.coffs[6] * scaleX, this.coffs[7] * scaleY, this.coffs[8] * scaleZ, result);
@@ -220118,7 +220176,7 @@ class Matrix3d {
         this.coffs[7] *= scaleY;
         this.coffs[8] *= scaleZ;
         if (this.inverseState === InverseMatrixState.inverseStored && this.inverseCoffs !== undefined) {
-            // apply reciprocal scales to the ROWS of the inverse .  . .
+            // apply reverse scales to the ROWS of the inverse
             const divX = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.conditionalDivideFraction(1.0, scaleX);
             const divY = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.conditionalDivideFraction(1.0, scaleY);
             const divZ = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.conditionalDivideFraction(1.0, scaleZ);
@@ -220141,7 +220199,7 @@ class Matrix3d {
      * @param scaleX scale factor for row x
      * @param scaleY scale factor for row y
      * @param scaleZ scale factor for row z
-     * @param result optional result.
+     * @param result optional preallocated result.
      */
     scaleRows(scaleX, scaleY, scaleZ, result) {
         return Matrix3d.createRowValues(this.coffs[0] * scaleX, this.coffs[1] * scaleX, this.coffs[2] * scaleX, this.coffs[3] * scaleY, this.coffs[4] * scaleY, this.coffs[5] * scaleY, this.coffs[6] * scaleZ, this.coffs[7] * scaleZ, this.coffs[8] * scaleZ, result);
@@ -220185,12 +220243,49 @@ class Matrix3d {
     }
     /** create a Matrix3d whose values are uniformly scaled from this.
      * @param scale scale factor to apply.
-     * @param result optional result.
+     * @param result optional preallocated result.
      * @returns Return the new or repopulated matrix
      */
     scale(scale, result) {
         return Matrix3d.createRowValues(this.coffs[0] * scale, this.coffs[1] * scale, this.coffs[2] * scale, this.coffs[3] * scale, this.coffs[4] * scale, this.coffs[5] * scale, this.coffs[6] * scale, this.coffs[7] * scale, this.coffs[8] * scale, result);
     }
+    /**
+     * Create a rigid matrix (columns and rows are unit length and pairwise perpendicular) for
+     * the given eye coordinate.
+     * * column z is parallel to x,y,z
+     * * column x is perpendicular to column z and is in the xy plane
+     * * column y is perpendicular to both.  It is the "up" vector on the view plane.
+     * * Multiplying the returned matrix times a local (view) vector gives the world vector.
+     * * Multiplying transpose of the returned matrix times a world vector gives the local
+     * (view) vector.
+     * @param x eye x coordinate
+     * @param y eye y coordinate
+     * @param z eye z coordinate
+     * @param result optional preallocated result
+     */
+    static createRigidViewAxesZTowardsEye(x, y, z, result) {
+        result = Matrix3d.createIdentity(result);
+        const rxy = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.hypotenuseXY(x, y);
+        // if coordinate is (0,0,z), i.e., Top or Bottom view
+        if (_Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.isSmallMetricDistance(rxy)) {
+            if (z < 0.0)
+                result.scaleColumnsInPlace(1.0, -1.0, -1.0);
+        }
+        else {
+            const c = x / rxy;
+            const s = y / rxy;
+            // if coordinate is (x,y,0), i.e., Front or Back or Left or Right view
+            result.setRowValues(-s, 0, c, c, 0, s, 0, 1, 0);
+            // if coordinate is (x,y,z), i.e., other views such as Iso or RightIso
+            if (z !== 0.0) {
+                const r = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.hypotenuseXYZ(x, y, z);
+                const s1 = z / r;
+                const c1 = rxy / r;
+                result.applyGivensColumnOp(1, 2, c1, -s1);
+            }
+        }
+        return result;
+    }
     /** Return the determinant of this matrix. */
     determinant() {
         return this.coffs[0] * this.coffs[4] * this.coffs[8]
@@ -222356,9 +222451,12 @@ __webpack_require__.r(__webpack_exports__);
  * @module CartesianGeometry
  */
 // cspell:word CWXY
+// cspell:word arctan
+// cspell:word Rodrigues
 
 
 
+// cspell:word CCWXY
 /**
  *  * `XYZ` is a minimal object containing x,y,z and operations that are meaningful without change in both point and vector.
  *  * `XYZ` is not instantiable.
@@ -223195,7 +223293,7 @@ class Vector3d extends XYZ {
         return { v: this.safeDivideOrNull(magnitude, result), mag: magnitude };
     }
     /**
-     * Return a unit vector parallel with this.  Return undefined if this.magnitude is near zero.
+     * Return a unit vector parallel with this. Return undefined if this.magnitude is near zero.
      * @param result optional result.
      */
     normalize(result) {
@@ -223701,18 +223799,17 @@ class Vector3d extends XYZ {
         else
             return theta;
     }
-    /**
-   * Return the (strongly typed Angle) angle from this vector to vectorB, measured in the plane containing both,
-   * with vectorW indicating which side to view to control sign of the angle.
-   * * The returned angle can range from negative 180 degrees (negative PI radians) to positive 180 degrees
-   * * (positive PI radians), not closed on the negative side.
-   * * The returned angle is "in the plane containing the two vectors"
-   * * `vectorW` distinguishes between the sides of the plane, but does not have to be perpendicular.
-   * * The returned angle has the same sign as vectorW dot product (thisVector cross vectorB)
-   * * Use planarRadiansTo to measure the angle between vectors that are projected to another plane.
-   * @param vectorB target vector.
-   * @param vectorW distinguishes between the sides of the plane.
-   */
+    /** Return the (strongly typed Angle) angle from this vector to vectorB, measured in the plane containing both,
+    * with vectorW indicating which side to view to control sign of the angle.
+    * * The returned angle can range from negative 180 degrees (negative PI radians) to positive 180 degrees
+    * * (positive PI radians), not closed on the negative side.
+    * * The returned angle is "in the plane containing the two vectors"
+    * * `vectorW` distinguishes between the sides of the plane, but does not have to be perpendicular.
+    * * The returned angle has the same sign as vectorW dot product (thisVector cross vectorB)
+    * * Use planarRadiansTo to measure the angle between vectors that are projected to another plane.
+    * @param vectorB target vector.
+    * @param vectorW distinguishes between the sides of the plane.
+    */
     signedAngleTo(vectorB, vectorW) {
         return _Angle__WEBPACK_IMPORTED_MODULE_2__.Angle.createRadians(this.signedRadiansTo(vectorB, vectorW));
     }
@@ -228635,7 +228732,7 @@ class Segment1d {
      */
     reverseInPlace() { const x = this.x0; this.x0 = this.x1; this.x1 = x; }
     /**
-     * * if `x1<x0` multiplied by the scale factor is (strictly) negative, swap the x0 and x1 member values.
+     * * if `x1-x0` multiplied by the scale factor is (strictly) negative, swap the x0 and x1 member values.
      * * This makes the fractionToPoint evaluates reverse direction.
      */
     reverseIfNeededForDeltaSign(sign = 1) {
@@ -236449,6 +236546,20 @@ class SmallSystem {
         }
         return undefined;
     }
+    /**
+     * Compute the intersection of three planes.
+     * @param xyzA point on the first plane
+     * @param normalA normal of the first plane
+     * @param xyzB point on the second plane
+     * @param normalB normal of the second plane
+     * @param xyzC point on the third plane
+     * @param normalC normal of the third plane
+     * @param result optional result
+     * @returns intersection point of the three planes (as a Vector3d), or undefined if at least two planes are parallel.
+     */
+    static intersect3Planes(xyzA, normalA, xyzB, normalB, xyzC, normalC, result) {
+        return this.linearSystem3d(normalA.x, normalA.y, normalA.z, normalB.x, normalB.y, normalB.z, normalC.x, normalC.y, normalC.z, _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.dotProductXYZXYZ(xyzA.x, xyzA.y, xyzA.z, normalA.x, normalA.y, normalA.z), _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.dotProductXYZXYZ(xyzB.x, xyzB.y, xyzB.z, normalB.x, normalB.y, normalB.z), _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.dotProductXYZXYZ(xyzC.x, xyzC.y, xyzC.z, normalC.x, normalC.y, normalC.z), result);
+    }
     /**
      * * in rowB, replace `rowB[j] += a * rowB[pivot] * rowA[j] / rowA[pivot]` for `j>pivot`
      * @param rowA row that does not change
@@ -240560,10 +240671,29 @@ class PolyfaceBuilder extends _geometry3d_GeometryHandler__WEBPACK_IMPORTED_MODU
         if (sector.uv)
             sector.uvIndex = this._polyface.addParam(sector.uv);
     }
+    addSectorTriangle(sectorA0, sectorA1, sectorA2) {
+        if (sectorA0.xyz.isAlmostEqual(sectorA1.xyz)
+            || sectorA1.xyz.isAlmostEqual(sectorA2.xyz)
+            || sectorA2.xyz.isAlmostEqual(sectorA0.xyz)) {
+            // trivially degenerate triangle !!! skip !!!
+        }
+        else {
+            if (this._options.needNormals)
+                this.addIndexedTriangleNormalIndexes(sectorA0.normalIndex, sectorA1.normalIndex, sectorA2.normalIndex);
+            if (this._options.needParams)
+                this.addIndexedTriangleParamIndexes(sectorA0.uvIndex, sectorA1.uvIndex, sectorA2.uvIndex);
+            this.addIndexedTrianglePointIndexes(sectorA0.xyzIndex, sectorA1.xyzIndex, sectorA2.xyzIndex);
+            this._polyface.terminateFacet();
+        }
+    }
     addSectorQuadA01B01(sectorA0, sectorA1, sectorB0, sectorB1) {
         if (sectorA0.xyz.isAlmostEqual(sectorA1.xyz) && sectorB0.xyz.isAlmostEqual(sectorB1.xyz)) {
             // ignore null quad !!
         }
+        else if (this._options.shouldTriangulate) {
+            this.addSectorTriangle(sectorA0, sectorA1, sectorB1);
+            this.addSectorTriangle(sectorB1, sectorB0, sectorA0);
+        }
         else {
             if (this._options.needNormals)
                 this.addIndexedQuadNormalIndexes(sectorA0.normalIndex, sectorA1.normalIndex, sectorB0.normalIndex, sectorB1.normalIndex);
@@ -240640,12 +240770,30 @@ class PolyfaceBuilder extends _geometry3d_GeometryHandler__WEBPACK_IMPORTED_MODU
         }
         const numPoints = pointA.length;
         for (let i = 1; i < numPoints; i++) {
-            if (pointA.atUncheckedIndex(i - 1) !== pointA.atUncheckedIndex(i) || pointB.atUncheckedIndex(i - 1) !== pointB.atUncheckedIndex(i)) {
-                this.addIndexedQuadPointIndexes(pointA.atUncheckedIndex(i - 1), pointA.atUncheckedIndex(i), pointB.atUncheckedIndex(i - 1), pointB.atUncheckedIndex(i));
-                if (normalA && normalB)
-                    this.addIndexedQuadNormalIndexes(normalA.atUncheckedIndex(i - 1), normalA.atUncheckedIndex(i), normalB.atUncheckedIndex(i - 1), normalB.atUncheckedIndex(i));
-                if (paramA && paramB)
-                    this.addIndexedQuadParamIndexes(paramA.atUncheckedIndex(i - 1), paramA.atUncheckedIndex(i), paramB.atUncheckedIndex(i - 1), paramB.atUncheckedIndex(i));
+            if (this.options.shouldTriangulate) {
+                if (distinctIndices(pointA.atUncheckedIndex(i - 1), pointA.atUncheckedIndex(i), pointB.atUncheckedIndex(i))) {
+                    this.addIndexedTrianglePointIndexes(pointA.atUncheckedIndex(i - 1), pointA.atUncheckedIndex(i), pointB.atUncheckedIndex(i));
+                    if (normalA && normalB)
+                        this.addIndexedTriangleNormalIndexes(normalA.atUncheckedIndex(i - 1), normalA.atUncheckedIndex(i), normalB.atUncheckedIndex(i - 1));
+                    if (paramA && paramB)
+                        this.addIndexedTriangleParamIndexes(paramA.atUncheckedIndex(i - 1), paramA.atUncheckedIndex(i), paramB.atUncheckedIndex(i - 1));
+                }
+                if (distinctIndices(pointB.atUncheckedIndex(i), pointB.atUncheckedIndex(i - 1), pointA.atUncheckedIndex(i - 1))) {
+                    this.addIndexedTrianglePointIndexes(pointA.atUncheckedIndex(i - 1), pointB.atUncheckedIndex(i), pointB.atUncheckedIndex(i - 1));
+                    if (normalA && normalB)
+                        this.addIndexedTriangleNormalIndexes(normalA.atUncheckedIndex(i - 1), normalB.atUncheckedIndex(i), normalB.atUncheckedIndex(i - 1));
+                    if (paramA && paramB)
+                        this.addIndexedTriangleParamIndexes(paramA.atUncheckedIndex(i - 1), paramB.atUncheckedIndex(i), paramB.atUncheckedIndex(i - 1));
+                }
+            }
+            else {
+                if (pointA.atUncheckedIndex(i - 1) !== pointA.atUncheckedIndex(i) || pointB.atUncheckedIndex(i - 1) !== pointB.atUncheckedIndex(i)) {
+                    this.addIndexedQuadPointIndexes(pointA.atUncheckedIndex(i - 1), pointA.atUncheckedIndex(i), pointB.atUncheckedIndex(i - 1), pointB.atUncheckedIndex(i));
+                    if (normalA && normalB)
+                        this.addIndexedQuadNormalIndexes(normalA.atUncheckedIndex(i - 1), normalA.atUncheckedIndex(i), normalB.atUncheckedIndex(i - 1), normalB.atUncheckedIndex(i));
+                    if (paramA && paramB)
+                        this.addIndexedQuadParamIndexes(paramA.atUncheckedIndex(i - 1), paramA.atUncheckedIndex(i), paramB.atUncheckedIndex(i - 1), paramB.atUncheckedIndex(i));
+                }
                 this._polyface.terminateFacet();
             }
         }
@@ -241642,6 +241790,9 @@ function resolveToIndexedXYZCollectionOrCarrier(points) {
         return points.packedPoints;
     return points;
 }
+function distinctIndices(i0, i1, i2) {
+    return i0 !== i1 && i1 !== i2 && i2 !== i0;
+}
 
 
 /***/ }),
@@ -242810,38 +242961,41 @@ function compressUnusedGrowableXYZArray(data: GrowableXYZArray, indices: number[
 __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "DuplicateFacetClusterSelector": () => (/* binding */ DuplicateFacetClusterSelector),
+/* harmony export */   "OffsetMeshOptions": () => (/* binding */ OffsetMeshOptions),
 /* harmony export */   "PolyfaceQuery": () => (/* binding */ PolyfaceQuery)
 /* harmony export */ });
 /* harmony import */ var _geometry3d_PointHelpers__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(/*! ../geometry3d/PointHelpers */ "../../core/geometry/lib/esm/geometry3d/PointHelpers.js");
-/* harmony import */ var _curve_CurveCollection__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../curve/CurveCollection */ "../../core/geometry/lib/esm/curve/CurveCollection.js");
+/* harmony import */ var _curve_CurveCollection__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../curve/CurveCollection */ "../../core/geometry/lib/esm/curve/CurveCollection.js");
 /* harmony import */ var _curve_internalContexts_MultiChainCollector__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ../curve/internalContexts/MultiChainCollector */ "../../core/geometry/lib/esm/curve/internalContexts/MultiChainCollector.js");
-/* harmony import */ var _curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ../curve/LineSegment3d */ "../../core/geometry/lib/esm/curve/LineSegment3d.js");
-/* harmony import */ var _curve_LineString3d__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../curve/LineString3d */ "../../core/geometry/lib/esm/curve/LineString3d.js");
-/* harmony import */ var _curve_Loop__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../curve/Loop */ "../../core/geometry/lib/esm/curve/Loop.js");
+/* harmony import */ var _curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ../curve/LineSegment3d */ "../../core/geometry/lib/esm/curve/LineSegment3d.js");
+/* harmony import */ var _curve_LineString3d__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../curve/LineString3d */ "../../core/geometry/lib/esm/curve/LineString3d.js");
+/* harmony import */ var _curve_Loop__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../curve/Loop */ "../../core/geometry/lib/esm/curve/Loop.js");
 /* harmony import */ var _curve_StrokeOptions__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__(/*! ../curve/StrokeOptions */ "../../core/geometry/lib/esm/curve/StrokeOptions.js");
-/* harmony import */ var _Geometry__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../Geometry */ "../../core/geometry/lib/esm/Geometry.js");
-/* harmony import */ var _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ../geometry3d/Angle */ "../../core/geometry/lib/esm/geometry3d/Angle.js");
+/* harmony import */ var _Geometry__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../Geometry */ "../../core/geometry/lib/esm/Geometry.js");
+/* harmony import */ var _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../geometry3d/Angle */ "../../core/geometry/lib/esm/geometry3d/Angle.js");
 /* harmony import */ var _geometry3d_FrameBuilder__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(/*! ../geometry3d/FrameBuilder */ "../../core/geometry/lib/esm/geometry3d/FrameBuilder.js");
-/* harmony import */ var _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../geometry3d/Point3dVector3d */ "../../core/geometry/lib/esm/geometry3d/Point3dVector3d.js");
-/* harmony import */ var _geometry3d_PolygonOps__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../geometry3d/PolygonOps */ "../../core/geometry/lib/esm/geometry3d/PolygonOps.js");
+/* harmony import */ var _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../geometry3d/Point3dVector3d */ "../../core/geometry/lib/esm/geometry3d/Point3dVector3d.js");
+/* harmony import */ var _geometry3d_PolygonOps__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../geometry3d/PolygonOps */ "../../core/geometry/lib/esm/geometry3d/PolygonOps.js");
 /* harmony import */ var _geometry3d_Range__WEBPACK_IMPORTED_MODULE_27__ = __webpack_require__(/*! ../geometry3d/Range */ "../../core/geometry/lib/esm/geometry3d/Range.js");
-/* harmony import */ var _geometry4d_Matrix4d__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../geometry4d/Matrix4d */ "../../core/geometry/lib/esm/geometry4d/Matrix4d.js");
-/* harmony import */ var _geometry4d_MomentData__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../geometry4d/MomentData */ "../../core/geometry/lib/esm/geometry4d/MomentData.js");
-/* harmony import */ var _numerics_UnionFind__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ../numerics/UnionFind */ "../../core/geometry/lib/esm/numerics/UnionFind.js");
+/* harmony import */ var _geometry4d_Matrix4d__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ../geometry4d/Matrix4d */ "../../core/geometry/lib/esm/geometry4d/Matrix4d.js");
+/* harmony import */ var _geometry4d_MomentData__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../geometry4d/MomentData */ "../../core/geometry/lib/esm/geometry4d/MomentData.js");
+/* harmony import */ var _numerics_UnionFind__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ../numerics/UnionFind */ "../../core/geometry/lib/esm/numerics/UnionFind.js");
 /* harmony import */ var _topology_ChainMerge__WEBPACK_IMPORTED_MODULE_24__ = __webpack_require__(/*! ../topology/ChainMerge */ "../../core/geometry/lib/esm/topology/ChainMerge.js");
 /* harmony import */ var _topology_Graph__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(/*! ../topology/Graph */ "../../core/geometry/lib/esm/topology/Graph.js");
 /* harmony import */ var _topology_HalfEdgeGraphSearch__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(/*! ../topology/HalfEdgeGraphSearch */ "../../core/geometry/lib/esm/topology/HalfEdgeGraphSearch.js");
 /* harmony import */ var _topology_Merging__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(/*! ../topology/Merging */ "../../core/geometry/lib/esm/topology/Merging.js");
-/* harmony import */ var _FacetOrientation__WEBPACK_IMPORTED_MODULE_28__ = __webpack_require__(/*! ./FacetOrientation */ "../../core/geometry/lib/esm/polyface/FacetOrientation.js");
-/* harmony import */ var _IndexedEdgeMatcher__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./IndexedEdgeMatcher */ "../../core/geometry/lib/esm/polyface/IndexedEdgeMatcher.js");
+/* harmony import */ var _FacetOrientation__WEBPACK_IMPORTED_MODULE_29__ = __webpack_require__(/*! ./FacetOrientation */ "../../core/geometry/lib/esm/polyface/FacetOrientation.js");
+/* harmony import */ var _IndexedEdgeMatcher__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./IndexedEdgeMatcher */ "../../core/geometry/lib/esm/polyface/IndexedEdgeMatcher.js");
 /* harmony import */ var _IndexedPolyfaceVisitor__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ./IndexedPolyfaceVisitor */ "../../core/geometry/lib/esm/polyface/IndexedPolyfaceVisitor.js");
-/* harmony import */ var _multiclip_BuildAverageNormalsContext__WEBPACK_IMPORTED_MODULE_29__ = __webpack_require__(/*! ./multiclip/BuildAverageNormalsContext */ "../../core/geometry/lib/esm/polyface/multiclip/BuildAverageNormalsContext.js");
-/* harmony import */ var _multiclip_SweepLineStringToFacetContext__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./multiclip/SweepLineStringToFacetContext */ "../../core/geometry/lib/esm/polyface/multiclip/SweepLineStringToFacetContext.js");
+/* harmony import */ var _multiclip_BuildAverageNormalsContext__WEBPACK_IMPORTED_MODULE_30__ = __webpack_require__(/*! ./multiclip/BuildAverageNormalsContext */ "../../core/geometry/lib/esm/polyface/multiclip/BuildAverageNormalsContext.js");
+/* harmony import */ var _multiclip_SweepLineStringToFacetContext__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./multiclip/SweepLineStringToFacetContext */ "../../core/geometry/lib/esm/polyface/multiclip/SweepLineStringToFacetContext.js");
 /* harmony import */ var _multiclip_XYPointBuckets__WEBPACK_IMPORTED_MODULE_26__ = __webpack_require__(/*! ./multiclip/XYPointBuckets */ "../../core/geometry/lib/esm/polyface/multiclip/XYPointBuckets.js");
-/* harmony import */ var _Polyface__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./Polyface */ "../../core/geometry/lib/esm/polyface/Polyface.js");
+/* harmony import */ var _Polyface__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./Polyface */ "../../core/geometry/lib/esm/polyface/Polyface.js");
 /* harmony import */ var _PolyfaceBuilder__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(/*! ./PolyfaceBuilder */ "../../core/geometry/lib/esm/polyface/PolyfaceBuilder.js");
 /* harmony import */ var _RangeLengthData__WEBPACK_IMPORTED_MODULE_25__ = __webpack_require__(/*! ./RangeLengthData */ "../../core/geometry/lib/esm/polyface/RangeLengthData.js");
 /* harmony import */ var _topology_SpaceTriangulation__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__(/*! ../topology/SpaceTriangulation */ "../../core/geometry/lib/esm/topology/SpaceTriangulation.js");
+/* harmony import */ var _topology_HalfEdgeGraphFromIndexedLoopsContext__WEBPACK_IMPORTED_MODULE_28__ = __webpack_require__(/*! ../topology/HalfEdgeGraphFromIndexedLoopsContext */ "../../core/geometry/lib/esm/topology/HalfEdgeGraphFromIndexedLoopsContext.js");
+/* harmony import */ var _multiclip_OffsetMeshContext__WEBPACK_IMPORTED_MODULE_31__ = __webpack_require__(/*! ./multiclip/OffsetMeshContext */ "../../core/geometry/lib/esm/polyface/multiclip/OffsetMeshContext.js");
 /*---------------------------------------------------------------------------------------------
 * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
 * See LICENSE.md in the project root for license terms and full copyright notice.
@@ -242881,6 +243035,41 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+
+
+/**
+ * Options carrier for [[PolyfaceQuery.cloneOffset]].
+ * * Default options are strongly recommended.
+ * * The option most likely to be changed is chamferTurnAngle
+ * @public
+ */
+class OffsetMeshOptions {
+    /** Constructor -- CAPTURE parameters ... */
+    constructor(smoothSingleAngleBetweenNormals = _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createDegrees(25), smoothAccumulatedAngleBetweenNormals = _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createDegrees(60), chamferTurnAngle = _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createDegrees(90)) {
+        this.smoothSingleAngleBetweenNormals = smoothSingleAngleBetweenNormals.clone();
+        this.smoothAccumulatedAngleBetweenNormals = smoothAccumulatedAngleBetweenNormals.clone();
+        this.chamferAngleBetweenNormals = chamferTurnAngle.clone();
+    }
+    /** construct and return an OffsetMeshOptions with given parameters.
+     * * Angles are forced to minimum values.
+     * * Clones of the angles are given to the constructor.
+     * @param smoothSingleRadiansBetweenNormals an angle larger than this (between facets) is considered a sharp edge
+     * @param smoothAccumulatedAngleBetweenNormals angles that sum to this much may be consolidated for average normal
+     * @param chamferTurnAngleBetweenNormals when facets meet with larger angle, a chamfer edge may be added if the angle between facet normals is larger than this.
+     */
+    static create(smoothSingleAngleBetweenNormals = _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createDegrees(25), smoothAccumulatedAngleBetweenNormals = _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createDegrees(60), chamferTurnAngleBetweenNormals = _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createDegrees(120)) {
+        const mySmoothSingleRadiansBetweenNormals = smoothSingleAngleBetweenNormals.clone();
+        const mySmoothAccumulatedRadiansBetweenNormals = smoothAccumulatedAngleBetweenNormals.clone();
+        const myChamferTurnAngleBetweenNormals = chamferTurnAngleBetweenNormals.clone();
+        if (mySmoothSingleRadiansBetweenNormals.degrees < 1)
+            mySmoothAccumulatedRadiansBetweenNormals.setDegrees(1.0);
+        if (mySmoothAccumulatedRadiansBetweenNormals.degrees < 1.0)
+            mySmoothAccumulatedRadiansBetweenNormals.setDegrees(1.0);
+        if (mySmoothAccumulatedRadiansBetweenNormals.degrees < 15.0)
+            mySmoothAccumulatedRadiansBetweenNormals.setDegrees(15.0);
+        return new OffsetMeshOptions(mySmoothSingleRadiansBetweenNormals, mySmoothAccumulatedRadiansBetweenNormals, myChamferTurnAngleBetweenNormals);
+    }
+}
 /**
  * Enumeration of cases for retaining facets among duplicates
  * @public
@@ -242902,12 +243091,12 @@ var DuplicateFacetClusterSelector;
 class PolyfaceQuery {
     /** copy the points from a visitor into a Linestring3d in a Loop object */
     static visitorToLoop(visitor) {
-        const ls = _curve_LineString3d__WEBPACK_IMPORTED_MODULE_0__.LineString3d.createPoints(visitor.point.getPoint3dArray());
-        return _curve_Loop__WEBPACK_IMPORTED_MODULE_1__.Loop.create(ls);
+        const ls = _curve_LineString3d__WEBPACK_IMPORTED_MODULE_1__.LineString3d.createPoints(visitor.point.getPoint3dArray());
+        return _curve_Loop__WEBPACK_IMPORTED_MODULE_2__.Loop.create(ls);
     }
     /** Create a linestring loop for each facet of the polyface. */
     static indexedPolyfaceToLoops(polyface) {
-        const result = _curve_CurveCollection__WEBPACK_IMPORTED_MODULE_2__.BagOfCurves.create();
+        const result = _curve_CurveCollection__WEBPACK_IMPORTED_MODULE_3__.BagOfCurves.create();
         const visitor = polyface.createVisitor(1);
         while (visitor.moveToNextFacet()) {
             const loop = PolyfaceQuery.visitorToLoop(visitor);
@@ -242921,17 +243110,17 @@ class PolyfaceQuery {
     static sumFacetAreas(source, vectorToEye) {
         let s = 0;
         if (source !== undefined) {
-            if (source instanceof _Polyface__WEBPACK_IMPORTED_MODULE_3__.Polyface)
+            if (source instanceof _Polyface__WEBPACK_IMPORTED_MODULE_4__.Polyface)
                 return PolyfaceQuery.sumFacetAreas(source.createVisitor(1), vectorToEye);
             let unitVectorToEye;
             if (vectorToEye !== undefined)
                 unitVectorToEye = vectorToEye.normalize();
             source.reset();
             while (source.moveToNextFacet()) {
-                const scaledNormal = _geometry3d_PolygonOps__WEBPACK_IMPORTED_MODULE_4__.PolygonOps.areaNormal(source.point.getPoint3dArray());
+                const scaledNormal = _geometry3d_PolygonOps__WEBPACK_IMPORTED_MODULE_5__.PolygonOps.areaNormal(source.point.getPoint3dArray());
                 let area = scaledNormal.magnitude();
                 if (unitVectorToEye !== undefined) {
-                    const scale = _Geometry__WEBPACK_IMPORTED_MODULE_5__.Geometry.conditionalDivideCoordinate(1.0, area);
+                    const scale = _Geometry__WEBPACK_IMPORTED_MODULE_6__.Geometry.conditionalDivideCoordinate(1.0, area);
                     if (scale !== undefined)
                         area *= scaledNormal.dotProduct(unitVectorToEye) * scale;
                 }
@@ -242948,12 +243137,12 @@ class PolyfaceQuery {
     */
     static sumTetrahedralVolumes(source, origin) {
         let s = 0;
-        if (source instanceof _Polyface__WEBPACK_IMPORTED_MODULE_3__.Polyface)
+        if (source instanceof _Polyface__WEBPACK_IMPORTED_MODULE_4__.Polyface)
             return PolyfaceQuery.sumTetrahedralVolumes(source.createVisitor(0), origin);
         let myOrigin = origin;
-        const facetOrigin = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_6__.Point3d.create();
-        const targetA = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_6__.Point3d.create();
-        const targetB = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_6__.Point3d.create();
+        const facetOrigin = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_7__.Point3d.create();
+        const targetA = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_7__.Point3d.create();
+        const targetB = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_7__.Point3d.create();
         source.reset();
         while (source.moveToNextFacet()) {
             if (myOrigin === undefined)
@@ -242974,20 +243163,20 @@ class PolyfaceQuery {
      *
     */
     static sumVolumeBetweenFacetsAndPlane(source, plane) {
-        if (source instanceof _Polyface__WEBPACK_IMPORTED_MODULE_3__.Polyface)
+        if (source instanceof _Polyface__WEBPACK_IMPORTED_MODULE_4__.Polyface)
             return PolyfaceQuery.sumVolumeBetweenFacetsAndPlane(source.createVisitor(0), plane);
-        const facetOrigin = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_6__.Point3d.create();
-        const targetA = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_6__.Point3d.create();
-        const targetB = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_6__.Point3d.create();
-        const triangleNormal = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_6__.Vector3d.create();
+        const facetOrigin = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_7__.Point3d.create();
+        const targetA = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_7__.Point3d.create();
+        const targetB = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_7__.Point3d.create();
+        const triangleNormal = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_7__.Vector3d.create();
         const planeNormal = plane.getNormalRef();
         let h0, hA, hB;
         let signedVolumeSum = 0.0;
         let signedTriangleArea;
         let singleFacetArea;
-        const positiveAreaMomentSums = _geometry4d_MomentData__WEBPACK_IMPORTED_MODULE_7__.MomentData.create(undefined, true);
-        const negativeAreaMomentSums = _geometry4d_MomentData__WEBPACK_IMPORTED_MODULE_7__.MomentData.create(undefined, true);
-        const singleFacetProducts = _geometry4d_Matrix4d__WEBPACK_IMPORTED_MODULE_8__.Matrix4d.createZero();
+        const positiveAreaMomentSums = _geometry4d_MomentData__WEBPACK_IMPORTED_MODULE_8__.MomentData.create(undefined, true);
+        const negativeAreaMomentSums = _geometry4d_MomentData__WEBPACK_IMPORTED_MODULE_8__.MomentData.create(undefined, true);
+        const singleFacetProducts = _geometry4d_Matrix4d__WEBPACK_IMPORTED_MODULE_9__.Matrix4d.createZero();
         const projectToPlane = plane.getProjectionToPlane();
         source.reset();
         // For each facet ..
@@ -243014,7 +243203,7 @@ class PolyfaceQuery {
             }
             singleFacetProducts.setZero();
             source.point.multiplyTransformInPlace(projectToPlane);
-            _geometry3d_PolygonOps__WEBPACK_IMPORTED_MODULE_4__.PolygonOps.addSecondMomentAreaProducts(source.point, facetOrigin, singleFacetProducts);
+            _geometry3d_PolygonOps__WEBPACK_IMPORTED_MODULE_5__.PolygonOps.addSecondMomentAreaProducts(source.point, facetOrigin, singleFacetProducts);
             if (singleFacetArea > 0) {
                 positiveAreaMomentSums.accumulateProductsFromOrigin(facetOrigin, singleFacetProducts, 1.0);
             }
@@ -243024,8 +243213,8 @@ class PolyfaceQuery {
         }
         positiveAreaMomentSums.shiftOriginAndSumsToCentroidOfSums();
         negativeAreaMomentSums.shiftOriginAndSumsToCentroidOfSums();
-        const positiveAreaMoments = _geometry4d_MomentData__WEBPACK_IMPORTED_MODULE_7__.MomentData.inertiaProductsToPrincipalAxes(positiveAreaMomentSums.origin, positiveAreaMomentSums.sums);
-        const negativeAreaMoments = _geometry4d_MomentData__WEBPACK_IMPORTED_MODULE_7__.MomentData.inertiaProductsToPrincipalAxes(negativeAreaMomentSums.origin, negativeAreaMomentSums.sums);
+        const positiveAreaMoments = _geometry4d_MomentData__WEBPACK_IMPORTED_MODULE_8__.MomentData.inertiaProductsToPrincipalAxes(positiveAreaMomentSums.origin, positiveAreaMomentSums.sums);
+        const negativeAreaMoments = _geometry4d_MomentData__WEBPACK_IMPORTED_MODULE_8__.MomentData.inertiaProductsToPrincipalAxes(negativeAreaMomentSums.origin, negativeAreaMomentSums.sums);
         return {
             volume: signedVolumeSum / 6.0,
             positiveProjectedFacetAreaMoments: positiveAreaMoments,
@@ -243034,23 +243223,23 @@ class PolyfaceQuery {
     }
     /** Return the inertia products [xx,xy,xz,xw, yw, etc] integrated over all all facets, as viewed from origin. */
     static sumFacetSecondAreaMomentProducts(source, origin) {
-        if (source instanceof _Polyface__WEBPACK_IMPORTED_MODULE_3__.Polyface)
+        if (source instanceof _Polyface__WEBPACK_IMPORTED_MODULE_4__.Polyface)
             return PolyfaceQuery.sumFacetSecondAreaMomentProducts(source.createVisitor(0), origin);
-        const products = _geometry4d_Matrix4d__WEBPACK_IMPORTED_MODULE_8__.Matrix4d.createZero();
+        const products = _geometry4d_Matrix4d__WEBPACK_IMPORTED_MODULE_9__.Matrix4d.createZero();
         source.reset();
         while (source.moveToNextFacet()) {
-            _geometry3d_PolygonOps__WEBPACK_IMPORTED_MODULE_4__.PolygonOps.addSecondMomentAreaProducts(source.point, origin, products);
+            _geometry3d_PolygonOps__WEBPACK_IMPORTED_MODULE_5__.PolygonOps.addSecondMomentAreaProducts(source.point, origin, products);
         }
         return products;
     }
     /** Return the inertia products [xx,xy,xz,xw, yw, etc] integrated over all tetrahedral volumes from origin */
     static sumFacetSecondVolumeMomentProducts(source, origin) {
-        if (source instanceof _Polyface__WEBPACK_IMPORTED_MODULE_3__.Polyface)
+        if (source instanceof _Polyface__WEBPACK_IMPORTED_MODULE_4__.Polyface)
             return PolyfaceQuery.sumFacetSecondVolumeMomentProducts(source.createVisitor(0), origin);
-        const products = _geometry4d_Matrix4d__WEBPACK_IMPORTED_MODULE_8__.Matrix4d.createZero();
+        const products = _geometry4d_Matrix4d__WEBPACK_IMPORTED_MODULE_9__.Matrix4d.createZero();
         source.reset();
         while (source.moveToNextFacet()) {
-            _geometry3d_PolygonOps__WEBPACK_IMPORTED_MODULE_4__.PolygonOps.addSecondMomentVolumeProducts(source.point, origin, products);
+            _geometry3d_PolygonOps__WEBPACK_IMPORTED_MODULE_5__.PolygonOps.addSecondMomentVolumeProducts(source.point, origin, products);
         }
         return products;
     }
@@ -243064,7 +243253,7 @@ class PolyfaceQuery {
         if (!origin)
             return undefined;
         const inertiaProducts = PolyfaceQuery.sumFacetSecondAreaMomentProducts(source, origin);
-        return _geometry4d_MomentData__WEBPACK_IMPORTED_MODULE_7__.MomentData.inertiaProductsToPrincipalAxes(origin, inertiaProducts);
+        return _geometry4d_MomentData__WEBPACK_IMPORTED_MODULE_8__.MomentData.inertiaProductsToPrincipalAxes(origin, inertiaProducts);
     }
     /** Compute area moments for the mesh. In the returned MomentData:
      * * origin is the centroid.
@@ -243078,7 +243267,7 @@ class PolyfaceQuery {
         if (!origin)
             return undefined;
         const inertiaProducts = PolyfaceQuery.sumFacetSecondVolumeMomentProducts(source, origin);
-        return _geometry4d_MomentData__WEBPACK_IMPORTED_MODULE_7__.MomentData.inertiaProductsToPrincipalAxes(origin, inertiaProducts);
+        return _geometry4d_MomentData__WEBPACK_IMPORTED_MODULE_8__.MomentData.inertiaProductsToPrincipalAxes(origin, inertiaProducts);
     }
     /**
      * Test for convex volume by dihedral angle tests on all edges.
@@ -243110,14 +243299,14 @@ class PolyfaceQuery {
     *     * (but null edges are permitted -- These occur naturally at edges of quads at north or south pole)
     */
     static dihedralAngleSummary(source, ignoreBoundaries = false) {
-        const edges = new _IndexedEdgeMatcher__WEBPACK_IMPORTED_MODULE_9__.IndexedEdgeMatcher();
+        const edges = new _IndexedEdgeMatcher__WEBPACK_IMPORTED_MODULE_10__.IndexedEdgeMatcher();
         const visitor = source.createVisitor(1);
         visitor.reset();
         const centroidNormal = [];
         let normalCounter = 0;
         while (visitor.moveToNextFacet()) {
             const numEdges = visitor.pointCount - 1;
-            const normal = _geometry3d_PolygonOps__WEBPACK_IMPORTED_MODULE_4__.PolygonOps.centroidAreaNormal(visitor.point);
+            const normal = _geometry3d_PolygonOps__WEBPACK_IMPORTED_MODULE_5__.PolygonOps.centroidAreaNormal(visitor.point);
             if (normal === undefined)
                 return 0;
             centroidNormal.push(normal);
@@ -243134,12 +243323,12 @@ class PolyfaceQuery {
         let numPositive = 0;
         let numPlanar = 0;
         let numNegative = 0;
-        const edgeVector = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_6__.Vector3d.create();
+        const edgeVector = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_7__.Vector3d.create();
         for (const cluster of manifoldClusters) {
             const sideA = cluster[0];
             const sideB = cluster[1];
-            if (sideA instanceof _IndexedEdgeMatcher__WEBPACK_IMPORTED_MODULE_9__.SortableEdge
-                && sideB instanceof _IndexedEdgeMatcher__WEBPACK_IMPORTED_MODULE_9__.SortableEdge
+            if (sideA instanceof _IndexedEdgeMatcher__WEBPACK_IMPORTED_MODULE_10__.SortableEdge
+                && sideB instanceof _IndexedEdgeMatcher__WEBPACK_IMPORTED_MODULE_10__.SortableEdge
                 && source.data.point.vectorIndexIndex(sideA.vertexIndexA, sideA.vertexIndexB, edgeVector)) {
                 const dihedralAngle = centroidNormal[sideA.facetIndex].direction.signedAngleTo(centroidNormal[sideB.facetIndex].direction, edgeVector);
                 if (dihedralAngle.isAlmostZero)
@@ -243172,7 +243361,7 @@ class PolyfaceQuery {
      * * Any edge with 2 incident facets in the same direction triggers a `false` return.
     */
     static isPolyfaceManifold(source, allowSimpleBoundaries = false) {
-        const edges = new _IndexedEdgeMatcher__WEBPACK_IMPORTED_MODULE_9__.IndexedEdgeMatcher();
+        const edges = new _IndexedEdgeMatcher__WEBPACK_IMPORTED_MODULE_10__.IndexedEdgeMatcher();
         const visitor = source.createVisitor(1);
         visitor.reset();
         while (visitor.moveToNextFacet()) {
@@ -243195,9 +243384,9 @@ class PolyfaceQuery {
      * @returns
      */
     static boundaryEdges(source, includeDanglers = true, includeMismatch = true, includeNull = true) {
-        const result = new _curve_CurveCollection__WEBPACK_IMPORTED_MODULE_2__.BagOfCurves();
+        const result = new _curve_CurveCollection__WEBPACK_IMPORTED_MODULE_3__.BagOfCurves();
         const announceEdge = (pointA, pointB, _indexA, _indexB, _readIndex) => {
-            result.tryAddChild(_curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_10__.LineSegment3d.create(pointA, pointB));
+            result.tryAddChild(_curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_11__.LineSegment3d.create(pointA, pointB));
         };
         PolyfaceQuery.announceBoundaryEdges(source, announceEdge, includeDanglers, includeMismatch, includeNull);
         if (result.children.length === 0)
@@ -243216,8 +243405,8 @@ class PolyfaceQuery {
     static announceBoundaryEdges(source, announceEdge, includeDanglers = true, includeMismatch = true, includeNull = true) {
         if (source === undefined)
             return undefined;
-        const edges = new _IndexedEdgeMatcher__WEBPACK_IMPORTED_MODULE_9__.IndexedEdgeMatcher();
-        const visitor = source instanceof _Polyface__WEBPACK_IMPORTED_MODULE_3__.Polyface ? source.createVisitor(1) : source;
+        const edges = new _IndexedEdgeMatcher__WEBPACK_IMPORTED_MODULE_10__.IndexedEdgeMatcher();
+        const visitor = source instanceof _Polyface__WEBPACK_IMPORTED_MODULE_4__.Polyface ? source.createVisitor(1) : source;
         visitor.setNumWrap(1);
         visitor.reset();
         while (visitor.moveToNextFacet()) {
@@ -243242,7 +243431,7 @@ class PolyfaceQuery {
         const sourcePolyface = visitor.clientPolyface();
         for (const list of badList) {
             for (const e of list) {
-                const e1 = e instanceof _IndexedEdgeMatcher__WEBPACK_IMPORTED_MODULE_9__.SortableEdge ? e : e[0];
+                const e1 = e instanceof _IndexedEdgeMatcher__WEBPACK_IMPORTED_MODULE_10__.SortableEdge ? e : e[0];
                 const indexA = e1.vertexIndexA;
                 const indexB = e1.vertexIndexB;
                 const pointA = sourcePolyface.data.getPoint(indexA);
@@ -243257,7 +243446,7 @@ class PolyfaceQuery {
      * * Facets are ASSUMED to be convex and planar.
      */
     static announceSweepLinestringToConvexPolyfaceXY(linestringPoints, polyface, announce) {
-        const context = _multiclip_SweepLineStringToFacetContext__WEBPACK_IMPORTED_MODULE_11__.SweepLineStringToFacetContext.create(linestringPoints);
+        const context = _multiclip_SweepLineStringToFacetContext__WEBPACK_IMPORTED_MODULE_12__.SweepLineStringToFacetContext.create(linestringPoints);
         if (context) {
             const visitor = polyface.createVisitor(0);
             for (visitor.reset(); visitor.moveToNextFacet();) {
@@ -243290,7 +243479,7 @@ class PolyfaceQuery {
      * @internal
      */
     static async asyncAnnounceSweepLinestringToConvexPolyfaceXY(linestringPoints, polyface, announce) {
-        const context = _multiclip_SweepLineStringToFacetContext__WEBPACK_IMPORTED_MODULE_11__.SweepLineStringToFacetContext.create(linestringPoints);
+        const context = _multiclip_SweepLineStringToFacetContext__WEBPACK_IMPORTED_MODULE_12__.SweepLineStringToFacetContext.create(linestringPoints);
         this.awaitBlockCount = 0;
         let workTotal = 0;
         if (context) {
@@ -243310,11 +243499,11 @@ class PolyfaceQuery {
      * * Return array of arrays of facet indices.
      */
     static partitionFacetIndicesByVertexConnectedComponent(polyface) {
-        if (polyface instanceof _Polyface__WEBPACK_IMPORTED_MODULE_3__.Polyface) {
+        if (polyface instanceof _Polyface__WEBPACK_IMPORTED_MODULE_4__.Polyface) {
             return this.partitionFacetIndicesByVertexConnectedComponent(polyface.createVisitor(0));
         }
         // The polyface is really a visitor !!!
-        const context = new _numerics_UnionFind__WEBPACK_IMPORTED_MODULE_12__.UnionFindContext(this.visitorClientPointCount(polyface));
+        const context = new _numerics_UnionFind__WEBPACK_IMPORTED_MODULE_13__.UnionFindContext(this.visitorClientPointCount(polyface));
         for (polyface.reset(); polyface.moveToNextFacet();) {
             const firstVertexIndexOnThisFacet = polyface.pointIndex[0];
             for (const vertexIndex of polyface.pointIndex)
@@ -243347,7 +243536,7 @@ class PolyfaceQuery {
      * * Return array of arrays of facet indices.
      */
     static partitionFacetIndicesByVisibilityVector(polyface, vectorToEye, sideAngleTolerance) {
-        if (polyface instanceof _Polyface__WEBPACK_IMPORTED_MODULE_3__.Polyface) {
+        if (polyface instanceof _Polyface__WEBPACK_IMPORTED_MODULE_4__.Polyface) {
             return this.partitionFacetIndicesByVisibilityVector(polyface.createVisitor(0), vectorToEye, sideAngleTolerance);
         }
         const facetsInComponent = [];
@@ -243359,7 +243548,7 @@ class PolyfaceQuery {
         const sideComponent = facetsInComponent[2];
         const radiansTol = Math.max(sideAngleTolerance.radians, 1.0e-8);
         for (polyface.reset(); polyface.moveToNextFacet();) {
-            const areaNormal = _geometry3d_PolygonOps__WEBPACK_IMPORTED_MODULE_4__.PolygonOps.areaNormalGo(polyface.point);
+            const areaNormal = _geometry3d_PolygonOps__WEBPACK_IMPORTED_MODULE_5__.PolygonOps.areaNormalGo(polyface.point);
             const index = polyface.currentReadIndex();
             if (areaNormal) {
                 const angle = areaNormal.angleFromPerpendicular(vectorToEye);
@@ -243386,7 +243575,7 @@ class PolyfaceQuery {
      * @param vectorToEye
      * @param sideAngleTolerance
      */
-    static boundaryOfVisibleSubset(polyface, visibilitySelect, vectorToEye, sideAngleTolerance = _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_13__.Angle.createDegrees(1.0e-3)) {
+    static boundaryOfVisibleSubset(polyface, visibilitySelect, vectorToEye, sideAngleTolerance = _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createDegrees(1.0e-3)) {
         const partitionedIndices = this.partitionFacetIndicesByVisibilityVector(polyface, vectorToEye, sideAngleTolerance);
         if (partitionedIndices[visibilitySelect].length === 0)
             return undefined;
@@ -243400,8 +243589,8 @@ class PolyfaceQuery {
      * @param mesh
      */
     static announceBoundaryChainsAsLineString3d(mesh, announceLoop) {
-        const collector = new _curve_internalContexts_MultiChainCollector__WEBPACK_IMPORTED_MODULE_15__.MultiChainCollector(_Geometry__WEBPACK_IMPORTED_MODULE_5__.Geometry.smallMetricDistance, 1000);
-        PolyfaceQuery.announceBoundaryEdges(mesh, (pointA, pointB, _indexA, _indexB) => collector.captureCurve(_curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_10__.LineSegment3d.create(pointA, pointB)), true, false, false);
+        const collector = new _curve_internalContexts_MultiChainCollector__WEBPACK_IMPORTED_MODULE_15__.MultiChainCollector(_Geometry__WEBPACK_IMPORTED_MODULE_6__.Geometry.smallMetricDistance, 1000);
+        PolyfaceQuery.announceBoundaryEdges(mesh, (pointA, pointB, _indexA, _indexB) => collector.captureCurve(_curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_11__.LineSegment3d.create(pointA, pointB)), true, false, false);
         collector.announceChainsAsLineString3d(announceLoop);
     }
     /**
@@ -243412,7 +243601,7 @@ class PolyfaceQuery {
      * @returns
      */
     static cloneWithMaximalPlanarFacets(mesh) {
-        if (mesh instanceof _Polyface__WEBPACK_IMPORTED_MODULE_3__.Polyface)
+        if (mesh instanceof _Polyface__WEBPACK_IMPORTED_MODULE_4__.Polyface)
             return this.cloneWithMaximalPlanarFacets(mesh.createVisitor(0));
         const numFacets = PolyfaceQuery.visitorClientFacetCount(mesh);
         const smoothEdges = PolyfaceQuery.collectEdgesByDihedralAngle(mesh);
@@ -243437,7 +243626,7 @@ class PolyfaceQuery {
             const edges = [];
             const edgeStrings = [];
             PolyfaceQuery.announceBoundaryEdges(fragment, (pointA, pointB, _indexA, _indexB) => {
-                edges.push(_curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_10__.LineSegment3d.create(pointA, pointB));
+                edges.push(_curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_11__.LineSegment3d.create(pointA, pointB));
                 edgeStrings.push([pointA.clone(), pointB.clone()]);
             });
             const chains = _curve_internalContexts_MultiChainCollector__WEBPACK_IMPORTED_MODULE_15__.OffsetHelpers.collectChains(edges, gapTolerance, planarityTolerance);
@@ -243478,7 +243667,7 @@ class PolyfaceQuery {
      * @returns
      */
     static fillSimpleHoles(mesh, options, unfilledChains) {
-        if (mesh instanceof _Polyface__WEBPACK_IMPORTED_MODULE_3__.Polyface)
+        if (mesh instanceof _Polyface__WEBPACK_IMPORTED_MODULE_4__.Polyface)
             return this.fillSimpleHoles(mesh.createVisitor(0), options, unfilledChains);
         const builder = _PolyfaceBuilder__WEBPACK_IMPORTED_MODULE_16__.PolyfaceBuilder.create();
         const chains = [];
@@ -243492,7 +243681,7 @@ class PolyfaceQuery {
                 rejected = true;
             else if (options.maxPerimeter !== undefined && _geometry3d_PointHelpers__WEBPACK_IMPORTED_MODULE_21__.Point3dArray.sumEdgeLengths(points, false) > options.maxPerimeter)
                 rejected = true;
-            else if (options.upVector !== undefined && _geometry3d_PolygonOps__WEBPACK_IMPORTED_MODULE_4__.PolygonOps.sumTriangleAreasPerpendicularToUpVector(points, options.upVector) <= 0.0)
+            else if (options.upVector !== undefined && _geometry3d_PolygonOps__WEBPACK_IMPORTED_MODULE_5__.PolygonOps.sumTriangleAreasPerpendicularToUpVector(points, options.upVector) <= 0.0)
                 rejected = true;
             if (!rejected && _topology_SpaceTriangulation__WEBPACK_IMPORTED_MODULE_22__.SpacePolygonTriangulation.triangulateSimplestSpaceLoop(points, (_loop, triangles) => {
                 for (const t of triangles)
@@ -243515,7 +243704,7 @@ class PolyfaceQuery {
    *
    */
     static clonePartitions(polyface, partitions) {
-        if (polyface instanceof _Polyface__WEBPACK_IMPORTED_MODULE_3__.Polyface) {
+        if (polyface instanceof _Polyface__WEBPACK_IMPORTED_MODULE_4__.Polyface) {
             return this.clonePartitions(polyface.createVisitor(0), partitions);
         }
         polyface.setNumWrap(0);
@@ -243539,7 +243728,7 @@ class PolyfaceQuery {
     /** Clone facets that pass an filter function
      */
     static cloneFiltered(source, filter) {
-        if (source instanceof _Polyface__WEBPACK_IMPORTED_MODULE_3__.Polyface) {
+        if (source instanceof _Polyface__WEBPACK_IMPORTED_MODULE_4__.Polyface) {
             return this.cloneFiltered(source.createVisitor(0), filter);
         }
         source.setNumWrap(0);
@@ -243591,9 +243780,9 @@ class PolyfaceQuery {
      * @return collection of facet index arrays, one array per connected component
      */
     static partitionFacetIndicesBySortableEdgeClusters(edgeClusters, numFacets) {
-        const context = new _numerics_UnionFind__WEBPACK_IMPORTED_MODULE_12__.UnionFindContext(numFacets);
+        const context = new _numerics_UnionFind__WEBPACK_IMPORTED_MODULE_13__.UnionFindContext(numFacets);
         for (const cluster of edgeClusters) {
-            if (cluster instanceof _IndexedEdgeMatcher__WEBPACK_IMPORTED_MODULE_9__.SortableEdge) {
+            if (cluster instanceof _IndexedEdgeMatcher__WEBPACK_IMPORTED_MODULE_10__.SortableEdge) {
                 // this edge does not connect anywhere.  Ignore it!!
             }
             else {
@@ -243625,11 +243814,11 @@ class PolyfaceQuery {
      * @return collection of facet index arrays, one per connected component
      */
     static partitionFacetIndicesByEdgeConnectedComponent(polyface, stopAtVisibleEdges = false) {
-        if (polyface instanceof _Polyface__WEBPACK_IMPORTED_MODULE_3__.Polyface) {
+        if (polyface instanceof _Polyface__WEBPACK_IMPORTED_MODULE_4__.Polyface) {
             return this.partitionFacetIndicesByEdgeConnectedComponent(polyface.createVisitor(0), stopAtVisibleEdges);
         }
         polyface.setNumWrap(1);
-        const matcher = new _IndexedEdgeMatcher__WEBPACK_IMPORTED_MODULE_9__.IndexedEdgeMatcher();
+        const matcher = new _IndexedEdgeMatcher__WEBPACK_IMPORTED_MODULE_10__.IndexedEdgeMatcher();
         polyface.reset();
         let numFacets = 0;
         while (polyface.moveToNextFacet()) {
@@ -243667,7 +243856,7 @@ class PolyfaceQuery {
     static sweepLinestringToFacetsXYReturnLines(linestringPoints, polyface) {
         const drapeGeometry = [];
         this.announceSweepLinestringToConvexPolyfaceXY(linestringPoints, polyface, (_linestring, _segmentIndex, _polyface, _facetIndex, points, indexA, indexB) => {
-            drapeGeometry.push(_curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_10__.LineSegment3d.create(points[indexA], points[indexB]));
+            drapeGeometry.push(_curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_11__.LineSegment3d.create(points[indexA], points[indexB]));
         });
         return drapeGeometry;
     }
@@ -243702,7 +243891,7 @@ class PolyfaceQuery {
      * * Return statistical summary of x,y,z ranges.
      */
     static collectRangeLengthData(polyface) {
-        if (polyface instanceof _Polyface__WEBPACK_IMPORTED_MODULE_3__.Polyface) {
+        if (polyface instanceof _Polyface__WEBPACK_IMPORTED_MODULE_4__.Polyface) {
             return this.collectRangeLengthData(polyface.createVisitor(0));
         }
         const rangeData = new _RangeLengthData__WEBPACK_IMPORTED_MODULE_25__.RangeLengthData();
@@ -243720,10 +243909,10 @@ class PolyfaceQuery {
         const rangeSearcher = _multiclip_XYPointBuckets__WEBPACK_IMPORTED_MODULE_26__.XYPointBuckets.create(polyface.data.point, 30);
         const builder = _PolyfaceBuilder__WEBPACK_IMPORTED_MODULE_16__.PolyfaceBuilder.create();
         const edgeRange = _geometry3d_Range__WEBPACK_IMPORTED_MODULE_27__.Range3d.createNull();
-        const point0 = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_6__.Point3d.create();
-        const point1 = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_6__.Point3d.create();
-        const spacePoint = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_6__.Point3d.create();
-        const segment = _curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_10__.LineSegment3d.create(point0, point1);
+        const point0 = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_7__.Point3d.create();
+        const point1 = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_7__.Point3d.create();
+        const spacePoint = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_7__.Point3d.create();
+        const segment = _curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_11__.LineSegment3d.create(point0, point1);
         for (oldFacetVisitor.reset(); oldFacetVisitor.moveToNextFacet();) {
             newFacetVisitor.clearArrays();
             for (let i = 0; i + 1 < oldFacetVisitor.point.length; i++) {
@@ -243732,7 +243921,7 @@ class PolyfaceQuery {
                 oldFacetVisitor.point.getPoint3dAtUncheckedPointIndex(i + 1, point1);
                 newFacetVisitor.pushDataFrom(oldFacetVisitor, i);
                 edgeRange.setNull();
-                _curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_10__.LineSegment3d.create(point0, point1, segment);
+                _curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_11__.LineSegment3d.create(point0, point1, segment);
                 let detailArray;
                 edgeRange.extend(point0);
                 edgeRange.extend(point1);
@@ -243877,8 +244066,8 @@ class PolyfaceQuery {
         const oldFacetVisitor = polyface.createVisitor(2); // This is to visit the existing facets.
         const newFacetVisitor = polyface.createVisitor(0); // This is to build the new facets.
         const builder = _PolyfaceBuilder__WEBPACK_IMPORTED_MODULE_16__.PolyfaceBuilder.create();
-        const vector01 = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_6__.Vector3d.create();
-        const vector12 = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_6__.Vector3d.create();
+        const vector01 = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_7__.Vector3d.create();
+        const vector12 = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_7__.Vector3d.create();
         const numPoint = polyface.data.point.length;
         const pointState = new Int32Array(numPoint);
         // FIRST PASS -- in each sector of each facet, determine if the sector has colinear incoming and outgoing vectors.
@@ -243925,7 +244114,7 @@ class PolyfaceQuery {
      */
     static setEdgeVisibility(polyface, clusters, value) {
         for (const cluster of clusters) {
-            if (cluster instanceof _IndexedEdgeMatcher__WEBPACK_IMPORTED_MODULE_9__.SortableEdge) {
+            if (cluster instanceof _IndexedEdgeMatcher__WEBPACK_IMPORTED_MODULE_10__.SortableEdge) {
                 this.setSingleEdgeVisibility(polyface, cluster.facetIndex, cluster.vertexIndexA, value);
             }
             else if (Array.isArray(cluster)) {
@@ -243968,9 +244157,9 @@ class PolyfaceQuery {
      * @param polyface a mesh, or a visitor assumed to have numWrap === 1
     */
     static createIndexedEdges(polyface) {
-        if (polyface instanceof _Polyface__WEBPACK_IMPORTED_MODULE_3__.Polyface)
+        if (polyface instanceof _Polyface__WEBPACK_IMPORTED_MODULE_4__.Polyface)
             return this.createIndexedEdges(polyface.createVisitor(1));
-        const edges = new _IndexedEdgeMatcher__WEBPACK_IMPORTED_MODULE_9__.IndexedEdgeMatcher();
+        const edges = new _IndexedEdgeMatcher__WEBPACK_IMPORTED_MODULE_10__.IndexedEdgeMatcher();
         polyface.reset();
         while (polyface.moveToNextFacet()) {
             const numEdges = polyface.pointCount - 1;
@@ -243989,17 +244178,17 @@ class PolyfaceQuery {
      * @param sharpEdges true to reverse the angle threshold test and return sharp edges; otherwise return smooth edges (default)
      */
     static collectEdgesByDihedralAngle(mesh, maxSmoothEdgeAngle, sharpEdges = false) {
-        if (mesh instanceof _Polyface__WEBPACK_IMPORTED_MODULE_3__.Polyface)
+        if (mesh instanceof _Polyface__WEBPACK_IMPORTED_MODULE_4__.Polyface)
             return this.collectEdgesByDihedralAngle(mesh.createVisitor(1), maxSmoothEdgeAngle, sharpEdges);
         mesh.setNumWrap(1);
         const allEdges = this.createIndexedEdges(mesh);
         const manifoldEdges = [];
         allEdges.sortAndCollectClusters(manifoldEdges);
         if (undefined === maxSmoothEdgeAngle || maxSmoothEdgeAngle.radians < 0)
-            maxSmoothEdgeAngle = _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_13__.Angle.createRadians(_Geometry__WEBPACK_IMPORTED_MODULE_5__.Geometry.smallAngleRadians);
+            maxSmoothEdgeAngle = _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createRadians(_Geometry__WEBPACK_IMPORTED_MODULE_6__.Geometry.smallAngleRadians);
         const outEdges = [];
-        const normal0 = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_6__.Vector3d.create();
-        const normal1 = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_6__.Vector3d.create();
+        const normal0 = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_7__.Vector3d.create();
+        const normal1 = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_7__.Vector3d.create();
         for (const pair of manifoldEdges) {
             if (Array.isArray(pair) && pair.length === 2) {
                 const e0 = pair[0];
@@ -244038,8 +244227,8 @@ class PolyfaceQuery {
         this.markAllEdgeVisibility(mesh, false);
         this.setEdgeVisibility(mesh, boundaryEdges, true);
         if (sharpEdgeAngle !== undefined) {
-            const normal0 = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_6__.Vector3d.create();
-            const normal1 = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_6__.Vector3d.create();
+            const normal0 = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_7__.Vector3d.create();
+            const normal1 = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_7__.Vector3d.create();
             for (const pair of pairedEdges) {
                 if (Array.isArray(pair) && pair.length === 2) {
                     const e0 = pair[0];
@@ -244061,9 +244250,9 @@ class PolyfaceQuery {
      */
     static computeFacetUnitNormal(visitor, facetIndex, result) {
         if (!result)
-            result = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_6__.Vector3d.create();
+            result = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_7__.Vector3d.create();
         if (visitor.moveToReadIndex(facetIndex)) {
-            if (_geometry3d_PolygonOps__WEBPACK_IMPORTED_MODULE_4__.PolygonOps.unitNormal(visitor.point, result))
+            if (_geometry3d_PolygonOps__WEBPACK_IMPORTED_MODULE_5__.PolygonOps.unitNormal(visitor.point, result))
                 return result;
         }
         return undefined;
@@ -244078,20 +244267,41 @@ class PolyfaceQuery {
         for (let i = 0; i < data.edgeVisible.length; i++)
             data.edgeVisible[i] = value;
     }
+    /**
+     * Create a HalfEdgeGraph with a face for each facet of the IndexedPolyface
+     * @param mesh mesh to convert
+     * @internal
+     */
+    static convertToHalfEdgeGraph(mesh) {
+        const builder = new _topology_HalfEdgeGraphFromIndexedLoopsContext__WEBPACK_IMPORTED_MODULE_28__.HalfEdgeGraphFromIndexedLoopsContext();
+        const visitor = mesh.createVisitor(0);
+        for (visitor.reset(); visitor.moveToNextFacet();) {
+            builder.insertLoop(visitor.pointIndex);
+        }
+        const graph = builder.graph;
+        const xyz = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_7__.Point3d.create();
+        graph.announceNodes((_graph, halfEdge) => {
+            const vertexIndex = halfEdge.i;
+            mesh.data.getPoint(vertexIndex, xyz);
+            halfEdge.setXYZ(xyz);
+            return true;
+        });
+        return graph;
+    }
     /**
      * * Examine adjacent facet orientations throughout the mesh
      * * If possible, reverse a subset to achieve proper pairing.
      * @param mesh
      */
     static reorientVertexOrderAroundFacetsForConsistentOrientation(mesh) {
-        return _FacetOrientation__WEBPACK_IMPORTED_MODULE_28__.FacetOrientationFixup.doFixup(mesh);
+        return _FacetOrientation__WEBPACK_IMPORTED_MODULE_29__.FacetOrientationFixup.doFixup(mesh);
     }
     /**
      * Set up indexed normals with one normal in the plane of each facet of the mesh.
      * @param polyface
      */
     static buildPerFaceNormals(polyface) {
-        _multiclip_BuildAverageNormalsContext__WEBPACK_IMPORTED_MODULE_29__.BuildAverageNormalsContext.buildPerFaceNormals(polyface);
+        _multiclip_BuildAverageNormalsContext__WEBPACK_IMPORTED_MODULE_30__.BuildAverageNormalsContext.buildPerFaceNormals(polyface);
     }
     /**
     * * At each vertex of the mesh
@@ -244103,8 +244313,21 @@ class PolyfaceQuery {
     * @param polyface polyface to update.
     * @param toleranceAngle averaging is done between normals up to this angle.
     */
-    static buildAverageNormals(polyface, toleranceAngle = _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_13__.Angle.createDegrees(31.0)) {
-        _multiclip_BuildAverageNormalsContext__WEBPACK_IMPORTED_MODULE_29__.BuildAverageNormalsContext.buildFastAverageNormals(polyface, toleranceAngle);
+    static buildAverageNormals(polyface, toleranceAngle = _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createDegrees(31.0)) {
+        _multiclip_BuildAverageNormalsContext__WEBPACK_IMPORTED_MODULE_30__.BuildAverageNormalsContext.buildFastAverageNormals(polyface, toleranceAngle);
+    }
+    /**
+     * Offset the faces of the mesh.
+     * @param source original mesh
+     * @param signedOffsetDistance distance to offset
+     * @param offsetOptions angle options.  The default options are recommended.
+     * @returns shifted mesh.
+     */
+    static cloneOffset(source, signedOffsetDistance, offsetOptions = OffsetMeshOptions.create()) {
+        const strokeOptions = _curve_StrokeOptions__WEBPACK_IMPORTED_MODULE_23__.StrokeOptions.createForFacets();
+        const offsetBuilder = _PolyfaceBuilder__WEBPACK_IMPORTED_MODULE_16__.PolyfaceBuilder.create(strokeOptions);
+        _multiclip_OffsetMeshContext__WEBPACK_IMPORTED_MODULE_31__.OffsetMeshContext.buildOffsetMeshWithEdgeChamfers(source, offsetBuilder, signedOffsetDistance, offsetOptions);
+        return offsetBuilder.claimPolyface();
     }
 }
 // amount of computation to do per step of async methods.
@@ -245016,6 +245239,1064 @@ class LinearSearchRange2dArray {
 }
 
 
+/***/ }),
+
+/***/ "../../core/geometry/lib/esm/polyface/multiclip/OffsetMeshContext.js":
+/*!***************************************************************************!*\
+  !*** ../../core/geometry/lib/esm/polyface/multiclip/OffsetMeshContext.js ***!
+  \***************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "FacetOffsetProperties": () => (/* binding */ FacetOffsetProperties),
+/* harmony export */   "OffsetMeshContext": () => (/* binding */ OffsetMeshContext),
+/* harmony export */   "SectorOffsetProperties": () => (/* binding */ SectorOffsetProperties)
+/* harmony export */ });
+/* harmony import */ var _numerics_Polynomials__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../../numerics/Polynomials */ "../../core/geometry/lib/esm/numerics/Polynomials.js");
+/* harmony import */ var _geometry3d_GrowableXYZArray__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../geometry3d/GrowableXYZArray */ "../../core/geometry/lib/esm/geometry3d/GrowableXYZArray.js");
+/* harmony import */ var _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../geometry3d/Point3dVector3d */ "../../core/geometry/lib/esm/geometry3d/Point3dVector3d.js");
+/* harmony import */ var _geometry3d_PolygonOps__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../../geometry3d/PolygonOps */ "../../core/geometry/lib/esm/geometry3d/PolygonOps.js");
+/* harmony import */ var _geometry3d_Ray3d__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../../geometry3d/Ray3d */ "../../core/geometry/lib/esm/geometry3d/Ray3d.js");
+/* harmony import */ var _topology_Graph__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../topology/Graph */ "../../core/geometry/lib/esm/topology/Graph.js");
+/* harmony import */ var _topology_HalfEdgeGraphFromIndexedLoopsContext__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../../topology/HalfEdgeGraphFromIndexedLoopsContext */ "../../core/geometry/lib/esm/topology/HalfEdgeGraphFromIndexedLoopsContext.js");
+/* harmony import */ var _Geometry__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../Geometry */ "../../core/geometry/lib/esm/Geometry.js");
+/* harmony import */ var _geometry3d_PolylineCompressionByEdgeOffset__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../../geometry3d/PolylineCompressionByEdgeOffset */ "../../core/geometry/lib/esm/geometry3d/PolylineCompressionByEdgeOffset.js");
+/* harmony import */ var _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ../../geometry3d/Angle */ "../../core/geometry/lib/esm/geometry3d/Angle.js");
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Polyface
+ */
+
+
+
+
+
+
+
+
+
+
+function isDefinedAndTrue(value) {
+    if (value === undefined)
+        return false;
+    return value;
+}
+class AverageNormalData {
+    constructor() {
+        this.numActiveSectors = 0;
+        this.numInactiveSectors = 0; // exterior and sling.
+        this.averageNormal = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_0__.Vector3d.create();
+        this.radiansSum = 0.0;
+        this.maxDeviationRadiansFromAverage = 0.0;
+    }
+    clear() {
+        this.numActiveSectors = 0;
+        this.numInactiveSectors = 0; // exterior and sling.
+        this.averageNormal.setZero();
+        this.radiansSum = 0.0;
+        this.maxDeviationRadiansFromAverage = 0.0;
+    }
+    /** Add a normal to the evolving sum, scaled by radians in the corner */
+    accumulateNormal(node, normal, inactiveMask) {
+        if (node.isMaskSet(inactiveMask)) {
+            this.numInactiveSectors++;
+        }
+        else {
+            const sectorSweepRadians = _topology_Graph__WEBPACK_IMPORTED_MODULE_1__.HalfEdge.sectorSweepRadiansXYZ(node, normal);
+            this.averageNormal.addScaledInPlace(normal, sectorSweepRadians);
+            this.radiansSum += sectorSweepRadians;
+            this.numActiveSectors++;
+        }
+    }
+    /** normalize the accumulated normals. */
+    finishNormalAveraging() {
+        if (this.numActiveSectors > 0 && this.averageNormal.normalizeInPlace()) {
+            return true;
+        }
+        return false;
+    }
+    /** Compute the deviation from average.   update max deviation member */
+    recordDeviation(normal, isActive) {
+        if (isActive) {
+            const radians = this.averageNormal.radiansTo(normal);
+            this.maxDeviationRadiansFromAverage = Math.max(Math.abs(this.maxDeviationRadiansFromAverage), radians);
+        }
+        else {
+        }
+    }
+    /** Return the max deviation as computed on prior calls to recordDeviation */
+    get maxDeviationRadians() { return this.maxDeviationRadiansFromAverage; }
+}
+function emitSector(sector) {
+    if (OffsetMeshContext.stringDebugFunction !== undefined) {
+        OffsetMeshContext.stringDebugFunction(`    Sector xyz    ${sector.xyz.x},${sector.xyz.y},${sector.xyz.z} `);
+        OffsetMeshContext.stringDebugFunction(`           normal ${sector.normal.x},${sector.normal.y},${sector.normal.z} `);
+    }
+}
+// facet properties used during offset.
+//
+class FacetOffsetProperties {
+    constructor(facetIndex, normal) {
+        this.facetIndex = facetIndex;
+        this.facetNormal = normal;
+    }
+}
+/**
+ * Sector properties during offset.
+ * * this.normal may be initially assigned as the facet normal but can mutate by
+ *     averaging with neighbors.
+ * * this.xyz is initially the base mesh xyz but is expected to move along the normal.
+ * * this.count is used locally in computations.
+ */
+class SectorOffsetProperties {
+    constructor(normal, xyz) {
+        this.xyz = xyz;
+        this.normal = normal;
+        this.count = 0;
+    }
+    /**
+     * Compute the angle between plane normals on opposite sides of the edge.
+     * * parallel normals have zero angle.
+     * * if the edge cuts inward to the volume behind the faces, the angle is negative.
+     * * if the edge is outward (a convex edge) the the volume, the angle is positive.
+     * @param edgeNodeA node on one side of the edge
+     * @param edgeVector pre-allocated vector to receive vector along edge.
+     * @param averageNormal pre-allocated vector to receive the average normal for a chamfer of the offset edge.
+     * @param offsetDistance distance of offset being constructed.  The sign of this resolves angle ambiguity.
+     * @param radiansTolerance tolerance for large angle between normals.
+     * @returns true if this edge has SectorOffsetProperties on both sides and the angle between normals angle exceeds radiansTolerance.
+     */
+    static edgeHasLargeExteriorAngleBetweenNormals(edgeNodeA, edgeVector, averageNormal, offsetDistance, radiansTolerance = Math.PI * 0.5) {
+        const propsA = edgeNodeA.edgeTag;
+        const edgeNodeB = edgeNodeA.edgeMate;
+        const propsB = edgeNodeB.edgeTag;
+        if (propsA !== undefined && propsB !== undefined) {
+            edgeNodeA.vectorToFaceSuccessor(edgeVector);
+            const radians = propsA.normal.signedRadiansTo(propsB.normal, edgeVector);
+            if (_Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.split3WaySign(offsetDistance, -1, 1, 1) * radians >= radiansTolerance) {
+                _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_0__.Vector3d.createAdd2Scaled(propsA.normal, 1.0, propsB.normal, 1.0, averageNormal);
+                if (averageNormal.normalizeInPlace())
+                    return true;
+            }
+        }
+        return false;
+    }
+    static almostEqualNormals(sectorA, sectorB, radiansTolerance = _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.smallAngleRadians) {
+        return sectorA.normal.radiansTo(sectorB.normal) <= radiansTolerance;
+    }
+    static radiansBetweenNormals(sectorA, sectorB) {
+        return sectorA.normal.radiansTo(sectorB.normal);
+    }
+    // Set the offset point this.xyz as sum of the nodeXyz + distance * this.normal
+    setOffsetPointAtDistanceAtHalfEdge(halfEdge, distance) {
+        halfEdge.getPoint3d(this.xyz);
+        this.xyz.addScaledInPlace(this.normal, distance);
+    }
+    // Copy xyz from parameter into (preexisting object) xyz
+    static setXYZAtHalfEdge(halfEdge, xyz) {
+        const props = halfEdge.edgeTag;
+        if (props !== undefined && xyz !== undefined)
+            props.xyz.set(xyz.x, xyz.y, xyz.z);
+    }
+    // Set the offset point this.xyz directly
+    setXYAndZ(xyz) {
+        this.xyz.set(xyz.x, xyz.y, xyz.z);
+    }
+    // Look through the half edge to its properties.  Set the normal there.  Optionally set xyz from node xyz and offset distance
+    static setNormalAtHalfEdge(halfEdge, uvw, distance) {
+        const props = halfEdge.edgeTag;
+        if (props !== undefined) {
+            props.normal.set(uvw.x, uvw.y, uvw.z);
+            if (distance !== undefined)
+                props.setOffsetPointAtDistanceAtHalfEdge(halfEdge, distance);
+        }
+    }
+    // Look through the half edge and its vertex successor to properties.  Get the two normals. Return the angle sweeping from one to the next
+    static sweepRadiansAroundNormal(nodeA, upVector) {
+        const propsA = nodeA.edgeTag;
+        const propsB = nodeA.vertexSuccessor.edgeTag;
+        if (propsA !== undefined && propsB !== undefined) {
+            return propsA.normal.planarRadiansTo(propsB.normal, upVector);
+        }
+        return undefined;
+    }
+    // Look through the half edge to its properties.  return (if possible) the coordinates
+    static getSectorPointAtHalfEdge(halfEdge, xyz, xyzArray) {
+        const props = halfEdge.edgeTag;
+        if (props !== undefined) {
+            if (xyz !== undefined)
+                xyz.setFromPoint3d(props.xyz);
+            if (xyzArray !== undefined)
+                xyzArray.push(props.xyz);
+            return true;
+        }
+        return false;
+    }
+    // access the XYZ and push to the array (which makes copies, not reference)
+    // return pointer to the SectorOffsetProperties
+    static pushXYZ(xyzArray, halfEdge) {
+        const sector = halfEdge.edgeTag;
+        if (sector !== undefined)
+            xyzArray.push(sector.xyz);
+        return sector;
+    }
+    // Dereference to execute:       accumulatingVector += halfEdge.edgeTag.normal * scale
+    static accumulateScaledNormalAtHalfEdge(halfEdge, scale, accumulatingVector) {
+        const sector = halfEdge.edgeTag;
+        if (sector !== undefined)
+            accumulatingVector.addScaledInPlace(sector.normal, scale);
+    }
+}
+/*
+About Chamfer Edges ..... as constructed in addChamferTopologyToAllEdges
+
+When edge vertex X to vertex Y has a sharp angle between normals, a "chamfer face" must be created to "fatten" it.
+
+The original half edges (nodes) for the edge are AX and AY.  These are "mates" in the halfEdge mental model. As always,
+AX is (as needed)
+   (i) the preferred half edge for the left side of the edge moving from X to Y. (i.e. above the edge)
+   (ii) a part of the face loop for the face to the left when proceeding CCW around the face to the above the drawn edge
+   (iii) a part of the vertex loop around X
+Likewise, AY is (as needed)
+   (i) the preferred half edge for the left side of the edge moving from Y to X (i.e. below the edge)
+   (ii) a part of the face loop for the face to the left of the edge when proceeding CCW around the face below the edge.
+   (iii) a part of the vertex loop around Y
+
+      AX------>
+X______________________________________________________________________Y
+                                                      <---AY
+
+When the chamfer face is created, it needs to have a sliver face "inside the edge" -- something in the space here
+
+      AX------>
+  _____________________________________________________________________
+ /                                                                     \
+X                                                                       Y
+ \_____________________________________________________________________/
+                                                      <---AY
+
+The chamfer face will have a plane normal is the average of the two faces' plane normals.
+
+The creation sequence for the chamfer face puts a slit "inside the edge" as above   HalfEdges AX and AY remain as parts
+of their respective face loops.   In addition, at each end a singleton edge "sling" face is inserted at each
+end of the sliver face.
+
+The sequence is:
+
+  STEP 1: splitEdgeCreateSliver creates the sliver face with 2 half edges DX and DY
+  STEP 2: splitEdge (with undefined as the "prior" edge) creates a sling with HalfEdge CX "inside" and BX "outside".
+             (The sling face is not yet attached to X -- briefly floating in space)
+  STEP 3: pinch of HalfEdges BX and DX inserts the sling face "inside" the slit face at the X end.
+
+  Steps 2 and 3 are executed from each end.   Due to the symmetric structure, a 2-pass loop can apply the logic at each end without distinct names in code.
+
+         AX------>
+     _______________________________________________________________
+    /                                              <---DY           \
+   /                                                                 \
+  /    BX--->                                                         \
+ / _______________                                    _______________  \
+| /               \                                  /     <----CY   \ |
+|/                 \                                /                 \|
+X                   |                              |                   Y
+|\   CX--->         /                               \                 /|
+| \_______________/                                  \_______________/ |
+ \                                                         <---BY     /
+  \                                                                   /
+   \      DX--->                                                     /
+    \ ______________________________________________________________/
+                                                    <---AY
+
+During the construction, the letters ABCD are used as above, but with prefixes emphasizing their role
+outsideAX, outsideAY
+slingB, slingC, sliverD
+
+The "inside" sling faces (CX and CY) each have their own FacetOffsetProperties and SectorOffsetProperties.
+The sliver face has its own FacetOffsetProperties which are referenced by DX, BY, DY, BX.
+Each of those 4 has its own SectorOffSetProperties.
+
+Important properties during offset construction:
+1) the original graph always has original topology and coordinates
+2) Each face of the original graph has a FacetOffsetProperties with a representative point and a normal.  These are unchanged during the computation.
+3) Each node has its own SectorOffsetProperties with a coordinate and normal independent of the parent node.
+   3.1 The first offset coordinates in each node are directly offset by face normal.
+   3.2 This creates mismatch across edges and around vertices.
+   3.3 Various sweeps "around each vertex" try to do intersections among appropriate offset planes to find
+        common coordinates in place of the initial mismatches.
+4) The independence of all the sectors allows the offset construction to fix things up in any order it chooses.
+5) During the construction, the xyz in SectorOffsetProperties around a single vertex do NOT have to match.
+6) At output time, there are three sweeps:
+   6.1: By face:  Go around the face and output a facet with the coordinates in the various sectors.
+   6.2: By edge: For each edge, if the sector xyz match across both ends output nothing.  If not, output a triangle or quad
+   6.3: By vertex:  At each vertex, if all vertex coordinates match  output nothing.   Otherwise output a facet with all the coordinates.
+*/
+class OffsetMeshContext {
+    constructor(basePolyface, baseGraph, options) {
+        this._basePolyface = basePolyface;
+        this._baseGraph = baseGraph;
+        this._breakMaskA = baseGraph.grabMask();
+        this._breakMaskB = baseGraph.grabMask();
+        this._insideOfChamferFace = baseGraph.grabMask();
+        this._outsideOfChamferFace = baseGraph.grabMask();
+        this._insideChamferSling = baseGraph.grabMask();
+        this._outsideEndOfChamferFace = baseGraph.grabMask();
+        this._exteriorMask = _topology_Graph__WEBPACK_IMPORTED_MODULE_1__.HalfEdgeMask.EXTERIOR;
+        this._offsetCoordinatesReassigned = baseGraph.grabMask();
+        this._smoothRadiansBetweenNormals = options.smoothSingleAngleBetweenNormals.radians;
+        this._chamferTurnRadians = options.chamferAngleBetweenNormals.radians;
+        this._smoothAccumulatedRadiansBetweenNormals = options.smoothAccumulatedAngleBetweenNormals.radians;
+    }
+    /** "Exterior" side of a bare edge of the mesh */
+    get exteriorMask() { return this._exteriorMask; }
+    /** "First" sector of a smooth sequence. */
+    get breakMaskA() { return this._breakMaskA; }
+    /** "Last" sector of a smooth sequence. */
+    get breakMaskB() { return this._breakMaskB; }
+    /** This edge is on a chamfered face, and along the original edge */
+    get insideOfChamferFace() { return this._insideOfChamferFace; }
+    /** This is the original edge of a chamfer face */
+    get outsideOfChamferFace() { return this._outsideOfChamferFace; }
+    /** This edge is on a chamfered face, and at the end -- other side may be a sling */
+    get insideChamferSling() { return this._insideChamferSling; }
+    /** This is the outside of the end of a chamfer face -- i.e. the inside of a new face-at-vertex */
+    get outsideEndOfChamferFace() { return this._outsideEndOfChamferFace; }
+    // At each node . .
+    // * Find the sector data
+    // * recompute the sector point using node XYZ and sectorData normal.
+    applyFaceNormalOffsetsToSectorData(distance) {
+        this._baseGraph.announceNodes((_graph, node) => {
+            const sectorData = node.edgeTag;
+            if (sectorData !== undefined) {
+                sectorData.setOffsetPointAtDistanceAtHalfEdge(node, distance);
+            }
+            return true;
+        });
+    }
+    /**
+     * * build a mesh offset by given distance.
+     * * output the mesh to the given builder.
+     * @param basePolyface original mesh
+     * @param builder polyface builder to receive the new mesh.
+     * @param distance signed offset distance.
+     */
+    static buildOffsetMeshWithEdgeChamfers(basePolyface, builder, distance, options) {
+        const baseGraph = this.buildBaseGraph(basePolyface);
+        if (baseGraph !== undefined) {
+            const offsetBuilder = new OffsetMeshContext(basePolyface, baseGraph, options);
+            offsetBuilder.applyFaceNormalOffsetsToSectorData(distance);
+            if (OffsetMeshContext.graphDebugFunction !== undefined)
+                OffsetMeshContext.graphDebugFunction("BaseGraph", baseGraph, offsetBuilder._breakMaskA, offsetBuilder._breakMaskB);
+            const outputSelector = options.outputSelector ? options.outputSelector : {
+                outputOffsetsFromFaces: true,
+                outputOffsetsFromEdges: true,
+                outputOffsetsFromVertices: true,
+            };
+            if (isDefinedAndTrue(outputSelector.outputOffsetsFromFacesBeforeChamfers))
+                offsetBuilder.announceFacetsWithSectorCoordinatesAroundFaces(builder);
+            offsetBuilder.addChamferTopologyToAllEdges(options, distance);
+            offsetBuilder.computeOffsetFacetIntersections(distance);
+            if (OffsetMeshContext.graphDebugFunction !== undefined)
+                OffsetMeshContext.graphDebugFunction("after computeEdgeChamfers", baseGraph, offsetBuilder._breakMaskA, offsetBuilder._breakMaskB);
+            if (isDefinedAndTrue(outputSelector.outputOffsetsFromFaces))
+                offsetBuilder.announceFacetsWithSectorCoordinatesAroundFaces(builder);
+            if (isDefinedAndTrue(outputSelector.outputOffsetsFromEdges))
+                offsetBuilder.announceFacetsWithSectorCoordinatesAroundEdges(builder);
+            if (isDefinedAndTrue(outputSelector.outputOffsetsFromVertices))
+                offsetBuilder.announceFacetsWithSectorCoordinatesAroundVertices(builder);
+        }
+    }
+    /**
+   * For each face of the graph, shift vertices by offsetDistance and emit to the builder as a facet
+   * @param polyfaceBuilder
+   */
+    announceSimpleOffsetFromFaces(polyfaceBuilder, offsetDistance) {
+        const xyzLoop = new _geometry3d_GrowableXYZArray__WEBPACK_IMPORTED_MODULE_3__.GrowableXYZArray();
+        const xyz = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_0__.Point3d.create(); // reused at each point around each facet.
+        const uvw = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_0__.Vector3d.create(); // reused once per facet
+        const announceNodeAroundFace = (node) => {
+            node.getPoint3d(xyz);
+            xyz.addInPlace(uvw);
+            xyzLoop.push(xyz);
+            return 0;
+        };
+        this._baseGraph.announceFaceLoops((_graph, seed) => {
+            if (!seed.isMaskSet(_topology_Graph__WEBPACK_IMPORTED_MODULE_1__.HalfEdgeMask.EXTERIOR)) {
+                const facetProperties = seed.faceTag;
+                uvw.setFromVector3d(facetProperties.facetNormal.direction);
+                uvw.scaleInPlace(offsetDistance);
+                xyzLoop.length = 0;
+                seed.sumAroundFace(announceNodeAroundFace);
+                polyfaceBuilder.addPolygonGrowableXYZArray(xyzLoop);
+            }
+            return true;
+        });
+    }
+    /**
+   * For each face of the graph, output the xyz of the sector data
+   * @param polyfaceBuilder
+   */
+    announceFacetsWithSectorCoordinatesAroundFaces(polyfaceBuilder) {
+        const xyzLoop = new _geometry3d_GrowableXYZArray__WEBPACK_IMPORTED_MODULE_3__.GrowableXYZArray();
+        // For face loop visits .. get the point from the sector data.
+        const announceNodeAroundFace = (node) => {
+            const sectorData = node.edgeTag;
+            if (sectorData !== undefined) {
+                xyzLoop.push(sectorData.xyz);
+            }
+            return 0;
+        };
+        this._baseGraph.announceFaceLoops((_graph, seed) => {
+            if (!seed.isMaskSet(_topology_Graph__WEBPACK_IMPORTED_MODULE_1__.HalfEdgeMask.EXTERIOR)) {
+                xyzLoop.length = 0;
+                seed.sumAroundFace(announceNodeAroundFace);
+                if (xyzLoop.length > 2)
+                    polyfaceBuilder.addPolygonGrowableXYZArray(xyzLoop);
+            }
+            return true;
+        });
+    }
+    countBits(mask) {
+        let n = 0;
+        let mask1 = mask;
+        while (mask1 !== 0) {
+            if (mask1 & 0x01)
+                n++;
+            mask1 = mask1 >> 1;
+        }
+        return n;
+    }
+    /**
+   * For each edge of the graph . .
+   * * Collect coordinates in 4 sectors going around the edge
+   * * Compress with tight tolerance so adjacent sectors with clean point match reduce to a single point.
+   * * Emit as a facet.
+   * @param polyfaceBuilder
+   */
+    announceFacetsWithSectorCoordinatesAroundEdges(polyfaceBuilder) {
+        const xyzLoop = new _geometry3d_GrowableXYZArray__WEBPACK_IMPORTED_MODULE_3__.GrowableXYZArray();
+        const primaryCompressionTolerance = _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.smallMetricDistance;
+        const allMasksForEdgesToIgnore = this._exteriorMask
+            | this._outsideEndOfChamferFace
+            | this._outsideOfChamferFace
+            | this._insideOfChamferFace
+            | this._insideChamferSling;
+        this._baseGraph.announceEdges((_graph, nodeA) => {
+            // This starts by looking for EXTERIOR on both sides ...
+            if (nodeA.findMaskAroundEdge(this._exteriorMask) !== undefined) {
+                return true;
+            }
+            else if (!nodeA.isMaskSet(allMasksForEdgesToIgnore)) { // By design, we believe that these two test for  allMasksForEdgesToIgnore condition would catch the EXTERIOR case above
+                const nodeB = nodeA.faceSuccessor;
+                const nodeC = nodeA.edgeMate;
+                if (!nodeC.isMaskSet(allMasksForEdgesToIgnore)) {
+                    const nodeD = nodeC.faceSuccessor;
+                    xyzLoop.clear();
+                    SectorOffsetProperties.getSectorPointAtHalfEdge(nodeA, undefined, xyzLoop);
+                    SectorOffsetProperties.getSectorPointAtHalfEdge(nodeB, undefined, xyzLoop);
+                    SectorOffsetProperties.getSectorPointAtHalfEdge(nodeC, undefined, xyzLoop);
+                    SectorOffsetProperties.getSectorPointAtHalfEdge(nodeD, undefined, xyzLoop);
+                    _geometry3d_PolylineCompressionByEdgeOffset__WEBPACK_IMPORTED_MODULE_4__.PolylineCompressionContext.compressInPlaceByShortEdgeLength(xyzLoop, primaryCompressionTolerance);
+                    if (xyzLoop.length > 2) {
+                        polyfaceBuilder.addPolygonGrowableXYZArray(xyzLoop);
+                    }
+                }
+            }
+            else {
+                return true;
+            }
+            return true;
+        });
+    }
+    getCoordinateString(node, showXYZ = true, showFaceSuccessorXYZ = false) {
+        if (showXYZ) {
+            if (showFaceSuccessorXYZ) {
+                return `${_topology_Graph__WEBPACK_IMPORTED_MODULE_1__.HalfEdge.nodeToIdXYZString(node)} ==> ${_topology_Graph__WEBPACK_IMPORTED_MODULE_1__.HalfEdge.nodeToIdXYZString(node.faceSuccessor)}`;
+            }
+            else {
+                return `${_topology_Graph__WEBPACK_IMPORTED_MODULE_1__.HalfEdge.nodeToIdXYZString(node)}`;
+            }
+        }
+        else {
+            if (showFaceSuccessorXYZ) {
+                return `==> ${_topology_Graph__WEBPACK_IMPORTED_MODULE_1__.HalfEdge.nodeToIdXYZString(node.faceSuccessor)}`;
+            }
+            else {
+                return "";
+            }
+        }
+    }
+    inspectMasks(node, showXYZ = true, showFaceSuccessorXYZ = false) {
+        const s = "[";
+        const v = s.concat(node.id.toString(), node.isMaskSet(this._exteriorMask) ? "X" : "", node.isMaskSet(this.breakMaskA) ? "A" : "", node.isMaskSet(this.breakMaskB) ? "B" : "", node.isMaskSet(this.insideChamferSling) ? "(sling)" : "", node.isMaskSet(this.insideOfChamferFace) ? "(in chamfer)" : "", node.isMaskSet(this.outsideEndOfChamferFace) ? "(@sling)" : "", node.isMaskSet(this.outsideOfChamferFace) ? "(@chamfer)" : "", this.getCoordinateString(node, showXYZ, showFaceSuccessorXYZ), "]");
+        return v;
+    }
+    /**
+   * For each face of the graph, output the xyz of the sector data
+   * @param polyfaceBuilder
+   */
+    announceFacetsWithSectorCoordinatesAroundVertices(polyfaceBuilder) {
+        const xyzLoop = new _geometry3d_GrowableXYZArray__WEBPACK_IMPORTED_MODULE_3__.GrowableXYZArray();
+        const primaryCompressionTolerance = _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.smallMetricDistance;
+        this._baseGraph.announceVertexLoops((_graph, seed) => {
+            if (!seed.findMaskAroundVertex(this._exteriorMask)) {
+                xyzLoop.length = 0;
+                seed.sumAroundVertex((node) => {
+                    if (!node.isMaskSet(this._insideChamferSling))
+                        SectorOffsetProperties.getSectorPointAtHalfEdge(node, undefined, xyzLoop);
+                    return 0.0;
+                });
+                _geometry3d_PolylineCompressionByEdgeOffset__WEBPACK_IMPORTED_MODULE_4__.PolylineCompressionContext.compressInPlaceByShortEdgeLength(xyzLoop, primaryCompressionTolerance);
+                if (xyzLoop.length > 2) {
+                    polyfaceBuilder.addPolygonGrowableXYZArray(xyzLoop);
+                }
+            }
+            return true;
+        });
+    }
+    /**
+       * * Exterior half edges have HalfEdgeMask.EXTERIOR
+       * * All interior half edge around a facet have facetTag pointing to a facetProperties object for that facet.
+       *    * the facetOffsetProperties object has the simple facet normal.
+       * * Each half edge has edgeTag pointing to to a sectorOffsetProperties object
+       *    * the sectorOffsetProperties has a copy of the facet normal.
+       * @param polyface
+       * @returns graph
+       */
+    static buildBaseGraph(polyface) {
+        const graphBuilder = new _topology_HalfEdgeGraphFromIndexedLoopsContext__WEBPACK_IMPORTED_MODULE_5__.HalfEdgeGraphFromIndexedLoopsContext();
+        const visitor = polyface.createVisitor();
+        const xyzA = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_0__.Point3d.create();
+        const xyzB = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_0__.Point3d.create();
+        for (visitor.reset(); visitor.moveToNextFacet();) {
+            const normal = _geometry3d_PolygonOps__WEBPACK_IMPORTED_MODULE_6__.PolygonOps.centroidAreaNormal(visitor.point);
+            if (normal !== undefined) {
+                const edgeA = graphBuilder.insertLoop(visitor.pointIndex, (insideHalfEdge) => {
+                    const mate = insideHalfEdge.edgeMate;
+                    polyface.data.getPoint(insideHalfEdge.i, xyzA);
+                    insideHalfEdge.setXYZ(xyzA);
+                    polyface.data.getPoint(mate.i, xyzB);
+                    mate.setXYZ(xyzB);
+                });
+                const facetProperties = new FacetOffsetProperties(visitor.currentReadIndex(), normal);
+                if (edgeA !== undefined) {
+                    edgeA.sumAroundFace((edgeB) => {
+                        edgeB.faceTag = facetProperties;
+                        edgeB.edgeTag = new SectorOffsetProperties(normal.direction.clone(), edgeB.getPoint3d());
+                        return 0;
+                    });
+                }
+            }
+        }
+        return graphBuilder.graph;
+    }
+    setOffsetAtDistanceAroundVertex(vertexSeed, distance, ignoreChamfers = false) {
+        vertexSeed.sumAroundVertex((nodeAroundVertex) => {
+            const props = nodeAroundVertex.edgeTag;
+            if (props !== undefined) {
+                if (ignoreChamfers && this.isInsideChamferOrSling(vertexSeed)) {
+                    // SKIP !!
+                }
+                else {
+                    props.setOffsetPointAtDistanceAtHalfEdge(nodeAroundVertex, distance);
+                }
+            }
+            return 0.0;
+        });
+    }
+    setOffsetXYAndZAroundVertex(vertexSeed, xyz) {
+        vertexSeed.sumAroundVertex((nodeAroundVertex) => {
+            const props = nodeAroundVertex.edgeTag;
+            if (props !== undefined) {
+                props.setXYAndZ(xyz);
+                nodeAroundVertex.setMask(this._offsetCoordinatesReassigned);
+            }
+            return 0.0;
+        });
+    }
+    /**
+    *  * start at vertexSeed.
+    *  * set the offset point at up to (and including) one with (a) this._breakMaskB or (b) this._exteriorMask
+    *  *
+    * @param vertexSeed first node to mark.
+    * @param f function to call to announce each node and its sector properties.
+    * @returns number of nodes marked.
+    */
+    announceNodeAndSectorPropertiesInSmoothSector(vertexSeed, f) {
+        let n = 0;
+        for (let currentNode = vertexSeed;; currentNode = currentNode.vertexSuccessor) {
+            const props = currentNode.edgeTag;
+            if (props !== undefined) {
+                f(currentNode, props);
+                n++;
+            }
+            if (currentNode.isMaskSet(this._breakMaskB))
+                return n;
+            // REMARK: these additional exit conditions should not happen if (a) the graph is properly marked and (b) the start node is not exterior.
+            if (currentNode.isMaskSet(this._exteriorMask))
+                return n;
+            if (currentNode === vertexSeed && n === 0)
+                return n;
+        }
+    }
+    computeAverageNormalAndMaxDeviationAroundVertex(vertexSeed, data) {
+        data.clear();
+        const inactiveNodeMask = this._exteriorMask | this._insideChamferSling;
+        vertexSeed.sumAroundVertex((node) => {
+            const sectorData = node.edgeTag;
+            if (sectorData)
+                data.accumulateNormal(node, sectorData.normal, inactiveNodeMask);
+            return 0.0;
+        });
+        if (!data.finishNormalAveraging()) {
+            return undefined;
+        }
+        vertexSeed.sumAroundVertex((node) => {
+            const sectorData = node.edgeTag;
+            if (sectorData)
+                data.recordDeviation(sectorData.normal, !node.isMaskSet(inactiveNodeMask));
+            return 0.0;
+        });
+        return data.maxDeviationRadians;
+    }
+    assignOffsetByAverageNormalAroundVertex(vertexSeed, maxAllowedDeviationRadians, data, distance) {
+        const maxDeviationRadians = this.computeAverageNormalAndMaxDeviationAroundVertex(vertexSeed, data);
+        if (OffsetMeshContext.stringDebugFunction) {
+            OffsetMeshContext.stringDebugFunction(`XYZ ${_topology_Graph__WEBPACK_IMPORTED_MODULE_1__.HalfEdge.nodeToIdXYZString(vertexSeed)} Average Normal ${data.averageNormal.toJSON()}`);
+            OffsetMeshContext.stringDebugFunction(`           angle ratio ${data.radiansSum / (2 * Math.PI)}   maxDeviation ${data.maxDeviationRadiansFromAverage}`);
+        }
+        if (maxDeviationRadians !== undefined && maxDeviationRadians <= maxAllowedDeviationRadians) {
+            vertexSeed.sumAroundVertex((node) => {
+                SectorOffsetProperties.setNormalAtHalfEdge(node, data.averageNormal, distance);
+                return 0;
+            });
+            return true;
+        }
+        return false;
+    }
+    /** Search around a vertex for a sector which has a different normal from its vertexPredecessor.
+     * * The seed will be the first candidate considered
+    */
+    markBreakEdgesAndSaveAverageNormalsAroundVertex(vertexSeed) {
+        vertexSeed.clearMaskAroundVertex(this._breakMaskA);
+        vertexSeed.clearMaskAroundVertex(this._breakMaskB);
+        const smoothSingleSmoothRadiansBetweenNormals = this._smoothRadiansBetweenNormals;
+        const accumulatedRadiansBetweenNormals = this._smoothAccumulatedRadiansBetweenNormals;
+        // Step 1: Examine the edge between nodeA and the sector on its vertex predecessor side.  This (alone) determines single angle breaks.
+        let numBreaks = 0;
+        let nodeP = vertexSeed;
+        let _numSmooth = 0;
+        do {
+            const nodeQ = nodeP.edgeMate;
+            const nodeR = nodeQ.faceSuccessor; // same as nodeA.vertexPredecessor
+            if (nodeP.isMaskSet(this._exteriorMask)) {
+                if (!nodeQ.isMaskSet(this._exteriorMask)) {
+                    nodeR.setMask(this._breakMaskB);
+                    numBreaks++;
+                }
+            }
+            else {
+                if (nodeP.isMaskSet(this._outsideOfChamferFace)) {
+                    nodeP.setMask(this._breakMaskA);
+                }
+                else if (nodeP.isMaskSet(this._outsideEndOfChamferFace)) {
+                    nodeP.setMask(this._breakMaskA);
+                    nodeP.setMask(this._breakMaskB);
+                }
+                else if (nodeP.isMaskSet(this._insideChamferSling)) {
+                    // This is the sling.   It's normal is along edge -- not really a break.
+                }
+                else if (nodeP.isMaskSet(this._insideOfChamferFace)) {
+                    nodeP.setMask(this._breakMaskA);
+                    nodeP.setMask(this._breakMaskB);
+                    nodeR.setMask(this._breakMaskB);
+                }
+                else if (nodeQ.isMaskSet(this._exteriorMask)) {
+                    numBreaks++;
+                    nodeP.setMask(this._breakMaskA);
+                }
+                else if (!SectorOffsetProperties.almostEqualNormals(nodeP.edgeTag, nodeR.edgeTag, smoothSingleSmoothRadiansBetweenNormals)) {
+                    nodeP.setMask(this._breakMaskA);
+                    numBreaks++;
+                    nodeR.setMask(this._breakMaskB);
+                }
+                else {
+                    _numSmooth++;
+                }
+            }
+            nodeP = nodeP.vertexSuccessor;
+        } while (nodeP !== vertexSeed);
+        if (OffsetMeshContext.stringDebugFunction !== undefined)
+            OffsetMeshContext.stringDebugFunction(`   numSkip   ${_numSmooth} `);
+        if (numBreaks === 0) {
+            // make the first vertex a break so subsequent searches have a place to start
+            vertexSeed.setMask(this._breakMaskA);
+            vertexSeed.vertexPredecessor.setMask(this._breakMaskB);
+            numBreaks = 1;
+        }
+        // Step 2: At each single break, sweep forward to its closing breakB.  Insert breaks at accumulated angles.
+        // (minor TODO: for the insertion case, try to split more equally.)
+        const nodeAStart = nodeP.findMaskAroundVertex(this._breakMaskA);
+        if (nodeAStart !== undefined) {
+            nodeP = nodeAStart;
+            do {
+                if (nodeP.isMaskSet(this._breakMaskA) && !nodeP.isMaskSet(this._breakMaskB)) {
+                    let accumulatedRadians = 0.0;
+                    do {
+                        const nodeB = nodeP.vertexSuccessor;
+                        accumulatedRadians += SectorOffsetProperties.radiansBetweenNormals(nodeP.edgeTag, nodeB.edgeTag);
+                        if (accumulatedRadians > accumulatedRadiansBetweenNormals) {
+                            nodeP.setMask(this._breakMaskB);
+                            nodeB.setMask(this._breakMaskA);
+                            numBreaks++;
+                            accumulatedRadians = 0.0;
+                        }
+                        nodeP = nodeB;
+                    } while (!nodeP.isMaskSet(this._breakMaskB));
+                }
+                else {
+                    nodeP = nodeP.vertexSuccessor;
+                }
+            } while (nodeP !== nodeAStart);
+        }
+        if (numBreaks > 0 && nodeAStart !== undefined) {
+            // In each compound sector, accumulate and install average normal.
+            nodeP = nodeAStart;
+            const averageNormal = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_0__.Vector3d.create();
+            const edgeVectorU = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_0__.Vector3d.create();
+            const edgeVectorV = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_0__.Vector3d.create();
+            averageNormal.setZero();
+            do {
+                if (nodeP.isMaskSet(this._breakMaskA) && !nodeP.isMaskSet(this._breakMaskB)) {
+                    let nodeQ = nodeP;
+                    averageNormal.setZero();
+                    for (;;) {
+                        nodeQ.vectorToFaceSuccessor(edgeVectorU);
+                        nodeQ.vectorToFacePredecessor(edgeVectorV);
+                        let singleSectorRadians = edgeVectorU.signedRadiansTo(edgeVectorV, nodeQ.faceTag.facetNormal.direction);
+                        if (singleSectorRadians < 0.0)
+                            singleSectorRadians += Math.PI * 2;
+                        SectorOffsetProperties.accumulateScaledNormalAtHalfEdge(nodeQ, singleSectorRadians, averageNormal);
+                        if (nodeQ.isMaskSet(this._breakMaskB))
+                            break;
+                        nodeQ = nodeQ.vertexSuccessor;
+                    }
+                    if (averageNormal.normalizeInPlace()) {
+                        nodeQ = nodeP;
+                        for (;;) {
+                            SectorOffsetProperties.setNormalAtHalfEdge(nodeQ, averageNormal);
+                            if (nodeQ.isMaskSet(this._breakMaskB))
+                                break;
+                            nodeQ = nodeQ.vertexSuccessor;
+                        }
+                    }
+                }
+                nodeP = nodeP.vertexSuccessor;
+            } while (nodeP !== nodeAStart);
+        }
+    }
+    /** Compute the point of intersection of the planes in the sectors of 3 half edges */
+    compute3SectorIntersection(nodeA, nodeB, nodeC, result) {
+        const sectorA = nodeA.edgeTag;
+        const sectorB = nodeB.edgeTag;
+        const sectorC = nodeC.edgeTag;
+        const vector = _numerics_Polynomials__WEBPACK_IMPORTED_MODULE_7__.SmallSystem.intersect3Planes(sectorA.xyz, sectorA.normal, sectorB.xyz, sectorB.normal, sectorC.xyz, sectorC.normal, result);
+        return vector;
+    }
+    /** Compute the point of intersection of the planes in the sectors of 3 half edges */
+    compute3SectorIntersectionDebug(nodeA, nodeB, nodeC, result) {
+        const sectorA = nodeA.edgeTag;
+        const sectorB = nodeB.edgeTag;
+        const sectorC = nodeC.edgeTag;
+        if (OffsetMeshContext.stringDebugFunction !== undefined) {
+            OffsetMeshContext.stringDebugFunction(`compute3${this.inspectMasks(nodeA)}${this.inspectMasks(nodeB)}${this.inspectMasks(nodeC)} `);
+            for (const sector of [sectorA, sectorB, sectorC])
+                emitSector(sector);
+        }
+        const vector = _numerics_Polynomials__WEBPACK_IMPORTED_MODULE_7__.SmallSystem.intersect3Planes(sectorA.xyz, sectorA.normal, sectorB.xyz, sectorB.normal, sectorC.xyz, sectorC.normal, result);
+        if (OffsetMeshContext.stringDebugFunction !== undefined) {
+            if (vector === undefined)
+                OffsetMeshContext.stringDebugFunction(" NO INTERSECTION");
+            else
+                OffsetMeshContext.stringDebugFunction(` ComputedVector ${vector.x},${vector.y},${vector.z} `);
+        }
+        return vector;
+    }
+    /** Compute the point of intersection of the planes in the sectors of 2 half edges, using cross product of their normals to resolve */
+    compute2SectorIntersection(nodeA, nodeB, result) {
+        const sectorA = nodeA.edgeTag;
+        const sectorB = nodeB.edgeTag;
+        const normalC = sectorA.normal.crossProduct(sectorB.normal);
+        return _numerics_Polynomials__WEBPACK_IMPORTED_MODULE_7__.SmallSystem.intersect3Planes(sectorA.xyz, sectorA.normal, sectorB.xyz, sectorB.normal, sectorB.xyz, normalC, result);
+    }
+    /**
+     * * at input, graph has all original faces and edges
+     *   * each sector points to a faceProperties with original facet normal
+     * * at exit:
+     *    * new "chamfer faces" are added outside of edges with angle between normal sin excess of options.chamferTurnAngleBetweenNormals
+     *    * the original edge is split along its length to create space
+     *      * one edge "along" each direction inside the slit.
+     *      * a sling edge at each end of the slit.
+     *          * outside of the sling is part of the slit face loop.
+     *          * inside is a single-node face
+     *    * thus the slit itself has 4 nodes.
+     *    * the two nodes at each end can thus contain the two distinct points at that end of the chamfer.
+     *    * all 4 nodes of the slit face point to a new FacetOffsetProperties with the average normal.
+     *    * the inside of each sling face has
+     *        * original vertex coordinates in the node
+     *        * face properties with a normal pointing outward from that end of the original edge -- hence define a plane that can clip the chamfer
+     *    * the two points at each end of the chamfer are computed as the intersection of
+     *        * chamfer plane
+     *        * sling plane
+     *        * adjacent plane of the face on the other side of the edge being chamfered.
+     * @param distance distance to offset.  The sign of this is important in the chamfer construction.
+     */
+    addChamferTopologyToAllEdges(options, distance) {
+        const edgesToChamfer = [];
+        const chamferRadians = options.chamferAngleBetweenNormals.radians;
+        const vertexXYZ = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_0__.Point3d.create(); // reuse
+        const edgeVector = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_0__.Vector3d.create(); // reuse
+        const outwardEdgeVector = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_0__.Vector3d.create(); // reuse
+        const averageNormal = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_0__.Vector3d.create(); // reuse
+        // collect all the edges with sharp turn angle.
+        this._baseGraph.announceEdges((_graph, edgeNode) => {
+            if (SectorOffsetProperties.edgeHasLargeExteriorAngleBetweenNormals(edgeNode, edgeVector, averageNormal, distance, chamferRadians)) {
+                edgesToChamfer.push(edgeNode);
+                return true;
+            }
+            return true;
+        });
+        // Create sliver faces.
+        // Sliver face gets an average normal from its neighbors.
+        //  outsideA is the HalfEdge labeled A in the diagram.
+        // sliverDX and sliverDY are the edges "inside the sliver" at the respective X and Y ends.
+        for (const outsideA of edgesToChamfer) {
+            // remark: this recomputes as in collection round.
+            if (SectorOffsetProperties.edgeHasLargeExteriorAngleBetweenNormals(outsideA, edgeVector, averageNormal, chamferRadians)) {
+                // This copies coordinates and vertex id .... sectorOffsetProperties are delayed until late in the 2-pass loop below.
+                // The returned HalfEdge is labeled D in the diagram
+                const sliverDX = this._baseGraph.splitEdgeCreateSliverFace(outsideA);
+                const sliverDY = sliverDX.facePredecessor;
+                const offsetPoint = sliverDX.getPoint3d();
+                offsetPoint.addScaledInPlace(averageNormal, distance);
+                const ray = _geometry3d_Ray3d__WEBPACK_IMPORTED_MODULE_8__.Ray3d.createCapture(offsetPoint, averageNormal.clone());
+                const facetProperties = new FacetOffsetProperties(-1, ray);
+                // for each side (hence end) of the sliver face, set mask and install a sling loop for the anticipated end of the chamfer face
+                // new node names in the loop omit X or Y suffix because that is implied by which pass is running.
+                let s = -1.0;
+                for (const sliverD of [sliverDX, sliverDY]) {
+                    edgeVector.scale(s, outwardEdgeVector);
+                    sliverD.getPoint3d(vertexXYZ);
+                    sliverD.setMask(this._insideOfChamferFace);
+                    sliverD.edgeMate.setMask(this._outsideOfChamferFace);
+                    // mark and reference the chamfer face.
+                    sliverD.faceTag = facetProperties;
+                    // sling at this end
+                    const slingB = this._baseGraph.splitEdge(undefined, vertexXYZ.x, vertexXYZ.y, vertexXYZ.z, sliverD.i);
+                    const slingC = slingB.edgeMate;
+                    slingB.setMask(this._outsideEndOfChamferFace);
+                    slingB.faceTag = facetProperties;
+                    slingC.setMask(this._insideChamferSling);
+                    _topology_Graph__WEBPACK_IMPORTED_MODULE_1__.HalfEdge.pinch(sliverD, slingB);
+                    const endNormal = _geometry3d_Ray3d__WEBPACK_IMPORTED_MODULE_8__.Ray3d.create(vertexXYZ, outwardEdgeVector); // clones the inputs
+                    const slingFaceProperties = new FacetOffsetProperties(-1, endNormal);
+                    slingC.faceTag = slingFaceProperties;
+                    // initialize sectors with existing vertex point.
+                    sliverD.edgeTag = new SectorOffsetProperties(averageNormal.clone(), offsetPoint.clone());
+                    slingB.edgeTag = new SectorOffsetProperties(averageNormal.clone(), offsetPoint.clone());
+                    slingC.edgeTag = new SectorOffsetProperties(outwardEdgeVector.clone(), vertexXYZ.clone());
+                    // OffsetMeshContext.stringDebugFunction("Chamfer Setup");
+                    const chamferPointE = this.compute3SectorIntersection(sliverD, sliverD.edgeMate, slingC);
+                    const chamferPointF = this.compute3SectorIntersection(slingB, slingB.vertexSuccessor, slingC);
+                    // sliverD.edgeTag = new SectorOffsetProperties(averageNormal.clone(), vertexXYZ.clone());
+                    SectorOffsetProperties.setXYZAtHalfEdge(sliverD, chamferPointE);
+                    SectorOffsetProperties.setXYZAtHalfEdge(slingB, chamferPointF);
+                    s *= -1.0;
+                }
+            }
+        }
+    }
+    /**
+     * * at input:
+     *   * Each node points to sectorOffsetProperties with previously computed XYZ (presumably mismatched)
+     * * at exit:
+     *    * Each sectorOffsetProperties has an offset point computed with consideration of offset planes in the neighborhood.
+     * @param distance distance to offset.
+     */
+    computeOffsetFacetIntersections(distance) {
+        if (OffsetMeshContext.stringDebugFunction !== undefined)
+            OffsetMeshContext.stringDebugFunction("*****                                 recompute intersections");
+        const breakEdges = [];
+        const vertexXYZ = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_0__.Point3d.create();
+        const chamferXYZ = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_0__.Point3d.create();
+        const maxVertexMove = 2.0 * distance;
+        const averageNormalData = new AverageNormalData();
+        const maxAllowedNormalDeviationRadians = _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_9__.Angle.degreesToRadians(25.0);
+        //
+        // FOR EACH VERTEX
+        //
+        this._baseGraph.announceVertexLoops((_graph, vertexSeedA) => {
+            // reposition to an important vertex.
+            // first choice: a chamfer face.
+            let vertexSeed = vertexSeedA.findMaskAroundVertex(this._outsideEndOfChamferFace);
+            if (vertexSeed === undefined)
+                vertexSeed = vertexSeedA.findMaskAroundVertex(this._breakMaskA);
+            if (vertexSeed === undefined)
+                vertexSeed = vertexSeedA;
+            if (OffsetMeshContext.stringDebugFunction !== undefined) {
+                OffsetMeshContext.stringDebugFunction("");
+                OffsetMeshContext.stringDebugFunction(` VERTEX LOOP   ${vertexSeed.getPoint3d().toJSON()} `);
+                vertexSeed.sumAroundVertex((node) => { OffsetMeshContext.stringDebugFunction(this.inspectMasks(node, false, true)); return 0; });
+            }
+            // Take care of the easiest vertices directly . . . note that this returns from the lambda, not computeOffsetFacetIntersections
+            if (this.assignOffsetByAverageNormalAroundVertex(vertexSeed, maxAllowedNormalDeviationRadians, averageNormalData, distance))
+                return true;
+            this.markBreakEdgesAndSaveAverageNormalsAroundVertex(vertexSeed);
+            this.setOffsetAtDistanceAroundVertex(vertexSeed, distance, true);
+            vertexSeed.collectMaskedEdgesAroundVertex(this._breakMaskA, true, breakEdges);
+            if (OffsetMeshContext.stringDebugFunction !== undefined) {
+                OffsetMeshContext.stringDebugFunction(` BREAK EDGES from ${this.inspectMasks(vertexSeed, true, false)}`);
+                for (const node of breakEdges) {
+                    OffsetMeshContext.stringDebugFunction(this.inspectMasks(node, false, true));
+                }
+            }
+            if (breakEdges.length <= 1) {
+                // just one smooth sequence.
+                // everything is set already.
+            }
+            else if (breakEdges.length === 2) {
+                // exterior vertex with two incident smooth
+                const vectorFromOrigin = this.compute2SectorIntersection(breakEdges[0], breakEdges[1]);
+                if (vectorFromOrigin !== undefined) {
+                    this.setOffsetXYAndZAroundVertex(vertexSeed, vectorFromOrigin);
+                }
+            }
+            else if (breakEdges.length === 3) {
+                if (OffsetMeshContext.stringDebugFunction !== undefined)
+                    OffsetMeshContext.stringDebugFunction(` Vertex Update just ${breakEdges.length} `);
+                const vectorFromOrigin = this.compute3SectorIntersection(breakEdges[0], breakEdges[1], breakEdges[2]);
+                if (vectorFromOrigin !== undefined) {
+                    this.setOffsetXYAndZAroundVertex(vertexSeed, vectorFromOrigin);
+                }
+                // simple 3-face corner . . .
+            }
+            else {
+                // Lots and Lots of edges
+                // each set of 3 sectors independently generates an offset for its central sector.
+                if (OffsetMeshContext.stringDebugFunction !== undefined)
+                    OffsetMeshContext.stringDebugFunction(` Vertex Update breakEdges ${breakEdges.length} `);
+                vertexSeed.getPoint3d(vertexXYZ);
+                // Pass 1 -- look for intersection among multiple chamfers
+                for (let i = 0; i < breakEdges.length; i++) {
+                    const i0 = i;
+                    const i1 = (i0 + 1) % breakEdges.length;
+                    const i2 = (i1 + 1) % breakEdges.length;
+                    if (breakEdges[i0].isMaskSet(this._outsideEndOfChamferFace)
+                        && breakEdges[i1].isMaskSet(this._outsideOfChamferFace)
+                        && breakEdges[i2].isMaskSet(this._insideOfChamferFace)) {
+                        if (OffsetMeshContext.stringDebugFunction !== undefined)
+                            OffsetMeshContext.stringDebugFunction(`    ChamferChamfer Fixup ${this.inspectMasks(breakEdges[i0])} ${this.inspectMasks(breakEdges[i1])} ${this.inspectMasks(breakEdges[i2])} `);
+                        const vectorFromOrigin = this.compute3SectorIntersection(breakEdges[i0], breakEdges[i1], breakEdges[i2]);
+                        if (vectorFromOrigin !== undefined) {
+                            // Treat all 3 spots as possibly compound sequences
+                            for (const iOutput of [i0, i1, i2]) {
+                                this.announceNodeAndSectorPropertiesInSmoothSector(breakEdges[iOutput], (node, properties) => {
+                                    properties.setXYAndZ(vectorFromOrigin);
+                                    node.setMask(this._offsetCoordinatesReassigned);
+                                });
+                            }
+                            // Since all three were reset, skip past.  This is done on the acyclic integer that controls the loop.
+                            i += 2;
+                        }
+                    }
+                }
+                // Pass 2 -- look for unassigned nodes just before or after a chamfer.
+                //  The chamfer wins
+                for (let i = 0; i < breakEdges.length; i++) {
+                    const i0 = i;
+                    const i1 = (i0 + 1) % breakEdges.length;
+                    if (this.isInsideSling(breakEdges[i0], breakEdges[i1]))
+                        continue;
+                    if (!this.isOffsetAssigned(breakEdges[i0])
+                        && breakEdges[i1].isMaskSet(this.insideOfChamferFace)) {
+                        this.transferXYZFromNodeToSmoothSector(breakEdges[i1], breakEdges[i0], "push left from chamfer", chamferXYZ);
+                    }
+                    else if (!this.isOffsetAssigned(breakEdges[i1])
+                        && breakEdges[i0].isMaskSet(this.outsideEndOfChamferFace)) {
+                        this.transferXYZFromNodeToSmoothSector(breakEdges[i0], breakEdges[i1], "push right from chamfer", chamferXYZ);
+                    }
+                }
+                // Pass 3 -- look for unassigned nodes as middle of 3-face intersections
+                for (let i = 0; i < breakEdges.length; i++) {
+                    const i0 = i;
+                    const i1 = (i0 + 1) % breakEdges.length;
+                    const i2 = (i1 + 1) % breakEdges.length;
+                    if (this.isInsideSling(breakEdges[i0], breakEdges[i1], breakEdges[i2]))
+                        continue;
+                    if (this.isOffsetAssigned(breakEdges[i1]))
+                        continue;
+                    if (OffsetMeshContext.stringDebugFunction !== undefined)
+                        OffsetMeshContext.stringDebugFunction(`    Intersection Fixup ${this.inspectMasks(breakEdges[i0])} ${this.inspectMasks(breakEdges[i1])} ${this.inspectMasks(breakEdges[i2])} `);
+                    const vectorFromOrigin = this.compute3SectorIntersection(breakEdges[i0], breakEdges[i1], breakEdges[i2]);
+                    if (vectorFromOrigin !== undefined) {
+                        if (vertexXYZ.distance(vectorFromOrigin) < maxVertexMove) {
+                            this.announceNodeAndSectorPropertiesInSmoothSector(breakEdges[i1], (node, properties) => {
+                                properties.setXYAndZ(vectorFromOrigin);
+                                node.setMask(this._offsetCoordinatesReassigned);
+                            });
+                        }
+                    }
+                }
+            }
+            if (OffsetMeshContext.stringDebugFunction !== undefined) {
+                const n0 = vertexSeed.countMaskAroundVertex(this._offsetCoordinatesReassigned, false);
+                const n1 = vertexSeed.countMaskAroundVertex(this._offsetCoordinatesReassigned, true);
+                const message = `   **** Vertex offset mask counts(TRUE ${n1})(FALSE ${n0})`;
+                OffsetMeshContext.stringDebugFunction(message);
+            }
+            return true;
+        });
+    }
+    // return true if any of these nodes is "inside" the sling at the end of a chamfer.
+    isInsideSling(node0, node1, node2) {
+        return node0.isMaskSet(this._insideChamferSling)
+            || (node1 !== undefined && node1.isMaskSet(this._insideChamferSling))
+            || (node2 !== undefined && node2.isMaskSet(this._insideChamferSling));
+    }
+    // return true if any of these nodes is "inside" the sling at the end of a chamfer.
+    isInsideChamferOrSling(node0) {
+        return node0.isMaskSet(this._insideChamferSling)
+            || node0.isMaskSet(this._insideOfChamferFace)
+            || node0.isMaskSet(this._outsideEndOfChamferFace);
+    }
+    isOffsetAssigned(node0, node1, node2) {
+        return node0.isMaskSet(this._offsetCoordinatesReassigned)
+            || (node1 !== undefined && node1.isMaskSet(this._offsetCoordinatesReassigned))
+            || (node2 !== undefined && node2.isMaskSet(this._offsetCoordinatesReassigned));
+    }
+    /**
+     *
+     * @param sourceNode node with good xyz
+     * @param destinationStartNode first of a sequence of nodes to set (delimited by masks)
+     * @param description string for debug
+     * @param workPoint point to use for coordinate transfer.
+     */
+    transferXYZFromNodeToSmoothSector(sourceNode, destinationStartNode, description, workPoint) {
+        if (OffsetMeshContext.stringDebugFunction !== undefined)
+            OffsetMeshContext.stringDebugFunction(`    ${description} ${this.inspectMasks(sourceNode)} to ${this.inspectMasks(destinationStartNode)}} `);
+        SectorOffsetProperties.getSectorPointAtHalfEdge(sourceNode, workPoint, undefined);
+        this.announceNodeAndSectorPropertiesInSmoothSector(destinationStartNode, (node, properties) => {
+            properties.setXYAndZ(workPoint);
+            node.setMask(this._offsetCoordinatesReassigned);
+        });
+    }
+}
+
+
 /***/ }),
 
 /***/ "../../core/geometry/lib/esm/polyface/multiclip/RangeSearch.js":
@@ -254224,16 +255505,16 @@ class Sample {
         _curve_Arc3d__WEBPACK_IMPORTED_MODULE_20__.Arc3d.createXY(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(5, 0), 5, _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createStartEndDegrees(180, 0)), _curve_Arc3d__WEBPACK_IMPORTED_MODULE_20__.Arc3d.createXY(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(15, 0), 5, _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createStartEndDegrees(180, 360)), _curve_Arc3d__WEBPACK_IMPORTED_MODULE_20__.Arc3d.createXY(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(25, 0), 5, _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createStartEndDegrees(180, 0)))));
         result.push(_curve_CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_44__.CurveChainWithDistanceIndex.createCapture(_curve_Path__WEBPACK_IMPORTED_MODULE_21__.Path.create(// 2-pt Interpolation Curve
         _bspline_InterpolationCurve3d__WEBPACK_IMPORTED_MODULE_45__.InterpolationCurve3d.createCapture(_bspline_InterpolationCurve3d__WEBPACK_IMPORTED_MODULE_45__.InterpolationCurve3dOptions.create({
-            fitPoints: [pointsA[0], pointsA[1]]
+            fitPoints: [pointsA[0], pointsA[1]],
         })))));
         result.push(_curve_CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_44__.CurveChainWithDistanceIndex.createCapture(_curve_Path__WEBPACK_IMPORTED_MODULE_21__.Path.create(// 3-pt Interpolation Curve
         _bspline_InterpolationCurve3d__WEBPACK_IMPORTED_MODULE_45__.InterpolationCurve3d.createCapture(_bspline_InterpolationCurve3d__WEBPACK_IMPORTED_MODULE_45__.InterpolationCurve3dOptions.create({
-            fitPoints: [pointsA[0], pointsA[1], pointsA[2]]
+            fitPoints: [pointsA[0], pointsA[1], pointsA[2]],
         })))));
         result.push(_curve_CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_44__.CurveChainWithDistanceIndex.createCapture(_curve_Path__WEBPACK_IMPORTED_MODULE_21__.Path.create(_bspline_InterpolationCurve3d__WEBPACK_IMPORTED_MODULE_45__.InterpolationCurve3d.createCapture(_bspline_InterpolationCurve3d__WEBPACK_IMPORTED_MODULE_45__.InterpolationCurve3dOptions.create({
             fitPoints: pointsA,
             startTangent: _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, -1),
-            endTangent: _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(-1, -1)
+            endTangent: _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(-1, -1),
         })))));
         result.push(_curve_CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_44__.CurveChainWithDistanceIndex.createCapture(_curve_Path__WEBPACK_IMPORTED_MODULE_21__.Path.create(_curve_spiral_IntegratedSpiral3d__WEBPACK_IMPORTED_MODULE_39__.IntegratedSpiral3d.createRadiusRadiusBearingBearing(_geometry3d_Segment1d__WEBPACK_IMPORTED_MODULE_40__.Segment1d.create(0, 100), _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createStartEndDegrees(10, 75), _geometry3d_Segment1d__WEBPACK_IMPORTED_MODULE_40__.Segment1d.create(0, 1), _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createOriginAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.createZero(), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRotationAroundAxisIndex(2, _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(30))), "bloss"))));
         result.push(_curve_CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_44__.CurveChainWithDistanceIndex.createCapture(_curve_Path__WEBPACK_IMPORTED_MODULE_21__.Path.create(_curve_spiral_DirectSpiral3d__WEBPACK_IMPORTED_MODULE_41__.DirectSpiral3d.createDirectHalfCosine(_geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createOriginAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.createZero(), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRotationAroundAxisIndex(2, _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(110))), 50, 350, _geometry3d_Segment1d__WEBPACK_IMPORTED_MODULE_40__.Segment1d.create(0, 1)))));
@@ -254347,8 +255628,11 @@ class Sample {
     /** Create swept "solids" that can be capped.
      * * At least one of each solid type.
      * * each is within 10 of the origin all directions.
+     * @param capped true to include caps
+     * @param rotationAngle angle of rotation for the angular sweep. The default is 90 degrees.
+     *      Beware that the rotation sweep created with the default or any positive angle produces a mesh with inward normals.
      */
-    static createClosedSolidSampler(capped) {
+    static createClosedSolidSampler(capped, rotationAngle = _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(90)) {
         const result = [];
         result.push(_solid_Box__WEBPACK_IMPORTED_MODULE_35__.Box.createRange(_geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range3d.createXYZXYZ(0, 0, 0, 3, 2, 5), capped));
         result.push(_solid_Cone__WEBPACK_IMPORTED_MODULE_33__.Cone.createAxisPoints(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 5), 1.0, 1.0, capped));
@@ -254360,18 +255644,23 @@ class Sample {
         const pointQ2 = arcA.fractionAndDistanceToPointOnTangent(1.0, 0.5);
         const pointR1 = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(point0.x, pointQ1.y);
         const pointR2 = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(point0.x, pointQ1.y);
+        const pointR3 = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(pointQ1.x - 1, pointQ1.y);
+        const pointR4 = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(pointQ1.x - 3, pointQ1.y);
         const linestringQ1 = _curve_LineString3d__WEBPACK_IMPORTED_MODULE_15__.LineString3d.create(arcA.fractionToPoint(1.0), pointQ1, pointR1, point0);
         const linestringQ2 = _curve_LineString3d__WEBPACK_IMPORTED_MODULE_15__.LineString3d.create(arcA.fractionToPoint(1.0), pointQ2, pointR2, point0);
+        const linestringQ3 = _curve_LineString3d__WEBPACK_IMPORTED_MODULE_15__.LineString3d.create(arcA.fractionToPoint(1.0), pointQ2, pointR3, pointR4, point0);
         const contourZ = _curve_Path__WEBPACK_IMPORTED_MODULE_21__.Path.create(linestringQ1.clone());
         const contourA = _curve_Loop__WEBPACK_IMPORTED_MODULE_23__.Loop.create(_curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_19__.LineSegment3d.create(point0, arcA.fractionToPoint(0)), arcA.clone(), linestringQ1.clone());
         const contourB = _curve_Loop__WEBPACK_IMPORTED_MODULE_23__.Loop.create(_curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_19__.LineSegment3d.create(point0, arcA.fractionToPoint(0)), arcA.clone(), linestringQ2.clone());
+        const contourC1 = _curve_Loop__WEBPACK_IMPORTED_MODULE_23__.Loop.create(_curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_19__.LineSegment3d.create(point0, arcA.fractionToPoint(0)), arcA.clone(), linestringQ3.clone());
         contourB.tryTransformInPlace(_geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createTranslationXYZ(1, 1, 3));
         // const contourC = contourB.cloneTransformed(Transform.createTranslationXYZ(2, 1, 4))!;
         result.push(_solid_LinearSweep__WEBPACK_IMPORTED_MODULE_30__.LinearSweep.create(contourA, _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.create(0, 0, 5), capped));
+        result.push(_solid_LinearSweep__WEBPACK_IMPORTED_MODULE_30__.LinearSweep.create(contourC1, _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.create(0, 0, 5), capped));
         const axis = _geometry3d_Ray3d__WEBPACK_IMPORTED_MODULE_14__.Ray3d.createXYZUVW(0, 8, 0, 1, 0, 0);
-        result.push(_solid_RotationalSweep__WEBPACK_IMPORTED_MODULE_31__.RotationalSweep.create(contourA.clone(), axis.clone(), _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(90), capped));
+        result.push(_solid_RotationalSweep__WEBPACK_IMPORTED_MODULE_31__.RotationalSweep.create(contourA.clone(), axis.clone(), rotationAngle, capped));
         if (!capped)
-            result.push(_solid_RotationalSweep__WEBPACK_IMPORTED_MODULE_31__.RotationalSweep.create(contourZ.clone(), axis.clone(), _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(90), false));
+            result.push(_solid_RotationalSweep__WEBPACK_IMPORTED_MODULE_31__.RotationalSweep.create(contourZ.clone(), axis.clone(), rotationAngle, false));
         result.push(_solid_RuledSweep__WEBPACK_IMPORTED_MODULE_36__.RuledSweep.create([contourA.clone(), contourB.clone()], capped));
         const transformC = _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createScaleAboutPoint(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 8), 0.5);
         const contourC = contourB.cloneTransformed(transformC);
@@ -258796,12 +260085,13 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "HalfEdgeGraph": () => (/* binding */ HalfEdgeGraph),
 /* harmony export */   "HalfEdgeMask": () => (/* binding */ HalfEdgeMask)
 /* harmony export */ });
-/* harmony import */ var _curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../curve/LineSegment3d */ "../../core/geometry/lib/esm/curve/LineSegment3d.js");
+/* harmony import */ var _curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../curve/LineSegment3d */ "../../core/geometry/lib/esm/curve/LineSegment3d.js");
 /* harmony import */ var _Geometry__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../Geometry */ "../../core/geometry/lib/esm/Geometry.js");
+/* harmony import */ var _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../geometry3d/Angle */ "../../core/geometry/lib/esm/geometry3d/Angle.js");
 /* harmony import */ var _geometry3d_Point2dVector2d__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../geometry3d/Point2dVector2d */ "../../core/geometry/lib/esm/geometry3d/Point2dVector2d.js");
 /* harmony import */ var _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../geometry3d/Point3dVector3d */ "../../core/geometry/lib/esm/geometry3d/Point3dVector3d.js");
-/* harmony import */ var _numerics_Polynomials__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../numerics/Polynomials */ "../../core/geometry/lib/esm/numerics/Polynomials.js");
-/* harmony import */ var _MaskManager__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./MaskManager */ "../../core/geometry/lib/esm/topology/MaskManager.js");
+/* harmony import */ var _numerics_Polynomials__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../numerics/Polynomials */ "../../core/geometry/lib/esm/numerics/Polynomials.js");
+/* harmony import */ var _MaskManager__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./MaskManager */ "../../core/geometry/lib/esm/topology/MaskManager.js");
 /*---------------------------------------------------------------------------------------------
 * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
 * See LICENSE.md in the project root for license terms and full copyright notice.
@@ -258815,6 +260105,7 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+
 // import { GraphChecker } from "../test/topology/Graph.test";
 /* eslint-disable @typescript-eslint/no-this-alias */
 // cspell:word CONSTU
@@ -258902,6 +260193,7 @@ class HalfEdge {
         this.sortAngle = undefined;
         this.sortData = undefined;
         this.edgeTag = undefined;
+        this.faceTag = undefined;
         // Always created in pairs, init here to make TS compiler and JS runtime happy
         this._facePredecessor = this;
         this._faceSuccessor = this;
@@ -259022,6 +260314,36 @@ class HalfEdge {
         }
         return newA;
     }
+    /**
+     * * Create a new sliver face "inside" an existing edge.
+     * * Insert it "within" the base edge.
+     * * This requires two new half edges.
+     * * if the base is undefined, create a single-edge loop.
+     * * This (unlike pinch) breaks the edgeMate pairing of the base edge.
+     * * This preserves xyz and i properties at all existing vertices.
+     * * The two new half edges are a sliver face (via their predecessor and successor)
+     * * Each new edge mates to one existing edge.
+     * @returns Returns the reference to the half edge created.
+     */
+    static splitEdgeCreateSliverFace(baseA, heArray) {
+        // raw edges ...
+        const newA = new HalfEdge();
+        const newB = new HalfEdge();
+        const baseB = baseA.edgeMate;
+        if (heArray) {
+            heArray.push(newA);
+            heArray.push(newB);
+        }
+        newA._faceSuccessor = newA._facePredecessor = newB;
+        newB._faceSuccessor = newB._facePredecessor = newA;
+        // newA is in vertex loop with baseA etc.
+        // newA mates to baseB
+        HalfEdge.setEdgeMates(newA, baseB);
+        HalfEdge.setEdgeMates(newB, baseA);
+        newA.copyDataFrom(baseA, true, true, false, false);
+        newB.copyDataFrom(baseB, true, true, false, false);
+        return newA;
+    }
     /**
      * Copy "edge based" content of fromNode to toNode
      * * edgeTag
@@ -259232,6 +260554,35 @@ class HalfEdge {
         }
         return count;
     }
+    /** Returns the first node with given mask value around this vertex loop.   */
+    findMaskAroundVertex(mask, value = true) {
+        let node = this;
+        do {
+            if (node.isMaskSet(mask) === value)
+                return node;
+            node = node.vertexSuccessor;
+        } while (node !== this);
+        return undefined;
+    }
+    /** Returns the first node with given mask value around this face loop.   */
+    findMaskAroundFace(mask, value = true) {
+        let node = this;
+        do {
+            if (node.isMaskSet(mask) === value)
+                return node;
+            node = node.faceSuccessor;
+        } while (node !== this);
+        return undefined;
+    }
+    /** Returns the first node with given mask value on this edge (i.e. examining this and this.mate)  */
+    findMaskAroundEdge(mask, value = true) {
+        if (this.isMaskSet(mask) === value)
+            return this;
+        const mate = this.edgeMate;
+        if (mate.isMaskSet(mask) === value)
+            return mate;
+        return undefined;
+    }
     /** Set a mask, and return prior value.
      * @param mask mask to apply
      */
@@ -259249,6 +260600,15 @@ class HalfEdge {
         this.y = node.y;
         this.z = node.z;
     }
+    /**
+     * Set (copy) the this.x, this.y, this.z from xyz.x, xyz.y, xyz.z
+     * @param node source with x,y,z properties
+     */
+    setXYZ(xyz) {
+        this.x = xyz.x;
+        this.y = xyz.y;
+        this.z = xyz.z;
+    }
     /**
      * Test if mask bits are set in the node's bitMask.
      * @return Return true (as a simple boolean, not a mask) if any bits of the mask parameter match bits of the node's bitMask
@@ -259338,6 +260698,10 @@ class HalfEdge {
         const s = `${node.id.toString()}+${HalfEdge.nodeToMaskString(node)}[${node.x},${node.y}]`;
         return s;
     }
+    /** Return the [id, [x,y],z] of a node.  Useful for collector methods. */
+    static nodeToIdXYZString(node) {
+        return `[${node.id.toString()}: ${node.x},${node.y},${node.z}]`;
+    }
     /** Create a string representation of the mask
      * * Null mask is empty string.
      * * Appended characters B,P,X for Boundary, Primary, Exterior mask bits.
@@ -259362,7 +260726,13 @@ class HalfEdge {
     }
     /** Return Vector3d to face successor */
     vectorToFaceSuccessor(result) {
-        return _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.create(this.faceSuccessor.x - this.x, this.faceSuccessor.y - this.y, this.faceSuccessor.z - this.z, result);
+        const other = this.faceSuccessor;
+        return _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.create(other.x - this.x, other.y - this.y, other.z - this.z, result);
+    }
+    /** Return Vector3d to face successor */
+    vectorToFacePredecessor(result) {
+        const other = this.facePredecessor;
+        return _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.create(other.x - this.x, other.y - this.y, other.z - this.z, result);
     }
     /** test if spaceNode is in the sector at sectorNode */
     static isNodeVisibleInSector(spaceNode, sectorNode) {
@@ -259486,6 +260856,14 @@ class HalfEdge {
     static testNodeMaskNotExterior(node) { return !node.isMaskSet(HalfEdgeMask.EXTERIOR); }
     /** Returns Returns true if the node does NOT have Mask.EXTERIOR_MASK set. */
     static testMateMaskExterior(node) { return node.edgeMate.isMaskSet(HalfEdgeMask.EXTERIOR); }
+    /** Returns radians between this edge and its face predecessor edge, using all three coordinates x,y,z and given normal to resolve sweep direction.
+     *   * The returned angle is positive, i.e. may be larger than PI radians.
+    */
+    static sectorSweepRadiansXYZ(node, normal) {
+        const nodeB = node.faceSuccessor;
+        const nodeC = node.facePredecessor;
+        return _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.orientedRadiansBetweenVectorsXYZ(nodeB.x - node.x, nodeB.y - node.y, nodeB.z - node.z, nodeC.x - node.x, nodeC.y - node.y, nodeC.z - node.z, normal.x, normal.y, normal.z, true);
+    }
     /** Returns Returns true if the face has positive area in xy parts. */
     static testFacePositiveAreaXY(node) {
         return node.countEdgesAroundFace() > 2 && node.signedFaceArea() > 0.0;
@@ -259517,6 +260895,26 @@ class HalfEdge {
         } while (node !== this);
         return nodes;
     }
+    /**
+     * search around a vertex for nodes that have a specified mask setting.
+     * @param vertexSeed first node to search
+     * @param mask target mask
+     * @param value target value for mask on half edges.
+     * @param collectedNodes optional array to be cleared and receive masked nodes
+     */
+    collectMaskedEdgesAroundVertex(mask, value = true, result) {
+        if (result === undefined)
+            result = [];
+        else
+            result.length = 0;
+        let node = this;
+        do {
+            if (node.isMaskSet(mask) === value)
+                result.push(node);
+            node = node.vertexSuccessor;
+        } while (node !== this);
+        return result;
+    }
     /**
      *
      * * Evaluate f(node) at each outbound node around this node's vertex loop.
@@ -259700,7 +261098,7 @@ class HalfEdge {
         const nodeB1 = nodeB0.faceSuccessor;
         if (!result)
             result = _geometry3d_Point2dVector2d__WEBPACK_IMPORTED_MODULE_0__.Vector2d.create();
-        if (_numerics_Polynomials__WEBPACK_IMPORTED_MODULE_3__.SmallSystem.linearSystem2d(nodeA1.x - nodeA0.x, nodeB0.x - nodeB1.x, nodeA1.y - nodeA0.y, nodeB0.y - nodeB1.y, nodeB0.x - nodeA0.x, nodeB0.y - nodeA0.y, result))
+        if (_numerics_Polynomials__WEBPACK_IMPORTED_MODULE_4__.SmallSystem.linearSystem2d(nodeA1.x - nodeA0.x, nodeB0.x - nodeB1.x, nodeA1.y - nodeA0.y, nodeB0.y - nodeB1.y, nodeB0.x - nodeA0.x, nodeB0.y - nodeA0.y, result))
             return result;
         return undefined;
     }
@@ -259709,8 +261107,7 @@ class HalfEdge {
      * * If the edge is horizontal with (approximate) identical y, return the node.
      * * If the edge is horizontal with different y, return undefined.
      * * If the edge is not horizontal, return the fractional position (possibly outside 0..1) of the intersection.
-     * @param nodeA Base node of edge
-     * @param result optional preallocated result
+     * @param node0 Base node of edge
      */
     static horizontalScanFraction(node0, y) {
         const node1 = node0.faceSuccessor;
@@ -259725,8 +261122,7 @@ class HalfEdge {
      * * Compute fractional coordinates of the intersection of a horizontal line with an edge.
      * * If the edge is horizontal return undefined (no test for horizontal at y!!!)
      * * If the edge is not horizontal and y is between its end y's, return the fraction
-     * @param nodeA Base node of edge
-     * @param result optional preallocated result
+     * @param node0 Base node of edge
      */
     static horizontalScanFraction01(node0, y) {
         const node1 = node0.faceSuccessor;
@@ -259740,6 +261136,31 @@ class HalfEdge {
             return fraction;
         return undefined;
     }
+    /**
+     * Copy various data from source to this.
+     * @param source other half edge.
+     * @param XYZ copy simple coordinates
+     * @param copyVertexData true to copy data belonging to the vertex. (i.e. the "i" member)
+     * @param copyVertexData true to copy data belonging to the edge. (i.e. call transferEdgeData)
+     * @param copyFaceData true to copy faceTag
+     */
+    copyDataFrom(source, copyXYZ, copyVertexData, copyEdgeData, copyFaceData) {
+        if (copyXYZ) {
+            this.x = source.x;
+            this.y = source.y;
+            this.z = source.z;
+        }
+        if (copyVertexData) {
+            this.i = source.i;
+        }
+        if (copyEdgeData) {
+            HalfEdge.transferEdgeProperties(source, this);
+            this.edgeTag = source.edgeTag;
+        }
+        if (copyFaceData) {
+            this.faceTag = source.faceTag;
+        }
+    }
 }
 HalfEdge._edgePropertyMasks = [HalfEdgeMask.BOUNDARY_EDGE, HalfEdgeMask.EXTERIOR, HalfEdgeMask.PRIMARY_EDGE, HalfEdgeMask.NULL_FACE];
 HalfEdge._totalNodesCreated = 0;
@@ -259753,7 +261174,7 @@ class HalfEdgeGraph {
     constructor() {
         this._numNodesCreated = 0;
         this.allHalfEdges = [];
-        this._maskManager = _MaskManager__WEBPACK_IMPORTED_MODULE_4__.MaskManager.create(HalfEdgeMask.ALL_GRAB_DROP_MASKS);
+        this._maskManager = _MaskManager__WEBPACK_IMPORTED_MODULE_5__.MaskManager.create(HalfEdgeMask.ALL_GRAB_DROP_MASKS);
     }
     /** Ask for a mask (from the graph's free pool.) for caller's use.
      * * Optionally clear the mask throughout the graph.
@@ -259780,6 +261201,19 @@ class HalfEdgeGraph {
         const a = HalfEdge.createHalfEdgePairWithCoordinates(xA, yA, zA, iA, xB, yB, zB, iB, this.allHalfEdges);
         return a;
     }
+    /**
+     * * Create 2 half edges forming 2 vertices, 1 edge, and 1 face
+     * * The two edges are joined as edgeMate pair.
+     * * The two edges are a 2-half-edge face loop in both the faceSuccessor and facePredecessor directions.
+     * * The two edges are added to the graph's HalfEdge set
+     * * Coordinates are set to zero.
+     * * ids are installed in the two half edges.
+     * @returns Return pointer to the first half edge created.  (This has idA as its id.)
+     */
+    createEdgeIdId(iA = 0, iB = 0) {
+        const a = HalfEdge.createHalfEdgePairWithCoordinates(0.0, 0.0, 0.0, iA, 0.0, 0.0, 0.0, iB, this.allHalfEdges);
+        return a;
+    }
     /**
      * * create an edge from coordinates x,y,z to (the tail of) an existing half edge.
      * @returns Return pointer to the half edge with tail at x,y,z
@@ -259824,6 +261258,20 @@ class HalfEdgeGraph {
         const he = HalfEdge.splitEdge(base, xA, yA, zA, iA, this.allHalfEdges);
         return he;
     }
+    /**
+     * * Create a sliver face "within" an edge.
+     * * this creates two half edges.
+     * * The existing edges both stay in their same face loops and retain coordinates and i value.
+     * * Each existing edge's mate is a new edge (rather than original mate)
+     * * Coordinates are copied to the new edges at respective vertices.
+     * * New faceTag and edgeTag undefined.
+     * * i members are copied around their respective vertices.
+     * @returns Returns the reference to the half edge created.
+     */
+    splitEdgeCreateSliverFace(base) {
+        const he = HalfEdge.splitEdgeCreateSliverFace(base, this.allHalfEdges);
+        return he;
+    }
     /**
      * * Insert a vertex in the edge beginning at base, with coordinates specified as a fraction along the existing edge.
      * * this creates two half edges.
@@ -259892,7 +261340,7 @@ class HalfEdgeGraph {
         const segments = [];
         for (const node of this.allHalfEdges) {
             if (node.id < node.edgeMate.id)
-                segments.push(_curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_5__.LineSegment3d.create(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(node.x, node.y), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(node.faceSuccessor.x, node.faceSuccessor.y)));
+                segments.push(_curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_6__.LineSegment3d.create(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(node.x, node.y), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(node.faceSuccessor.x, node.faceSuccessor.y)));
         }
         return segments;
     }
@@ -259961,6 +261409,26 @@ class HalfEdgeGraph {
                 break;
         }
     }
+    /**
+       * * Visit each edge of the graph once.
+       * * Call the announceEdge function.
+       * * the edge mate will NOT appear in an announceEdge call.
+       * * continue search if announceEdge(graph, node) returns true
+       * * terminate search if announceEdge (graph, node) returns false
+       * @param  announceEdge function to apply at one node of each edge.
+       */
+    announceEdges(announceEdge) {
+        this.clearMask(HalfEdgeMask.VISITED);
+        for (const node of this.allHalfEdges) {
+            if (node.getMask(HalfEdgeMask.VISITED))
+                continue;
+            const mate = node.edgeMate;
+            node.setMask(HalfEdgeMask.VISITED);
+            mate.setMask(HalfEdgeMask.VISITED);
+            if (!announceEdge(this, node))
+                break;
+        }
+    }
     /**
      * * Visit each vertex loop of the graph once.
      * * Call the announceVertex function
@@ -259979,8 +261447,8 @@ class HalfEdgeGraph {
         }
     }
     /**
-     * * Visit each vertex loop of the graph once.
-     * * Call the announceVertex function
+     * * Visit each half edge (node) of the graph once.
+     * * Call the announceNode function
      * * continue search if announceNode(graph, node) returns true
      * * terminate search if announce face (graph, node) returns false
      * @param  announceNode function to apply at one node of each face.
@@ -260039,6 +261507,99 @@ class HalfEdgeGraph {
 }
 
 
+/***/ }),
+
+/***/ "../../core/geometry/lib/esm/topology/HalfEdgeGraphFromIndexedLoopsContext.js":
+/*!************************************************************************************!*\
+  !*** ../../core/geometry/lib/esm/topology/HalfEdgeGraphFromIndexedLoopsContext.js ***!
+  \************************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "HalfEdgeGraphFromIndexedLoopsContext": () => (/* binding */ HalfEdgeGraphFromIndexedLoopsContext)
+/* harmony export */ });
+/* harmony import */ var _Graph__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Graph */ "../../core/geometry/lib/esm/topology/Graph.js");
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+
+/** @packageDocumentation
+ * @module Topology
+ */
+/**
+ * Context for building a half edge graph from loops defined only by indices.
+ * * Direct use case:
+ *   * Create the context.
+ *   * Repeatedly call insertLoop(indicesAroundLoop) to announce various loops.
+ *   * Finish by accessing the graph property.
+ * @internal
+ */
+class HalfEdgeGraphFromIndexedLoopsContext {
+    constructor() {
+        this._unmatchedEdges = new Map();
+        this._graph = new _Graph__WEBPACK_IMPORTED_MODULE_0__.HalfEdgeGraph();
+        this._halfEdgesAroundCurrentLoop = [];
+    }
+    get graph() { return this._graph; }
+    indexPairToString(index0, index1) {
+        return `${index0.toString()},${index1.toString()}`;
+    }
+    /** Create a loop with specified indices at its vertices.
+     * * For an edge with index pair [indexA, indexB]:
+     *   * if [indexB, indexA] has never appeared, a HalfEdge mated pair is created.
+     *      * One of that mated pair becomes a HalfEdge in this loop.
+     *      * The other is "unmatched"
+     *      * When announceMatedHalfEdges(halfEdge) is called:
+     *         * halfEdge and its mate are "new"
+     *         * all coordinates are zeros.
+     *         * each contains (as its halfEdge.id property) one index of the [indexA,indexB] pair.
+     *         * those coordinates and indices will never be referenced again by this construction sequence -- the caller is free to mutate them as needed.
+     *   * if [indexB, indexA] appeared previously (and its outer HalfEdge was left "unmatched"),
+     *              the "unmatched" HalfEdge is used in the loop being constructed.
+     * @param indices Array of indices around the edge.  This is accessed cyclically.
+     * @param announceMatedHalfEdges optional function to be called as mated pairs are created. At the call,
+     *     the given HalfEdge and its mate will have a pair of successive indices from the array.
+     */
+    insertLoop(indices, announceMatedHalfEdges) {
+        const n = indices.length;
+        if (n > 1) {
+            let index0 = indices[indices.length - 1];
+            this._halfEdgesAroundCurrentLoop.length = 0;
+            for (const index1 of indices) {
+                const insideString = this.indexPairToString(index0, index1);
+                const halfEdgePreviouslyConstructedFromOppositeSide = this._unmatchedEdges.get(insideString);
+                if (halfEdgePreviouslyConstructedFromOppositeSide === undefined) {
+                    // This is the first appearance of this edge in either direction.
+                    const outsideString = this.indexPairToString(index1, index0); // string referencing the "other" side of the new edge.
+                    const newHalfEdgeAroundLoop = this._graph.createEdgeIdId(index0, index1);
+                    if (announceMatedHalfEdges !== undefined)
+                        announceMatedHalfEdges(newHalfEdgeAroundLoop);
+                    this._unmatchedEdges.set(outsideString, newHalfEdgeAroundLoop.edgeMate);
+                    this._halfEdgesAroundCurrentLoop.push(newHalfEdgeAroundLoop);
+                    newHalfEdgeAroundLoop.edgeMate.setMask(_Graph__WEBPACK_IMPORTED_MODULE_0__.HalfEdgeMask.EXTERIOR);
+                }
+                else {
+                    this._halfEdgesAroundCurrentLoop.push(halfEdgePreviouslyConstructedFromOppositeSide);
+                    halfEdgePreviouslyConstructedFromOppositeSide.clearMask(_Graph__WEBPACK_IMPORTED_MODULE_0__.HalfEdgeMask.EXTERIOR);
+                }
+                index0 = index1;
+            }
+            let halfEdgeA = this._halfEdgesAroundCurrentLoop[this._halfEdgesAroundCurrentLoop.length - 1];
+            for (const halfEdgeB of this._halfEdgesAroundCurrentLoop) {
+                const halfEdgeC = halfEdgeA.faceSuccessor;
+                _Graph__WEBPACK_IMPORTED_MODULE_0__.HalfEdge.pinch(halfEdgeB, halfEdgeC);
+                halfEdgeA = halfEdgeB;
+            }
+            return this._halfEdgesAroundCurrentLoop[0];
+        }
+        return undefined;
+    }
+}
+
+
 /***/ }),
 
 /***/ "../../core/geometry/lib/esm/topology/HalfEdgeGraphSearch.js":
@@ -285523,7 +287084,7 @@ class TestContext {
         this.initializeRpcInterfaces({ title: this.settings.Backend.name, version: this.settings.Backend.version });
         const iModelClient = new imodels_client_management_1.IModelsClient({ api: { baseUrl: `https://${(_a = process.env.IMJS_URL_PREFIX) !== null && _a !== void 0 ? _a : ""}api.bentley.com/imodels` } });
         await core_frontend_1.NoRenderApp.startup({
-            applicationVersion: "4.0.0-dev.6",
+            applicationVersion: "4.0.0-dev.8",
             applicationId: this.settings.gprid,
             authorizationClient: new frontend_1.TestFrontendAuthorizationClient(this.adminUserAccessToken),
             hubAccess: new imodels_access_frontend_1.FrontendIModelsAccess(iModelClient),
@@ -304952,7 +306513,7 @@ module.exports = JSON.parse('{"name":"axios","version":"0.21.4","description":"P
 /***/ ((module) => {
 
 "use strict";
-module.exports = JSON.parse('{"name":"@itwin/core-frontend","version":"4.0.0-dev.6","description":"iTwin.js frontend components","main":"lib/cjs/core-frontend.js","module":"lib/esm/core-frontend.js","typings":"lib/cjs/core-frontend","license":"MIT","scripts":{"build":"npm run -s copy:public && npm run -s build:cjs","build:ci":"npm run -s build && npm run -s build:esm","build:cjs":"npm run -s copy:js:cjs && tsc 1>&2 --outDir lib/cjs","build:esm":"npm run -s copy:js:esm && tsc 1>&2 --module ES2020 --outDir lib/esm","clean":"rimraf lib .rush/temp/package-deps*.json","copy:public":"cpx \\"./src/public/**/*\\" ./lib/public","copy:js:cjs":"cpx \\"./src/**/*.js\\" ./lib/cjs","copy:js:esm":"cpx \\"./src/**/*.js\\" ./lib/esm","docs":"betools docs --includes=../../generated-docs/extract --json=../../generated-docs/core/core-frontend/file.json --tsIndexFile=./core-frontend.ts --onlyJson --excludes=webgl/**/*,**/primitives,**/map/*.d.ts,**/tile/*.d.ts,**/*-css.ts","extract-api":"betools extract-api --entry=core-frontend && npm run extract-extension-api","extract-extension-api":"eslint --no-eslintrc -c \\"../../tools/eslint-plugin/dist/configs/extension-exports-config.js\\" \\"./src/**/*.ts\\" 1>&2","lint":"eslint -f visualstudio \\"./src/**/*.ts\\" 1>&2","pseudolocalize":"betools pseudolocalize --englishDir ./src/public/locales/en --out ./public/locales/en-PSEUDO","test":"npm run -s webpackTests && certa -r chrome","cover":"npm -s test","test:debug":"certa -r chrome --debug","webpackTests":"webpack --config ./src/test/utils/webpack.config.js 1>&2"},"repository":{"type":"git","url":"https://github.com/iTwin/itwinjs-core/tree/master/core/frontend"},"keywords":["Bentley","BIM","iModel","digital-twin","iTwin"],"author":{"name":"Bentley Systems, Inc.","url":"http://www.bentley.com"},"peerDependencies":{"@itwin/appui-abstract":"workspace:^4.0.0-dev.6","@itwin/core-bentley":"workspace:^4.0.0-dev.6","@itwin/core-common":"workspace:^4.0.0-dev.6","@itwin/core-geometry":"workspace:^4.0.0-dev.6","@itwin/core-orbitgt":"workspace:^4.0.0-dev.6","@itwin/core-quantity":"workspace:^4.0.0-dev.6"},"//devDependencies":["NOTE: All peerDependencies should also be listed as devDependencies since peerDependencies are not considered by npm install","NOTE: All tools used by scripts in this package must be listed as devDependencies"],"devDependencies":{"@itwin/appui-abstract":"workspace:*","@itwin/build-tools":"workspace:*","@itwin/core-bentley":"workspace:*","@itwin/core-common":"workspace:*","@itwin/core-geometry":"workspace:*","@itwin/core-orbitgt":"workspace:*","@itwin/core-quantity":"workspace:*","@itwin/certa":"workspace:*","@itwin/eslint-plugin":"workspace:*","@itwin/webgl-compatibility":"workspace:*","@types/chai":"4.3.1","@types/chai-as-promised":"^7","@types/deep-assign":"^0.1.0","@types/lodash":"^4.14.0","@types/mocha":"^8.2.2","@types/node":"18.11.5","@types/qs":"^6.5.0","@types/semver":"7.3.10","@types/superagent":"^4.1.14","@types/sinon":"^9.0.0","babel-loader":"~8.2.5","babel-plugin-istanbul":"~6.1.1","chai":"^4.1.2","chai-as-promised":"^7","cpx2":"^3.0.0","eslint":"^7.11.0","glob":"^7.1.2","mocha":"^10.0.0","nyc":"^15.1.0","rimraf":"^3.0.2","sinon":"^9.0.2","source-map-loader":"^4.0.0","typescript":"~4.4.0","webpack":"^5.64.4"},"//dependencies":["NOTE: these dependencies should be only for things that DO NOT APPEAR IN THE API","NOTE: core-frontend should remain UI technology agnostic, so no react/angular dependencies are allowed"],"dependencies":{"@itwin/object-storage-azure":"~1.4.0","@itwin/cloud-agnostic-core":"~1.4.0","@itwin/object-storage-core":"~1.4.0","@itwin/core-i18n":"workspace:*","@itwin/core-telemetry":"workspace:*","@itwin/webgl-compatibility":"workspace:*","@loaders.gl/core":"^3.1.6","@loaders.gl/draco":"^3.1.6","deep-assign":"^2.0.0","fuse.js":"^3.3.0","lodash":"^4.17.10","qs":"^6.5.3","semver":"^7.3.5","superagent":"^7.1.5","wms-capabilities":"0.4.0","reflect-metadata":"0.1.13"},"nyc":{"extends":"./node_modules/@itwin/build-tools/.nycrc"},"eslintConfig":{"plugins":["@itwin"],"extends":"plugin:@itwin/itwinjs-recommended","rules":{"@itwin/no-internal-barrel-imports":["error",{"required-barrel-modules":["./src/tile/internal.ts"]}],"@itwin/public-extension-exports":["error",{"releaseTags":["public","preview"],"outputApiFile":false}]},"overrides":[{"files":["*.test.ts","*.test.tsx","**/test/**/*.ts"],"rules":{"@itwin/no-internal-barrel-imports":"off"}}]}}');
+module.exports = JSON.parse('{"name":"@itwin/core-frontend","version":"4.0.0-dev.8","description":"iTwin.js frontend components","main":"lib/cjs/core-frontend.js","module":"lib/esm/core-frontend.js","typings":"lib/cjs/core-frontend","license":"MIT","scripts":{"build":"npm run -s copy:public && npm run -s build:cjs","build:ci":"npm run -s build && npm run -s build:esm","build:cjs":"npm run -s copy:js:cjs && tsc 1>&2 --outDir lib/cjs","build:esm":"npm run -s copy:js:esm && tsc 1>&2 --module ES2020 --outDir lib/esm","clean":"rimraf lib .rush/temp/package-deps*.json","copy:public":"cpx \\"./src/public/**/*\\" ./lib/public","copy:js:cjs":"cpx \\"./src/**/*.js\\" ./lib/cjs","copy:js:esm":"cpx \\"./src/**/*.js\\" ./lib/esm","docs":"betools docs --includes=../../generated-docs/extract --json=../../generated-docs/core/core-frontend/file.json --tsIndexFile=./core-frontend.ts --onlyJson --excludes=webgl/**/*,**/primitives,**/map/*.d.ts,**/tile/*.d.ts,**/*-css.ts","extract-api":"betools extract-api --entry=core-frontend && npm run extract-extension-api","extract-extension-api":"eslint --no-eslintrc -c \\"../../tools/eslint-plugin/dist/configs/extension-exports-config.js\\" \\"./src/**/*.ts\\" 1>&2","lint":"eslint -f visualstudio \\"./src/**/*.ts\\" 1>&2","pseudolocalize":"betools pseudolocalize --englishDir ./src/public/locales/en --out ./public/locales/en-PSEUDO","test":"npm run -s webpackTests && certa -r chrome","cover":"npm -s test","test:debug":"certa -r chrome --debug","webpackTests":"webpack --config ./src/test/utils/webpack.config.js 1>&2"},"repository":{"type":"git","url":"https://github.com/iTwin/itwinjs-core/tree/master/core/frontend"},"keywords":["Bentley","BIM","iModel","digital-twin","iTwin"],"author":{"name":"Bentley Systems, Inc.","url":"http://www.bentley.com"},"peerDependencies":{"@itwin/appui-abstract":"workspace:^4.0.0-dev.8","@itwin/core-bentley":"workspace:^4.0.0-dev.8","@itwin/core-common":"workspace:^4.0.0-dev.8","@itwin/core-geometry":"workspace:^4.0.0-dev.8","@itwin/core-orbitgt":"workspace:^4.0.0-dev.8","@itwin/core-quantity":"workspace:^4.0.0-dev.8"},"//devDependencies":["NOTE: All peerDependencies should also be listed as devDependencies since peerDependencies are not considered by npm install","NOTE: All tools used by scripts in this package must be listed as devDependencies"],"devDependencies":{"@itwin/appui-abstract":"workspace:*","@itwin/build-tools":"workspace:*","@itwin/core-bentley":"workspace:*","@itwin/core-common":"workspace:*","@itwin/core-geometry":"workspace:*","@itwin/core-orbitgt":"workspace:*","@itwin/core-quantity":"workspace:*","@itwin/certa":"workspace:*","@itwin/eslint-plugin":"workspace:*","@itwin/webgl-compatibility":"workspace:*","@types/chai":"4.3.1","@types/chai-as-promised":"^7","@types/deep-assign":"^0.1.0","@types/lodash":"^4.14.0","@types/mocha":"^8.2.2","@types/node":"18.11.5","@types/qs":"^6.5.0","@types/semver":"7.3.10","@types/superagent":"^4.1.14","@types/sinon":"^9.0.0","babel-loader":"~8.2.5","babel-plugin-istanbul":"~6.1.1","chai":"^4.1.2","chai-as-promised":"^7","cpx2":"^3.0.0","eslint":"^7.11.0","glob":"^7.1.2","mocha":"^10.0.0","nyc":"^15.1.0","rimraf":"^3.0.2","sinon":"^9.0.2","source-map-loader":"^4.0.0","typescript":"~4.4.0","webpack":"^5.64.4"},"//dependencies":["NOTE: these dependencies should be only for things that DO NOT APPEAR IN THE API","NOTE: core-frontend should remain UI technology agnostic, so no react/angular dependencies are allowed"],"dependencies":{"@itwin/object-storage-azure":"~1.4.0","@itwin/cloud-agnostic-core":"~1.4.0","@itwin/object-storage-core":"~1.4.0","@itwin/core-i18n":"workspace:*","@itwin/core-telemetry":"workspace:*","@itwin/webgl-compatibility":"workspace:*","@loaders.gl/core":"^3.1.6","@loaders.gl/draco":"^3.1.6","deep-assign":"^2.0.0","fuse.js":"^3.3.0","lodash":"^4.17.10","qs":"^6.5.3","semver":"^7.3.5","superagent":"^7.1.5","wms-capabilities":"0.4.0","reflect-metadata":"0.1.13"},"nyc":{"extends":"./node_modules/@itwin/build-tools/.nycrc"},"eslintConfig":{"plugins":["@itwin"],"extends":"plugin:@itwin/itwinjs-recommended","rules":{"@itwin/no-internal-barrel-imports":["error",{"required-barrel-modules":["./src/tile/internal.ts"]}],"@itwin/public-extension-exports":["error",{"releaseTags":["public","preview"],"outputApiFile":false}]},"overrides":[{"files":["*.test.ts","*.test.tsx","**/test/**/*.ts"],"rules":{"@itwin/no-internal-barrel-imports":"off"}}]}}');
 
 /***/ }),