@itwin/ecschema-rpcinterface-tests 5.0.0-dev.62 → 5.0.0-dev.64

package/lib/dist/bundled-tests.js

@@ -71063,21 +71063,12 @@ class Schema {
             ? refSchema.getItemSync(itemName, itemConstructor)
             : refSchema.getItemSync(itemName);
     }
-    /**
-     * Returns an iterator over all of the items in this schema.
-     */
-    getItems() {
+    *getItems(itemConstructor) {
         if (!this._items)
-            return new Map().values();
-        return this._items.values();
-    }
-    /**
-     * Returns an iterator over all ECClasses within this schema
-     */
-    *getClasses() {
-        for (const [, value] of this._items) {
-            if (_Class__WEBPACK_IMPORTED_MODULE_8__.ECClass.isECClass(value))
-                yield value;
+            return;
+        for (const item of this._items.values()) {
+            if (itemConstructor === undefined || (0,_ECObjects__WEBPACK_IMPORTED_MODULE_4__.isSupportedSchemaItemType)(item.schemaItemType, itemConstructor.schemaItemType))
+                yield item;
         }
     }
     /**
@@ -183093,82 +183084,115 @@ __webpack_require__.r(__webpack_exports__);
 /** @packageDocumentation
  * @module Bspline
  */
-// import { Point2d } from "../Geometry2d";
 
 
 
-/** Bspline knots and poles for 1d-to-Nd.
+/**
+ * Knots and poles for a B-spline function mapping R to R^n.
  * * The "pole" (aka control point) of this class is a block of `poleLength` numbers.
  * * Derived classes (not this class) assign meaning such as x,y,z,w.
- * * for instance, an instance of this class with `poleLength===3` does not know if its poles are x,y,z or weighted 2D x,y,w
+ * * For instance, an instance of this class with `poleLength===3` does not know if its poles are x,y,z or
+ * weighted 2D x,y,w.
  * @public
  */
 class BSpline1dNd {
-    /** knots of the bspline */
+    /** Knots of the bspline. */
     knots;
-    /** poles, packed in blocks of `poleLength` doubles. */
+    /** Poles packed in blocks of `poleLength` doubles. */
     packedData;
-    /** (property accessor) Return the number of numeric values per pole. */
+    /** The number of numeric values per pole. */
     poleLength;
     /** (property accessor) Return the degree of the polynomials. */
-    get degree() { return this.knots.degree; }
-    /** (property accessor) Return the number of order (one more than degree) of the polynomials */
-    get order() { return this.knots.degree + 1; }
-    /** (property accessor) Return the number of bezier spans (including null spans at multiple knots)*/
-    get numSpan() { return this.numPoles - this.knots.degree; }
-    /** (property accessor)  Return the number of poles*/
-    get numPoles() { return this.packedData.length / this.poleLength; }
-    /** copy 3 values of pole `i` into a point.
+    get degree() {
+        return this.knots.degree;
+    }
+    /** (property accessor) Return the order (one more than degree) of the polynomials. */
+    get order() {
+        return this.knots.degree + 1;
+    }
+    /** (property accessor) Return the number of bezier spans (including null spans at multiple knots). */
+    get numSpan() {
+        return this.numPoles - this.knots.degree;
+    }
+    /** (property accessor) Return the number of poles. */
+    get numPoles() {
+        return this.packedData.length / this.poleLength;
+    }
+    /**
+     * Copy 3 values of pole `i` into a point.
      * * The calling class is responsible for knowing if this is an appropriate access to the blocked data.
      */
-    getPoint3dPole(i, result) { return _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_0__.Point3d.createFromPacked(this.packedData, i, result); }
-    /** preallocated array (length === `order`) used as temporary in evaluations */
-    basisBuffer; // one set of basis function values.   ALLOCATED BY CTOR FOR FREQUENT REUSE
-    /** preallocated array (length === `poleLength`) used as temporary in evaluations */
-    poleBuffer; // one set of target values.  ALLOCATED BY CTOR FOR FREQUENT REUSE
-    /** preallocated array (length === `order`) used as temporary in evaluations */
-    basisBuffer1; // one set of basis function values.   ALLOCATED BY CTOR FOR FREQUENT REUSE
-    /** preallocated array (length === `order`) used as temporary in evaluations */
-    basisBuffer2; // one set of basis function values.   ALLOCATED BY CTOR FOR FREQUENT REUSE
-    /** preallocated array (length === `poleLength`) used as temporary in evaluations */
-    poleBuffer1; // one set of target values.  ALLOCATED BY CTOR FOR FREQUENT REUSE
-    /** preallocated array (length === `poleLength`) used as temporary in evaluations */
-    poleBuffer2; // one set of target values.  ALLOCATED BY CTOR FOR FREQUENT REUSE
+    getPoint3dPole(i, result) {
+        return _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_0__.Point3d.createFromPacked(this.packedData, i, result);
+    }
     /**
-     * initialize arrays for given spline dimensions.
-     * @param numPoles number of poles
-     * @param poleLength number of coordinates per pole (e.g.. 3 for 3D unweighted, 4 for 3d weighted, 2 for 2d unweighted, 3 for 2d weighted)
-     * @param order number of poles in support for a section of the bspline
-     * @param knots KnotVector.  This is captured, not cloned.
+     * Values of the `order` relevant B-spline basis functions at a parameter.
+     * * Preallocated to length `order` in the constructor and used as a temporary in evaluations.
+     */
+    basisBuffer;
+    /**
+     * Derivatives of the `order` relevant B-spline basis functions at a parameter.
+     * * Preallocated to length `order` in the constructor and used as a temporary in evaluations.
+     */
+    basisBuffer1;
+    /**
+     * Second derivatives of the `order` relevant B-spline basis functions at a parameter.
+     * * Preallocated to length `order` in the constructor and used as a temporary in evaluations.
+     */
+    basisBuffer2;
+    /**
+     * Temporary to hold a single point.
+     * * Preallocated to length `poleLength` in the constructor.
+     */
+    poleBuffer;
+    /**
+     * Temporary to hold a single derivative vector.
+     * * Preallocated to length `poleLength` in the constructor.
+     */
+    poleBuffer1;
+    /**
+     * Temporary to hold a single second derivative vector.
+     * * Preallocated to length `poleLength` in the constructor.
+     */
+    poleBuffer2;
+    /**
+     * Initialize arrays for given spline dimensions.
+     * @param numPoles number of poles.
+     * @param poleLength number of coordinates per pole (e.g.. 3 for 3D unweighted, 4 for 3d weighted, 2 for 2d unweighted,
+     * 3 for 2d weighted).
+     * @param order number of poles defining a Bezier segment of the B-spline function.
+     * @param knots the KnotVector. This is captured, not cloned.
      */
     constructor(numPoles, poleLength, order, knots) {
         this.knots = knots;
         this.packedData = new Float64Array(numPoles * poleLength);
         this.poleLength = poleLength;
         this.basisBuffer = new Float64Array(order);
-        this.poleBuffer = new Float64Array(poleLength);
         this.basisBuffer1 = new Float64Array(order);
         this.basisBuffer2 = new Float64Array(order);
+        this.poleBuffer = new Float64Array(poleLength);
         this.poleBuffer1 = new Float64Array(poleLength);
         this.poleBuffer2 = new Float64Array(poleLength);
     }
     /**
-     * create a 1Bspline1dNd`
-     * @param numPoles number of poles
-     * @param poleLength number of coordinates per pole (e.g.. 3 for 3D unweighted, 4 for 3d weighted, 2 for 2d unweighted, 3 for 2d weighted)
-     * @param order number of poles in support for a section of the bspline
-     * @param knots KnotVector.  This is captured, not cloned.
+     * Create a `BSpline1dNd`.
+     * @param numPoles number of poles.
+     * @param poleLength number of coordinates per pole (e.g.. 3 for 3D unweighted, 4 for 3d weighted, 2 for 2d unweighted,
+     * 3 for 2d weighted).
+     * @param order number of poles defining a Bezier segment of the B-spline function.
+     * @param knots the KnotVector. This is captured, not cloned.
      */
     static create(numPoles, poleLength, order, knots) {
         return new BSpline1dNd(numPoles, poleLength, order, knots);
     }
-    /** Map a span index and local fraction to knot value. */
-    spanFractionToKnot(span, localFraction) {
-        return this.knots.spanFractionToKnot(span, localFraction);
+    /** Map a span index and span fraction to knot value. */
+    spanFractionToKnot(spanIndex, spanFraction) {
+        return this.knots.spanFractionToKnot(spanIndex, spanFraction);
     }
     /**
-     * Evaluate the `order` basis functions (and optionally one or two derivatives) at a given fractional position within indexed span.
-     * @returns true if and only if output arrays are sufficiently sized
+     * Evaluate the `order` basis functions (and optionally one or two derivatives) at a given fractional position within
+     * indexed span.
+     * @returns true if and only if output arrays are sufficiently sized.
     */
     evaluateBasisFunctionsInSpan(spanIndex, spanFraction, f, df, ddf) {
         if (spanIndex < 0)
@@ -183182,57 +183206,64 @@ class BSpline1dNd {
             this.knots.evaluateBasisFunctions(knotIndex0, globalKnot, f);
     }
     /**
-     * * Evaluate the basis functions at spanIndex and fraction.
-     *   * Evaluations are stored in the preallocated `this.basisBuffer`
-     * * Immediately do the summations of the basis values times the respective control points
-     *   * Summations are stored in the preallocated `this.poleBuffer`
-     * */
-    evaluateBuffersInSpan(spanIndex, spanFraction) {
-        this.evaluateBasisFunctionsInSpan(spanIndex, spanFraction, this.basisBuffer);
-        this.sumPoleBufferForSpan(spanIndex);
-    }
-    /**
-     * * Evaluate the basis functions and one derivative at spanIndex and fraction.
-     *   * Evaluations are stored in the preallocated `this.basisBuffer`
-     * * Immediately do the summations of the basis values times the respective control points
-     *   * Summations are stored in the preallocated `this.poleBuffer` and `this.poleBuffer1`
-     * */
-    evaluateBuffersInSpan1(spanIndex, spanFraction) {
-        this.evaluateBasisFunctionsInSpan(spanIndex, spanFraction, this.basisBuffer, this.basisBuffer1);
-        this.sumPoleBufferForSpan(spanIndex);
-        this.sumPoleBuffer1ForSpan(spanIndex);
-    }
-    /** sum poles in `poleBuffer` at span `spanIndex` by the weights in the `basisBuffer` */
+     * Compute the linear combination of the given span's poles and the weights in `basisBuffer`, and store this point
+     * in `poleBuffer`.
+     */
     sumPoleBufferForSpan(spanIndex) {
         this.poleBuffer.fill(0);
         let k = spanIndex * this.poleLength;
-        for (const f of this.basisBuffer) {
-            for (let j = 0; j < this.poleLength; j++) {
+        for (const f of this.basisBuffer)
+            for (let j = 0; j < this.poleLength; j++)
                 this.poleBuffer[j] += f * this.packedData[k++];
-            }
-        }
     }
-    /** sum poles in `poleBuffer1` at span `spanIndex` by the weights in the `basisBuffer1`, i.e. form first derivatives */
+    /**
+     * Compute the linear combination of the given span's poles and the weights in `basisBuffer1`, and store this
+     * derivative vector in `poleBuffer1`.
+     */
     sumPoleBuffer1ForSpan(spanIndex) {
         this.poleBuffer1.fill(0);
         let k = spanIndex * this.poleLength;
-        for (const f of this.basisBuffer1) {
-            for (let j = 0; j < this.poleLength; j++) {
+        for (const f of this.basisBuffer1)
+            for (let j = 0; j < this.poleLength; j++)
                 this.poleBuffer1[j] += f * this.packedData[k++];
-            }
-        }
     }
-    /** sum poles in `poleBuffer2` at span `spanIndex` by the weights in the `basisBuffer2`, i.e. form second derivatives */
+    /**
+     * Compute the linear combination of the given span's poles and the weights in `basisBuffer2`, and store this
+     * second derivative vector in `poleBuffer2`.
+     */
     sumPoleBuffer2ForSpan(spanIndex) {
         this.poleBuffer2.fill(0);
         let k = spanIndex * this.poleLength;
         for (const f of this.basisBuffer2) {
-            for (let j = 0; j < this.poleLength; j++) {
+            for (let j = 0; j < this.poleLength; j++)
                 this.poleBuffer2[j] += f * this.packedData[k++];
-            }
         }
     }
-    /** Evaluate the function values and 1 or 2 derivatives into `this.poleBuffer`, `this.poleBuffer1` and `this.poleBuffer2` */
+    /**
+     * * Evaluate the basis functions at spanIndex and fraction.
+     *   * Evaluations are stored in the preallocated `this.basisBuffer`.
+     * * Immediately do the summations of the basis values times the respective poles.
+     *   * Summations are stored in the preallocated `this.poleBuffer`
+     * */
+    evaluateBuffersInSpan(spanIndex, spanFraction) {
+        this.evaluateBasisFunctionsInSpan(spanIndex, spanFraction, this.basisBuffer);
+        this.sumPoleBufferForSpan(spanIndex);
+    }
+    /**
+     * * Evaluate the basis functions and one derivative at spanIndex and fraction.
+     *   * Function evaluations are stored in the preallocated `this.basisBuffer`; derivative evaluations in `this.basisBuffer1`.
+     * * Immediately do the summations of the basis values times the respective poles.
+     *   * Summations are stored in the preallocated `this.poleBuffer` and `this.poleBuffer1`
+     * */
+    evaluateBuffersInSpan1(spanIndex, spanFraction) {
+        this.evaluateBasisFunctionsInSpan(spanIndex, spanFraction, this.basisBuffer, this.basisBuffer1);
+        this.sumPoleBufferForSpan(spanIndex);
+        this.sumPoleBuffer1ForSpan(spanIndex);
+    }
+    /**
+     * Evaluate the B-spline function and optional derivatives at the given parameter in knot space.
+     * * Function value is stored in `poleBuffer`; optional derivative vectors in `poleBuffer1` and `poleBuffer2`.
+     */
     evaluateBuffersAtKnot(u, numDerivative = 0) {
         const knotIndex0 = this.knots.knotToLeftKnotIndex(u);
         if (numDerivative < 1) {
@@ -183251,36 +183282,30 @@ class BSpline1dNd {
             this.sumPoleBuffer2ForSpan(knotIndex0 - this.degree + 1);
         }
     }
-    /**
-     * Reverse the (blocked) poles (in `this.packedData` in place.
-     */
+    /** Reverse the instance poles and knots in place. */
     reverseInPlace() {
-        // reverse poles in blocks ...
-        const b = this.poleLength;
+        const pLen = this.poleLength;
         const data = this.packedData;
-        for (let i0 = 0, j0 = b * (this.numPoles - 1); i0 < j0; i0 += b, j0 -= b) {
-            let t = 0;
-            for (let i = 0; i < b; i++) {
-                t = data[i0 + i];
-                data[i0 + i] = data[j0 + i];
-                data[j0 + i] = t;
-            }
+        for (let i0 = 0, j0 = pLen * (this.numPoles - 1); i0 < j0; i0 += pLen, j0 -= pLen) {
+            for (let i = 0; i < pLen; i++)
+                [data[i0 + i], data[j0 + i]] = [data[j0 + i], data[i0 + i]];
         }
         this.knots.reflectKnots();
     }
     /**
-     * Test if the leading and trailing polygon coordinates are replicated in the manner of a "closed" bspline polygon which has been expanded
-     * to act as a normal bspline.
-     * @returns true if `degree` leading and trailing polygon blocks match
-     * @deprecated in 4.x. Use testClosablePolygon instead.
+     * Test if the leading and trailing polygon coordinates are replicated in the manner of a "closed" bspline polygon
+     * which has been expanded to act as a normal bspline.
+     * @returns true if `degree` leading and trailing polygon blocks match.
+     * @deprecated in 4.x. Use `testClosablePolygon` instead.
      */
     testCloseablePolygon(mode) {
         return this.testClosablePolygon(mode);
     }
     /**
-     * Test if the leading and trailing polygon coordinates are replicated in the manner of a "closed" bspline polygon which has been expanded
-     * to act as a normal bspline.
-     * @returns true if `degree` leading and trailing polygon blocks match
+     * Test if the leading and trailing poles are replicated in the manner of a "closed" B-spline function with wraparound
+     * control polygon.
+     * @param mode wrap mode, indicating the number of wraparound poles to check. If undefined, `knots.wrappable` is used.
+     * @returns true if the expected leading and trailing poles match, according to `mode`.
      */
     testClosablePolygon(mode) {
         if (mode === undefined)
@@ -183302,9 +183327,10 @@ class BSpline1dNd {
         }
         return true;
     }
-    /** Insert knot and resulting pole into the instance, optionally multiple times.
-     * @param knot the knot to be inserted (may already exist in the KnotVector)
-     * @param totalMultiplicity the total multiplicity of the knot on return
+    /**
+     * Insert the knot and resulting pole into the instance, optionally multiple times.
+     * @param knot the knot to be inserted (may already exist in the KnotVector).
+     * @param totalMultiplicity the total multiplicity of the knot on return.
      */
     addKnot(knot, totalMultiplicity) {
         if (knot < this.knots.leftKnot || knot > this.knots.rightKnot)
@@ -183428,83 +183454,117 @@ __webpack_require__.r(__webpack_exports__);
 
 /**
  * Base class for BSplineCurve3d and BSplineCurve3dH.
- * * A bspline curve consists of a set of knots and a set of poles.
- * * The bspline curve is a function of the independent "knot axis" variable
- * * The curve "follows" the poles loosely.
- * * The is a set of polynomial spans.
+ * * A B-spline curve consists of an array of `knots`, an array of `poles`, and a `degree`.
+ * * The knot array is a non-decreasing sequence of numbers. It is also called a "knot vector".
+ *   * The curve is a parametric function whose domain is a sub-range of its knots.
+ *   * The API sometimes refers to a domain parameter `u` as a "knot", even if `u` is not actually an entry in the
+ * knot array.
+ * * The curve loosely "follows" the line string formed by the poles, aka the "control polygon".
+ * * The curve is a chain of polynomial segments, aka "spans" or "fragments". B-spline theory identifies these as
+ * Bezier curves.
  * * The polynomial spans all have same `degree`.
- * * Within each span, the polynomial of that `degree` is controlled by `order = degree + 1` contiguous points called poles.
- * * The is a strict relationship between knot and poles counts:  `numPoles + order = numKnots + 2'
- * * The number of spans is `numSpan = numPoles - degree`
- * * For a given `spanIndex`:
- *   * The `order` poles begin at index `spanIndex`.
- *   * The `2*order` knots begin as span index
- *   * The knot interval for this span is from `knot[degree+span-1] to knot[degree+span]`
- * * The active part of the knot axis is `knot[degree-1] < knot < knot[degree-1 + numSpan]` i.e. `knot[degree-1] < knot < knot[numPoles]
+ * * Each span is controlled by `order = degree + 1` contiguous points in the pole array.
+ * * There is a strict relationship between knot and poles counts: `numPoles + order = numKnots + 2'.
+ * * The number of spans is `numSpan = numPoles - degree`.
+ * * For a span with index `spanIndex`:
+ *   * The `order` relevant poles begin at pole index `spanIndex`.
+ *   * The `2*degree` relevant knots begin at knot index `spanIndex`.
+ *   * The span domain is the knot range `[knot[spanIndex+degree-1], knot[spanIndex+degree]]`.
+ * * The curve domain is the knot range `[knot[degree-1], knot[numSpan+degree-1]]`, or equivalently
+ * `[knot[degree-1], knot[numPoles-1]]`. The API refers to this domain as the "active knot interval" of the curve.
  *
- * Nearly all bsplines are "clamped ".
- * * Clamping make the curve pass through its first and last poles, with tangents directed along the first and last edges of the control polygon.
- * * The knots for a clamped bspline have `degree` copies of the lowest knot value and `degree` copies of the highest knot value.
- * * For instance, the knot vector `[0,0,0,1,2,3,3,3]
- *   * can be evaluated from `0<=knot<=3`
- *   * has 3 spans: 0 to 1, 1 to 2, 2 to 3
+ * Nearly all B-spline curves are "clamped".
+ * * This means that in the `knots` array, the first `degree` knots are equal, and the last `degree` knots are equal.
+ * We say the smallest knot and the largest knot have multiplicity `degree`.
+ * * Clamping make the curve pass through its first and last poles, with tangents directed along the first and
+ * last edges of the control polygon.
+ * * For instance, a cubic B-spline curve with knot vector `[0,0,0,1,2,3,3,3]`
+ *   * can be evaluated at parameter values in the range `[0, 3]`
+ *   * has 3 spans, with domains `[0, 1]`, `[1, 2]`, and `[2, 3]`
  *   * has 6 poles
  *   * passes through its first and last poles.
- * * `create` methods may allow classic convention that has an extra knot at the beginning and end of the knot vector.
- *   * The extra knots (first and last) were never referenced by the bspline recurrence relations.
- *   * When the `create` methods recognize the classic setup (`numPoles + order = numKnots`), the extra knot is not saved with the BSplineCurve3dBase knots.
+ * * The `create` methods may allow the classic convention that has an extra knot at the beginning and end of the
+ * knot vector.
+ *   * These two extra knots are not actually needed to define the B-spline curve.
+ *   * When the `create` methods recognize the classic setup (`numPoles + order = numKnots`), the extra knots are
+ * not saved with the BSplineCurve3dBase knots.
  *
- * * The weighted variant has the problem that CurvePrimitive 3d typing does not allow undefined result where Point4d has zero weight.
- * * The convention for these is to return 000 in such places.
+ * * The weighted variant [[BSplineCurve3dH]] has the problem that `CurvePrimitive` 3D typing does not allow the
+ *  undefined result where a homogeneous pole has zero weight; the convention in this case is to return 000.
  *
  * * Note the class relationships:
- *   * BSpline1dNd knows the bspline recurrence relations for control points (poles) with no physical meaning.
- *   * BsplineCurve3dBase owns a protected BSpline1dNd
- *   * BsplineCurve3dBase is derived from CurvePrimitive, which creates obligation to act as a 3D curve, such as
- *     * evaluate fraction to point and derivatives wrt fraction
- *     * compute intersection with plane
- *   * BSplineCurve3d and BSplineCurve3dH have variant logic driven by whether or not there are "weights" on the poles.
- *     * For `BSplineCurve3d`, the xyz value of pole calculations are "final" values for 3d evaluation
+ *   * [[BSpline1dNd]] knows the definitional B-spline recurrence relation with no physical interpretation for the poles.
+ *   * BsplineCurve3dBase owns a protected BSpline1dNd.
+ *   * `BsplineCurve3dBase` is derived from [[CurvePrimitive]], which creates obligation to act as a 3D curve, e.g.,
+ *     * evaluate fraction to point and derivatives wrt fraction.
+ *     * compute intersection with plane.
+ *   * [[BSplineCurve3d]] and [[BSplineCurve3dH]] have variant logic driven by whether or not there are "weights" on the poles.
+ *     * For `BSplineCurve3d`, the xyz value of pole calculations are "final" values for 3d evaluation.
  *     * For `BSplineCurve3dH`, various `BSpline1dNd` results with xyzw have to be normalized back to xyz.
  *
  * * These classes do not support "periodic" variants.
- *   * Periodic curves need to have certain leading knots and poles replicated at the end
+ *   * Periodic curves historically have carried a flag (e.g., "closed") indicating that certain un-stored
+ * leading/trailing knots and poles are understood to wrap around periodically.
+ *   * Instead, these classes carry no such flag. They represent such curves with explicitly wrapped knots/poles.
+ *
+ * * Visualization can be found at https://www.itwinjs.org/sandbox/SaeedTorabi/BSpline/
  * @public
  */
 class BSplineCurve3dBase extends _curve_CurvePrimitive__WEBPACK_IMPORTED_MODULE_0__.CurvePrimitive {
-    /** String name for schema properties */
+    /** String name for schema properties. */
     curvePrimitiveType = "bsplineCurve";
-    /** The underlying blocked-pole spline, with simple x,y,z poles */
+    /** The underlying blocked-pole spline, with simple x,y,z poles. */
     _bcurve;
     _definitionData;
-    set definitionData(data) { this._definitionData = data; }
-    get definitionData() { return this._definitionData; }
+    set definitionData(data) {
+        this._definitionData = data;
+    }
+    get definitionData() {
+        return this._definitionData;
+    }
     constructor(poleDimension, numPoles, order, knots) {
         super();
         this._bcurve = _BSpline1dNd__WEBPACK_IMPORTED_MODULE_1__.BSpline1dNd.create(numPoles, poleDimension, order, knots);
     }
-    /** Return the degree (one less than the order) of the curve */
-    get degree() { return this._bcurve.degree; }
-    /** Return the order (one more than degree) of the curve */
-    get order() { return this._bcurve.order; }
-    /** Return the number of bezier spans in the curve.  Note that this number includes the number of null spans at repeated knows */
-    get numSpan() { return this._bcurve.numSpan; }
-    /** Return the number of poles */
-    get numPoles() { return this._bcurve.numPoles; }
-    /** Return live reference to the packed control point coordinates of the curve. */
-    get polesRef() { return this._bcurve.packedData; }
-    /** Return live reference to the knots of the curve. */
-    get knotsRef() { return this._bcurve.knots.knots; }
-    /** Number of components per pole.
-     * * 3 for conventional (x,y,z) curve
-     * * 4 for weighted (wx,wy,wz,w) curve
+    /** Return the degree (one less than the order) of the curve. */
+    get degree() {
+        return this._bcurve.degree;
+    }
+    /** Return the order (one more than degree) of the curve. */
+    get order() {
+        return this._bcurve.order;
+    }
+    /**
+     * Return the number of Bezier spans in the curve. Note that this number includes the number of null
+     * spans at repeated knows.
      */
-    get poleDimension() { return this._bcurve.poleLength; }
+    get numSpan() {
+        return this._bcurve.numSpan;
+    }
+    /** Return the number of poles. */
+    get numPoles() {
+        return this._bcurve.numPoles;
+    }
+    /** Return live reference to the poles of the curve. */
+    get polesRef() {
+        return this._bcurve.packedData;
+    }
+    /** Return live reference to the knots of the curve. */
+    get knotsRef() {
+        return this._bcurve.knots.knots;
+    }
     /**
-     * return a simple array form of the knots.  optionally replicate the first and last
-     * in classic over-clamped manner
+     * Number of components per pole, e.g.,
+     * * 3 for conventional (x,y,z) curve.
+     * * 4 for weighted (wx,wy,wz,w) curve.
      */
-    copyKnots(includeExtraEndKnot) { return this._bcurve.knots.copyKnots(includeExtraEndKnot); }
+    get poleDimension() {
+        return this._bcurve.poleLength;
+    }
+    /** Return a simple array form of the knots. Optionally replicate the first and last in classic over-clamped manner. */
+    copyKnots(includeExtraEndKnot) {
+        return this._bcurve.knots.copyKnots(includeExtraEndKnot);
+    }
     /** Get the flag indicating the curve might be suitable for having wrapped "closed" interpretation. */
     getWrappable() {
         return this._bcurve.knots.wrappable;
@@ -183514,7 +183574,7 @@ class BSplineCurve3dBase extends _curve_CurvePrimitive__WEBPACK_IMPORTED_MODULE_
         this._bcurve.knots.wrappable = value;
     }
     /**
-     * Test knots and control points to determine if it is possible to close (aka "wrap") the curve.
+     * Test knots and poles to determine if it is possible to close (aka "wrap") the curve.
      * @returns the manner in which it is possible to close the curve. See `BSplineWrapMode` for particulars of each mode.
      */
     get isClosableCurve() {
@@ -183527,25 +183587,18 @@ class BSplineCurve3dBase extends _curve_CurvePrimitive__WEBPACK_IMPORTED_MODULE_
             return _KnotVector__WEBPACK_IMPORTED_MODULE_2__.BSplineWrapMode.None;
         return mode;
     }
-    /** Evaluate the curve point at `fraction` */
+    /** Evaluate the curve point at the given fractional parameter. */
     fractionToPoint(fraction, result) {
         return this.knotToPoint(this._bcurve.knots.fractionToKnot(fraction), result);
     }
-    /** Construct a ray with
-     * * origin at the fractional position along the arc
-     * * direction is the first derivative, i.e. tangent along the curve
-     */
+    /** Evaluate the curve and derivative at the given fractional parameter. */
     fractionToPointAndDerivative(fraction, result) {
         const knot = this._bcurve.knots.fractionToKnot(fraction);
         result = this.knotToPointAndDerivative(knot, result);
         result.direction.scaleInPlace(this._bcurve.knots.knotLength01);
         return result;
     }
-    /** Construct a plane with
-     * * origin at the fractional position along the arc
-     * * x axis is the first derivative, i.e. tangent along the curve
-     * * y axis is the second derivative
-     */
+    /** Evaluate the curve and two derivatives at the given fractional parameter. */
     fractionToPointAnd2Derivatives(fraction, result) {
         const knot = this._bcurve.knots.fractionToKnot(fraction);
         result = this.knotToPointAnd2Derivatives(knot, result);
@@ -183554,22 +183607,23 @@ class BSplineCurve3dBase extends _curve_CurvePrimitive__WEBPACK_IMPORTED_MODULE_
         result.vectorV.scaleInPlace(a * a);
         return result;
     }
+    /** Return the start point of the curve. */
+    startPoint() {
+        return this.evaluatePointInSpan(0, 0.0);
+    }
+    /** Return the end point of the curve. */
+    endPoint() {
+        return this.evaluatePointInSpan(this.numSpan - 1, 1.0);
+    }
     /**
-     * Return the start point of the curve.
-     */
-    startPoint() { return this.evaluatePointInSpan(0, 0.0); }
-    /**
-     * Return the end point of the curve
-     */
-    endPoint() { return this.evaluatePointInSpan(this.numSpan - 1, 1.0); }
-    /** Reverse the curve in place.
-     * * Poles are reversed
-     * * knot values are mirrored around the middle of the
-     */
-    reverseInPlace() { this._bcurve.reverseInPlace(); }
-    /**
-     * Return an array with this curve's bezier fragments.
+     * Reverse the curve in place.
+     * * Poles are reversed.
+     * * Knot values are mirrored around the middle of the knot array.
      */
+    reverseInPlace() {
+        this._bcurve.reverseInPlace();
+    }
+    /** Return an array with this curve's Bezier fragments. */
     collectBezierSpans(prefer3dH) {
         const result = [];
         const numSpans = this.numSpan;
@@ -183588,17 +183642,18 @@ class BSplineCurve3dBase extends _curve_CurvePrimitive__WEBPACK_IMPORTED_MODULE_
             return poleIndex * this._bcurve.poleLength;
         return undefined;
     }
-    /** Search for the curve point that is closest to the spacePoint.
-     *
+    /**
+     * Search for the curve point that is closest to the spacePoint.
      * * If the space point is exactly on the curve, this is the reverse of fractionToPoint.
-     * * Since CurvePrimitive should always have start and end available as candidate points, this method should always succeed
-     * @param spacePoint point in space
+     * * Since CurvePrimitive should always have start and end available as candidate points, this method should always
+     * succeed.
+     * @param spacePoint point in space.
      * @param _extend ignored (pass false). A BSplineCurve3dBase cannot be extended.
      * @param result optional pre-allocated detail to populate and return.
      * @returns details of the closest point.
      */
     closestPoint(spacePoint, _extend, result) {
-        // seed at start point -- final point comes with final bezier perpendicular step.
+        // seed at start point; final point comes with final bezier perpendicular step
         const point = this.fractionToPoint(0);
         result = _curve_CurveLocationDetail__WEBPACK_IMPORTED_MODULE_3__.CurveLocationDetail.createCurveFractionPointDistance(this, 0.0, point, point.distance(spacePoint), result);
         let span;
@@ -183607,9 +183662,9 @@ class BSplineCurve3dBase extends _curve_CurvePrimitive__WEBPACK_IMPORTED_MODULE_
             if (this._bcurve.knots.isIndexOfRealSpan(i)) {
                 span = this.getSaturatedBezierSpan3dOr3dH(i, true, span);
                 if (span) {
-                    // umm ... if the bspline is discontinuous, both ends should be tested.  Ignore that possibility ...
+                    // if the B-spline is discontinuous, both ends should be tested; ignore that possibility
                     if (span.updateClosestPointByTruePerpendicular(spacePoint, result, false, true)) {
-                        // the detail records the span bezier -- promote it to the parent curve . ..
+                        // the detail records the span bezier; promote it to the parent curve
                         result.curve = this;
                         result.fraction = span.fractionToParentFraction(result.fraction);
                     }
@@ -183620,13 +183675,14 @@ class BSplineCurve3dBase extends _curve_CurvePrimitive__WEBPACK_IMPORTED_MODULE_
     }
     /** Return a transformed deep clone. */
     cloneTransformed(transform) {
-        const curve1 = this.clone();
-        curve1.tryTransformInPlace(transform);
-        return curve1;
+        const curve = this.clone();
+        curve.tryTransformInPlace(transform);
+        return curve;
     }
-    /** Return a curve primitive which is a portion of this curve.
-     * @param fractionA [in] start fraction
-     * @param fractionB [in] end fraction
+    /**
+     * Return a curve primitive which is a portion of this curve.
+     * @param fractionA start fraction.
+     * @param fractionB end fraction.
      */
     clonePartialCurve(fractionA, fractionB) {
         const clone = this.clone();
@@ -183637,11 +183693,8 @@ class BSplineCurve3dBase extends _curve_CurvePrimitive__WEBPACK_IMPORTED_MODULE_
         clone._bcurve.addKnot(knotB, clone.degree);
         if (origNumKnots === clone._bcurve.knots.knots.length)
             return clone; // full curve
-        if (knotA > knotB) {
-            const tmp = knotA;
-            knotA = knotB;
-            knotB = tmp;
-        }
+        if (knotA > knotB)
+            [knotA, knotB] = [knotB, knotA];
         // choose first/last knot and pole such that knotA/knotB has degree multiplicity in the new knot sequence
         const iStartKnot = clone._bcurve.knots.knotToLeftKnotIndex(knotA) - clone.degree + 1;
         const iStartPole = iStartKnot * clone._bcurve.poleLength;
@@ -183651,15 +183704,17 @@ class BSplineCurve3dBase extends _curve_CurvePrimitive__WEBPACK_IMPORTED_MODULE_
             iLastKnotLeftMultiple = iLastKnot + 1;
         const iEndPole = (iLastKnotLeftMultiple + 1) * clone._bcurve.poleLength; // one past last pole
         const iEndKnot = iLastKnotLeftMultiple + clone.degree; // one past last knot
-        // trim the arrays (leave knots unnormalized!)
+        // trim the arrays (leave knots unnormalized)
         clone._bcurve.knots.setKnotsCapture(clone._bcurve.knots.knots.slice(iStartKnot, iEndKnot));
         clone._bcurve.packedData = clone._bcurve.packedData.slice(iStartPole, iEndPole);
         clone.setWrappable(_KnotVector__WEBPACK_IMPORTED_MODULE_2__.BSplineWrapMode.None); // always open
         return clone;
     }
-    /** Implement `CurvePrimitive.appendPlaneIntersections`
-     * @param plane A plane (e.g. specific type Plane3dByOriginAndUnitNormal or Point4d)
-     * @param result growing array of plane intersections
+    /**
+     * Implement `CurvePrimitive.appendPlaneIntersections` to compute intersections of the curve with a plane.
+     * @param plane the plane with which to intersect the curve. Concrete types include [[Plane3dByOriginAndUnitNormal]],
+     * [[Point4d]], etc.
+     * @param result growing array of plane intersections.
      * @return number of intersections appended to the array.
     */
     appendPlaneIntersectionPoints(plane, result) {
@@ -183670,34 +183725,32 @@ class BSplineCurve3dBase extends _curve_CurvePrimitive__WEBPACK_IMPORTED_MODULE_
         const point4d = _geometry4d_Point4d__WEBPACK_IMPORTED_MODULE_4__.Point4d.create();
         // compute all pole altitudes from the plane
         const minMax = _geometry3d_Range__WEBPACK_IMPORTED_MODULE_5__.Range1d.createNull();
-        // Put the altitudes of all the bspline poles in one array.
+        // put the altitudes of all the B-spline poles in one array
         for (let i = 0; i < numPole; i++) {
             allCoffs[i] = plane.weightedAltitude(this.getPolePoint4d(i, point4d));
             minMax.extendX(allCoffs[i]);
         }
-        // A univariate bspline through the altitude poles gives altitude as function of the bspline knot.
+        // A univariate B-spline through the altitude poles gives altitude as function of the B-spline knot.
         // The (bspline) altitude function for each span is `order` consecutive altitudes.
         // If those altitudes bracket zero, the span may potentially have a crossing.
-        // When that occurs,
         let univariateBezier;
         let numFound = 0;
         let previousFraction = -1000.0;
         if (minMax.containsX(0.0)) {
             for (let spanIndex = 0; spanIndex < numSpan; spanIndex++) {
-                if (this._bcurve.knots.isIndexOfRealSpan(spanIndex)) { // ignore trivial knot intervals.
+                if (this._bcurve.knots.isIndexOfRealSpan(spanIndex)) { // ignore trivial knot intervals
                     // outer range test ...
                     minMax.setNull();
                     minMax.extendArraySubset(allCoffs, spanIndex, order);
                     if (minMax.containsX(0.0)) {
-                        // pack the bspline support into a univariate bezier ...
+                        // pack the B-spline support into a univariate bezier
                         univariateBezier = _numerics_BezierPolynomials__WEBPACK_IMPORTED_MODULE_6__.UnivariateBezier.createArraySubset(allCoffs, spanIndex, order, univariateBezier);
                         // saturate and solve the bezier
                         _Bezier1dNd__WEBPACK_IMPORTED_MODULE_7__.Bezier1dNd.saturate1dInPlace(univariateBezier.coffs, this._bcurve.knots, spanIndex);
                         const roots = univariateBezier.roots(0.0, true);
                         if (roots) {
                             for (const spanFraction of roots) {
-                                // promote each local bezier fraction to global fraction.
-                                // save the curve evaluation at that fraction.
+                                // promote each local bezier fraction to global fraction and save the curve evaluation at that fraction
                                 numFound++;
                                 const fraction = this._bcurve.knots.spanFractionToFraction(spanIndex, spanFraction);
                                 if (!_Geometry__WEBPACK_IMPORTED_MODULE_8__.Geometry.isAlmostEqualNumber(fraction, previousFraction)) {
@@ -183716,9 +183769,7 @@ class BSplineCurve3dBase extends _curve_CurvePrimitive__WEBPACK_IMPORTED_MODULE_
     }
     /**
      * Construct an offset of the instance curve as viewed in the xy-plane (ignoring z).
-     * * No attempt is made to join the offsets of smaller constituent primitives. To construct a fully joined offset
-     *   for an aggregate instance (e.g., LineString3d, CurveChainWithDistanceIndex), use RegionOps.constructCurveXYOffset() instead.
-     * @param offsetDistanceOrOptions offset distance (positive to left of the instance curve), or options object
+     * @param offsetDistanceOrOptions offset distance (positive to left of the instance curve), or options object.
      */
     constructOffsetXY(offsetDistanceOrOptions) {
         const options = _curve_OffsetOptions__WEBPACK_IMPORTED_MODULE_9__.OffsetOptions.create(offsetDistanceOrOptions);
@@ -183726,18 +183777,21 @@ class BSplineCurve3dBase extends _curve_CurvePrimitive__WEBPACK_IMPORTED_MODULE_
         this.emitStrokableParts(handler, options.strokeOptions);
         return handler.claimResult();
     }
-    /** Project instance geometry (via dispatch) onto the given ray, and return the extreme fractional parameters of projection.
+    /**
+     * Project instance geometry (via dispatch) onto the given ray, and return the extreme fractional parameters
+     * of projection.
      * @param ray ray onto which the instance is projected. A `Vector3d` is treated as a `Ray3d` with zero origin.
-     * @param lowHigh optional receiver for output
-     * @returns range of fractional projection parameters onto the ray, where 0.0 is start of the ray and 1.0 is the end of the ray.
+     * @param lowHigh optional receiver for output.
+     * @returns range of fractional projection parameters onto the ray, where 0.0 is start of the ray and 1.0 is the
+     * end of the ray.
      */
     projectedParameterRange(ray, lowHigh) {
         return _curve_internalContexts_PlaneAltitudeRangeContext__WEBPACK_IMPORTED_MODULE_11__.PlaneAltitudeRangeContext.findExtremeFractionsAlongDirection(this, ray, lowHigh);
     }
 }
 /**
- * A BSplineCurve3d is a bspline curve whose poles are Point3d.
- * See BSplineCurve3dBase for description of knots, order, degree.
+ * A BSplineCurve3d is a B-spline curve whose poles are Point3d.
+ * See BSplineCurve3dBase for description of knots, order, degree, and poles.
  * @public
  */
 class BSplineCurve3d extends BSplineCurve3dBase {
@@ -183747,11 +183801,19 @@ class BSplineCurve3d extends BSplineCurve3dBase {
             this._workBezier = _BezierCurve3d__WEBPACK_IMPORTED_MODULE_12__.BezierCurve3d.createOrder(this.order);
         return this._workBezier;
     }
-    /** test of `other` is an instance of BSplineCurve3d */
-    isSameGeometryClass(other) { return other instanceof BSplineCurve3d; }
+    constructor(numPoles, order, knots) {
+        super(3, numPoles, order, knots);
+    }
+    /** Test if `other` is an instance of BSplineCurve3d. */
+    isSameGeometryClass(other) {
+        return other instanceof BSplineCurve3d;
+    }
     /** Apply `transform` to the poles. */
-    tryTransformInPlace(transform) { _geometry3d_PointHelpers__WEBPACK_IMPORTED_MODULE_13__.Point3dArray.multiplyInPlace(transform, this._bcurve.packedData); return true; }
-    /** Get a pole as simple Point3d. */
+    tryTransformInPlace(transform) {
+        _geometry3d_PointHelpers__WEBPACK_IMPORTED_MODULE_13__.Point3dArray.multiplyInPlace(transform, this._bcurve.packedData);
+        return true;
+    }
+    /** Get a pole as a simple Point3d. */
     getPolePoint3d(poleIndex, result) {
         const k = this.poleIndexToDataIndex(poleIndex);
         if (k !== undefined) {
@@ -183760,7 +183822,7 @@ class BSplineCurve3d extends BSplineCurve3dBase {
         }
         return undefined;
     }
-    /** Get a pole as Point4d with weight 1 */
+    /** Get a pole as Point4d with weight 1. */
     getPolePoint4d(poleIndex, result) {
         const k = this.poleIndexToDataIndex(poleIndex);
         if (k !== undefined) {
@@ -183769,23 +183831,26 @@ class BSplineCurve3d extends BSplineCurve3dBase {
         }
         return undefined;
     }
-    /** Convert  `spanIndex` and `localFraction` to a knot. */
-    spanFractionToKnot(span, localFraction) {
-        return this._bcurve.spanFractionToKnot(span, localFraction);
-    }
-    constructor(numPoles, order, knots) {
-        super(3, numPoles, order, knots);
-    }
-    /** Return a simple array of arrays with the control points as `[[x,y,z],[x,y,z],..]` */
-    copyPoints() { return _geometry3d_PointHelpers__WEBPACK_IMPORTED_MODULE_13__.Point3dArray.unpackNumbersToNestedArrays(this._bcurve.packedData, 3); }
-    /** Return a simple array of the control points coordinates */
-    copyPointsFloat64Array() { return this._bcurve.packedData.slice(); }
     /**
-     * return a simple array form of the knots.  optionally replicate the first and last
-     * in classic over-clamped manner
+     * Convert the fractional position in the given span to a knot.
+     * * The returned value is not necessarily a knot, but it is a valid parameter in the domain of the B-spline curve.
      */
-    copyKnots(includeExtraEndKnot) { return this._bcurve.knots.copyKnots(includeExtraEndKnot); }
-    /** Create a bspline with uniform knots. */
+    spanFractionToKnot(spanIndex, spanFraction) {
+        return this._bcurve.spanFractionToKnot(spanIndex, spanFraction);
+    }
+    /** Return a simple array of arrays with the poles as `[[x,y,z],[x,y,z],..]`. */
+    copyPoints() {
+        return _geometry3d_PointHelpers__WEBPACK_IMPORTED_MODULE_13__.Point3dArray.unpackNumbersToNestedArrays(this._bcurve.packedData, 3);
+    }
+    /** Return a simple array of poles' coordinates. */
+    copyPointsFloat64Array() {
+        return this._bcurve.packedData.slice();
+    }
+    /** Return a simple array form of the knots. Optionally replicate the first and last in classic over-clamped manner. */
+    copyKnots(includeExtraEndKnot) {
+        return this._bcurve.knots.copyKnots(includeExtraEndKnot);
+    }
+    /** Create a B-spline with uniform knots. */
     static createUniformKnots(poles, order) {
         const numPoles = poles instanceof Float64Array ? poles.length / 3 : poles.length;
         if (order < 2 || numPoles < order)
@@ -183809,9 +183874,10 @@ class BSplineCurve3d extends BSplineCurve3dBase {
         }
         return curve;
     }
-    /** Create a smoothly closed B-spline curve with uniform knots.
-     *  Note that the curve does not start at the first pole!
-    */
+    /**
+     * Create a smoothly closed B-spline curve with uniform knots.
+     * * Note that the curve does not start at the first pole.
+     */
     static createPeriodicUniformKnots(poles, order) {
         if (order < 2)
             return undefined;
@@ -183882,21 +183948,23 @@ class BSplineCurve3d extends BSplineCurve3dBase {
         return _BSplineCurveOps__WEBPACK_IMPORTED_MODULE_16__.BSplineCurveOps.createThroughPointsC2Cubic(options);
     }
     /**
-     *
+     * Create a B-spline curve from an Akima curve.
      * @param options collection of points and end conditions.
      */
     static createFromAkimaCurve3dOptions(options) {
         return _BSplineCurveOps__WEBPACK_IMPORTED_MODULE_16__.BSplineCurveOps.createThroughPoints(options.fitPoints, 4); // temporary
     }
     /**
-     * Create a bspline with given knots.
+     * Create a B-spline curve with given knots.
      * * The poles have several variants:
-     *    * Float64Array(3 * numPoles) in blocks of [x,y,z]
-     *    * Point3d[]
-     *    * number[][], with inner dimension 3
+     *    * Float64Array(3 * numPoles) in blocks of [x,y,z].
+     *    * Point3d[].
+     *    * number[][], with inner dimension 3.
      * * Two count conditions are recognized:
-     *    * If poleArray.length + order === knotArray.length, the first and last are assumed to be the extraneous knots of classic clamping.
+     *    * If poleArray.length + order === knotArray.length, the first and last are assumed to be the extraneous knots
+     *      of classic clamping.
      *    * If poleArray.length + order === knotArray.length + 2, the knots are in modern form.
+     * * Visualization can be found at https://www.itwinjs.org/sandbox/SaeedTorabi/BSpline/
      */
     static create(poleArray, knotArray, order) {
         if (order < 2)
@@ -183934,31 +184002,42 @@ class BSplineCurve3d extends BSplineCurve3dBase {
         }
         return curve;
     }
-    /** Return a deep clone */
+    /** Return a deep clone. */
     clone() {
-        const knotVector1 = this._bcurve.knots.clone();
-        const curve1 = new BSplineCurve3d(this.numPoles, this.order, knotVector1);
-        curve1._bcurve.packedData = this._bcurve.packedData.slice();
-        return curve1;
+        const knotVector = this._bcurve.knots.clone();
+        const curve = new BSplineCurve3d(this.numPoles, this.order, knotVector);
+        curve._bcurve.packedData = this._bcurve.packedData.slice();
+        return curve;
     }
-    /** Evaluate at a position given by fractional position within a span. */
+    /** Evaluate the curve at a fractional position within a given span. */
     evaluatePointInSpan(spanIndex, spanFraction) {
         this._bcurve.evaluateBuffersInSpan(spanIndex, spanFraction);
         return _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_14__.Point3d.createFrom(this._bcurve.poleBuffer);
     }
-    /** Evaluate point and derivative vector at a position given by fractional position within a span.
-     * * The derivative is with respect to the span fraction (NOT scaled to either global fraction or knot)
+    /**
+     * Evaluate the curve and derivative at a fractional position within a given span.
+     * * The derivative is with respect to the span fractional parameter, _not_ to the curve's parameter or fractional parameter.
      */
     evaluatePointAndDerivativeInSpan(spanIndex, spanFraction) {
         this._bcurve.evaluateBuffersInSpan1(spanIndex, spanFraction);
         return _geometry3d_Ray3d__WEBPACK_IMPORTED_MODULE_17__.Ray3d.createCapture(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_14__.Point3d.createFrom(this._bcurve.poleBuffer), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_14__.Vector3d.createFrom(this._bcurve.poleBuffer1));
     }
-    /** Evaluate at a position given by a knot value.  */
+    /**
+     * Evaluate the curve at the given parameter.
+     * @param u parameter in curve domain.
+     * @param result optional result.
+     * @returns the point on the curve.
+     */
     knotToPoint(u, result) {
         this._bcurve.evaluateBuffersAtKnot(u);
         return _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_14__.Point3d.createFrom(this._bcurve.poleBuffer, result);
     }
-    /** Evaluate at a position given by a knot value.  */
+    /**
+     * Evaluate the curve and derivative at the given parameter.
+     * @param u parameter in curve domain.
+     * @param result optional result.
+     * @returns the ray with origin at the curve point and direction as the derivative.
+     */
     knotToPointAndDerivative(u, result) {
         this._bcurve.evaluateBuffersAtKnot(u, 1);
         if (!result)
@@ -183967,12 +184046,17 @@ class BSplineCurve3d extends BSplineCurve3dBase {
         result.direction.setFrom(this._bcurve.poleBuffer1);
         return result;
     }
-    /** Evaluate at a position given by a knot value.  Return point with 2 derivatives. */
+    /**
+     * Evaluate the curve and two derivatives at the given parameter.
+     * @param u parameter in the curve domain.
+     * @param result optional result.
+     * @returns the plane with origin at the curve point, vectorU as the 1st derivative, and vectorV as the 2nd derivative.
+     */
     knotToPointAnd2Derivatives(u, result) {
         this._bcurve.evaluateBuffersAtKnot(u, 2);
         return _geometry3d_Plane3dByOriginAndVectors__WEBPACK_IMPORTED_MODULE_18__.Plane3dByOriginAndVectors.createOriginAndVectorsXYZ(this._bcurve.poleBuffer[0], this._bcurve.poleBuffer[1], this._bcurve.poleBuffer[2], this._bcurve.poleBuffer1[0], this._bcurve.poleBuffer1[1], this._bcurve.poleBuffer1[2], this._bcurve.poleBuffer2[0], this._bcurve.poleBuffer2[1], this._bcurve.poleBuffer2[2], result);
     }
-    /** test if almost the same curve as `other` */
+    /** Test if `this` is almost the same curve as `other`. */
     isAlmostEqual(other) {
         if (other instanceof BSplineCurve3d) {
             return this._bcurve.knots.isAlmostEqual(other._bcurve.knots)
@@ -183980,15 +184064,19 @@ class BSplineCurve3d extends BSplineCurve3dBase {
         }
         return false;
     }
-    /** test if this curve is entirely within plane. */
+    /** Test if this curve lies entirely in the given plane. */
     isInPlane(plane) {
         return _geometry3d_PointHelpers__WEBPACK_IMPORTED_MODULE_13__.Point3dArray.isCloseToPlane(this._bcurve.packedData, plane);
     }
-    /** Return the control polygon length as approximation (always overestimate) of the curve length. */
-    quickLength() { return _geometry3d_PointHelpers__WEBPACK_IMPORTED_MODULE_13__.Point3dArray.sumEdgeLengths(this._bcurve.packedData); }
-    /** Emit beziers or strokes (selected by the stroke options) to the handler. */
+    /**
+     * Return the control polygon length as an approximation to the curve length.
+     * * The returned length is always an overestimate.
+     */
+    quickLength() {
+        return _geometry3d_PointHelpers__WEBPACK_IMPORTED_MODULE_13__.Point3dArray.sumEdgeLengths(this._bcurve.packedData);
+    }
+    /** Emit Beziers or strokes (selected by the stroke options) to the handler. */
     emitStrokableParts(handler, options) {
-        const needBeziers = handler.announceBezierCurve !== undefined;
         const workBezier = this.initializeWorkBezier();
         const numSpan = this.numSpan;
         let numStrokes;
@@ -183996,7 +184084,7 @@ class BSplineCurve3d extends BSplineCurve3dBase {
             const bezier = this.getSaturatedBezierSpan3dOr3dH(spanIndex, false, workBezier);
             if (bezier) {
                 numStrokes = bezier.computeStrokeCountForOptions(options);
-                if (needBeziers) {
+                if (handler.announceBezierCurve) {
                     handler.announceBezierCurve(bezier, numStrokes, this, spanIndex, this._bcurve.knots.spanFractionToFraction(spanIndex, 0.0), this._bcurve.knots.spanFractionToFraction(spanIndex, 1.0));
                 }
                 else {
@@ -184021,7 +184109,7 @@ class BSplineCurve3d extends BSplineCurve3dBase {
         return numStroke;
     }
     /**
-     * Compute individual segment stroke counts.  Attach in a StrokeCountMap.
+     * Compute individual segment stroke counts. Attach in a StrokeCountMap.
      * @param options StrokeOptions that determine count
      * @param parentStrokeMap evolving parent map.
      * @alpha
@@ -184040,7 +184128,7 @@ class BSplineCurve3d extends BSplineCurve3dBase {
         }
         _curve_CurvePrimitive__WEBPACK_IMPORTED_MODULE_0__.CurvePrimitive.installStrokeCountMap(this, myData, parentStrokeMap);
     }
-    /** Append strokes to a linestring. */
+    /** Append strokes to the given linestring. */
     emitStrokes(dest, options) {
         const workBezier = this.initializeWorkBezier();
         const numSpan = this.numSpan;
@@ -184051,16 +184139,17 @@ class BSplineCurve3d extends BSplineCurve3dBase {
         }
     }
     /**
-     * Test knots and control points to determine if it is possible to close (aka "wrap") the curve.
+     * Test knots and poles to determine if it is possible to close (aka "wrap") the curve.
      * @returns the manner in which it is possible to close the curve. See `BSplineWrapMode` for particulars of each mode.
      */
     get isClosable() {
         return this.isClosableCurve;
     }
     /**
-     * Return a BezierCurveBase for this curve.  The concrete return type may be BezierCurve3d or BezierCurve3dH according to this type.
-     * @param spanIndex
-     * @param result optional reusable curve.  This will only be reused if it is a BezierCurve3d with matching order.
+     * Return the Bezier fragment corresponding to the given span of this curve.
+     * * The concrete return type may be [[BezierCurve3d]] or [[BezierCurve3dH]] according to the instance type and `prefer3dH`.
+     * @param spanIndex index of span.
+     * @param result optional reusable curve. This will only be reused if its type and order matches.
      */
     getSaturatedBezierSpan3dOr3dH(spanIndex, prefer3dH, result) {
         if (prefer3dH)
@@ -184068,9 +184157,9 @@ class BSplineCurve3d extends BSplineCurve3dBase {
         return this.getSaturatedBezierSpan3d(spanIndex, result);
     }
     /**
-     * Return a CurvePrimitive (which is a BezierCurve3d) for a specified span of this curve.
-     * @param spanIndex
-     * @param result optional reusable curve.  This will only be reused if it is a BezierCurve3d with matching order.
+     * Return the Bezier fragment corresponding to the given span of this curve.
+     * @param spanIndex index of span.
+     * @param result optional reusable curve. This will only be reused if its type and order matches.
      */
     getSaturatedBezierSpan3d(spanIndex, result) {
         if (spanIndex < 0 || spanIndex >= this.numSpan)
@@ -184081,13 +184170,13 @@ class BSplineCurve3d extends BSplineCurve3dBase {
         const bezier = result;
         bezier.loadSpanPoles(this._bcurve.packedData, spanIndex);
         if (bezier.saturateInPlace(this._bcurve.knots, spanIndex))
-            return result;
+            return bezier;
         return undefined;
     }
     /**
-     * Return a CurvePrimitive (which is a BezierCurve3dH) for a specified span of this curve.
-     * @param spanIndex
-     * @param result optional reusable curve.  This will only be reused if it is a BezierCurve3d with matching order.
+     * Return the Bezier fragment corresponding to the given span of this curve.
+     * @param spanIndex index of span.
+     * @param result optional reusable curve. This will only be reused if its type and order matches.
      */
     getSaturatedBezierSpan3dH(spanIndex, result) {
         if (spanIndex < 0 || spanIndex >= this.numSpan)
@@ -184101,15 +184190,16 @@ class BSplineCurve3d extends BSplineCurve3dBase {
             return bezier;
         return undefined;
     }
-    /** Second step of double dispatch:  call `handler.handleBSplineCurve3d(this)` */
+    /** Second step of double dispatch: call `handler.handleBSplineCurve3d(this)`. */
     dispatchToGeometryHandler(handler) {
         return handler.handleBSplineCurve3d(this);
     }
     /**
-     * Extend a range so in includes the range of this curve
-     * * REMARK: this is based on the poles, not the exact curve.  This is generally larger than the true curve range.
-     * @param rangeToExtend
-     * @param transform transform to apply to points as they are entered into the range.
+     * Extend a range so it contains the range of this curve.
+     * * This computation is based on the poles, not the curve itself, so the returned range is generally larger than the
+     * tightest possible range.
+     * @param rangeToExtend range to extend.
+     * @param transform transform to apply to the poles as they are entered into the range.
      */
     extendRange(rangeToExtend, transform) {
         const buffer = this._bcurve.packedData;
@@ -186871,13 +186961,11 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
-// ================================================================================================================
-// ================================================================================================================
-// ================================================================================================================
-// ================================================================================================================
-/** 3d Bezier curve class.
+/**
+ * 3d Bezier curve class.
  * * Use BezierCurve3dH if the curve has weights.
  * * The control points (xyz) are managed as the _packedData buffer in the _polygon member of BezierCurveBase.
+ * * Visualization can be found at https://www.itwinjs.org/sandbox/SaeedTorabi/Bezier/
  * @public
  */
 class BezierCurve3d extends _BezierCurveBase__WEBPACK_IMPORTED_MODULE_0__.BezierCurveBase {
@@ -188032,8 +188120,9 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   BSplineWrapMode: () => (/* binding */ BSplineWrapMode),
 /* harmony export */   KnotVector: () => (/* binding */ KnotVector)
 /* harmony export */ });
-/* harmony import */ var _Geometry__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../Geometry */ "../../core/geometry/lib/esm/Geometry.js");
-/* harmony import */ var _geometry3d_PointHelpers__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../geometry3d/PointHelpers */ "../../core/geometry/lib/esm/geometry3d/PointHelpers.js");
+/* harmony import */ var _itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @itwin/core-bentley */ "../../core/bentley/lib/esm/core-bentley.js");
+/* harmony import */ var _Geometry__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../Geometry */ "../../core/geometry/lib/esm/Geometry.js");
+/* harmony import */ var _geometry3d_PointHelpers__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../geometry3d/PointHelpers */ "../../core/geometry/lib/esm/geometry3d/PointHelpers.js");
 /*---------------------------------------------------------------------------------------------
 * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
 * See LICENSE.md in the project root for license terms and full copyright notice.
@@ -188043,6 +188132,7 @@ __webpack_require__.r(__webpack_exports__);
  */
 
 
+
 /**
  * B-spline curve and surface types in this library are non-periodic. But they can be created from legacy periodic data.
  * This enumeration lists the possible ways a B-spline object can have been created from legacy periodic data.
@@ -188052,68 +188142,89 @@ var BSplineWrapMode;
 (function (BSplineWrapMode) {
     /** No conversion performed. */
     BSplineWrapMode[BSplineWrapMode["None"] = 0] = "None";
-    /** The B-spline was opened up by adding degree wrap-around control points to the legacy periodic data.
-     * * This is typical of B-splines constructed with maximum (degree - 1) continuity.
+    /**
+     * The legacy periodic B-spline data was opened up by adding `degree` wrap-around poles.
+     * * This is typical of B-spline curves and surfaces constructed with maximum `degree - 1` continuity.
      * * Knots are unaffected by this conversion.
      */
     BSplineWrapMode[BSplineWrapMode["OpenByAddingControlPoints"] = 1] = "OpenByAddingControlPoints";
-    /** The B-spline was opened up by removing degree extreme knots from the legacy periodic data.
+    /**
+     * The legacy periodic B-spline data was opened up by removing `degree` exterior knots.
      * * This is typical of rational B-spline curves representing full circles and ellipses.
      * * Poles are unaffected by this conversion.
      */
     BSplineWrapMode[BSplineWrapMode["OpenByRemovingKnots"] = 2] = "OpenByRemovingKnots";
 })(BSplineWrapMode || (BSplineWrapMode = {}));
 /**
- * Array of non-decreasing numbers acting as a knot array for B-splines.
+ * Array of non-decreasing numbers acting as a knot vector for B-spline curves and surfaces.
  *
  * * Essential identity: numKnots = numPoles + order - 2 = numPoles + degree - 1
- * * Various B-spline libraries have confusion over how many "end knots" are needed. Many libraries (including MicroStation and Parasolid)
- * demand order knots at each end for clamping. But only order-1 are really needed. This class uses the order-1 convention.
+ * * Various B-spline libraries have confusion over how many "end knots" are needed. Many libraries (including MicroStation
+ * and Parasolid) demand order knots at each end for clamping. However, only order-1 are really needed. This class uses the
+ * order-1 convention.
  * * A span is a single interval of the knots.
- * * The left knot of span {k} is knot {k+degree-1}.
+ * * The left knot of the span with index `k>=0` is the knot with index `k+degree-1`.
+ * * A knot vector is clamped when the first `degree` knots are equal and the last `degree` knots are equal.
+ * * The "active knot interval" is the subset of the knot vector sans its first and last `degree-1` knots, and serves as
+ * the parametric domain of the associated B-spline object.
  * * This class provides queries to convert among spanIndex, knotIndex, spanFraction, fraction of knot range, and knot.
- * * Core computations (evaluateBasisFunctions) have leftKnotIndex and global knot value as inputs.  Callers need to
- * know their primary values (global knot, spanFraction).
+ * * Callers need to distinguish core computational inputs such as left knot index, knot value, span index, and span fraction.
  * @public
  */
 class KnotVector {
     /** The simple array of knot values. */
     knots;
-    /** Return the degree of basis functions defined in these knots. */
+    /** The degree of basis functions defined in these knots. */
     degree;
+    /** The leftmost knot value (of the active interval, ignoring unclamped leading knots). */
     _knot0;
+    /** The rightmost knot value (of the active interval, ignoring unclamped leading knots). */
     _knot1;
     _wrapMode;
-    /** tolerance for considering two knots to be the same. */
+    /** Tolerance for considering two knots to be the same. */
     static knotTolerance = 1.0e-9;
-    /** Return the leftmost knot value (of the active interval, ignoring unclamped leading knots)*/
-    get leftKnot() { return this._knot0; }
-    /** Return the rightmost knot value (of the active interval, ignoring unclamped leading knots)*/
-    get rightKnot() { return this._knot1; }
-    /** Return the index of the leftmost knot of the active interval */
-    get leftKnotIndex() { return this.degree - 1; }
-    /** Return the index of the rightmost knot of the active interval */
-    get rightKnotIndex() { return this.knots.length - this.degree; }
-    /** Whether this KnotVector was created by converting legacy periodic data during deserialization. The conversion used is specified by BSplineWrapMode, and is reversed at serialization time. */
-    get wrappable() { return this._wrapMode === undefined ? BSplineWrapMode.None : this._wrapMode; }
-    set wrappable(value) { this._wrapMode = value; }
-    /** Return the number of bezier spans.  Note that this includes zero-length spans if there are repeated knots. */
-    get numSpans() { return this.rightKnotIndex - this.leftKnotIndex; }
+    /** Return the leftmost knot value (of the active interval, ignoring unclamped leading knots). */
+    get leftKnot() {
+        return this._knot0;
+    }
+    /** Return the rightmost knot value (of the active interval, ignoring unclamped leading knots). */
+    get rightKnot() {
+        return this._knot1;
+    }
+    /** Return the index of the leftmost knot of the active interval. */
+    get leftKnotIndex() {
+        return this.degree - 1;
+    }
+    /** Return the index of the rightmost knot of the active interval. */
+    get rightKnotIndex() {
+        return this.knots.length - this.degree;
+    }
     /**
-     *
-     * * If knots is a number array or Float64Array, the those values become the local knot array.
-     * * If knots is a simple number, the local knot array is allocated to that size but left as zeros.
-     * @param knots
-     * @param degree
+     * Whether this KnotVector was created by converting legacy periodic data during deserialization. The conversion used
+     * is specified by BSplineWrapMode, and is reversed at serialization time.
+     */
+    get wrappable() {
+        return this._wrapMode === undefined ? BSplineWrapMode.None : this._wrapMode;
+    }
+    set wrappable(value) {
+        this._wrapMode = value;
+    }
+    /** Return the number of Bezier spans. Note that this includes zero-length spans if there are repeated knots. */
+    get numSpans() {
+        return this.rightKnotIndex - this.leftKnotIndex;
+    }
+    /**
+     * Private constructor.
+     * * If `knots` is a number array or Float64Array, then its values are copied to the instance array.
+     * * If `knots` is a number, the instance array is allocated to this size but left as zeros.
      */
     constructor(knots, degree, wrapMode) {
         this.degree = degree;
         this._wrapMode = wrapMode;
-        // default values to satisfy compiler -- real values happen in setupFixedValues, or final else defers to user
+        // default values to satisfy compiler; real values happen in setupFixedValues or the final else clause defers to user
         this._knot0 = 0.0;
         this._knot1 = 1.0;
-        // satisfy the initialize checker ..
-        if (Array.isArray(knots)) { // remark:  This ctor is private.  The callers (as of April 2019) do not use this path.
+        if (Array.isArray(knots)) {
             this.knots = new Float64Array(knots.length);
             this.setKnots(knots);
             this.setupFixedValues();
@@ -188122,23 +188233,32 @@ class KnotVector {
             this.knots = knots.slice();
             this.setupFixedValues();
         }
-        else { // caller is responsible for filling array separately ...
-            this.knots = new Float64Array(knots);
+        else { // caller is responsible for filling array separately
+            const knotSize = knots;
+            this.knots = new Float64Array(knotSize);
         }
     }
-    /** copy degree and knots to a new KnotVector. */
-    clone() { return new KnotVector(this.knots, this.degree, this.wrappable); }
+    /** Copy degree and knots to a new KnotVector. */
+    clone() {
+        return new KnotVector(this.knots, this.degree, this.wrappable);
+    }
     setupFixedValues() {
         if (this.degree > 0 && this.knots.length > this.degree) {
             this._knot0 = this.knots[this.degree - 1];
             this._knot1 = this.knots[this.knots.length - this.degree];
         }
     }
-    /** Return the total knot distance from beginning to end. */
-    get knotLength01() { return this._knot1 - this._knot0; }
     /**
-     * Returns true if all numeric values have wraparound conditions that allow the knots to be closed with specified wrap mode.
-     * @param mode optional test mode.  If undefined, use this.wrappable.
+     * Return the length of the active knot interval.
+     * * This is the size of (one dimension of) the parametric domain for the associated B-spline object.
+     */
+    get knotLength01() {
+        return this._knot1 - this._knot0;
+    }
+    /**
+     * Returns true if all numeric values have wraparound conditions that allow the knots to be closed with specified
+     * wrap mode.
+     * @param mode optional test mode. If undefined, use this.wrappable.
      */
     testClosable(mode) {
         if (mode === undefined)
@@ -188172,11 +188292,11 @@ class KnotVector {
         }
         return false;
     }
-    /** Test matching degree and knot values */
+    /** Test matching degree and knot values. */
     isAlmostEqual(other) {
         if (this.degree !== other.degree)
             return false;
-        return _geometry3d_PointHelpers__WEBPACK_IMPORTED_MODULE_0__.NumberArray.isAlmostEqual(this.knots, other.knots, KnotVector.knotTolerance);
+        return _geometry3d_PointHelpers__WEBPACK_IMPORTED_MODULE_1__.NumberArray.isAlmostEqual(this.knots, other.knots, KnotVector.knotTolerance);
     }
     /** Compute the multiplicity of the input knot, or zero if not a knot. */
     getKnotMultiplicity(knot) {
@@ -188212,8 +188332,9 @@ class KnotVector {
         }
         return m;
     }
-    /** Transform knots to span [0,1].
-     * @returns false if and only if this.knotLength01 is trivial
+    /**
+     * Transform knots such that the active knot range becomes [0,1].
+     * @returns false if and only if `this.knotLength01` is trivial.
      */
     normalize() {
         if (this.knotLength01 < KnotVector.knotTolerance)
@@ -188231,8 +188352,7 @@ class KnotVector {
         this.setupFixedValues();
         return true;
     }
-    /** install knot values from an array, optionally ignoring first and last.
-     */
+    /** Install knot values from an array, optionally ignoring first and last. */
     setKnots(knots, skipFirstAndLast) {
         const numAllocate = skipFirstAndLast ? knots.length - 2 : knots.length;
         if (numAllocate !== this.knots.length)
@@ -188247,17 +188367,17 @@ class KnotVector {
         }
         this.setupFixedValues();
     }
-    /** Set knots to input array (CAPTURED)  */
+    /** Set knots to input array (CAPTURED).  */
     setKnotsCapture(knots) {
         this.knots = knots;
         this.setupFixedValues();
     }
     /**
      * Create knot vector with {degree-1} replicated knots at start and end, and uniform knots between.
-     * @param numPoles Number of poles
-     * @param degree degree of polynomial
-     * @param a0 left knot value for active interval
-     * @param a1 right knot value for active interval
+     * @param numPoles number of poles.
+     * @param degree degree of polynomial.
+     * @param a0 left knot value for active interval.
+     * @param a1 right knot value for active interval.
      */
     static createUniformClamped(numPoles, degree, a0, a1) {
         const knots = new KnotVector(numPoles + degree - 1, degree);
@@ -188274,24 +188394,26 @@ class KnotVector {
     }
     /**
      * Create knot vector with wraparound knots at start and end, and uniform knots between.
-     * @param  numInterval number of intervals in knot space.  (NOT POLE COUNT)
-     * @param degree degree of polynomial
-     * @param a0 left knot value for active interval
-     * @param a1 right knot value for active interval
+     * @param numInterval the number of intervals into which to uniformly divide the active knot interval `[a0,a1]`,
+     * creating `numInterval-1` equally spaced interior knots between `a0` and `a1`.
+     * This number is equal to the number of Bezier spans in the associated B-spline object.
+     * It is _not_ the pole count.
+     * @param degree degree of polynomial.
+     * @param a0 left knot value for active interval.
+     * @param a1 right knot value for active interval.
      */
     static createUniformWrapped(numInterval, degree, a0, a1) {
         const knots = new KnotVector(numInterval + 2 * degree - 1, degree);
         const du = 1.0 / numInterval;
-        for (let i = 1 - degree, k = 0; i < numInterval + degree; i++, k++) {
-            knots.knots[k] = _Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.interpolate(a0, i * du, a1);
-        }
+        for (let i = 1 - degree, k = 0; i < numInterval + degree; i++, k++)
+            knots.knots[k] = _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.interpolate(a0, i * du, a1);
         knots.setupFixedValues();
         return knots;
     }
     /**
      * Create knot vector with given knot values and degree.
-     * @param knotArray knot values
-     * @param degree degree of polynomial
+     * @param knotArray knot values.
+     * @param degree degree of polynomial.
      * @param skipFirstAndLast true to skip copying the first and last knot values.
      */
     static create(knotArray, degree, skipFirstAndLast) {
@@ -188302,29 +188424,34 @@ class KnotVector {
     }
     /**
      * Return the average of degree consecutive knots beginning at knotIndex.
+     * * If `knotIndex` is negative, return `leftKnot`.
+     * * If `knotIndex > rightKnotIndex` return `rightKnot`.
      */
     grevilleKnot(knotIndex) {
         if (knotIndex < 0)
             return this.leftKnot;
         if (knotIndex > this.rightKnotIndex)
             return this.rightKnot;
+        knotIndex = Math.floor(knotIndex);
         let sum = 0.0;
         for (let i = knotIndex; i < knotIndex + this.degree; i++)
             sum += this.knots[i];
         return sum / this.degree;
     }
-    /** Return an array sized for a set of the basis function values. */
-    createBasisArray() { return new Float64Array(this.degree + 1); }
+    /** Return an array of size `degree + 1`, e.g., to hold the set of relevant basis function values at a parameter. */
+    createBasisArray() {
+        return new Float64Array(this.degree + 1);
+    }
     /** Convert localFraction within the interval following an indexed knot to a knot value. */
     baseKnotFractionToKnot(knotIndex0, localFraction) {
         const knot0 = this.knots[knotIndex0];
-        localFraction = _Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.clamp(localFraction, 0, 1);
+        localFraction = _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.clamp(localFraction, 0, 1);
         return knot0 + localFraction * (this.knots[knotIndex0 + 1] - knot0);
     }
     /** Convert localFraction within an indexed bezier span to a knot value. */
     spanFractionToKnot(spanIndex, localFraction) {
         const k = this.spanIndexToLeftKnotIndex(spanIndex);
-        localFraction = _Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.clamp(localFraction, 0, 1);
+        localFraction = _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.clamp(localFraction, 0, 1);
         return this.knots[k] + localFraction * (this.knots[k + 1] - this.knots[k]);
     }
     /** Convert localFraction within an indexed bezier span to fraction of active knot range. */
@@ -188334,35 +188461,41 @@ class KnotVector {
     }
     /** Return fraction of active knot range to knot value. */
     fractionToKnot(fraction) {
-        fraction = _Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.clamp(fraction, 0, 1); // B-splines are not extendable
-        return _Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.interpolate(this.knots[this.degree - 1], fraction, this.knots[this.knots.length - this.degree]);
+        fraction = _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.clamp(fraction, 0, 1); // B-splines are not extendable
+        return _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.interpolate(this.knots[this.degree - 1], fraction, this.knots[this.knots.length - this.degree]);
+    }
+    isKnotInValidSpan(knotIndex0, u) {
+        const spanIsValid = knotIndex0 >= this.degree - 1 && knotIndex0 + this.degree < this.knots.length;
+        const uIsInSpan = this.knots[knotIndex0] <= u && u <= this.knots[knotIndex0 + 1];
+        return spanIsValid && uIsInSpan;
     }
     /**
      * Evaluate the B-spline basis functions f[] at a parameter u in a knot span.
      * * This method implements the Mansfield-Cox-de Boor recurrence relation.
      * @param knotIndex0 index of the left knot of the span.
      * @param u value in the knot span: knot[knotIndex0] <= u <= knot[knotIndex0 + 1].
-     * @param f preallocated output array of order basis function values
-     * @returns true if and only if output array is sufficiently sized
+     * @param f preallocated output array of order basis function values.
+     * @returns true if and only if output array is sufficiently sized.
      */
     evaluateBasisFunctions(knotIndex0, u, f) {
         if (f.length < this.degree + 1)
             return false;
+        (0,_itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.assert)(() => this.isKnotInValidSpan(knotIndex0, u), "knot is in a valid span");
         f[0] = 1.0;
         if (this.degree < 1)
             return true;
-        // direct compute for linear part ...
+        // direct compute for linear part
         const u0 = this.knots[knotIndex0];
         const u1 = this.knots[knotIndex0 + 1];
         f[1] = (u - u0) / (u1 - u0);
         f[0] = 1.0 - f[1];
         if (this.degree < 2)
             return true;
-        // Each iteration of the outer loop evaluates the basis functions of degree depth+1 using
-        // one or two values of the basis functions of one less degree from the preceding iteration.
+        // each iteration of the outer loop evaluates the basis functions of degree depth+1 using
+        // one or two values of the basis functions of one less degree from the preceding iteration
         for (let depth = 1; depth < this.degree; depth++) {
             let kLeft = knotIndex0 - depth;
-            let kRight = kLeft + depth + 1;
+            let kRight = knotIndex0 + 1;
             let gCarry = 0.0;
             for (let step = 0; step <= depth; step++) {
                 const tLeft = this.knots[kLeft++];
@@ -188384,10 +188517,10 @@ class KnotVector {
      * in a knot span.
      * @param knotIndex0 index of the left knot of the span.
      * @param u value in the knot span: knot[knotIndex0] <= u <= knot[knotIndex0 + 1].
-     * @param f preallocated output array of order basis function values
-     * @param df preallocated output array of order basis derivative values
-     * @param ddf optional preallocated output array of order basis second derivative values
-     * @returns true if and only if output arrays are sufficiently sized
+     * @param f preallocated output array of order basis function values.
+     * @param df preallocated output array of order basis derivative values.
+     * @param ddf optional preallocated output array of order basis second derivative values.
+     * @returns true if and only if output arrays are sufficiently sized.
      */
     evaluateBasisFunctions1(knotIndex0, u, f, df, ddf) {
         if (f.length < this.degree + 1)
@@ -188396,15 +188529,16 @@ class KnotVector {
             return false;
         if (ddf && ddf.length < this.degree + 1)
             return false;
+        (0,_itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.assert)(() => this.isKnotInValidSpan(knotIndex0, u), "knot is in a valid span");
         f[0] = 1.0;
         df[0] = 0.0;
         if (this.degree < 1)
             return true;
-        // direct compute for linear part ...
+        // direct compute for linear part
         const u0 = this.knots[knotIndex0];
         const u1 = this.knots[knotIndex0 + 1];
-        // ah = 1/(u1-u0)      is the derivative of fraction0
-        // (-ah) is the derivative of fraction1.
+        // ah = 1/(u1-u0) is the derivative of fraction0
+        // -ah is the derivative of fraction1
         let ah = 1.0 / (u1 - u0);
         f[1] = (u - u0) * ah;
         f[0] = 1.0 - f[1];
@@ -188423,7 +188557,7 @@ class KnotVector {
             let dgCarry = 0.0;
             let ddgCarry = 0.0;
             // f, df, ddf, are each row vectors with product of `step` linear terms.
-            // f is multiplied on the right by matrix V.  Each row has 2 nonzero entries (which sum to 1)  (0,0,1-fraction, fraction,0,0,0)
+            // f is multiplied on the right by matrix V.  Each row has 2 nonzero entries (which sum to 1) (0,0,1-fraction, fraction,0,0,0)
             //    Each row of the derivative dV is two entries (0,0, -1/h, 1/h,0,0,0)
             // Hence fnew = f * V
             //      dfnew = df * V + f * dV
@@ -188445,7 +188579,7 @@ class KnotVector {
                 df[step] = dgCarry + dg0;
                 gCarry = g1;
                 dgCarry = dg1;
-                if (ddf) { // do the backward reference to df before rewriting df !!!
+                if (ddf) { // do the backward reference to df before rewriting df
                     const ddg1 = ddf[step] * fraction + dfSave;
                     const ddg0 = ddf[step] * fraction1 - dfSave;
                     ddf[step] = ddgCarry + ddg0;
@@ -188459,9 +188593,10 @@ class KnotVector {
         }
         return true;
     }
-    /** Find the knot span bracketing knots[i] <= u < knots[i+1] and return i.
+    /**
+     * Find the knot span bracketing knots[i] <= u < knots[i+1] and return i.
      * * If u has no such bracket, return the smaller index of the closest nontrivial bracket.
-     * @param u value to bracket
+     * @param u value to bracket.
      */
     knotToLeftKnotIndex(u) {
         for (let i = this.leftKnotIndex; i < this.rightKnotIndex; ++i) {
@@ -188477,7 +188612,7 @@ class KnotVector {
     }
     /**
      * Given a span index, return the index of the knot at its left.
-     * @param spanIndex index of span
+     * @param spanIndex index of span.
      */
     spanIndexToLeftKnotIndex(spanIndex) {
         const d = this.degree;
@@ -188492,15 +188627,16 @@ class KnotVector {
     }
     /**
      * Given a span index, test if it is within range and has nonzero length.
-     * * note that a false return does not imply there are no more spans.  This may be a double knot (zero length span) followed by more real spans
+     * * note that a false return does not imply there are no more spans. This may be a double knot (zero length span)
+     * followed by more real spans
      * @param spanIndex index of span to test.
      */
     isIndexOfRealSpan(spanIndex) {
         if (spanIndex >= 0 && spanIndex < this.numSpans)
-            return !_Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.isSmallMetricDistance(this.spanIndexToSpanLength(spanIndex));
+            return !_Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.isSmallMetricDistance(this.spanIndexToSpanLength(spanIndex));
         return false;
     }
-    /** Reflect all knots so `leftKnot` and `rightKnot` are maintained but interval lengths reverse. */
+    /** Reflect all knots so `leftKnot` and `rightKnot` are maintained but interval lengths are reversed. */
     reflectKnots() {
         const a = this.leftKnot;
         const b = this.rightKnot;
@@ -195831,6 +195967,8 @@ class Arc3d extends _CurvePrimitive__WEBPACK_IMPORTED_MODULE_1__.CurvePrimitive
     }
     /**
      * Construct a circular arc chain approximation to the instance elliptical arc.
+     * * Visualization can be found at https://www.itwinjs.org/sandbox/SaeedTorabi/ArcApproximationGeneral and
+     *  https://www.itwinjs.org/sandbox/SaeedTorabi/ArcApproximation
      * @param options bundle of options for sampling an elliptical arc (use default options if undefined).
      * @returns the approximating curve chain, the circular instance, or undefined if construction fails.
      */
@@ -229802,9 +229940,9 @@ class Point3dArray {
         return result;
     }
     /**
-     * return an 2-dimensional array containing all the values of `data` in arrays of numPerBlock
-     * @param data simple array of numbers
-     * @param numPerBlock number of values in each block at first level down
+     * Return a 2-dimensional array containing all the values of `data` in arrays of numPerBlock
+     * @param data simple array of numbers.
+     * @param numPerBlock number of values in each block at first level down.
      */
     static unpackNumbersToNestedArrays(data, numPerBlock) {
         const result = [];
@@ -235074,8 +235212,8 @@ class Ray3d {
      * @param vertex2 third vertex of the triangle
      * @param distanceTol optional tolerance used to check if ray is parallel to the triangle or if we have line
      * intersection but not ray intersection (if tolerance is not provided, Geometry.smallMetricDistance is used)
-     * @param parameterTol optional tolerance used to snap barycentric coordinates of the intersection point to
-     * a triangle edge or vertex (if tolerance is not provided, Geometry.smallFloatingPoint is used)
+     * @param parameterTol optional tolerance used to allow intersections just beyond an edge/vertex in barycentric
+     * coordinate space (if tolerance is not provided, Geometry.smallFloatingPoint is used)
      * @param result optional pre-allocated object to fill and return
      * @returns the intersection point if ray intersects the triangle. Otherwise, return undefined.
     */
@@ -235131,13 +235269,13 @@ class Ray3d {
         const s = Ray3d._workVector3 = _Point3dVector3d__WEBPACK_IMPORTED_MODULE_0__.Vector3d.createStartEnd(vertex0, this.origin, Ray3d._workVector3);
         let u = f * s.dotProduct(h);
         if (u < 0.0) {
-            if (u > -parameterTol)
+            if (u >= -parameterTol)
                 u = 0.0;
             else
                 return undefined; // ray does not intersect the triangle
         }
         else if (u > 1.0) {
-            if (u < 1.0 + parameterTol)
+            if (u <= 1.0 + parameterTol)
                 u = 1.0;
             else
                 return undefined; // ray does not intersect the triangle
@@ -235145,20 +235283,17 @@ class Ray3d {
         const q = Ray3d._workVector4 = s.crossProduct(edge1, Ray3d._workVector4);
         let v = f * this.direction.dotProduct(q);
         if (v < 0.0) {
-            if (v > -parameterTol)
+            if (v >= -parameterTol)
                 v = 0.0;
             else
                 return undefined; // ray does not intersect the triangle
         }
-        else if (u + v > 1.0) {
-            if (u + v < 1.0 + parameterTol)
-                v = 1.0 - u;
-            else
-                return undefined; // ray does not intersect the triangle
+        else if (u + v > 1.0 + parameterTol) {
+            return undefined; // ray does not intersect the triangle
         }
         // at this stage, we know the line (parameterized as the ray) intersects the triangle
         const t = f * edge2.dotProduct(q);
-        if (t <= distanceTol) // line intersection but not ray intersection
+        if (t < -distanceTol) // line intersection but not ray intersection
             return undefined;
         return this.origin.plusScaled(this.direction, t, result); // ray intersection
     }
@@ -312363,7 +312498,7 @@ var loadLanguages = instance.loadLanguages;
 /***/ ((module) => {
 
 "use strict";
-module.exports = /*#__PURE__*/JSON.parse('{"name":"@itwin/core-frontend","version":"5.0.0-dev.62","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 && npm run -s build:esm && npm run -s webpackWorkers && npm run -s copy:workers","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 ES2022 --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","copy:workers":"cpx \\"./lib/workers/webpack/parse-imdl-worker.js\\" ./lib/public/scripts","docs":"betools docs --json=../../generated-docs/core/core-frontend/file.json --tsIndexFile=./core-frontend.ts --onlyJson --excludes=webgl/**/*,**/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-inline-config -c extraction.eslint.config.js  \\"./src/**/*.ts\\" 1>&2","lint":"eslint \\"./src/**/*.ts\\" 1>&2","lint-fix":"eslint --fix -f visualstudio \\"./src/**/*.ts\\" 1>&2","pseudolocalize":"betools pseudolocalize --englishDir ./src/public/locales/en --out ./public/locales/en-PSEUDO","test":"npm run webpackTestWorker && vitest --run","cover":"npm run webpackTestWorker && vitest --run --coverage","test:debug":"vitest --run","webpackTests":"webpack --config ./src/test/utils/webpack.config.js 1>&2 && npm run -s webpackTestWorker","webpackTestWorker":"webpack --config ./src/test/worker/webpack.config.js 1>&2 && cpx \\"./lib/test/test-worker.js\\" ./lib/test","webpackWorkers":"webpack --config ./src/workers/ImdlParser/webpack.config.js 1>&2"},"repository":{"type":"git","url":"https://github.com/iTwin/itwinjs-core.git","directory":"core/frontend"},"keywords":["Bentley","BIM","iModel","digital-twin","iTwin"],"author":{"name":"Bentley Systems, Inc.","url":"http://www.bentley.com"},"peerDependencies":{"@itwin/appui-abstract":"workspace:*","@itwin/core-bentley":"workspace:*","@itwin/core-common":"workspace:*","@itwin/core-geometry":"workspace:*","@itwin/core-orbitgt":"workspace:*","@itwin/core-quantity":"workspace:*"},"//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/eslint-plugin":"5.0.0-dev.1","@types/chai-as-promised":"^7","@vitest/browser":"^2.1.0","@vitest/coverage-v8":"^2.1.0","babel-loader":"~8.2.5","babel-plugin-istanbul":"~6.1.1","cpx2":"^3.0.0","eslint":"^9.13.0","glob":"^10.3.12","playwright":"~1.47.1","rimraf":"^3.0.2","source-map-loader":"^4.0.0","typescript":"~5.6.2","typemoq":"^2.1.0","vitest":"^2.1.0","vite-multiple-assets":"^1.3.1","vite-plugin-static-copy":"1.0.6","webpack":"^5.97.1"},"//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/cloud-agnostic-core":"^2.2.4","@itwin/object-storage-core":"^2.2.5","@itwin/core-i18n":"workspace:*","@itwin/webgl-compatibility":"workspace:*","@loaders.gl/core":"^3.1.6","@loaders.gl/draco":"^3.1.6","fuse.js":"^3.3.0","wms-capabilities":"0.4.0"}}');
+module.exports = /*#__PURE__*/JSON.parse('{"name":"@itwin/core-frontend","version":"5.0.0-dev.64","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 && npm run -s build:esm && npm run -s webpackWorkers && npm run -s copy:workers","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 ES2022 --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","copy:workers":"cpx \\"./lib/workers/webpack/parse-imdl-worker.js\\" ./lib/public/scripts","docs":"betools docs --json=../../generated-docs/core/core-frontend/file.json --tsIndexFile=./core-frontend.ts --onlyJson --excludes=webgl/**/*,**/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-inline-config -c extraction.eslint.config.js  \\"./src/**/*.ts\\" 1>&2","lint":"eslint \\"./src/**/*.ts\\" 1>&2","lint-fix":"eslint --fix -f visualstudio \\"./src/**/*.ts\\" 1>&2","pseudolocalize":"betools pseudolocalize --englishDir ./src/public/locales/en --out ./public/locales/en-PSEUDO","test":"npm run webpackTestWorker && vitest --run","cover":"npm run webpackTestWorker && vitest --run --coverage","test:debug":"vitest --run","webpackTests":"webpack --config ./src/test/utils/webpack.config.js 1>&2 && npm run -s webpackTestWorker","webpackTestWorker":"webpack --config ./src/test/worker/webpack.config.js 1>&2 && cpx \\"./lib/test/test-worker.js\\" ./lib/test","webpackWorkers":"webpack --config ./src/workers/ImdlParser/webpack.config.js 1>&2"},"repository":{"type":"git","url":"https://github.com/iTwin/itwinjs-core.git","directory":"core/frontend"},"keywords":["Bentley","BIM","iModel","digital-twin","iTwin"],"author":{"name":"Bentley Systems, Inc.","url":"http://www.bentley.com"},"peerDependencies":{"@itwin/appui-abstract":"workspace:*","@itwin/core-bentley":"workspace:*","@itwin/core-common":"workspace:*","@itwin/core-geometry":"workspace:*","@itwin/core-orbitgt":"workspace:*","@itwin/core-quantity":"workspace:*"},"//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/eslint-plugin":"5.0.0-dev.1","@types/chai-as-promised":"^7","@vitest/browser":"^2.1.0","@vitest/coverage-v8":"^2.1.0","babel-loader":"~8.2.5","babel-plugin-istanbul":"~6.1.1","cpx2":"^3.0.0","eslint":"^9.13.0","glob":"^10.3.12","playwright":"~1.47.1","rimraf":"^3.0.2","source-map-loader":"^4.0.0","typescript":"~5.6.2","typemoq":"^2.1.0","vitest":"^2.1.0","vite-multiple-assets":"^1.3.1","vite-plugin-static-copy":"1.0.6","webpack":"^5.97.1"},"//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/cloud-agnostic-core":"^2.2.4","@itwin/object-storage-core":"^2.2.5","@itwin/core-i18n":"workspace:*","@itwin/webgl-compatibility":"workspace:*","@loaders.gl/core":"^3.1.6","@loaders.gl/draco":"^3.1.6","fuse.js":"^3.3.0","wms-capabilities":"0.4.0"}}');
 
 /***/ })