@itwin/rpcinterface-full-stack-tests 4.0.0-dev.55 → 4.0.0-dev.56

package/lib/dist/bundled-tests.js

@@ -176432,7 +176432,11 @@ class Geometry {
     static resolveToUndefined(value, targetValue) {
         return value === targetValue ? undefined : value;
     }
-    /** Simple interpolation between values, but choosing (based on fraction) a or b as starting point for maximum accuracy. */
+    /**
+     * Simple interpolation between values, but choosing (based on fraction) a or b as starting
+     * point for maximum accuracy.
+     * * If `f = 0`, then `a` is returned and if `f = 1`, then `b` is returned.
+     */
     static interpolate(a, f, b) {
         return f <= 0.5 ? a + f * (b - a) : b - (1.0 - f) * (b - a);
     }
@@ -205259,11 +205263,11 @@ class Angle {
         }
     }
     /**
-   * Create an Angle from a JSON object
-   * @param json object from JSON.parse. If a number, value is in *DEGREES*
-   * @param defaultValRadians if json is undefined, default value in radians.
-   * @return a new Angle
-   */
+     * Create an Angle from a JSON object
+     * @param json object from JSON.parse. If a number, value is in *DEGREES*
+     * @param defaultValRadians if json is undefined, default value in radians.
+     * @return a new Angle
+     */
     static fromJSON(json, defaultValRadians) {
         const val = new Angle();
         val.setFromJSON(json, defaultValRadians);
@@ -205318,21 +205322,15 @@ class Angle {
         // all larger radians reference from 360 degrees (2PI)
         return 360.0 + 180 * ((radians - 2.0 * pi) / pi);
     }
-    /**
-     * Return the cosine of this Angle object's angle.
-     */
+    /** Return the cosine of this Angle object's angle */
     cos() {
         return Math.cos(this._radians);
     }
-    /**
-     * Return the sine of this Angle object's angle.
-     */
+    /** Return the sine of this Angle object's angle */
     sin() {
         return Math.sin(this._radians);
     }
-    /**
-     * Return the tangent of this Angle object's angle.
-     */
+    /** Return the tangent of this Angle object's angle */
     tan() {
         return Math.tan(this._radians);
     }
@@ -205344,11 +205342,11 @@ class Angle {
     static isHalfCircleRadians(radians) {
         return Math.abs(Math.abs(radians) - Math.PI) <= _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.smallAngleRadians;
     }
-    /** test if the angle is a full circle */
+    /** Test if the angle is a full circle */
     get isFullCircle() {
         return Angle.isFullCircleRadians(this._radians);
     }
-    /** test if the angle is a half circle (in either direction) */
+    /** Test if the angle is a half circle (in either direction) */
     get isHalfCircle() {
         return Angle.isHalfCircleRadians(this._radians);
     }
@@ -205417,7 +205415,7 @@ class Angle {
         // fall through for NaN disaster.
         return 0;
     }
-    /** return a (newly allocated) Angle object with value 0 radians */
+    /** Return a (newly allocated) Angle object with value 0 radians */
     static zero() {
         return new Angle(0);
     }
@@ -205571,19 +205569,19 @@ class Angle {
         return value;
     }
     /**
-       * Return the half angle cosine, sine, and radians for given dot products between vectors. The vectors define
-       * an ellipse using x(t) = c + U cos(t) + V sin(t) so U and V are at angle t=0 degree and t=90 degree. The
-       * half angle t0 is an angle such that x(t0) is one of the ellipse semi-axis.
-       * * This construction arises e.g. in `Arc3d.toScaledMatrix3d`.
-       * * Given ellipse x(t) = c + U cos(t) + V sin(t), find t0 such that radial vector W(t0) = x(t0) - c is
-       * perpendicular to the ellipse.
-       * * Then 0 = W(t0).x'(t0) = (U cos(t0) + V sin(t0)).(V cos(t0) - U sin(t0)) = U.V cos(2t0) + 0.5 (V.V - U.U) sin(2t0)
-       * implies sin(2t0) / cos(2t0) = 2 U.V / (U.U - V.V), i.e., t0 can be computed given the three dot products on the RHS.
-       * math details can be found at docs/learning/geometry/Angle.md
-       * @param dotUU dot product of vectorU with itself
-       * @param dotVV dot product of vectorV with itself
-       * @param dotUV dot product of vectorU with vectorV
-       */
+     * Return the half angle cosine, sine, and radians for given dot products between vectors. The vectors define
+     * an ellipse using x(t) = c + U cos(t) + V sin(t) so U and V are at angle t=0 degree and t=90 degree. The
+     * half angle t0 is an angle such that x(t0) is one of the ellipse semi-axis.
+     * * This construction arises e.g. in `Arc3d.toScaledMatrix3d`.
+     * * Given ellipse x(t) = c + U cos(t) + V sin(t), find t0 such that radial vector W(t0) = x(t0) - c is
+     * perpendicular to the ellipse.
+     * * Then 0 = W(t0).x'(t0) = (U cos(t0) + V sin(t0)).(V cos(t0) - U sin(t0)) = U.V cos(2t0) + 0.5 (V.V - U.U) sin(2t0)
+     * implies sin(2t0) / cos(2t0) = 2 U.V / (U.U - V.V), i.e., t0 can be computed given the three dot products on the RHS.
+     * math details can be found at docs/learning/geometry/Angle.md
+     * @param dotUU dot product of vectorU with itself
+     * @param dotVV dot product of vectorV with itself
+     * @param dotUV dot product of vectorU with vectorV
+     */
     static dotProductsToHalfAngleTrigValues(dotUU, dotVV, dotUV, favorZero = true) {
         const cos2t0 = dotUU - dotVV;
         const sin2t0 = 2.0 * dotUV;
@@ -205592,9 +205590,8 @@ class Angle {
         return Angle.trigValuesToHalfAngleTrigValues(cos2t0, sin2t0);
     }
     /**
-     * * Returns the angle between two vectors, with the vectors given as xyz components
+     * Returns the angle between two vectors, with the vectors given as xyz components
      * * The returned angle is between 0 and PI
-     *
      * @param ux x component of vector u
      * @param uy y component of vector u
      * @param uz z component of vector u
@@ -205607,7 +205604,8 @@ class Angle {
         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.
+     * 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.
@@ -205621,7 +205619,8 @@ class Angle {
      * @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)
+     * @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;
@@ -205632,8 +205631,8 @@ class Angle {
         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.
+                // 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 {
@@ -205748,7 +205747,8 @@ class AngleSweep {
     get endAngle() {
         return _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createRadians(this._radians1);
     }
-    /** Create a sweep as one of
+    /**
+     * Create a sweep as one of
      * * A clone of a given sweep
      * * 0 to given angle
      * * full circle if no arg given (sweep 0 to 360 degrees)
@@ -205760,7 +205760,8 @@ class AngleSweep {
             return new AngleSweep(0, data.radians);
         return AngleSweep.create360();
     }
-    /** (private) constructor with start and end angles in radians.
+    /**
+     * (private) constructor with start and end angles in radians.
      * * Use explicitly named static methods to clarify intent and units of inputs:
      *
      * * createStartEndRadians (startRadians:number, endRadians:number)
@@ -205775,9 +205776,9 @@ class AngleSweep {
         this._radians1 = endRadians;
     }
     /**
-     * directly set the start and end angles in radians
+     * Directly set the start and end angles in radians
      * * If the difference between startRadians and endRadians is greater than 360, the function limits the angle sweep to 360.
-     * */
+     */
     setStartEndRadians(startRadians = 0, endRadians = 2.0 * Math.PI) {
         const delta = endRadians - startRadians;
         if (_Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.isFullCircleRadians(delta)) {
@@ -205786,14 +205787,14 @@ class AngleSweep {
         this._radians0 = startRadians;
         this._radians1 = endRadians;
     }
-    /** directly set the start and end angles in degrees */
+    /** Directly set the start and end angles in degrees */
     setStartEndDegrees(startDegrees = 0, endDegrees = 360.0) {
         this.setStartEndRadians(_Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.degreesToRadians(startDegrees), _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.degreesToRadians(endDegrees));
     }
     /**
-     * create an AngleSweep from start and end angles given in radians.
+     * Create an AngleSweep from start and end angles given in radians.
      * * If the difference between startRadians and endRadians is greater than 360, the function limits the angle sweep to 360.
-     * */
+     */
     static createStartEndRadians(startRadians = 0, endRadians = 2.0 * Math.PI, result) {
         result = result ? result : new AngleSweep();
         result.setStartEndRadians(startRadians, endRadians);
@@ -205803,23 +205804,23 @@ class AngleSweep {
     cloneMinusRadians(radians) {
         return new AngleSweep(this._radians0 - radians, this._radians1 - radians);
     }
-    /** create an AngleSweep from start and end angles given in degrees. */
+    /** Create an AngleSweep from start and end angles given in degrees. */
     static createStartEndDegrees(startDegrees = 0, endDegrees = 360, result) {
         return AngleSweep.createStartEndRadians(_Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.degreesToRadians(startDegrees), _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.degreesToRadians(endDegrees), result);
     }
-    /** create an angle sweep from strongly typed start and end angles */
+    /** Create an angle sweep from strongly typed start and end angles */
     static createStartEnd(startAngle, endAngle, result) {
         result = result ? result : new AngleSweep();
         result.setStartEndRadians(startAngle.radians, endAngle.radians);
         return result;
     }
-    /** create an AngleSweep from start and end angles given in radians. */
+    /** Create an AngleSweep from start and end angles given in radians. */
     static createStartSweepRadians(startRadians = 0, sweepRadians = Math.PI, result) {
         result = result ? result : new AngleSweep();
         result.setStartEndRadians(startRadians, startRadians + sweepRadians);
         return result;
     }
-    /** create an AngleSweep from start and sweep given in degrees.  */
+    /** Create an AngleSweep from start and sweep given in degrees.  */
     static createStartSweepDegrees(startDegrees = 0, sweepDegrees = 360, result) {
         return AngleSweep.createStartEndRadians(_Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.degreesToRadians(startDegrees), _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.degreesToRadians(startDegrees + sweepDegrees), result);
     }
@@ -205831,17 +205832,17 @@ class AngleSweep {
     interpolate(fraction, other) {
         return new AngleSweep(_Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.interpolate(this._radians0, fraction, other._radians0), _Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.interpolate(this._radians1, fraction, other._radians1));
     }
-    /** copy from other AngleSweep. */
+    /** Copy from other AngleSweep. */
     setFrom(other) {
         this._radians0 = other._radians0;
         this._radians1 = other._radians1;
     }
-    /** create a full circle sweep (CCW). startRadians defaults to 0 */
+    /** Create a full circle sweep (CCW). startRadians defaults to 0 */
     static create360(startRadians) {
         startRadians = startRadians ? startRadians : 0.0;
         return new AngleSweep(startRadians, startRadians + 2.0 * Math.PI);
     }
-    /** create a sweep from the south pole to the north pole (-90 to +90). */
+    /** Create a sweep from the south pole to the north pole (-90 to +90). */
     static createFullLatitude() {
         return AngleSweep.createStartEndRadians(-0.5 * Math.PI, 0.5 * Math.PI);
     }
@@ -205851,7 +205852,8 @@ class AngleSweep {
         this._radians0 = this._radians1;
         this._radians1 = tmp;
     }
-    /**  return a sweep for the "other" part of the circle.
+    /**
+     * Return a sweep for the "other" part of the circle.
      * @param reverseDirection true to move backwards (CW) from start to end, false to more forwards (CCW) from start to end.
      */
     cloneComplement(reverseDirection = false, result) {
@@ -205861,9 +205863,7 @@ class AngleSweep {
         else
             return AngleSweep.createStartEndRadians(this.endRadians, this.startRadians + s * Math.PI, result);
     }
-    /**
-     * Restrict start and end angles into the range (-90,+90) in degrees.
-     * */
+    /** Restrict start and end angles into the range (-90,+90) in degrees */
     capLatitudeInPlace() {
         const limit = 0.5 * Math.PI;
         this._radians0 = _Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.clampToStartEnd(this._radians0, -limit, limit);
@@ -205883,7 +205883,7 @@ class AngleSweep {
         return _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.isAlmostEqualRadiansNoPeriodShift(this._radians0, -a)
             && _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.isAlmostEqualRadiansNoPeriodShift(this._radians1, a);
     }
-    /** return a clone of this sweep. */
+    /** Return a clone of this sweep. */
     clone() {
         return new AngleSweep(this._radians0, this._radians1);
     }
@@ -205897,15 +205897,16 @@ class AngleSweep {
     fractionToAngle(fraction) {
         return _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createRadians(this.fractionToRadians(fraction));
     }
-    /** return 2PI divided by the sweep radians (i.e. 360 degrees divided by sweep angle).
+    /**
+     * Return 2PI divided by the sweep radians (i.e. 360 degrees divided by sweep angle).
      * * This is the number of fractional intervals required to cover a whole circle.
      */
     fractionPeriod() {
         return _Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.safeDivideFraction(Math.PI * 2.0, Math.abs(this._radians1 - this._radians0), 1.0);
     }
-    /** return the fractionalized position of the given angle (as Angle) computed without consideration of
+    /**
+     * Return the fractionalized position of the given angle (as Angle) computed without consideration of
      * 2PI period and without consideration of angle sweep direction (CW or CCW).
-     *
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
      * *  interior angles are between 0 and 1
@@ -205918,8 +205919,8 @@ class AngleSweep {
     angleToUnboundedFraction(theta) {
         return _Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.safeDivideFraction(theta.radians - this._radians0, this._radians1 - this._radians0, 1.0);
     }
-    /** return the fractionalized position of the given angle (as radians), computed with consideration of 2PI period.
-     *
+    /**
+     * Return the fractionalized position of the given angle (as radians), computed with consideration of 2PI period.
      * *  consider radians0 as `start` angle of the sweep and radians1 as `end` angle of the sweep
      * *  fraction is always positive
      * *  the start angle is at fraction 0
@@ -205944,8 +205945,8 @@ class AngleSweep {
         const fraction2 = _Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.safeDivideFraction(delta2, -sweep, zeroSweepDefault);
         return fraction2;
     }
-    /** return the fractionalized position of the given angle (as radians), computed with consideration of 2PI period.
-     *
+    /**
+     * Return the fractionalized position of the given angle (as radians), computed with consideration of 2PI period.
      * *  fraction is always positive
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
@@ -205956,8 +205957,8 @@ class AngleSweep {
     radiansToPositivePeriodicFraction(radians, zeroSweepDefault = 0.0) {
         return AngleSweep.radiansToPositivePeriodicFractionStartEnd(radians, this._radians0, this._radians1, zeroSweepDefault);
     }
-    /** return the fractionalized position of the given angle (as Angle), computed with consideration of 2PI period.
-     *
+    /**
+     * Return the fractionalized position of the given angle (as Angle), computed with consideration of 2PI period.
      * *  fraction is always positive
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
@@ -205968,8 +205969,8 @@ class AngleSweep {
     angleToPositivePeriodicFraction(theta) {
         return this.radiansToPositivePeriodicFraction(theta.radians);
     }
-    /** return the fractionalized position of the given array of angles (as radian), computed with consideration of 2PI period.
-     *
+    /**
+     * Return the fractionalized position of the given array of angles (as radian), computed with consideration of 2PI period.
      * *  fraction is always positive
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
@@ -205983,9 +205984,9 @@ class AngleSweep {
             data.reassign(i, this.radiansToPositivePeriodicFraction(data.atUncheckedIndex(i)));
         }
     }
-    /** return the fractionalized position of the given angle (as radian) computed with consideration of
+    /**
+     * Return the fractionalized position of the given angle (as radian) computed with consideration of
      * 2PI period and with consideration of angle sweep direction (CW or CCW).
-     *
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
      * *  interior angles are between 0 and 1
@@ -206009,9 +206010,9 @@ class AngleSweep {
         const fraction = 0.5 + _Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.safeDivideFraction(delta2, -sweep, 0.0);
         return fraction;
     }
-    /** return the fractionalized position of the given angle (as Angle) computed with consideration of
+    /**
+     * Return the fractionalized position of the given angle (as Angle) computed with consideration of
      * 2PI period and with consideration of angle sweep direction (CW or CCW).
-     *
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
      * *  interior angles are between 0 and 1
@@ -206022,7 +206023,7 @@ class AngleSweep {
     angleToSignedPeriodicFraction(theta) {
         return this.radiansToSignedPeriodicFraction(theta.radians);
     }
-    /** test if the given angle (as radians) is within sweep (between radians0 and radians1)   */
+    /** Test if the given angle (as radians) is within sweep (between radians0 and radians1)   */
     static isRadiansInStartEnd(radians, radians0, radians1, allowPeriodShift = true) {
         const delta0 = radians - radians0;
         const delta1 = radians - radians1;
@@ -206032,16 +206033,16 @@ class AngleSweep {
             return allowPeriodShift ? _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.isAlmostEqualRadiansAllowPeriodShift(radians, radians0) : _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.isAlmostEqualRadiansNoPeriodShift(radians, radians0);
         return allowPeriodShift ? this.radiansToPositivePeriodicFractionStartEnd(radians, radians0, radians1, 1000.0) <= 1.0 : false;
     }
-    /** test if the given angle (as radians) is within sweep  */
+    /** Test if the given angle (as radians) is within sweep  */
     isRadiansInSweep(radians, allowPeriodShift = true) {
         return AngleSweep.isRadiansInStartEnd(radians, this.startRadians, this.endRadians, allowPeriodShift);
     }
-    /** test if the given angle (as Angle) is within the sweep */
+    /** Test if the given angle (as Angle) is within the sweep */
     isAngleInSweep(angle) {
         return this.isRadiansInSweep(angle.radians);
     }
-    /** set this AngleSweep from various sources:
-     *
+    /**
+     * Set this AngleSweep from various sources:
      * * if json is undefined, a full-circle sweep is returned.
      * * If json is an AngleSweep object, it is cloned
      * * If json is an array of 2 numbers, those numbers are start and end angles in degrees.
@@ -206063,7 +206064,7 @@ class AngleSweep {
         else
             this.setStartEndRadians(); // default full circle
     }
-    /** create an AngleSweep from a json object. */
+    /** Create an AngleSweep from a json object. */
     static fromJSON(json) {
         const result = AngleSweep.create360();
         result.setFromJSON(json);
@@ -206076,7 +206077,8 @@ class AngleSweep {
     toJSON() {
         return [this.startDegrees, this.endDegrees];
     }
-    /** test if this angle sweep and other angle sweep match with radians tolerance.
+    /**
+     * Test if this angle sweep and other angle sweep match with radians tolerance.
      * * Period shifts are allowed.
      */
     isAlmostEqualAllowPeriodShift(other) {
@@ -206085,14 +206087,16 @@ class AngleSweep {
         return _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.isAlmostEqualRadiansAllowPeriodShift(this._radians0, other._radians0)
             && _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.isAlmostEqualRadiansAllowPeriodShift(this._radians1 - this._radians0, other._radians1 - other._radians0);
     }
-    /** test if this angle sweep and other angle sweep match with radians tolerance.
+    /**
+     * Test if this angle sweep and other angle sweep match with radians tolerance.
      * * Period shifts are not allowed.
      */
     isAlmostEqualNoPeriodShift(other) {
         return _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.isAlmostEqualRadiansNoPeriodShift(this._radians0, other._radians0)
             && _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.isAlmostEqualRadiansNoPeriodShift(this._radians1 - this._radians0, other._radians1 - other._radians0);
     }
-    /** test if start and end angles match with radians tolerance.
+    /**
+     * Test if start and end angles match with radians tolerance.
      * * Period shifts are not allowed.
      * * This function is equivalent to isAlmostEqualNoPeriodShift. It is present for consistency with other classes.
      * However, it is recommended to use isAlmostEqualNoPeriodShift which has a clearer name.
@@ -213359,7 +213363,7 @@ class Matrix3d {
         return undefined;
     }
     /**
-     * Multiply `matrixInverse * [x,y,z]` and return result as `Point4d` the with given weight as last element.
+     * Multiply `matrixInverse * [x,y,z]` and return result as a `Point4d` with the given weight as the last coordinate.
      * * Equivalent to solving `matrix * result = [x,y,z]` for an unknown `result`.
      * * Result is `undefined` if the matrix is singular (e.g. has parallel columns or a zero magnitude column)
      * @return result as a Point4d with the same weight.
@@ -213495,20 +213499,17 @@ class Matrix3d {
     }
     /**
      * Multiply `this` Matrix3d (considered to be a Transform with 0 `origin`) times `other` Transform.
-     * **Note:** If `other = [B   b]`, then we promote `this` matrix to be a Transform [A   0].
-     * Then `this * other` is defined as [A*B   Aa]. That's because we create a 4x4 matrix for each Transform
-     * with the 3x3 `matrix` and `origin` as upper 3x4 part of a 4x4 matrix and 0001 as the final row. Then we
-     * multiply those two 4x4 matrixes:
+     * * **Note:** If `this = [A   0]` and `other = [B   b]`, then `this * other` is defined as [A*B   Ab] because:
      * ```
      * equation
      * \begin{matrix}
-     * \text{`this` matrix }\bold{A}\text{ promoted to block Transform} & \blockTransform{A}{0} \\
-     * \text{`other` Transform with `matrix` part }\bold{B}\text{ and `origin` part }\bold{b} & \blockTransform{B}{b}\\
+     * \text{this matrix }\bold{A}\text{ promoted to block Transform} & \blockTransform{A}{0} \\
+     * \text{other Transform with `matrix` part }\bold{B}\text{ and origin part }\bold{b} & \blockTransform{B}{b}\\
      * \text{product}& \blockTransform{A}{0}\blockTransform{B}{b}=\blockTransform{AB}{Ab}
      * \end{matrix}
      * ```
      * @param other the `other` Transform to be multiplied to `this` matrix.
-     * @param result optional preallocated result to reuse.
+     * @param result optional preallocated `result` to reuse.
      */
     multiplyMatrixTransform(other, result) {
         if (!result)
@@ -214291,7 +214292,7 @@ __webpack_require__.r(__webpack_exports__);
 
 /* cspell:word cxcz, cxsz, cxcy, cxsy, sxcz, sxsz, sxcy, sxsy, cycz, cysz, sycz, sysz */
 /**
- * represents a non-trivial rotation using three simple axis rotation angles and an order in which to apply them.
+ * Represents a non-trivial rotation using three simple axis rotation angles and an order in which to apply them.
  * * This class accommodates application-specific interpretation of "multiplying 3 rotation matrices" with regard to
  *   * Whether a "vector" is a "row" or a "column"
  *   * The order in which the X,Y,Z rotations are applied.
@@ -214349,7 +214350,7 @@ class OrderedRotationAngles {
     get zRadians() {
         return this._z.radians;
     }
-    /** the flag controlling whether vectors are treated as rows or as columns */
+    /** The flag controlling whether vectors are treated as rows or as columns */
     static get treatVectorsAsColumns() {
         return OrderedRotationAngles._sTreatVectorsAsColumns;
     }
@@ -214432,7 +214433,7 @@ class OrderedRotationAngles {
      * * In the failure case the method's return value is `undefined`.
      * * In the failure case, if the optional result was supplied, that result will nonetheless be filled with
      * a set of angles.
-     * */
+     */
     static createFromMatrix3d(matrix, order, result) {
         // treat vector as columns
         let m11 = matrix.coffs[0], m12 = matrix.coffs[1], m13 = matrix.coffs[2];
@@ -215229,21 +215230,19 @@ class Point2dArrayCarrier extends _IndexedXYCollection__WEBPACK_IMPORTED_MODULE_
         return undefined;
     }
     /**
-   * Return the cross product of vectors from point at originIndex to points at indexA and indexB
-   * @param originIndex index of origin
-   * @param indexA index of first target within the array
-   * @param indexB index of second target within the array
-   * @param result caller-allocated vector.
-   * @returns return true if indexA, indexB both valid
-   */
+     * Return the cross product of vectors from point at originIndex to points at indexA and indexB
+     * @param originIndex index of origin
+     * @param indexA index of first target within the array
+     * @param indexB index of second target within the array
+     * @param result caller-allocated vector.
+     * @returns return true if indexA, indexB both valid
+     */
     crossProductIndexIndexIndex(originIndex, indexA, indexB) {
         if (this.isValidIndex(originIndex) && this.isValidIndex(indexA) && this.isValidIndex(indexB))
             return _Point2dVector2d__WEBPACK_IMPORTED_MODULE_1__.XY.crossProductToPoints(this.data[originIndex], this.data[indexA], this.data[indexB]);
         return undefined;
     }
-    /**
-     * read-only property for number of XYZ in the collection.
-     */
+    /** Read-only property for number of XYZ in the collection. */
     get length() {
         return this.data.length;
     }
@@ -215289,10 +215288,11 @@ __webpack_require__.r(__webpack_exports__);
  * @module CartesianGeometry
  */
 // cspell:word JSONXY
-// cspell:word CWXY
+// cspell:word CWXY CCWXY
 
 
-/** Minimal object containing x,y and operations that are meaningful without change in both point and vector.
+/**
+ * Minimal object containing x,y and operations that are meaningful without change in both point and vector.
  *  * `XY` is not instantiable.
  *  * The derived (instantiable) classes are
  *    * `Point2d`
@@ -215337,11 +215337,11 @@ class XY {
     isAlmostEqualXY(x, y, tol) {
         return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.isSameCoordinate(this.x, x, tol) && _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.isSameCoordinate(this.y, y, tol);
     }
-    /** return a json array  `[x,y]`   */
+    /** Return a json array  `[x,y]`   */
     toJSON() {
         return [this.x, this.y];
     }
-    /** return a json object `{x: 1, y:2}`  */
+    /** Return a json object `{x: 1, y:2}`  */
     toJSONXY() {
         return { x: this.x, y: this.y };
     }
@@ -215349,7 +215349,7 @@ class XY {
      * Set x and y from a JSON input such as `[1,2]` or `{x:1, y:2}`
      * * If no JSON input is provided, 0 would be used as default values for x and y.
      * @param json the JSON input
-     * */
+     */
     setFromJSON(json) {
         if (Array.isArray(json)) {
             this.set(json[0] || 0, json[1] || 0);
@@ -215377,17 +215377,13 @@ class XY {
     maxDiff(other) {
         return Math.max(Math.abs(this.x - other.x), Math.abs(this.y - other.y));
     }
-    /**
-     * Return the x,y component corresponding to 0,1.
-     */
+    /** Return the x,y component corresponding to 0,1 */
     at(index) {
         if (index < 0.5)
             return this.x;
         return this.y;
     }
-    /**
-     * Set value at index 0 or 1.
-     */
+    /** Set value at index 0 or 1 */
     setAt(index, value) {
         if (index < 0.5)
             this.x = value;
@@ -215404,7 +215400,7 @@ class XY {
         }
         return index;
     }
-    /** returns true if the x,y components are both small by metric metric tolerance */
+    /** Returns true if the x,y components are both small by metric metric tolerance */
     get isAlmostZero() {
         return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.isSmallMetricDistance(this.x) && _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.isSmallMetricDistance(this.y);
     }
@@ -215420,11 +215416,11 @@ class XY {
     magnitudeSquared() {
         return this.x * this.x + this.y * this.y;
     }
-    /** returns true if the x,y components are exactly equal. */
+    /** Returns true if the x,y components are exactly equal. */
     isExactEqual(other) {
         return this.x === other.x && this.y === other.y;
     }
-    /** returns true if x,y match `other` within metric tolerance */
+    /** Returns true if x,y match `other` within metric tolerance */
     isAlmostEqualMetric(other, distanceTol = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.smallMetricDistance) {
         return this.maxDiff(other) <= distanceTol;
     }
@@ -215436,7 +215432,7 @@ class XY {
     unitVectorTo(other, result) {
         return this.vectorTo(other, result).normalize(result);
     }
-    /** cross product of vectors from origin to targets */
+    /** Cross product of vectors from origin to targets */
     static crossProductToPoints(origin, targetA, targetB) {
         return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.crossProductXYXY(targetA.x - origin.x, targetA.y - origin.y, targetB.x - origin.x, targetB.y - origin.y);
     }
@@ -215449,7 +215445,7 @@ class Point2d extends XY {
     constructor(x = 0, y = 0) {
         super(x, y);
     }
-    /** return a new Point2d with x,y coordinates from this. */
+    /** Return a new Point2d with x,y coordinates from this. */
     clone(result) {
         return Point2d.create(this.x, this.y, result);
     }
@@ -215471,7 +215467,7 @@ class Point2d extends XY {
      * Set x and y from a JSON input such as `[1,2]` or `{x:1, y:2}`
      * * If no JSON input is provided, 0 would be used as default values for x and y.
      * @param json the JSON input
-     * */
+     */
     static fromJSON(json) {
         const val = new Point2d();
         val.setFromJSON(json);
@@ -215487,7 +215483,8 @@ class Point2d extends XY {
     static createZero(result) {
         return Point2d.create(0, 0, result);
     }
-    /** Starting at this point, move along vector by tangentFraction of the vector length, and then
+    /**
+     * Starting at this point, move along vector by tangentFraction of the vector length, and then
      * to the left by leftFraction of the perpendicular vector length.
      * @param tangentFraction distance to move along the vector, as a fraction of vector
      * @param leftFraction distance to move perpendicular to the vector, as a fraction of the rotated vector
@@ -215498,7 +215495,8 @@ class Point2d extends XY {
         const dy = vector.y;
         return Point2d.create(this.x + tangentFraction * dx - leftFraction * dy, this.y + tangentFraction * dy + leftFraction * dx);
     }
-    /** Interpolate at tangentFraction between this instance and point, and then Move by leftFraction
+    /**
+     * Interpolate at tangentFraction between this instance and point, and then Move by leftFraction
      * along the xy perpendicular of the vector between the points.
      */
     forwardLeftInterpolate(tangentFraction, leftFraction, point) {
@@ -215561,7 +215559,8 @@ class Point2d extends XY {
         const y2 = target2.y - this.y;
         return x1 * y2 - y1 * x2;
     }
-    /** Return the fractional coordinate of the projection of this instance x,y onto the
+    /**
+     * Return the fractional coordinate of the projection of this instance x,y onto the
      * line from startPoint to endPoint.
      * @param startPoint start point of line
      * @param endPoint end point of line
@@ -215575,7 +215574,8 @@ class Point2d extends XY {
         return numerator / denominator;
     }
 }
-/** 2D vector with `x`,`y` as properties
+/**
+ * 2D vector with `x`,`y` as properties
  * @public
  */
 class Vector2d extends XY {
@@ -215613,7 +215613,7 @@ class Vector2d extends XY {
     static createZero(result) {
         return Vector2d.create(0, 0, result);
     }
-    /** copy contents from another Point3d, Point2d, Vector2d, or Vector3d, or leading entries of Float64Array */
+    /** Copy contents from another Point3d, Point2d, Vector2d, or Vector3d, or leading entries of Float64Array */
     static createFrom(data, result) {
         if (data instanceof Float64Array) {
             if (data.length >= 2)
@@ -215628,7 +215628,7 @@ class Vector2d extends XY {
      * Set x and y from a JSON input such as `[1,2]` or `{x:1, y:2}`
      * * If no JSON input is provided, 0 would be used as default values for x and y.
      * @param json the JSON input
-     * */
+     */
     static fromJSON(json) {
         const val = new Vector2d();
         val.setFromJSON(json);
@@ -215660,7 +215660,8 @@ class Vector2d extends XY {
         }
         return undefined;
     }
-    /** Return a (new or optionally reused) vector which is `this` divided by `denominator`
+    /**
+     * Return a (new or optionally reused) vector which is `this` divided by `denominator`
      * * return undefined if denominator is zero.
      */
     safeDivideOrNull(denominator, result) {
@@ -215681,7 +215682,7 @@ class Vector2d extends XY {
      * it's returning the length of the projection as a fraction of the target magnitude.
      * @param target the target vector
      * @param defaultFraction the returned value in case magnitude square of target vector is very small
-     * */
+     */
     fractionOfProjectionToVector(target, defaultFraction) {
         /*
          * projection length is (this.target)/||target||
@@ -215736,7 +215737,7 @@ class Vector2d extends XY {
         }
         return result;
     }
-    /** return a new Vector2d rotated CCW by given angle */
+    /** Return a new Vector2d rotated CCW by given angle */
     rotateXY(angle, result) {
         const s = angle.sin();
         const c = angle.cos();
@@ -215748,7 +215749,8 @@ class Vector2d extends XY {
         result.y = xx * s + yy * c;
         return result;
     }
-    /** Return a vector computed at fractional position between this vector and vectorB
+    /**
+     * Return a vector computed at fractional position between this vector and vectorB
     * @param fraction fractional position.  0 is at `this`.  1 is at `vectorB`.
     *                 True fractions are "between", negatives are "before this", beyond 1 is "beyond vectorB".
     * @param vectorB second vector
@@ -215771,14 +215773,14 @@ class Vector2d extends XY {
         }
         return result;
     }
-    /** return {this + vector}. */
+    /** Return {this + vector}. */
     plus(vector, result) {
         result = result ? result : new Vector2d();
         result.x = this.x + vector.x;
         result.y = this.y + vector.y;
         return result;
     }
-    /** return {this - vector}. */
+    /** Return {this - vector}. */
     minus(vector, result) {
         result = result ? result : new Vector2d();
         result.x = this.x - vector.x;
@@ -215813,34 +215815,34 @@ class Vector2d extends XY {
         result.y = this.y * scale;
         return result;
     }
-    /** return a vector parallel to this but with specified length */
+    /** Return a vector parallel to this but with specified length */
     scaleToLength(length, result) {
         const mag = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.correctSmallMetricDistance(this.magnitude());
         if (mag === 0)
             return undefined;
         return this.scale(length / mag, result);
     }
-    /** return the dot product of this with vectorB */
+    /** Return the dot product of this with vectorB */
     dotProduct(vectorB) {
         return this.x * vectorB.x + this.y * vectorB.y;
     }
-    /** dot product with vector from pointA to pointB */
+    /** Dot product with vector from pointA to pointB */
     dotProductStartEnd(pointA, pointB) {
         return this.x * (pointB.x - pointA.x) + this.y * (pointB.y - pointA.y);
     }
-    /** vector cross product {this CROSS vectorB} */
+    /** Vector cross product {this CROSS vectorB} */
     crossProduct(vectorB) {
         return this.x * vectorB.y - this.y * vectorB.x;
     }
     /**
-     * return the radians (as a simple number, not strongly typed Angle) signed angle from this to vectorB.
+     * Return the radians (as a simple number, not strongly typed Angle) signed angle from this to vectorB.
      * This is positive if the shortest turn is counterclockwise, negative if clockwise.
      */
     radiansTo(vectorB) {
         return Math.atan2(this.crossProduct(vectorB), this.dotProduct(vectorB));
     }
     /**
-     * return the (strongly typed) signed angle from this to vectorB.
+     * Return the (strongly typed) signed angle from this to vectorB.
      * This is positive if the shortest turn is counterclockwise, negative if clockwise.
      */
     angleTo(vectorB) {
@@ -215928,7 +215930,7 @@ class Point3dArrayCarrier extends _IndexedXYZCollection__WEBPACK_IMPORTED_MODULE
         super();
         this.data = data;
     }
-    /** test if `index` is a valid index into the array. */
+    /** Test if `index` is a valid index into the array. */
     isValidIndex(index) {
         return index >= 0 && index < this.data.length;
     }
@@ -215970,23 +215972,23 @@ class Point3dArrayCarrier extends _IndexedXYZCollection__WEBPACK_IMPORTED_MODULE
         return undefined;
     }
     /**
-     * access x of indexed point
+     * Access x of indexed point
      * * WARNING: make sure `pointIndex` is a valid index, otherwise, you get random results
-     * */
+     */
     getXAtUncheckedPointIndex(pointIndex) {
         return this.data[pointIndex].x;
     }
     /**
-     * access y of indexed point
+     * Access y of indexed point
      * * WARNING: make sure `pointIndex` is a valid index, otherwise, you get random results
-     * */
+     */
     getYAtUncheckedPointIndex(pointIndex) {
         return this.data[pointIndex].y;
     }
     /**
-     * access z of indexed point
+     * Access z of indexed point
      * * WARNING: make sure `pointIndex` is a valid index, otherwise, you get random results
-     * */
+     */
     getZAtUncheckedPointIndex(pointIndex) {
         return this.data[pointIndex].z;
     }
@@ -216053,10 +216055,7 @@ class Point3dArrayCarrier extends _IndexedXYZCollection__WEBPACK_IMPORTED_MODULE
         if (this.isValidIndex(originIndex) && this.isValidIndex(indexA) && this.isValidIndex(indexB))
             result.addCrossProductToTargetsInPlace(data[originIndex].x, data[originIndex].y, data[originIndex].z, data[indexA].x, data[indexA].y, data[indexA].z, data[indexB].x, data[indexB].y, data[indexB].z);
     }
-    /**
-     * Accumulate scale times the x,y,z values at index to the sum.
-     * No action if index is out of bounds.
-     */
+    /** Accumulate scale times the x,y,z values at index to the sum. No action if index is out of bounds */
     accumulateScaledXYZ(index, scale, sum) {
         if (this.isValidIndex(index)) {
             const point = this.data[index];
@@ -216065,20 +216064,19 @@ class Point3dArrayCarrier extends _IndexedXYZCollection__WEBPACK_IMPORTED_MODULE
             sum.z += scale * point.z;
         }
     }
-    /**
-     * read-only property for number of XYZ in the collection.
-     */
+    /** Read-only property for number of XYZ in the collection */
     get length() {
         return this.data.length;
     }
-    /** push a (clone of) point onto the collection
+    /**
+     * Push a (clone of) point onto the collection
      * * point itself is not pushed -- xyz data is extracted into the native form of the collection.
      */
     push(data) {
         this.data.push(data.clone());
     }
     /**
-     * push a new point (given by coordinates) onto the collection
+     * Push a new point (given by coordinates) onto the collection
      * @param x x coordinate
      * @param y y coordinate
      * @param z z coordinate
@@ -216086,26 +216084,26 @@ class Point3dArrayCarrier extends _IndexedXYZCollection__WEBPACK_IMPORTED_MODULE
     pushXYZ(x, y, z) {
         this.data.push(_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(x === undefined ? 0.0 : x, y === undefined ? 0.0 : y, z === undefined ? 0.0 : z));
     }
-    /** extract (copy) the final point */
+    /** Extract (copy) the final point */
     back(result) {
         if (this.data.length > 0) {
             return this.data[this.data.length - 1].clone(result);
         }
         return undefined;
     }
-    /** extract (copy) the first point */
+    /** Extract (copy) the first point */
     front(result) {
         if (this.data.length > 0) {
             return this.data[0].clone(result);
         }
         return undefined;
     }
-    /** remove the final point. */
+    /** Remove the final point. */
     pop() {
         if (this.data.length > 0)
             this.data.pop();
     }
-    /** remove all points. */
+    /** Remove all points. */
     clear() {
         this.data.length = 0;
     }
@@ -216174,7 +216172,8 @@ __webpack_require__.r(__webpack_exports__);
 
 // cspell:words CWXY CCWXY arctan Rodrigues
 /**
- *  * `XYZ` is a minimal object containing x,y,z and operations that are meaningful without change in both point and vector.
+ * * `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.
  *  * The derived (instantiable) classes are
  *    * `Point3d`
@@ -216218,7 +216217,8 @@ class XYZ {
     static isXYAndZ(arg) {
         return this.isXAndY(arg) && this.hasZ(arg);
     }
-    /** Test if arg is any of:
+    /**
+     * Test if arg is any of:
      * * XAndY
      * * XYAndZ
      * * [number,number]
@@ -216227,7 +216227,8 @@ class XYZ {
     static isAnyImmediatePointType(arg) {
         return Point3d.isXAndY(arg) || _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.isNumberArray(arg, 2);
     }
-    /** Look for (in order) an x coordinate present as:
+    /**
+     * Look for (in order) an x coordinate present as:
      * * arg.x
      * * arg[0]
      */
@@ -216238,7 +216239,8 @@ class XYZ {
             return arg[0];
         return defaultValue;
     }
-    /** Look for (in order) an x coordinate present as:
+    /**
+     * Look for (in order) an x coordinate present as:
      * * arg.y
      * * arg[1]
      */
@@ -216249,7 +216251,8 @@ class XYZ {
             return arg[1];
         return defaultValue;
     }
-    /** Look for (in order) an x coordinate present as:
+    /**
+     * Look for (in order) an x coordinate present as:
      * * arg.z
      * * arg[2]
      */
@@ -216312,7 +216315,8 @@ class XYZ {
             this.setZero();
         }
     }
-    /** Returns true if this and other have equal x,y,z parts within Geometry.smallMetricDistance.
+    /**
+     * Returns true if this and other have equal x,y,z parts within Geometry.smallMetricDistance.
      * @param other The other XYAndZ to compare
      * @param tol The tolerance for the comparison. If undefined, use [[Geometry.smallMetricDistance]]
      */
@@ -216393,9 +216397,7 @@ class XYZ {
     maxDiff(other) {
         return Math.max(Math.abs(this.x - other.x), Math.abs(this.y - other.y), Math.abs(this.z - other.z));
     }
-    /**
-     * Return the x,y, z component corresponding to 0,1,2.
-     */
+    /** Return the x,y, z component corresponding to 0,1,2 */
     at(index) {
         if (index < 0.5)
             return this.x;
@@ -216403,9 +216405,7 @@ class XYZ {
             return this.z;
         return this.y;
     }
-    /**
-     * Set value at index 0 or 1 or 2.
-     */
+    /** Set value at index 0 or 1 or 2 */
     setAt(index, value) {
         if (index < 0.5)
             this.x = value;
@@ -216459,27 +216459,27 @@ class XYZ {
     magnitudeSquaredXY() {
         return this.x * this.x + this.y * this.y;
     }
-    /** exact equality test. */
+    /** Exact equality test. */
     isExactEqual(other) {
         return this.x === other.x && this.y === other.y && this.z === other.z;
     }
-    /** equality test with Geometry.smallMetricDistance tolerance */
+    /** Equality test with Geometry.smallMetricDistance tolerance */
     isAlmostEqualMetric(other) {
         return this.maxDiff(other) <= _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.smallMetricDistance;
     }
-    /** add x,y,z from other in place. */
+    /** Add x,y,z from other in place. */
     addInPlace(other) {
         this.x += other.x;
         this.y += other.y;
         this.z += other.z;
     }
-    /** add x,y,z from other in place. */
+    /** Add x,y,z from other in place. */
     subtractInPlace(other) {
         this.x -= other.x;
         this.y -= other.y;
         this.z -= other.z;
     }
-    /** add (in place) the scaled x,y,z of other */
+    /** Add (in place) the scaled x,y,z of other */
     addScaledInPlace(other, scale) {
         this.x += scale * other.x;
         this.y += scale * other.y;
@@ -216491,7 +216491,7 @@ class XYZ {
         this.y *= scale;
         this.z *= scale;
     }
-    /** add to x, y, z parts */
+    /** Add to x, y, z parts */
     addXYZInPlace(dx = 0.0, dy = 0.0, dz = 0.0) {
         this.x += dx;
         this.y += dy;
@@ -216509,7 +216509,8 @@ class XYZ {
     scaledVectorTo(other, scale, result) {
         return Vector3d.create(scale * (other.x - this.x), scale * (other.y - this.y), scale * (other.z - this.z), result);
     }
-    /** Return a unit vector from this vector to other. Return a 000 vector if the input is too small to normalize.
+    /**
+     * Return a unit vector from this vector to other. Return a 000 vector if the input is too small to normalize.
      * @param other target of created vector.
      * @param result optional result vector.
      */
@@ -216520,7 +216521,7 @@ class XYZ {
     freeze() {
         return Object.freeze(this);
     }
-    /** access x part of XYZProps (which may be .x or [0]) */
+    /** Access x part of XYZProps (which may be .x or [0]) */
     static x(xyz, defaultValue = 0) {
         if (xyz === undefined)
             return defaultValue;
@@ -216530,7 +216531,7 @@ class XYZ {
             return xyz.x;
         return defaultValue;
     }
-    /** access x part of XYZProps (which may be .x or [0]) */
+    /** Access x part of XYZProps (which may be .x or [0]) */
     static y(xyz, defaultValue = 0) {
         if (xyz === undefined)
             return defaultValue;
@@ -216540,7 +216541,7 @@ class XYZ {
             return xyz.y;
         return defaultValue;
     }
-    /** access x part of XYZProps (which may be .x or [0]) */
+    /** Access x part of XYZProps (which may be .x or [0]) */
     static z(xyz, defaultValue = 0) {
         if (xyz === undefined)
             return defaultValue;
@@ -216575,7 +216576,8 @@ class Point3d extends XYZ {
     clone(result) {
         return Point3d.create(this.x, this.y, this.z, result);
     }
-    /** Create a new Point3d with given coordinates
+    /**
+     * Create a new Point3d with given coordinates
      * @param x x part
      * @param y y part
      * @param z z part
@@ -216648,8 +216650,8 @@ class Point3d extends XYZ {
     static createZero(result) {
         return Point3d.create(0, 0, 0, result);
     }
-    /** Return the cross product of the vectors from this to pointA and pointB
-     *
+    /**
+     * Return the cross product of the vectors from this to pointA and pointB
      * *  the result is a vector
      * *  the result is perpendicular to both vectors, with right hand orientation
      * *  the magnitude of the vector is twice the area of the triangle.
@@ -216657,21 +216659,20 @@ class Point3d extends XYZ {
     crossProductToPoints(pointA, pointB, result) {
         return Vector3d.createCrossProduct(pointA.x - this.x, pointA.y - this.y, pointA.z - this.z, pointB.x - this.x, pointB.y - this.y, pointB.z - this.z, result);
     }
-    /** Return the magnitude of the cross product of the vectors from this to pointA and pointB
-     */
+    /** Return the magnitude of the cross product of the vectors from this to pointA and pointB */
     crossProductToPointsMagnitude(pointA, pointB) {
         return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.crossProductMagnitude(pointA.x - this.x, pointA.y - this.y, pointA.z - this.z, pointB.x - this.x, pointB.y - this.y, pointB.z - this.z);
     }
-    /** Return the triple product of the vectors from this to pointA, pointB, pointC
-     *
+    /**
+     * Return the triple product of the vectors from this to pointA, pointB, pointC
      * * This is a scalar (number)
      * * This is 6 times the (signed) volume of the tetrahedron on the 4 points.
      */
     tripleProductToPoints(pointA, pointB, pointC) {
         return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.tripleProduct(pointA.x - this.x, pointA.y - this.y, pointA.z - this.z, pointB.x - this.x, pointB.y - this.y, pointB.z - this.z, pointC.x - this.x, pointC.y - this.y, pointC.z - this.z);
     }
-    /** Return the cross product of the vectors from this to pointA and pointB
-     *
+    /**
+     * Return the cross product of the vectors from this to pointA and pointB
      * *  the result is a scalar
      * *  the magnitude of the vector is twice the signed area of the triangle.
      * *  this is positive for counter-clockwise order of the points, negative for clockwise.
@@ -216681,8 +216682,8 @@ class Point3d extends XYZ {
     }
     /**
      * Return a point interpolated between `this` point and the `other` point.
-     * * fraction specifies where the interpolated point is located on the line passing `this` and `other`.
-     * */
+     * * Fraction specifies where the interpolated point is located on the line passing `this` and `other`.
+     */
     interpolate(fraction, other, result) {
         if (fraction <= 0.5)
             return Point3d.create(this.x + fraction * (other.x - this.x), this.y + fraction * (other.y - this.y), this.z + fraction * (other.z - this.z), result);
@@ -216735,7 +216736,8 @@ class Point3d extends XYZ {
     static createScale(source, scale, result) {
         return Point3d.create(source.x * scale, source.y * scale, source.z * scale, result);
     }
-    /** create a point that is a linear combination (weighted sum) of 2 input points.
+    /**
+     * Create a point that is a linear combination (weighted sum) of 2 input points.
      * @param pointA first input point
      * @param scaleA scale factor for pointA
      * @param pointB second input point
@@ -216773,7 +216775,8 @@ class Point3d extends XYZ {
         return startPoint.dotVectorsToTargets(endPoint, this) / denominator;
     }
 }
-/** 3D vector with `x`,`y`,`z` as properties
+/**
+ * 3D vector with `x`,`y`,`z` as properties
  * @public
  */
 class Vector3d extends XYZ {
@@ -216798,7 +216801,7 @@ class Vector3d extends XYZ {
         return Vector3d.create(this.x, this.y, this.z, result);
     }
     /**
-     * return a Vector3d (new or reused from optional result)
+     * Return a Vector3d (new or reused from optional result)
      * @param x x component
      * @param y y component
      * @param z z component
@@ -216851,7 +216854,6 @@ class Vector3d extends XYZ {
     }
     /**
      * Return the cross product of the vectors from origin to pointA and pointB.
-     *
      * * the result is a vector
      * * the result is perpendicular to both vectors, with right hand orientation
      * * the magnitude of the vector is twice the area of the triangle.
@@ -217028,7 +217030,8 @@ class Vector3d extends XYZ {
         this.z *= a;
         return true;
     }
-    /** Create a normalized vector from the inputs.
+    /**
+     * Create a normalized vector from the inputs.
      * @param result optional result
      * @returns undefined if and only if normalization fails
     */
@@ -217062,7 +217065,8 @@ class Vector3d extends XYZ {
             return defaultFraction;
         return numerator / denominator;
     }
-    /** Return a new vector with components negated from the calling instance.
+    /**
+     * Return a new vector with components negated from the calling instance.
      * @param result optional result vector.
      */
     negate(result) {
@@ -217144,7 +217148,8 @@ class Vector3d extends XYZ {
         const normal = this.crossProduct(target).normalize();
         return normal ? normal.crossProduct(this, result) : undefined;
     }
-    /** Rotate this vector 90 degrees around an axis vector.
+    /**
+     * Rotate this vector 90 degrees around an axis vector.
      * * Note that simple cross is in the plane perpendicular to axis -- it loses the part
      * of "this" that is along the axis. The unit and scale is supposed to fix that.
      * This matches with Rodrigues' rotation formula because cos(theta) = 0 and sin(theta) = 1
@@ -217233,8 +217238,10 @@ class Vector3d extends XYZ {
     static createAdd2Scaled(vectorA, scaleA, vectorB, scaleB, result) {
         return Vector3d.create(vectorA.x * scaleA + vectorB.x * scaleB, vectorA.y * scaleA + vectorB.y * scaleB, vectorA.z * scaleA + vectorB.z * scaleB, result);
     }
-    /** Return the (strongly typed Vector3d) `thisVector3d + vectorA * scalarA + vectorB * scalarB`
-     * with all components presented as numbers */
+    /**
+     * Return the (strongly typed Vector3d) `thisVector3d + vectorA * scalarA + vectorB * scalarB`
+     * with all components presented as numbers
+     */
     static createAdd2ScaledXYZ(ax, ay, az, scaleA, bx, by, bz, scaleB, result) {
         return Vector3d.create(ax * scaleA + bx * scaleB, ay * scaleA + by * scaleB, az * scaleA + bz * scaleB, result);
     }
@@ -217261,7 +217268,8 @@ class Vector3d extends XYZ {
             return undefined;
         return this.scale(length / mag, result);
     }
-    /** Compute the cross product of this vector with `vectorB`.   Immediately pass it to `normalize`.
+    /**
+     * Compute the cross product of this vector with `vectorB`.   Immediately pass it to `normalize`.
      * @param vectorB second vector for cross product.
      * @returns see `Vector3d` method `normalize()` for error condition.
      */
@@ -217348,7 +217356,8 @@ class Vector3d extends XYZ {
     crossProductMagnitude(vectorB) {
         return Math.sqrt(this.crossProductMagnitudeSquared(vectorB));
     }
-    /** Return the dot product of this vector with vectorB.
+    /**
+     * Return the dot product of this vector with vectorB.
      * @param vectorB second vector of cross product
      * @returns the dot product of this instance with vectorB
      */
@@ -217404,7 +217413,8 @@ class Vector3d extends XYZ {
         return this.x * (pointB.x - pointA.x)
             + this.y * (pointB.y - pointA.y);
     }
-    /** Dot product with vector from pointA to pointB, with pointB given as (weighted) wx,wy,wz,w
+    /**
+     * Dot product with vector from pointA to pointB, with pointB given as (weighted) wx,wy,wz,w
      * * We need to unweight pointB (which is a homogeneous point) to be able to participate in the
      * vector dot product
      * * if the weight is near zero metric, the return is zero.
@@ -217448,7 +217458,7 @@ class Vector3d extends XYZ {
         return Vector3d.createCrossProduct(this.x, this.y, this.z, vectorB.x, vectorB.y, vectorB.z, result);
     }
     /**
-     * return cross product of `this` with the vector `(x, y, z)`
+     * Return cross product of `this` with the vector `(x, y, z)`
      * @param x x component of second vector
      * @param y y component of second vector
      * @param z z component of second vector
@@ -217458,12 +217468,12 @@ class Vector3d extends XYZ {
         return Vector3d.createCrossProduct(this.x, this.y, this.z, x, y, z, result);
     }
     /**
-   * Return the angle in radians (not as strongly typed Angle) from this vector to vectorB.
-   * * The returned angle is between 0 and `Math.PI`.
-   * * The returned angle is measured in the plane containing the two vectors.
-   * * Use `planarRadiansTo` and `signedRadiansTo` to return an angle measured in a specific plane.
-   * @param vectorB target vector.
-   */
+     * Return the angle in radians (not as strongly typed Angle) from this vector to vectorB.
+     * * The returned angle is between 0 and `Math.PI`.
+     * * The returned angle is measured in the plane containing the two vectors.
+     * * Use `planarRadiansTo` and `signedRadiansTo` to return an angle measured in a specific plane.
+     * @param vectorB target vector.
+     */
     radiansTo(vectorB) {
         // ||axb|| = ||a|| ||b|| |sin(t)| and a.b = ||a|| ||b|| cos(t) ==>
         // ||axb|| / a.b = sin(t)/cos(t) = tan(t) ==> t = arctan(||axb|| / a.b).
@@ -217499,16 +217509,16 @@ class Vector3d extends XYZ {
         return _Angle__WEBPACK_IMPORTED_MODULE_2__.Angle.createAtan2(this.crossProductXY(vectorB), this.dotProductXY(vectorB));
     }
     /**
-   * Return the angle in radians (not as strongly-typed Angle) from this vector to vectorB, measured
-   * in their containing plane whose normal lies in the same half-space as vectorW.
-   * * The returned angle is between `-Math.PI` and `Math.PI`.
-   * * If the cross product of this vector and vectorB lies on the same side of the plane as vectorW,
-   * this function returns `radiansTo(vectorB)`; otherwise, it returns `-radiansTo(vectorB)`.
-   * * `vectorW` does not have to be perpendicular to the plane.
-   * * Use `planarRadiansTo` to measure the angle between vectors that are projected to another plane.
-   * @param vectorB target vector.
-   * @param vectorW determines the side of the plane in which the returned angle is measured
-   */
+     * Return the angle in radians (not as strongly-typed Angle) from this vector to vectorB, measured
+     * in their containing plane whose normal lies in the same half-space as vectorW.
+     * * The returned angle is between `-Math.PI` and `Math.PI`.
+     * * If the cross product of this vector and vectorB lies on the same side of the plane as vectorW,
+     * this function returns `radiansTo(vectorB)`; otherwise, it returns `-radiansTo(vectorB)`.
+     * * `vectorW` does not have to be perpendicular to the plane.
+     * * Use `planarRadiansTo` to measure the angle between vectors that are projected to another plane.
+     * @param vectorB target vector.
+     * @param vectorW determines the side of the plane in which the returned angle is measured
+     */
     signedRadiansTo(vectorB, vectorW) {
         const p = this.crossProduct(vectorB);
         const theta = Math.atan2(p.magnitude(), this.dotProduct(vectorB));
@@ -217517,7 +217527,8 @@ class Vector3d extends XYZ {
         else
             return theta;
     }
-    /** Return the (strongly-typed) angle from this vector to vectorB, measured
+    /**
+     * Return the (strongly-typed) angle from this vector to vectorB, measured
      * in their containing plane whose normal lies in the same half-space as vectorW.
      * * The returned angle is between -180 and 180 degrees.
      * * If the cross product of this vector and vectorB lies on the same side of the plane as vectorW,
@@ -217560,15 +217571,19 @@ class Vector3d extends XYZ {
     planarAngleTo(vectorB, planeNormal) {
         return _Angle__WEBPACK_IMPORTED_MODULE_2__.Angle.createRadians(this.planarRadiansTo(vectorB, planeNormal));
     }
-    /** Return the smallest angle (in radians) from the (bidirectional) line containing `this`
-   * to the (bidirectional) line containing `vectorB` */
+    /**
+     * Return the smallest angle (in radians) from the (bidirectional) line containing `this`
+     * to the (bidirectional) line containing `vectorB`
+     */
     smallerUnorientedRadiansTo(vectorB) {
         const c = this.dotProduct(vectorB);
         const s = this.crossProductMagnitude(vectorB);
         return Math.atan2(Math.abs(s), Math.abs(c));
     }
-    /** Return the smallest (strongly typed) angle from the (bidirectional) line containing `this`
-     * to the (bidirectional) line containing `vectorB` */
+    /**
+     * Return the smallest (strongly typed) angle from the (bidirectional) line containing `this`
+     * to the (bidirectional) line containing `vectorB`
+     */
     smallerUnorientedAngleTo(vectorB) {
         return _Angle__WEBPACK_IMPORTED_MODULE_2__.Angle.createRadians(this.smallerUnorientedRadiansTo(vectorB));
     }
@@ -223469,7 +223484,7 @@ class Transform {
     }
     /**
      * Return a modified copy of `this` Transform so that its `matrix` part is rigid (`origin` part is untouched).
-     * * For details of how the matrix is modified to rigid, see documentation of `Matrix3d.axisOrderCrossProductsInPlace`
+     * * @see [[Matrix3d.axisOrderCrossProductsInPlace]] documentation for details of how the matrix is modified to rigid.
      */
     cloneRigid(axisOrder = _Geometry__WEBPACK_IMPORTED_MODULE_0__.AxisOrder.XYZ) {
         const modifiedMatrix = _Matrix3d__WEBPACK_IMPORTED_MODULE_2__.Matrix3d.createRigidFromMatrix3d(this.matrix, axisOrder);
@@ -223477,7 +223492,7 @@ class Transform {
             return undefined;
         return new Transform(this.origin.cloneAsPoint3d(), modifiedMatrix);
     }
-    /** Create a Transform with the given `origin` and `matrix`. */
+    /** Create a Transform with the given `origin` and `matrix`. Inputs are captured, not cloned. */
     static createRefs(origin, matrix, result) {
         if (!origin)
             origin = _Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.createZero();
@@ -223488,7 +223503,7 @@ class Transform {
         }
         return new Transform(origin, matrix);
     }
-    /** Create a Transform with complete contents given */
+    /** Create a Transform with complete contents given. `q` inputs make the matrix and `a` inputs make the origin */
     static createRowValues(qxx, qxy, qxz, ax, qyx, qyy, qyz, ay, qzx, qzy, qzz, az, result) {
         if (result) {
             result._origin.set(ax, ay, az);
@@ -223503,6 +223518,8 @@ class Transform {
     }
     /**
      * Create a Transform with translation provided by x,y,z parts.
+     * * Translation Transform maps any vector `v` to `v + p` where `p = (x,y,z)`
+     * * Visualization can be found at https://www.itwinjs.org/sandbox/SaeedTorabi/MoveCube
      * @param x x part of translation
      * @param y y part of translation
      * @param z z part of translation
@@ -223514,6 +223531,8 @@ class Transform {
     }
     /**
      * Create a Transform with specified `translation` part.
+     * * Translation Transform maps any vector `v` to `v + translation`
+     * * Visualization can be found at https://www.itwinjs.org/sandbox/SaeedTorabi/MoveCube
      * @param translation x,y,z parts of the translation
      * @param result optional pre-allocated Transform
      * @returns new or updated transform
@@ -223560,6 +223579,7 @@ class Transform {
      * local-to-world mapping.
      * * This function is a closely related to `createFixedPointAndMatrix` whose point input is the fixed point
      * of the world-to-world transformation.
+     * * If origin is `undefined`, (0,0,0) is used. If matrix is `undefined` the identity matrix is used.
      */
     static createOriginAndMatrix(origin, matrix, result) {
         if (result) {
@@ -223585,7 +223605,7 @@ class Transform {
     }
     /**
      * Create a Transform such that its `matrix` part is rigid.
-     * * For details of how the matrix is created to be rigid, see documentation of `Matrix3d.createRigidFromColumns`
+     * @see [[Matrix3d.createRigidFromColumns]] for details of how the matrix is created to be rigid.
      */
     static createRigidFromOriginAndColumns(origin, vectorX, vectorY, axisOrder, result) {
         const matrix = _Matrix3d__WEBPACK_IMPORTED_MODULE_2__.Matrix3d.createRigidFromColumns(vectorX, vectorY, axisOrder, result ? result._matrix : undefined);
@@ -223597,10 +223617,10 @@ class Transform {
             return result;
         }
         /**
-         * We don't want to pass "origin" to createRefs because createRefs does not clone "origin" and use its reference.
-         * That means if "origin" is changed via Transform at any point, the initial "origin" passed by the user is also
-         * changed. To avoid that, we pass undefined to createRefs. This would cause createRefs to create a new "origin"
-         * equals (0,0,0) which then we set it to the "origin" passed by user in the next line.
+         * We don't want to pass "origin" to createRefs because createRefs does not clone "origin". That means if "origin"
+         * is changed via Transform at any point, the initial "origin" passed by the user is also changed. To avoid that,
+         * we pass "undefined" to createRefs so that it allocates a new point which then we set it to the "origin" which
+         * is passed by user in the next line.
          */
         result = Transform.createRefs(undefined, matrix);
         result._origin.setFromPoint3d(origin);
@@ -223623,18 +223643,19 @@ class Transform {
         return Transform.createRefs(undefined, matrix.clone());
     }
     /**
-     * Create a transform with the specified `matrix` and points `a` and `b`. The returned Transform, transforms
-     * point `p` to `M*(p-a) + b` (i.e., `Tp = M*(p-a) + b`) so transforms point `a` to 'b'.
+     * Create a transform with the specified `matrix` and points `a` and `b`. The returned Transform maps
+     * point `p` to `M*(p-a) + b` (i.e., `Tp = M*(p-a) + b`), so maps `a` to 'b'.
      */
     static createMatrixPickupPutdown(matrix, a, b, result) {
-        // we define the origin o = b - M*a so Tp = M*p + o = M*p + (b - M*a) = M*(x-a) + b
+        // we define the origin o = b - M*a so Tp = M*p + o = M*p + (b - M*a) = M*(p-a) + b
         const origin = _Matrix3d__WEBPACK_IMPORTED_MODULE_2__.Matrix3d.xyzMinusMatrixTimesXYZ(b, matrix, a);
         return Transform.createRefs(origin, matrix.clone(), result);
     }
     /**
      * Create a Transform which leaves the fixedPoint unchanged and scales everything else around it by
-     * a single scale factor. The returned Transform, transforms a point `p` to `M*p + (f - M*f)`
+     * a single scale factor. The returned Transform maps a point `p` to `M*p + (f - M*f)`
      * where `f` is the fixedPoint and M is the scale matrix (i.e., `Tp = M*(p-f) + f`).
+     * * Visualization can be found at https://www.itwinjs.org/sandbox/SaeedTorabi/ScaleCube
      */
     static createScaleAboutPoint(fixedPoint, scale, result) {
         const matrix = _Matrix3d__WEBPACK_IMPORTED_MODULE_2__.Matrix3d.createScale(scale, scale, scale);
@@ -223676,8 +223697,7 @@ class Transform {
         return _Matrix3d__WEBPACK_IMPORTED_MODULE_2__.Matrix3d.xyzPlusMatrixTimesCoordinates(this._origin, this._matrix, x, y, z, result);
     }
     /**
-     * Multiply a specific row (component) of the transform matrix times xyz and add it to the origin element
-     * at the same row. Return the result.
+     * Multiply a specific row (component) of the 3x4 instance times (x,y,z,1). Return the result.
      */
     multiplyComponentXYZ(componentIndex, x, y, z = 0) {
         const coffs = this._matrix.coffs;
@@ -223685,8 +223705,7 @@ class Transform {
         return this.origin.at(componentIndex) + (coffs[idx] * x) + (coffs[idx + 1] * y) + (coffs[idx + 2] * z);
     }
     /**
-     * Multiply a specific row (component) of the transform matrix times xyz and add it to the origin element
-     * at the same row times w. Return the result.
+     * Multiply a specific row (component) of the 3x4 instance times (x,y,z,w). Return the result.
      */
     multiplyComponentXYZW(componentIndex, x, y, z, w) {
         const coffs = this._matrix.coffs;
@@ -223694,31 +223713,38 @@ class Transform {
         return (this.origin.at(componentIndex) * w) + (coffs[idx] * x) + (coffs[idx + 1] * y) + (coffs[idx + 2] * z);
     }
     /**
-     * If `p = (x,y,z)` then transform is `Tp = M*p + o*w`. This function returns the transformed point as a new
-     * point4d (`Tp` as first 3 elements and `w` as last element) or in the pre-allocated result (if result is given).
+     * Transform the homogeneous point. Return as a new `Point4d`, or in the pre-allocated result (if result is given).
+     * * If `p = (x,y,z)` then this method computes `Tp = M*p + o*w` and returns the `Point4d` formed by `Tp` in the
+     * first three coordinates, and `w` in the fourth.
+     * * Logically, this is multiplication by the 4x4 matrix formed from the 3x4 instance augmented with fourth row 0001.
      */
     multiplyXYZW(x, y, z, w, result) {
         return _Matrix3d__WEBPACK_IMPORTED_MODULE_2__.Matrix3d.xyzPlusMatrixTimesWeightedCoordinates(this._origin, this._matrix, x, y, z, w, result);
     }
     /**
-     * If `p = (x,y,z)` then transform is `Tp = M*p + o*w`. This function returns the transformed point as a new
-     * Float64Array with size 4 (`Tp` as first 3 elements and `w` as last element) or in the pre-allocated result
-     * (if result is given).
+     * Transform the homogeneous point. Return as new `Float64Array` with size 4, or in the pre-allocated result (if
+     * result is given).
+     * * If `p = (x,y,z)` then this method computes `Tp = M*p + o*w` and returns the `Float64Array` formed by `Tp`
+     * in the first 3 numbers of the array and `w` as the fourth.
+     * * Logically, this is multiplication by the 4x4 matrix formed from the 3x4 instance augmented with fourth row 0001.
      */
     multiplyXYZWToFloat64Array(x, y, z, w, result) {
         return _Matrix3d__WEBPACK_IMPORTED_MODULE_2__.Matrix3d.xyzPlusMatrixTimesWeightedCoordinatesToFloat64Array(this._origin, this._matrix, x, y, z, w, result);
     }
     /**
-     * If `p = (x,y,z)` then transform is `Tp = M*p + o`. This function returns the transformed point as a new
-     * Float64Array with size 3 (`Tp` as 3 elements) or in the pre-allocated result (if result is given).
+     * * Transform the point. Return as new `Float64Array` with size 3, or in the pre-allocated result (if result is given).
+     * * If `p = (x,y,z)` then this method computes `Tp = M*p + o` and returns it as the first 3 elements of the array.
      */
     multiplyXYZToFloat64Array(x, y, z, result) {
         return _Matrix3d__WEBPACK_IMPORTED_MODULE_2__.Matrix3d.xyzPlusMatrixTimesCoordinatesToFloat64Array(this._origin, this._matrix, x, y, z, result);
     }
     /**
-     * Treat the 3x3 `matrix` and `origin` as upper 3x4 part of a 4x4 matrix, with 0001 as the final row. Now multiply
-     * the transposed of this 4x4 matrix by Point4d given as xyzw. Return as a new point4d (`M*p` as first 3 elements
-     * and `o*p + w` as last element where `p = (x,y,z)`) or in the pre-allocated result (if result is given).
+     * Multiply the homogeneous point by the transpose of `this` Transform. Return as a new `Point4d` or in the
+     * pre-allocated result (if result is given).
+     * * If `p = (x,y,z)` then this method computes `M^t*p` and returns it in the first three coordinates of the `Point4d`,
+     * and `o*p + w` in the fourth.
+     * * Logically, this is multiplication by the transpose of the 4x4 matrix formed from the 3x4 instance augmented with
+     * fourth row 0001.
      */
     multiplyTransposeXYZW(x, y, z, w, result) {
         const coffs = this._matrix.coffs;
@@ -223737,9 +223763,9 @@ class Transform {
             this.multiplyPoint3dArrayInPlace(chain);
     }
     /**
-     * If for a point `p` we have `Tp = M*p + o = point` (where `point` is the transformed point), then
-     * `p = MInverse * (point - o)`. This function returns the original point `p` if `point` is the
-     * transformed point (`Tp = point`).
+     * Multiply the point by the inverse Transform.
+     * * If for a point `p` we have `Tp = M*p + o = q`, then `p = MInverse*(q - o) = TInverse q` so `TInverse`
+     * Transform has matrix part `MInverse` and origin part `-MInverse*o`.
      * * Return as a new point or in the optional `result`.
      * * Returns `undefined` if the `matrix` part if this Transform is singular.
      */
@@ -223747,9 +223773,13 @@ class Transform {
         return this._matrix.multiplyInverseXYZAsPoint3d(point.x - this._origin.x, point.y - this._origin.y, point.z - this._origin.z, result);
     }
     /**
-     * If for a point `p` we have `Tp = M*p + w*o = weightedPoint` (where `weightedPoint` is the transformed point), then
-     * `p = MInverse * (weightedPoint - w*o)`. This function returns a Point4d where first 3 elements are the original
-     *  point `p` if `weightedPoint` is the transformed point (`Tp = weightedPoint`) and the last element is `w`.
+     * Multiply the homogenous point by the inverse Transform.
+     * * If for a point `p` we have `Tp = M*p + o = q`, then `p = MInverse*(q - o) = TInverse q` so `TInverse` Transform
+     * has matrix part `MInverse` and origin part `-MInverse*o`.
+     * * This method computes `TInverse p = MInverse*p - w*MInverse*o` and returns the `Point4d` formed by `TInverse*p`
+     * in the first three coordinates, and `w` in the fourth.
+     * * Logically, this is multiplication by the inverse of the 4x4 matrix formed from the 3x4 instance augmented with
+     * fourth row 0001. This is equivalent to the 4x4 matrix formed in similar fashion from the inverse of this instance.
      * * Return as a new point or in the optional `result`.
      * * Returns `undefined` if the `matrix` part if this Transform is singular.
      */
@@ -223758,9 +223788,9 @@ class Transform {
         return this._matrix.multiplyInverseXYZW(weightedPoint.x - w * this.origin.x, weightedPoint.y - w * this.origin.y, weightedPoint.z - w * this.origin.z, w, result);
     }
     /**
-     * If for a point `p = (x,y,z)` we have `Tp = M*p + o = point` (where `point` is the transformed point), then
-     * `p = MInverse * (point - o)`. This function returns the original point `p` if `point` is the transformed
-     * point (`Tp = point`).
+     * Multiply the point by the inverse Transform.
+     * * If for a point `p` we have `Tp = M*p + o = q`, then `p = MInverse*(q - o) = TInverse q` so `TInverse` Transform
+     * has matrix part `MInverse` and origin part `-MInverse*o`.
      * * Return as a new point or in the optional `result`.
      * * Returns `undefined` if the `matrix` part if this Transform is singular.
      */
@@ -223799,35 +223829,35 @@ class Transform {
         return numSource;
     }
     /**
-     * If for each point `p` we have `Tp = M*p + o = point` (where `point` is the transformed point), then
-     * `p = MInverse * (point - o)`. This function returns the array of original points `p[]` if `points`
-     * is the array of transformed point (`Tp = point` for each `p` and `point`).
-     * * If `results` is given, resize it to match the input `points` array and update it with original points `p[]`.
-     * * If `results` is not given, return a new array.
+     * Multiply each point in the array by the inverse of `this` Transform.
+     * * For a transform `T = [M o]` the inverse transform `T' = [M' -M'o]` exists if and only if `M` has an inverse
+     * `M'`. Indeed, for any point `p`, we have `T'Tp = T'(Mp + o) = M'(Mp + o) - M'o = M'Mp + M'o - M'o = p.`
+     * * If `result` is given, resize it to match the input `points` array and update it with original points `p[]`.
+     * * If `result` is not given, return a new array.
      * * Returns `undefined` if the `matrix` part if this Transform is singular.
      */
-    multiplyInversePoint3dArray(points, results) {
+    multiplyInversePoint3dArray(points, result) {
         if (!this._matrix.computeCachedInverse(true))
             return undefined;
         const originX = this.origin.x;
         const originY = this.origin.y;
         const originZ = this.origin.z;
-        if (results) {
-            const n = Transform.matchArrayLengths(points, results, _Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.createZero);
+        if (result) {
+            const n = Transform.matchArrayLengths(points, result, _Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.createZero);
             for (let i = 0; i < n; i++)
-                this._matrix.multiplyInverseXYZAsPoint3d(points[i].x - originX, points[i].y - originY, points[i].z - originZ, results[i]);
+                this._matrix.multiplyInverseXYZAsPoint3d(points[i].x - originX, points[i].y - originY, points[i].z - originZ, result[i]);
+            return result;
         }
-        results = [];
+        result = [];
         for (const point of points)
-            results.push(this._matrix.multiplyInverseXYZAsPoint3d(point.x - originX, point.y - originY, point.z - originZ));
-        return results;
+            result.push(this._matrix.multiplyInverseXYZAsPoint3d(point.x - originX, point.y - originY, point.z - originZ));
+        return result;
     }
     /**
-     * If for each point `p` we have `Tp = M*p + o = point` (where `point` is the transformed point), then
-     * `p = MInverse * (point - o)`. This function calculates the array of original points `p[]` if `points`
-     * is the array of transformed point (`Tp = point` for each `p` and `point`) and replaces `points`
-     * with the array of original points.
-     * * Returns `true` if the `matrix` part if this Transform is invertible and `false if singular.
+     * Multiply each point in the array by the inverse of `this` Transform in place.
+     * * For a transform `T = [M o]` the inverse transform `T' = [M' -M'o]` exists if and only if `M` has an inverse
+     * `M'`. Indeed, for any point `p`, we have `T'Tp = T'(Mp + o) = M'(Mp + o) - M'o = M'Mp + M'o - M'o = p.`
+     * * Returns `true` if the `matrix` part if this Transform is invertible and `false` if singular.
      */
     multiplyInversePoint3dArrayInPlace(points) {
         if (!this._matrix.computeCachedInverse(true))
@@ -223896,7 +223926,8 @@ class Transform {
     /**
      * Calculate `transformA * transformB` and store it into the calling instance (`this`).
      * * **Note:** If `transformA = [A   a]` and `transformB = [B   b]` then `transformA * transformB` is defined as
-     * `[A*B   Ab+a]`. See `multiplyTransformTransform` doc for math details.
+     * `[A*B   Ab+a]`.
+     * * @see [[multiplyTransformTransform]] documentation for math details.
      * @param transformA first operand
      * @param transformB second operand
      */
@@ -223906,19 +223937,17 @@ class Transform {
     }
     /**
      * Multiply `this` Transform times `other` Transform.
-     * **Note:** If `this = [A   a]` and `other = [B   b]` then `this * other` is defined as [A*B   Ab+a].
-     * That's because we create a 4x4 matrix for each Transform with the 3x3 `matrix` and `origin`
-     * as upper 3x4 part of a 4x4 matrix and 0001 as the final row. Then we multiply those two 4x4 matrixes:
+     * * **Note:** If `this = [A   a]` and `other = [B   b]` then `this * other` is defined as [A*B   Ab+a] because:
      * ```
      * equation
      * \begin{matrix}
-     *    \text{`this` Transform with `matrix` part }\bold{A}\text{ and `origin` part }\bold{a} & \blockTransform{A}{a}\\
-     *    \text{`other` Transform with `matrix` part }\bold{B}\text{ and `origin` part }\bold{b} & \blockTransform{B}{b} \\
+     *    \text{this Transform with matrix part }\bold{A}\text{ and origin part }\bold{a} & \blockTransform{A}{a}\\
+     *    \text{other Transform with matrix part }\bold{B}\text{ and origin part }\bold{b} & \blockTransform{B}{b} \\
      * \text{product}& \blockTransform{A}{a}\blockTransform{B}{b}=\blockTransform{AB}{Ab + a}
      * \end{matrix}
      * ```
      * @param other the 'other` Transform to be multiplied to `this` Transform.
-     * @param result optional preallocated result to reuse.
+     * @param result optional preallocated `result` to reuse.
      */
     multiplyTransformTransform(other, result) {
         if (!result)
@@ -223928,20 +223957,17 @@ class Transform {
     }
     /**
      * Multiply `this` Transform times `other` Matrix3d (considered to be a Transform with 0 `origin`).
-     * **Note:** If `this = [A   a]`, then we promote `other` matrix to be a Transform [B   0].
-     * Then `this * other` is defined as [A*B   a]. That's because we create a 4x4 matrix for each Transform
-     * with the 3x3 `matrix` and `origin` as upper 3x4 part of a 4x4 matrix and 0001 as the final row. Then we
-     * multiply those two 4x4 matrixes:
+     * * **Note:** If `this = [A   a]` and `other = [B   0]`, then `this * other` is defined as [A*B   a] because:
      * ```
      * equation
      * \begin{matrix}
-     *    \text{`this` Transform with `matrix` part }\bold{A}\text{ and `origin` part }\bold{a} & \blockTransform{A}{a}\\
-     *    \text{`other` matrix }\bold{B}\text{ promoted to block Transform} & \blockTransform{B}{0} \\
+     *    \text{this Transform with matrix part }\bold{A}\text{ and origin part }\bold{a} & \blockTransform{A}{a}\\
+     *    \text{other matrix }\bold{B}\text{ promoted to block Transform} & \blockTransform{B}{0} \\
      * \text{product}& \blockTransform{A}{a}\blockTransform{B}{0}=\blockTransform{AB}{a}
      * \end{matrix}
      * ```
      * @param other the `other` Matrix3d to be multiplied to `this` Transform.
-     * @param result optional preallocated result to reuse.
+     * @param result optional preallocated `result` to reuse.
      */
     multiplyTransformMatrix3d(other, result) {
         if (!result)
@@ -223951,13 +223977,13 @@ class Transform {
         return result;
     }
     /**
-     * Return the Range of the transformed corners.
+     * Return the range of the transformed corners.
      * * The 8 corners are transformed individually.
      * * **Note:** Suppose you have a geometry, a range box around that geometry, and your Transform is a rotation.
      * If you rotate the range box and recompute a new range box around the rotated range box, then the new range
      * box will have a larger volume than the original range box. However, if you rotate the geometry itself and
      * then recompute the range box, it will be a tighter range box around the rotated geometry. `multiplyRange`
-     * function creates the larger range box because it only has access to the range box and the geometry itself.
+     * function creates the larger range box because it only has access to the range box and not the geometry itself.
      */
     multiplyRange(range, result) {
         if (range.isNull)
@@ -223981,7 +224007,7 @@ class Transform {
     }
     /**
      * Return a Transform which is the inverse of `this` Transform.
-     * * If `transform = [M   o]` then `transformInverse = [MInverse   MInverse*-o]`
+     * * If `transform = [M   o]` then `transformInverse = [MInverse   -MInverse*o]`
      * * Return `undefined` if this Transform's matrix is singular.
      */
     inverse(result) {
@@ -223996,14 +224022,14 @@ class Transform {
         return Transform.createRefs(matrixInverse.multiplyXYZ(-this._origin.x, -this._origin.y, -this._origin.z), matrixInverse);
     }
     /**
-     * Initialize 2 Transforms: First Transform maps a box (axis aligned) specified by `min` and `max` to
-     * the unit box specified by 000 and 111 and inverse of it. Second Transform is the reverse of first.
-     * @param min the min corner of the box
-     * @param max the max corner of the box
-     * @param npcToGlobal maps global (the unit box specified by 000 and 111) to NPC (a box specified by `min`
-     * and `max`). Object created by caller, re-initialized here.
-     * @param globalToNpc maps NPC (a box specified by `min` and `max`) to global (the unit box specified by
-     * 000 and 111). Object created by caller, re-initialized here.
+     * Initialize 2 Transforms that map between the unit box (specified by 000 and 111) and the range box specified
+     * by the input points.
+     * @param min the min corner of the range box
+     * @param max the max corner of the range box
+     * @param npcToGlobal maps NPC coordinates into range box coordinates. Specifically, maps 000 to `min` and maps
+     * 111 to `max`. This Transform is the inverse of `globalToNpc`. Object created by caller, re-initialized here.
+     * @param globalToNpc maps range box coordinates into NPC coordinates. Specifically, maps `min` to 000 and maps
+     * `max` to 111. This Transform is the inverse of `npcToGlobal`. Object created by caller, re-initialized here.
      * * NPC stands for `Normalized Projection Coordinate`
      */
     static initFromRange(min, max, npcToGlobal, globalToNpc) {
@@ -224256,11 +224282,11 @@ __webpack_require__.r(__webpack_exports__);
  */
 class YawPitchRollAngles {
     /**
-     * constructor
+     * Constructor
      * @param yaw counterclockwise rotation angle around z
      * @param pitch **clockwise** rotation angle around y
      * @param roll counterclockwise rotation angle around x
-     * */
+     */
     constructor(yaw = _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.zero(), pitch = _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.zero(), roll = _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.zero()) {
         this.yaw = yaw;
         this.pitch = pitch;
@@ -224274,29 +224300,29 @@ class YawPitchRollAngles {
         return Object.freeze(this);
     }
     /**
-     * constructor for YawPitchRollAngles with angles in degrees.
+     * Constructor for YawPitchRollAngles with angles in degrees.
      * @param yawDegrees counterclockwise rotation angle (in degrees) around z
      * @param pitchDegrees **clockwise** rotation angle (in degrees) around y
      * @param rollDegrees counterclockwise rotation angle (in degrees) around x
-     * */
+     */
     static createDegrees(yawDegrees, pitchDegrees, rollDegrees) {
         return new YawPitchRollAngles(_Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createDegrees(yawDegrees), _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createDegrees(pitchDegrees), _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createDegrees(rollDegrees));
     }
     /**
-     * constructor for YawPitchRollAngles with angles in radians.
+     * Constructor for YawPitchRollAngles with angles in radians.
      * @param yawRadians counterclockwise rotation angle (in radians) around z
      * @param pitchRadians **clockwise** rotation angle (in radians) around y
      * @param rollRadians counterclockwise rotation angle (in radians) around x
-     * */
+     */
     static createRadians(yawRadians, pitchRadians, rollRadians) {
         return new YawPitchRollAngles(_Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createRadians(yawRadians), _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createRadians(pitchRadians), _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createRadians(rollRadians));
     }
-    /** construct a `YawPitchRoll` object from an object with 3 named angles */
+    /** Construct a `YawPitchRoll` object from an object with 3 named angles */
     static fromJSON(json) {
         json = json ? json : {};
         return new YawPitchRollAngles(_Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.fromJSON(json.yaw), _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.fromJSON(json.pitch), _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.fromJSON(json.roll));
     }
-    /** populate yaw, pitch and roll fields using `Angle.fromJSON` */
+    /** Populate yaw, pitch and roll fields using `Angle.fromJSON` */
     setFromJSON(json) {
         json = json ? json : {};
         this.yaw = _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.fromJSON(json.yaw);
@@ -224306,7 +224332,7 @@ class YawPitchRollAngles {
     /**
      * Convert to a JSON object of form { pitch: 20 , roll: 30 , yaw: 10 }. Angles are in degrees.
      * Any values that are exactly zero (with tolerance `Geometry.smallAngleRadians`) are omitted.
-     **/
+     */
     toJSON() {
         const val = {};
         if (!this.pitch.isAlmostZero)
@@ -224336,15 +224362,12 @@ class YawPitchRollAngles {
             && this.pitch.isAlmostEqualAllowPeriodShift(other.pitch)
             && this.roll.isAlmostEqualAllowPeriodShift(other.roll);
     }
-    /**
-     * Make a copy of this YawPitchRollAngles.
-     */
+    /** Make a copy of this YawPitchRollAngles */
     clone() {
         return new YawPitchRollAngles(this.yaw.clone(), this.pitch.clone(), this.roll.clone());
     }
     /**
      * Expand the angles into a (rigid rotation) matrix.
-     *
      * * The returned matrix is "rigid" (i.e., it has unit length rows and columns, and its transpose is its inverse).
      * * The rigid matrix is always a right handed coordinate system.
      * @param result optional pre-allocated `Matrix3d`
@@ -224381,7 +224404,8 @@ class YawPitchRollAngles {
         */
         return _Matrix3d__WEBPACK_IMPORTED_MODULE_1__.Matrix3d.createRowValues(cz * cy, -(sz * cx + cz * sy * sx), (sz * sx - cz * sy * cx), sz * cy, (cz * cx - sz * sy * sx), -(cz * sx + sz * sy * cx), sy, cy * sx, cy * cx, result);
     }
-    /** Returns true if this rotation does nothing.
+    /**
+     * Returns true if this rotation does nothing.
      * * If allowPeriodShift is false, any nonzero angle is considered a non-identity
      * * If allowPeriodShift is true, all angles are individually allowed to be any multiple of 360 degrees.
      */
@@ -224426,7 +224450,8 @@ class YawPitchRollAngles {
             angles: YawPitchRollAngles.createFromMatrix3d(transform.matrix),
         };
     }
-    /** Attempts to create a YawPitchRollAngles object from a Matrix3d
+    /**
+     * Attempts to create a YawPitchRollAngles object from a Matrix3d
      * * This conversion fails if the matrix is not rigid (unit rows and columns, and transpose is inverse)
      * * In the failure case the method's return value is `undefined`.
      * * In the failure case, if the optional result was supplied, that result will nonetheless be filled with
@@ -248738,19 +248763,22 @@ class SteppedIndexFunctionFactory {
     static createConstant(value = 0) {
         return (_i, _n) => value;
     }
-    /** Return a function that steps linearly
+    /**
+     * Return a function that steps linearly
      * *  f(i,n) = y0 + (i/n) * a
      */
     static createLinear(a, f0 = 0) {
         return (i, n) => (f0 + a * (i / n));
     }
-    /** Return a function that steps with cosine of angles in sweep
+    /**
+     * Return a function that steps with cosine of angles in sweep
      * *  f(i,n) = y0 + amplitude * cos(i/n)
      */
     static createCosine(amplitude, sweep = _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.create360(), f0 = 0) {
         return (i, n) => (f0 + amplitude * Math.cos(sweep.fractionToRadians(i / n)));
     }
-    /** Return a function that steps with cosine of angles in sweep.
+    /**
+     * Return a function that steps with cosine of angles in sweep.
      * *  f(i,n) = y0 + amplitude * sin(i/n)
      */
     static createSine(amplitude, sweep = _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.create360(), f0 = 0) {
@@ -248762,7 +248790,8 @@ class SteppedIndexFunctionFactory {
  * @alpha
  */
 class Sample {
-    /** Return an array of Point3d, with x,y,z all stepping through a range of values.
+    /**
+     * Return an array of Point3d, with x,y,z all stepping through a range of values.
      * x varies fastest, then y then z
      */
     static createPoint3dLattice(low, step, high) {
@@ -248773,7 +248802,8 @@ class Sample {
                     points.push(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(x, y, z));
         return points;
     }
-    /** Return an array of Point2d, with x,y all stepping through a range of values.
+    /**
+     * Return an array of Point2d, with x,y all stepping through a range of values.
      * x varies fastest, then y
      */
     static createPoint2dLattice(low, step, high) {
@@ -248821,7 +248851,8 @@ class Sample {
     static createCenteredRectangleXY(cx, cy, ax, ay, z = 0) {
         return this.createRectangleXY(cx - ax, cy - ay, 2 * ax, 2 * ay, z);
     }
-    /** Access the last point in the array. push another shifted by dx,dy,dz.
+    /**
+     * Access the last point in the array. push another shifted by dx,dy,dz.
      * * No push if all are 0.
      * * If array is empty, push a leading 000
      */
@@ -248843,7 +248874,8 @@ class Sample {
         points.push(points[0].clone());
         return points;
     }
-    /** Create points for an L shaped polygon
+    /**
+     * Create points for an L shaped polygon
      * * lower left at x0,y0.
      * * ax,ay are larger side lengths (lower left to corners along x and y directions)
      * * bx,by are smaller side lengths (inner corner to points along x and y directions)
@@ -248868,7 +248900,7 @@ class Sample {
         return [
             plane0, plane1, plane2,
             _clipping_ClipPlane__WEBPACK_IMPORTED_MODULE_6__.ClipPlane.createNormalAndDistance(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.create(3, 4, 0), 2.0),
-            _clipping_ClipPlane__WEBPACK_IMPORTED_MODULE_6__.ClipPlane.createEdgeXY(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 0, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(24, 32, 0))
+            _clipping_ClipPlane__WEBPACK_IMPORTED_MODULE_6__.ClipPlane.createEdgeXY(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 0, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(24, 32, 0)),
         ];
     }
     /**
@@ -248884,16 +248916,17 @@ class Sample {
         const quadrant4 = _clipping_ConvexClipPlaneSet__WEBPACK_IMPORTED_MODULE_7__.ConvexClipPlaneSet.createXYBox(0, -1, 1, 0);
         result.push(_clipping_UnionOfConvexClipPlaneSets__WEBPACK_IMPORTED_MODULE_8__.UnionOfConvexClipPlaneSets.createConvexSets([
             quadrant1.clone(),
-            quadrant4.clone()
+            quadrant4.clone(),
         ]));
         result.push(_clipping_UnionOfConvexClipPlaneSets__WEBPACK_IMPORTED_MODULE_8__.UnionOfConvexClipPlaneSets.createConvexSets([
             quadrant1.clone(),
             quadrant2.clone(),
-            quadrant4.clone()
+            quadrant4.clone(),
         ]));
         return result;
     }
-    /** Create (unweighted) bspline curves.
+    /**
+     * Create (unweighted) bspline curves.
      * order varies from 2 to 5
      */
     static createBsplineCurves(includeMultipleKnots = false) {
@@ -248930,7 +248963,8 @@ class Sample {
         }
         return result;
     }
-    /** Create weighted bspline curves.
+    /**
+     * Create weighted bspline curves.
      * order varies from 2 to 5
      */
     static createBspline3dHCurves() {
@@ -248968,8 +249002,7 @@ class Sample {
         }
         return result;
     }
-    /** Create weighted bsplines for circular arcs.
-     */
+    /** Create weighted bsplines for circular arcs. */
     static createBspline3dHArcs() {
         const result = [];
         const halfRadians = _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.degreesToRadians(60.0);
@@ -248984,14 +249017,15 @@ class Sample {
             _geometry4d_Point4d__WEBPACK_IMPORTED_MODULE_10__.Point4d.create(-1, 0, 0, c),
             _geometry4d_Point4d__WEBPACK_IMPORTED_MODULE_10__.Point4d.create(-c, -s, 0, 1),
             _geometry4d_Point4d__WEBPACK_IMPORTED_MODULE_10__.Point4d.create(c, -s, 0, c),
-            _geometry4d_Point4d__WEBPACK_IMPORTED_MODULE_10__.Point4d.create(1, 0, 0, 1)
+            _geometry4d_Point4d__WEBPACK_IMPORTED_MODULE_10__.Point4d.create(1, 0, 0, 1),
         ];
         const knots = [0, 0, 1, 1, 2, 2, 3, 3];
         const curve = _bspline_BSplineCurve3dH__WEBPACK_IMPORTED_MODULE_11__.BSplineCurve3dH.create(points, knots, 3);
         result.push(curve);
         return result;
     }
-    /** Return array   [x,y,z,w] bspline control points for an arc in 90 degree bspline spans.
+    /**
+     * Return array   [x,y,z,w] bspline control points for an arc in 90 degree bspline spans.
      * @param points array of [x,y,z,w]
      * @param center center of arc
      * @param axes matrix with 0 and 90 degree axes
@@ -249037,7 +249071,7 @@ class Sample {
             result.push(b);
         return result;
     }
-    /** create a plane from origin and normal coordinates -- default to 001 normal if needed. */
+    /** Create a plane from origin and normal coordinates -- default to 001 normal if needed. */
     static createPlane(x, y, z, u, v, w) {
         const point = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(x, y, z);
         const vector = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.create(u, v, w).normalize();
@@ -249057,22 +249091,23 @@ class Sample {
         return [
             _curve_LineString3d__WEBPACK_IMPORTED_MODULE_15__.LineString3d.createPoints([
                 _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0),
-                _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 0, 0)
+                _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 0, 0),
             ]),
             _curve_LineString3d__WEBPACK_IMPORTED_MODULE_15__.LineString3d.createPoints([
                 _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0),
                 _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 0, 0),
-                _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 1, 0)
+                _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 1, 0),
             ]),
             _curve_LineString3d__WEBPACK_IMPORTED_MODULE_15__.LineString3d.createPoints([
                 _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0),
                 _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 0, 0),
                 _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 1, 0),
-                _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(2, 2, 0)
-            ])
+                _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(2, 2, 0),
+            ]),
         ];
     }
-    /** Assorted Matrix3d:
+    /**
+     * Assorted Matrix3d:
      * * identity
      * * rotation around x
      * * rotation around general vector
@@ -249097,10 +249132,11 @@ class Sample {
             _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createTranslationXYZ(1, 2, 0),
             _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createTranslationXYZ(1, 2, 3),
             _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createFixedPointAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(4, 1, -2), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createUniformScale(2.0)),
-            _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createFixedPointAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(4, 1, -2), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRotationAroundVector(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.create(1, 2, 3), _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createRadians(10)))
+            _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createFixedPointAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(4, 1, -2), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRotationAroundVector(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.create(1, 2, 3), _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createRadians(10))),
         ];
     }
-    /** Return an array of Matrix3d with various skew and scale.  This includes at least:
+    /**
+     * Return an array of Matrix3d with various skew and scale.  This includes at least:
      * * identity
      * * 3 distinct diagonals.
      * * The distinct diagonal base with smaller value added to other 6 spots in succession.
@@ -249119,9 +249155,10 @@ class Sample {
             _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRowValues(5, 2, 3, 2, 6, 1, -1, 2, 7),
         ];
     }
-    /** Return an array of singular Matrix3d.  This includes at least:
+    /**
+     * Return an array of singular Matrix3d. This includes at least:
      * * all zeros
-     * * one nonzero column
+     * * one non-zero column
      * * two independent columns, third is zero
      * * two independent columns, third is sum of those
      * * two independent columns, third is copy of one
@@ -249133,26 +249170,26 @@ class Sample {
         const vector0 = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.createZero();
         return [
             _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createZero(),
-            // one nonzero column
+            // one non-zero column
             _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vectorU, vector0, vector0),
             _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vector0, vectorU, vector0),
-            _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vector0, vector0, vector0),
-            // two independent nonzero columns with zero
+            _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vector0, vector0, vectorU),
+            // two independent non-zero columns with one zero column
             _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vectorU, vectorV, vector0),
             _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vector0, vectorU, vectorV),
-            _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vectorV, vector0, vector0),
-            // third column dependent
+            _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vectorU, vector0, vectorV),
+            // two independent columns with one dependent column
             _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vectorU, vectorV, vectorUPlusV),
             _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vectorU, vectorUPlusV, vectorV),
-            _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vectorUPlusV, vectorV, vectorU),
-            // two independent with duplicate
-            _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vectorU, vectorV, vectorU),
+            _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vectorUPlusV, vectorU, vectorV),
+            // two independent with columns with one duplicate column
             _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vectorU, vectorU, vectorV),
-            _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vectorV, vectorV, vectorU)
+            _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vectorU, vectorV, vectorU),
+            _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vectorV, vectorU, vectorU),
         ];
     }
     /**
-     * * Return an array of rigid transforms.  This includes (at least)
+     * Return an array of rigid transforms. This includes (at least)
      *   * Identity
      *   * translation with identity matrix
      *   * rotation around origin and arbitrary vector
@@ -249167,16 +249204,15 @@ class Sample {
             _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createTranslationXYZ(distanceScale3 * 1, distanceScale3 * 2, distanceScale3 * 3),
             _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createFixedPointAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRotationAroundVector(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.unitY(), _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(10))),
             _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createFixedPointAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(distanceScale4 * 4, distanceScale4 * 1, -distanceScale4 * 2), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRotationAroundVector(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.create(1, 2, 3), _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(10))),
-            _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createFixedPointAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(distanceScale4 * 4, distanceScale4 * 1, -distanceScale4 * 2), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRotationAroundVector(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.create(-2, 1, 4), _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(35)))
+            _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createFixedPointAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(distanceScale4 * 4, distanceScale4 * 1, -distanceScale4 * 2), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRotationAroundVector(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.create(-2, 1, 4), _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(35))),
         ];
     }
-    /**
-     * Return a single rigid transform with all terms nonzero.
-     */
+    /** Return a single rigid transform with all terms nonzero. */
     static createMessyRigidTransform(fixedPoint) {
         return _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createFixedPointAndMatrix(fixedPoint ? fixedPoint : _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 2, 3), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRotationAroundVector(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.create(0.3, -0.2, 1.2), _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(15.7)));
     }
-    /** Return various rigid matrices:
+    /**
+     * Return various rigid matrices:
      * * identity
      * * small rotations around x, y, z
      * * small rotation around (1,2,3)
@@ -249206,9 +249242,7 @@ class Sample {
         }
         return result;
     }
-    /**
-     * Create full Map4d for each `Sample.createInvertibleTransforms ()`
-     */
+    /** Create full Map4d for each `Sample.createInvertibleTransforms()` */
     static createMap4ds() {
         const result = [];
         let transform;
@@ -249226,7 +249260,12 @@ class Sample {
     static createSimplePaths(withGaps = false) {
         const point0 = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0);
         const point1 = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(10, 0, 0);
-        const p1 = [point1, _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 10, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(6, 10, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(6, 10, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 10, 0)];
+        const p1 = [
+            point1, _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 10, 0),
+            _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(6, 10, 0),
+            _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(6, 10, 0),
+            _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 10, 0),
+        ];
         const segment1 = _curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_19__.LineSegment3d.create(point0, point1);
         const vectorU = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.unitX(3);
         const vectorV = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.unitY(3);
@@ -249241,7 +249280,8 @@ class Sample {
             simplePaths.push(_curve_Path__WEBPACK_IMPORTED_MODULE_21__.Path.create(_curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_19__.LineSegment3d.create(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(10, 0, 0)), _curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_19__.LineSegment3d.create(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(10, 10, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(5, 0, 0))));
         return simplePaths;
     }
-    /** Assorted `Path` with lines and arcs.
+    /**
+     * Assorted `Path` with lines and arcs.
      * Specifically useful for offset tests.
      */
     static createLineArcPaths() {
@@ -249270,12 +249310,16 @@ class Sample {
     }
     /** Assorted `PointString3d` objects. */
     static createSimplePointStrings() {
-        const p1 = [[_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 10, 0)], [_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(6, 10, 0)], [_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(6, 10, 0), [_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(6, 10, 0)]]];
+        const p1 = [
+            [_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 10, 0)],
+            [_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(6, 10, 0)],
+            [_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(6, 10, 0), [_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(6, 10, 0)]],
+        ];
         const simplePaths = [
             _curve_PointString3d__WEBPACK_IMPORTED_MODULE_22__.PointString3d.create(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 2, 0)),
             _curve_PointString3d__WEBPACK_IMPORTED_MODULE_22__.PointString3d.create(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(10, 0, 0)),
             _curve_PointString3d__WEBPACK_IMPORTED_MODULE_22__.PointString3d.create(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(10, 0, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(10, 5, 0)),
-            _curve_PointString3d__WEBPACK_IMPORTED_MODULE_22__.PointString3d.create(p1)
+            _curve_PointString3d__WEBPACK_IMPORTED_MODULE_22__.PointString3d.create(p1),
         ];
         return simplePaths;
     }
@@ -249304,8 +249348,7 @@ class Sample {
      * @param dx1 distance along x axis at y=dy
      * @param numPhase number of phases of the jump.
      * @param dyReturn y value for return to origin.  If 0, the wave ends at y=0 after then final "down" with one extra horizontal dx0
-     *     If nonzero, rise to that y value, return to x=0, and return down to origin.
-     *
+     * If nonzero, rise to that y value, return to x=0, and return down to origin.
      */
     static createSquareWave(origin, dx0, dy, dx1, numPhase, dyReturn) {
         const result = [origin.clone()];
@@ -249366,7 +249409,7 @@ class Sample {
         }
         return points;
     }
-    /** append sawtooth with x distances successively scaled by xFactor */
+    /** Append sawtooth with x distances successively scaled by xFactor */
     static appendVariableSawTooth(points, dxLow, riseX, riseY, dxHigh, numPhase, xFactor) {
         let factor = 1.0;
         for (let i = 0; i < numPhase; i++) {
@@ -249407,7 +249450,8 @@ class Sample {
         data.push(data[0].clone());
         return data;
     }
-    /** append to a linestring, taking steps along given vector directions
+    /**
+     * Append to a linestring, taking steps along given vector directions
      * If the linestring is empty, a 000 point is added.
      * @param linestring LineString3d to receive points.
      * @param numPhase number of phases of the sawtooth
@@ -249424,7 +249468,8 @@ class Sample {
             }
         }
     }
-    /** Assorted regions with arc boundaries
+    /**
+     * Assorted regions with arc boundaries
      * * full circle
      * * with varying sweep:
      *    * partial arc with single chord closure
@@ -249451,7 +249496,8 @@ class Sample {
         }
         return result;
     }
-    /** Assorted loops in xy plane:
+    /**
+     * Assorted loops in xy plane:
      * * unit square
      * * rectangle
      * * L shape
@@ -249491,10 +249537,14 @@ class Sample {
         ];
         if (includeBCurves) {
             const ey = 1.0;
-            result.push(_curve_ParityRegion__WEBPACK_IMPORTED_MODULE_24__.ParityRegion.create(_curve_Loop__WEBPACK_IMPORTED_MODULE_23__.Loop.create(_curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_19__.LineSegment3d.create(point0, pointA), _bspline_BSplineCurve__WEBPACK_IMPORTED_MODULE_9__.BSplineCurve3d.createUniformKnots([pointA, _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(ax + 1, ey),
+            result.push(_curve_ParityRegion__WEBPACK_IMPORTED_MODULE_24__.ParityRegion.create(_curve_Loop__WEBPACK_IMPORTED_MODULE_23__.Loop.create(_curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_19__.LineSegment3d.create(point0, pointA), _bspline_BSplineCurve__WEBPACK_IMPORTED_MODULE_9__.BSplineCurve3d.createUniformKnots([
+                pointA,
+                _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(ax + 1, ey),
                 _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(ax + 1, 2 * ey),
                 _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(ax + 2, 3 * ey),
-                _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(ax + 1, 4 * ey), pointB], 3), _curve_Arc3d__WEBPACK_IMPORTED_MODULE_20__.Arc3d.createCircularStartMiddleEnd(pointB, pointC1, point0))));
+                _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(ax + 1, 4 * ey),
+                pointB,
+            ], 3), _curve_Arc3d__WEBPACK_IMPORTED_MODULE_20__.Arc3d.createCircularStartMiddleEnd(pointB, pointC1, point0))));
         }
         return result;
     }
@@ -249508,7 +249558,7 @@ class Sample {
         const by = 2.0;
         const result = [
             _curve_UnionRegion__WEBPACK_IMPORTED_MODULE_25__.UnionRegion.create(_curve_Loop__WEBPACK_IMPORTED_MODULE_23__.Loop.create(_curve_LineString3d__WEBPACK_IMPORTED_MODULE_15__.LineString3d.createRectangleXY(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0), ax, ay)), _curve_Loop__WEBPACK_IMPORTED_MODULE_23__.Loop.create(_curve_LineString3d__WEBPACK_IMPORTED_MODULE_15__.LineString3d.createRectangleXY(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 2 * ay, 0), bx, by))),
-            _curve_UnionRegion__WEBPACK_IMPORTED_MODULE_25__.UnionRegion.create(_curve_Loop__WEBPACK_IMPORTED_MODULE_23__.Loop.create(_curve_LineString3d__WEBPACK_IMPORTED_MODULE_15__.LineString3d.create(Sample.createRectangleXY(parityRange.low.x, parityRange.high.y + 0.5, parityRange.xLength(), parityRange.yLength()))), parityRegions[0])
+            _curve_UnionRegion__WEBPACK_IMPORTED_MODULE_25__.UnionRegion.create(_curve_Loop__WEBPACK_IMPORTED_MODULE_23__.Loop.create(_curve_LineString3d__WEBPACK_IMPORTED_MODULE_15__.LineString3d.create(Sample.createRectangleXY(parityRange.low.x, parityRange.high.y + 0.5, parityRange.xLength(), parityRange.yLength()))), parityRegions[0]),
         ];
         return result;
     }
@@ -249527,7 +249577,8 @@ class Sample {
         ];
         return result;
     }
-    /** Assorted smooth curve primitives:
+    /**
+     * Assorted smooth curve primitives:
      * * line segments
      * * arcs
      */
@@ -249542,7 +249593,7 @@ class Sample {
             _curve_Arc3d__WEBPACK_IMPORTED_MODULE_20__.Arc3d.create(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.create(size, alpha * size, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.create(-alpha * beta * size, beta * size, 0), _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createStartEndDegrees(-40, 270)),
         ];
     }
-    /** assorted small polyface grids, possibly expanded by gridMultiplier */
+    /** Assorted small polyface grids, possibly expanded by gridMultiplier */
     static createSimpleIndexedPolyfaces(gridMultiplier) {
         const meshes = [
             Sample.createTriangularUnitGridPolyface(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.unitX(), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.unitY(), gridMultiplier * 3, 2 * gridMultiplier, false, false, false),
@@ -249773,7 +249824,7 @@ class Sample {
             }
         return _bspline_BSplineSurface__WEBPACK_IMPORTED_MODULE_28__.BSplineSurface3dH.create(xyzPoles, weights, numU, orderU, undefined, numV, orderV, undefined);
     }
-    /** assorted linear sweeps */
+    /** Assorted linear sweeps */
     static createSimpleLinearSweeps() {
         const result = [];
         const base = _curve_Loop__WEBPACK_IMPORTED_MODULE_23__.Loop.create(_curve_LineString3d__WEBPACK_IMPORTED_MODULE_15__.LineString3d.createRectangleXY(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(), 2, 3));
@@ -249792,7 +249843,7 @@ class Sample {
         const xyPoints = [
             _geometry3d_Point2dVector2d__WEBPACK_IMPORTED_MODULE_2__.Point2d.create(0, 0),
             _geometry3d_Point2dVector2d__WEBPACK_IMPORTED_MODULE_2__.Point2d.create(1, 0),
-            _geometry3d_Point2dVector2d__WEBPACK_IMPORTED_MODULE_2__.Point2d.create(1, 1)
+            _geometry3d_Point2dVector2d__WEBPACK_IMPORTED_MODULE_2__.Point2d.create(1, 1),
         ];
         result.push(_solid_LinearSweep__WEBPACK_IMPORTED_MODULE_30__.LinearSweep.createZSweep(xyPoints, 1, 3, false));
         // this forces artificial closure point . . .
@@ -249836,7 +249887,7 @@ class Sample {
         for (const axis of [
             _geometry3d_Ray3d__WEBPACK_IMPORTED_MODULE_14__.Ray3d.createXYZUVW(0, 0, 0, 0, 1, 0),
             _geometry3d_Ray3d__WEBPACK_IMPORTED_MODULE_14__.Ray3d.createXYZUVW(5, 0, 0, 0, 1, 0),
-            _geometry3d_Ray3d__WEBPACK_IMPORTED_MODULE_14__.Ray3d.createXYZUVW(-1, 0, 0, -1, 1, 0)
+            _geometry3d_Ray3d__WEBPACK_IMPORTED_MODULE_14__.Ray3d.createXYZUVW(-1, 0, 0, -1, 1, 0),
         ]) {
             result.push(_solid_RotationalSweep__WEBPACK_IMPORTED_MODULE_31__.RotationalSweep.create(base, axis, _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(45.0), false));
             result.push(_solid_RotationalSweep__WEBPACK_IMPORTED_MODULE_31__.RotationalSweep.create(base, axis, _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(150.0), true));
@@ -249861,7 +249912,7 @@ class Sample {
     /** Create true (non-spherical) ellipsoids. */
     static createEllipsoids() {
         return [
-            _solid_Sphere__WEBPACK_IMPORTED_MODULE_32__.Sphere.createEllipsoid(_geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createOriginAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRowValues(4, 1, 1, 1, 4, 1, 0.5, 0.2, 5)), _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createFullLatitude(), true)
+            _solid_Sphere__WEBPACK_IMPORTED_MODULE_32__.Sphere.createEllipsoid(_geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createOriginAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRowValues(4, 1, 1, 1, 4, 1, 0.5, 0.2, 5)), _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createFullLatitude(), true),
         ];
     }
     /** Create assorted cones. */
@@ -249919,8 +249970,7 @@ class Sample {
         result.push(_solid_Box__WEBPACK_IMPORTED_MODULE_35__.Box.createDgnBox(cornerA, frameY.columnX(), frameY.columnY(), cornerA.plusScaled(frameY.columnZ(), h), aX, aY, bX, bY, capped));
         return result;
     }
-    /** create an array of points for a rectangle with corners (x0,y0,z) and (x1,y1,z)
-     */
+    /** Create an array of points for a rectangle with corners (x0,y0,z) and (x1,y1,z) */
     static createRectangle(x0, y0, x1, y1, z = 0.0, closed = false) {
         const points = [
             _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(x0, y0, z),
@@ -249932,8 +249982,7 @@ class Sample {
             points.push(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(x0, y0, z));
         return points;
     }
-    /** create an array of points for a rectangle with corners of a Range2d.
-     */
+    /** Create an array of points for a rectangle with corners of a Range2d. */
     static createRectangleInRange2d(range, z = 0.0, closed = false) {
         const x0 = range.low.x;
         const x1 = range.high.x;
@@ -250042,8 +250091,9 @@ class Sample {
         }
         return points;
     }
-    /** Primary shape is a "triangle" with lower edge pushed in so it becomes a mild nonconvex quad.
-     *  Fractal effects are gentle.
+    /**
+     * Primary shape is a "triangle" with lower edge pushed in so it becomes a mild nonconvex quad.
+     * Fractal effects are gentle.
      */
     static nonConvexQuadSimpleFractal(numRecursion, perpendicularFactor) {
         const pattern = [
@@ -250060,7 +250110,7 @@ class Sample {
         ];
         return Sample.createRecursiveFractalPolygon(poles, pattern, numRecursion, perpendicularFactor);
     }
-    /** create a diamond with convex fractal */
+    /** Create a diamond with convex fractal */
     static createFractalDiamondConvexPattern(numRecursion, perpendicularFactor) {
         const pattern = [
             _geometry3d_Point2dVector2d__WEBPACK_IMPORTED_MODULE_2__.Point2d.create(),
@@ -250157,7 +250207,7 @@ class Sample {
         ];
         return Sample.createRecursiveFractalPolygon(poles, pattern, numRecursion, perpendicularFactor);
     }
-    /** append interpolated points from the array tail to the target. */
+    /** Append interpolated points from the array tail to the target. */
     static appendSplits(points, target, numSplit, includeTarget) {
         const pointA = points[points.length - 1];
         for (let i = 0; i < numSplit; i++)
@@ -250201,7 +250251,8 @@ class Sample {
         geometry.push(_curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_19__.LineSegment3d.createXYZXYZ(x0, y1, z0, x0, y1, z1));
         return geometry;
     }
-    /** Assorted transition spirals
+    /**
+     * Assorted transition spirals
      * * (All combinations of bearing radius bearing radius length subsets.)
      */
     static createSimpleTransitionSpirals() {
@@ -250222,10 +250273,11 @@ class Sample {
             _curve_spiral_DirectSpiral3d__WEBPACK_IMPORTED_MODULE_41__.DirectSpiral3d.createFromLengthAndRadius("ChineseCubic", r0, r1, _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(0), undefined, arcLength, undefined, _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createOriginAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 2, 0), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRotationAroundVector(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.unitZ(), _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(15)))),
             _curve_spiral_DirectSpiral3d__WEBPACK_IMPORTED_MODULE_41__.DirectSpiral3d.createFromLengthAndRadius("JapaneseCubic", r0, r1, _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(0), undefined, arcLength, undefined, _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createOriginAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 2, 0), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRotationAroundVector(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.unitZ(), _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(15)))),
             _curve_spiral_DirectSpiral3d__WEBPACK_IMPORTED_MODULE_41__.DirectSpiral3d.createFromLengthAndRadius("DirectHalfCosine", r0, r1, _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(0), undefined, arcLength, undefined, _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createOriginAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 2, 0), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRotationAroundVector(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.unitZ(), _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(15)))),
-            _curve_spiral_DirectSpiral3d__WEBPACK_IMPORTED_MODULE_41__.DirectSpiral3d.createCzechCubic(_geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createIdentity(), arcLength, r1)
+            _curve_spiral_DirectSpiral3d__WEBPACK_IMPORTED_MODULE_41__.DirectSpiral3d.createCzechCubic(_geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createIdentity(), arcLength, r1),
         ];
     }
-    /** Create a Bezier curve with significant twist effects
+    /**
+     * Create a Bezier curve with significant twist effects
      * * r and theta are circle in xy plane at steps in thetaStepper
      * * z varies with sin(phi) at steps in phiStepper.
      */
@@ -250281,18 +250333,10 @@ class Sample {
         result.push(_curve_CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_44__.CurveChainWithDistanceIndex.createCapture(_curve_Path__WEBPACK_IMPORTED_MODULE_21__.Path.create(// arc spline with smooth joins
         _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]],
-        })))));
+        _bspline_InterpolationCurve3d__WEBPACK_IMPORTED_MODULE_45__.InterpolationCurve3d.createCapture(_bspline_InterpolationCurve3d__WEBPACK_IMPORTED_MODULE_45__.InterpolationCurve3dOptions.create({ 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]],
-        })))));
-        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),
-        })))));
+        _bspline_InterpolationCurve3d__WEBPACK_IMPORTED_MODULE_45__.InterpolationCurve3d.createCapture(_bspline_InterpolationCurve3d__WEBPACK_IMPORTED_MODULE_45__.InterpolationCurve3dOptions.create({ 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) })))));
         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)))));
         return result;
@@ -250376,7 +250420,7 @@ class Sample {
         const sweep2 = _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createStartEndDegrees(160.0, 380.0);
         for (const arcs of [
             Sample.createArcs(1.0), Sample.createArcs(0.5),
-            Sample.createArcs(1.0, sweep1), Sample.createArcs(0.3, sweep2)
+            Sample.createArcs(1.0, sweep1), Sample.createArcs(0.3, sweep2),
         ]) {
             for (const arc of arcs)
                 result.push(arc);
@@ -250479,10 +250523,10 @@ class Sample {
         return points;
     }
     /**
-     * * let ay = 4
-     * * base polygon has vertices (0,0), (ax,0), (2*ax,0), (2* ax,ay), (ax,ay), (0,ay), (0,0).
-     * * shift the x coordinates of vertices 1,4 by indicated amounts (0-based numbering)
-     * * shift the y coordinates for points 1,2,3,4 by indicated amounts (in 0-based numbering)
+     * * Let ay = 4
+     * * Base polygon has vertices (0,0), (ax,0), (2*ax,0), (2* ax,ay), (ax,ay), (0,ay), (0,0).
+     * * Shift the x coordinates of vertices 1,4 by indicated amounts (0-based numbering)
+     * * Shift the y coordinates for points 1,2,3,4 by indicated amounts (in 0-based numbering)
      * * This is useful for testing non-y-monotonic face situations.
      * * Return as points.
      * @param dy1
@@ -250502,7 +250546,7 @@ class Sample {
         return points;
     }
     /**
-     * make line segments for each pair of adjacent points.
+     * Make line segments for each pair of adjacent points.
      * @param points array of points
      * @param forceClosure if true, inspect coordinates to determine if a closure edge is needed.
      */
@@ -250618,7 +250662,8 @@ class Sample {
         this.appendGeometry(this.createBagOfCurves(), result);
         return result;
     }
-    /** Create points on a sine wave
+    /**
+     * Create points on a sine wave
      * Point i is origin + (i * xStep, a *sin(theta0 + i * dTheta), b * sin(beta0 + i * dBeta))
      * * Default b is zero, so it is a simple sine wave
      * * If the dTheta and dBeta are equal, it is a sine wave in a tilted plane.
@@ -250627,8 +250672,9 @@ class Sample {
     static createPointSineWave(origin, numInterval = 24, xStep = Math.PI / 12, a = 1, thetaSweep = _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createStartEndDegrees(0, 360), b = 0, betaSweep = _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createStartEndDegrees(0, 180)) {
         return this.createPointsByIndexFunctions(numInterval, SteppedIndexFunctionFactory.createLinear(xStep, origin ? origin.x : 0), SteppedIndexFunctionFactory.createCosine(a, thetaSweep, origin ? origin.y : 0), SteppedIndexFunctionFactory.createCosine(b, betaSweep, origin ? origin.z : 0));
     }
-    /** Create points with x,y,z independent functions of i and numInterval,
-     *    Point3d.create (fx(i,numInterval), fy(i,numInterval), fz(i, numInterval));
+    /**
+     * Create points with x,y,z independent functions of i and numInterval,
+     * Point3d.create (fx(i,numInterval), fy(i,numInterval), fz(i, numInterval));
      */
     static createPointsByIndexFunctions(numInterval, fx, fy, fz) {
         const points = [];
@@ -250699,9 +250745,7 @@ class Sample {
         builder.addGreedyTriangulationBetweenLineStrings(point0, point1);
         return builder.claimPolyface();
     }
-    /**
-     *  create strokes on an arc at radius r0, then returning at radius r1.
-     */
+    /** Create strokes on an arc at radius r0, then returning at radius r1. */
     static createAnnulusPolyline(edgesPerQuadrant, center, r0, r1, theta0, theta1, addClosure) {
         const point0 = [];
         const point1 = [];
@@ -250771,7 +250815,12 @@ class Sample {
                 for (let yC = 0; yC + 1 <= ySweep; yC++) {
                     const yD = yC + 1;
                     if (acceptFunction(xA, yC))
-                        builder.addPolygon([_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(xA, yC, zA), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(xB, yC, zB), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(xB, yD, zB), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(xA, yD, zA)]);
+                        builder.addPolygon([
+                            _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(xA, yC, zA),
+                            _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(xB, yC, zB),
+                            _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(xB, yD, zB),
+                            _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(xA, yD, zA),
+                        ]);
                 }
             }
         }
@@ -250829,7 +250878,7 @@ Sample.plane3dByOriginAndUnitNormal = [
     _geometry3d_Plane3dByOriginAndUnitNormal__WEBPACK_IMPORTED_MODULE_13__.Plane3dByOriginAndUnitNormal.createYZPlane(),
     _geometry3d_Plane3dByOriginAndUnitNormal__WEBPACK_IMPORTED_MODULE_13__.Plane3dByOriginAndUnitNormal.createZXPlane(),
     Sample.createPlane(0, 0, 0, 3, 0, 1),
-    Sample.createPlane(1, 2, 3, 2, 4, -1)
+    Sample.createPlane(1, 2, 3, 2, 4, -1),
 ];
 /** Assorted Ray3d, not all unit direction vectors. */
 Sample.ray3d = [
@@ -250837,7 +250886,7 @@ Sample.ray3d = [
     Sample.createRay(0, 0, 0, 0, 1, 0),
     Sample.createRay(0, 0, 0, 0, 0, 1),
     Sample.createRay(0, 0, 0, 1, 2, 0),
-    Sample.createRay(1, 2, 3, 4, 2, -1)
+    Sample.createRay(1, 2, 3, 4, 2, -1),
 ];
 /** Assorted angles.  All principal directions, some others included. */
 Sample.angle = [
@@ -250846,7 +250895,7 @@ Sample.angle = [
     _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(180),
     _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(-90),
     _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(30),
-    _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(-105)
+    _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(-105),
 ];
 /** Assorted angle sweeps */
 Sample.angleSweep = [
@@ -250855,35 +250904,35 @@ Sample.angleSweep = [
     _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createStartEndDegrees(-90, 0),
     _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createStartEndDegrees(0, -90),
     _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createStartEndDegrees(0, 30),
-    _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createStartEndDegrees(45, 110)
+    _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createStartEndDegrees(45, 110),
 ];
-/** assorted line segments */
+/** Assorted line segments */
 Sample.lineSegment3d = [
     _curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_19__.LineSegment3d.create(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 0, 0)),
     _curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_19__.LineSegment3d.create(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 1, 0)),
     _curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_19__.LineSegment3d.create(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 1)),
-    _curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_19__.LineSegment3d.create(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 2, 3), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(-2, -3, 0.5))
+    _curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_19__.LineSegment3d.create(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 2, 3), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(-2, -3, 0.5)),
 ];
-/** Assorted Range1d:   single point, null, simple forward, simple reverse */
+/** Assorted Range1d: single point, null, simple forward, simple reverse */
 Sample.range1d = [
     _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range1d.createX(1),
     _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range1d.createNull(),
     _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range1d.createXX(1, 2),
-    _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range1d.createXX(2, 1)
+    _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range1d.createXX(2, 1),
 ];
 /** Assorted range2d: single point, null, 2 point with various creation orders. */
 Sample.range2d = [
     _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range2d.createXY(1, 2),
     _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range2d.createNull(),
     _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range2d.createXYXY(1, 2, 0, 3),
-    _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range2d.createXYXY(1, 2, 3, 4)
+    _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range2d.createXYXY(1, 2, 3, 4),
 ];
 /** Assorted range2d: single point, null, 2 point with various creation orders. */
 Sample.range3d = [
     _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range3d.createXYZ(1, 2, 3),
     _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range3d.createNull(),
     _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range3d.createXYZXYZ(1, 2, 0, 3, 4, 7),
-    _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range3d.createXYZXYZ(1, 2, 3, -2, -4, -1)
+    _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range3d.createXYZXYZ(1, 2, 3, -2, -4, -1),
 ];
 
 
@@ -281034,7 +281083,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://${process.env.IMJS_URL_PREFIX ?? ""}api.bentley.com/imodels` } });
         await core_frontend_1.NoRenderApp.startup({
-            applicationVersion: "4.0.0-dev.55",
+            applicationVersion: "4.0.0-dev.56",
             applicationId: this.settings.gprid,
             authorizationClient: new frontend_1.TestFrontendAuthorizationClient(this.adminUserAccessToken),
             hubAccess: new imodels_access_frontend_1.FrontendIModelsAccess(iModelClient),
@@ -300607,7 +300656,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.55","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 \\"./node_modules/@itwin/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.55","@itwin/core-bentley":"workspace:^4.0.0-dev.55","@itwin/core-common":"workspace:^4.0.0-dev.55","@itwin/core-geometry":"workspace:^4.0.0-dev.55","@itwin/core-orbitgt":"workspace:^4.0.0-dev.55","@itwin/core-quantity":"workspace:^4.0.0-dev.55"},"//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":"^4.0.0-dev.32","@itwin/webgl-compatibility":"workspace:*","@types/chai":"4.3.1","@types/chai-as-promised":"^7","@types/deep-assign":"^0.1.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":"~5.0.2","webpack":"^5.76.0"},"//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.5.0","@itwin/cloud-agnostic-core":"^1.5.0","@itwin/object-storage-core":"^1.5.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","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.56","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 \\"./node_modules/@itwin/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.56","@itwin/core-bentley":"workspace:^4.0.0-dev.56","@itwin/core-common":"workspace:^4.0.0-dev.56","@itwin/core-geometry":"workspace:^4.0.0-dev.56","@itwin/core-orbitgt":"workspace:^4.0.0-dev.56","@itwin/core-quantity":"workspace:^4.0.0-dev.56"},"//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":"^4.0.0-dev.32","@itwin/webgl-compatibility":"workspace:*","@types/chai":"4.3.1","@types/chai-as-promised":"^7","@types/deep-assign":"^0.1.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":"~5.0.2","webpack":"^5.76.0"},"//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.5.0","@itwin/cloud-agnostic-core":"^1.5.0","@itwin/object-storage-core":"^1.5.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","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"}}]}}');
 
 /***/ }),