@itwin/core-geometry 3.0.0-dev.76 → 3.0.0-dev.80

package/lib/esm/bspline/BSpline1dNd.js

@@ -0,0 +1,191 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Bspline
+ */
+// import { Point2d } from "../Geometry2d";
+import { Geometry } from "../Geometry";
+/* eslint-disable @typescript-eslint/naming-convention, no-empty */
+import { Point3d } from "../geometry3d/Point3dVector3d";
+import { BSplineWrapMode } from "./KnotVector";
+/** Bspline knots and poles for 1d-to-Nd.
+ * * 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 weighed 2D x,y,w
+ * @public
+ */
+export class BSpline1dNd {
+    /**
+     * 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.
+     */
+    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.poleBuffer1 = new Float64Array(poleLength);
+        this.poleBuffer2 = new Float64Array(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.
+     * * The calling clas sis responsible for knowing if this is an appropriate access to the blocked data.
+     */
+    getPoint3dPole(i, result) { return Point3d.createFromPacked(this.packedData, i, result); }
+    /**
+     * 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.
+     */
+    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);
+    }
+    /** Evaluate the `order` basis functions (and optionally one or two derivatives) at a given fractional position within indexed span. */
+    evaluateBasisFunctionsInSpan(spanIndex, spanFraction, f, df, ddf) {
+        if (spanIndex < 0)
+            spanIndex = 0;
+        if (spanIndex >= this.numSpan)
+            spanIndex = this.numSpan - 1;
+        const knotIndex0 = spanIndex + this.degree - 1;
+        const globalKnot = this.knots.baseKnotFractionToKnot(knotIndex0, spanFraction);
+        return df ?
+            this.knots.evaluateBasisFunctions1(knotIndex0, globalKnot, f, df, ddf) :
+            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.poleBuffer`
+     * */
+    evaluateBuffersInSpan1(spanIndex, spanFraction) {
+        this.evaluateBasisFunctionsInSpan(spanIndex, spanFraction, this.basisBuffer, this.basisBuffer1);
+        this.sumPoleBufferForSpan(spanIndex);
+        this.sumPoleBuffer1ForSpan(spanIndex);
+    }
+    /** sum poles at span `spanIndex` by the weights in the `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++) {
+                this.poleBuffer[j] += f * this.packedData[k++];
+            }
+        }
+    }
+    /** sum poles at span `spanIndex` by the weights in the `poleBuffer1`, i.e. form first derivatives */
+    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++) {
+                this.poleBuffer1[j] += f * this.packedData[k++];
+            }
+        }
+    }
+    /** sum poles at span `spanIndex` by the weights in the `poleBuffer2`, i.e. form second derivatives */
+    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++) {
+                this.poleBuffer2[j] += f * this.packedData[k++];
+            }
+        }
+    }
+    /** Evaluate the function values and 1 or 2 derivatives into `this.poleBuffer`, `this.poleBuffer1` and `this.poleBuffer2` */
+    evaluateBuffersAtKnot(u, numDerivative = 0) {
+        const knotIndex0 = this.knots.knotToLeftKnotIndex(u);
+        if (numDerivative < 1) {
+            this.knots.evaluateBasisFunctions(knotIndex0, u, this.basisBuffer);
+            this.sumPoleBufferForSpan(knotIndex0 - this.degree + 1);
+        }
+        else if (numDerivative === 1) {
+            this.knots.evaluateBasisFunctions1(knotIndex0, u, this.basisBuffer, this.basisBuffer1);
+            this.sumPoleBufferForSpan(knotIndex0 - this.degree + 1);
+            this.sumPoleBuffer1ForSpan(knotIndex0 - this.degree + 1);
+        }
+        else {
+            this.knots.evaluateBasisFunctions1(knotIndex0, u, this.basisBuffer, this.basisBuffer1, this.basisBuffer2);
+            this.sumPoleBufferForSpan(knotIndex0 - this.degree + 1);
+            this.sumPoleBuffer1ForSpan(knotIndex0 - this.degree + 1);
+            this.sumPoleBuffer2ForSpan(knotIndex0 - this.degree + 1);
+        }
+    }
+    /**
+     * Reverse the (blocked) poles (in `this.packedData` in place.
+     */
+    reverseInPlace() {
+        // reverse poles in blocks ...
+        const b = 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;
+            }
+        }
+        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
+     */
+    testCloseablePolygon(mode) {
+        if (mode === undefined)
+            mode = this.knots.wrappable;
+        const degree = this.degree;
+        const blockSize = this.poleLength;
+        const indexDelta = (this.numPoles - this.degree) * blockSize;
+        const data = this.packedData;
+        if (mode === BSplineWrapMode.OpenByAddingControlPoints) {
+            // expect {degree} matched points.
+            const numValuesToTest = degree * blockSize;
+            for (let i0 = 0; i0 < numValuesToTest; i0++) {
+                if (!Geometry.isSameCoordinate(data[i0], data[i0 + indexDelta]))
+                    return false;
+            }
+            return true;
+        }
+        if (mode === BSplineWrapMode.OpenByRemovingKnots) {
+            // no pole conditions are applied.
+            return true;
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=BSpline1dNd.js.map

package/lib/esm/bspline/BSpline1dNd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BSpline1dNd.js","sourceRoot":"","sources":["../../../src/bspline/BSpline1dNd.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module Bspline\r\n */\r\n\r\n// import { Point2d } from \"../Geometry2d\";\r\nimport { Geometry } from \"../Geometry\";\r\n/* eslint-disable @typescript-eslint/naming-convention, no-empty */\r\nimport { Point3d } from \"../geometry3d/Point3dVector3d\";\r\nimport { BSplineWrapMode, KnotVector } from \"./KnotVector\";\r\n\r\n/** Bspline knots and poles for 1d-to-Nd.\r\n * * The \"pole\" (aka control point) of this class is a block of `poleLength` numbers.\r\n * * Derived classes (not this class) assign meaning such as x,y,z,w.\r\n * * for instance, an instance of this class with `poleLength===3` does not know if its poles are x,y,z or weighed 2D x,y,w\r\n * @public\r\n */\r\nexport class BSpline1dNd {\r\n  /** knots of the bspline */\r\n  public knots: KnotVector;\r\n  /** poles, packed in blocks of `poleLength` doubles. */\r\n  public packedData: Float64Array;\r\n  /** (property accessor) Return the number of numeric values per pole. */\r\n  public poleLength: number;\r\n  /** (property accessor) Return the degree of the polynomials. */\r\n  public get degree(): number { return this.knots.degree; }\r\n  /** (property accessor) Return the number of order (one more than degree) of the polynomials */\r\n  public get order(): number { return this.knots.degree + 1; }\r\n  /** (property accessor) Return the number of bezier spans (including null spans at multiple knots)*/\r\n  public get numSpan(): number { return this.numPoles - this.knots.degree; }\r\n  /** (property accessor)  Return the number of poles*/\r\n  public get numPoles(): number { return this.packedData.length / this.poleLength; }\r\n  /** copy 3 values of pole `i` into a point.\r\n   * * The calling clas sis responsible for knowing if this is an appropriate access to the blocked data.\r\n   */\r\n  public getPoint3dPole(i: number, result?: Point3d): Point3d | undefined { return Point3d.createFromPacked(this.packedData, i, result); }\r\n  /** preallocated array (length === `order`) used as temporary in evaluations */\r\n  public basisBuffer: Float64Array; // one set of basis function values.   ALLOCATED BY CTOR FOR FREQUENT REUSE\r\n  /** preallocated array (length === `poleLength`) used as temporary in evaluations */\r\n  public poleBuffer: Float64Array; // one set of target values.  ALLOCATED BY CTOR FOR FREQUENT REUSE\r\n  /** preallocated array (length === `order`) used as temporary in evaluations */\r\n  public basisBuffer1: Float64Array; // one set of basis function values.   ALLOCATED BY CTOR FOR FREQUENT REUSE\r\n  /** preallocated array (length === `order`) used as temporary in evaluations */\r\n  public basisBuffer2: Float64Array; // one set of basis function values.   ALLOCATED BY CTOR FOR FREQUENT REUSE\r\n  /** preallocated array (length === `poleLength`) used as temporary in evaluations */\r\n  public poleBuffer1: Float64Array; // one set of target values.  ALLOCATED BY CTOR FOR FREQUENT REUSE\r\n  /** preallocated array (length === `poleLength`) used as temporary in evaluations */\r\n  public poleBuffer2: Float64Array; // one set of target values.  ALLOCATED BY CTOR FOR FREQUENT REUSE\r\n\r\n  /**\r\n   * initialize arrays for given spline dimensions.\r\n   * @param numPoles number of poles\r\n   * @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)\r\n   * @param order number of poles in support for a section of the bspline\r\n   * @param knots KnotVector.  This is captured, not cloned.\r\n   */\r\n  protected constructor(numPoles: number, poleLength: number, order: number, knots: KnotVector) {\r\n    this.knots = knots;\r\n    this.packedData = new Float64Array(numPoles * poleLength);\r\n    this.poleLength = poleLength;\r\n    this.basisBuffer = new Float64Array(order);\r\n    this.poleBuffer = new Float64Array(poleLength);\r\n    this.basisBuffer1 = new Float64Array(order);\r\n    this.basisBuffer2 = new Float64Array(order);\r\n    this.poleBuffer1 = new Float64Array(poleLength);\r\n    this.poleBuffer2 = new Float64Array(poleLength);\r\n  }\r\n\r\n  /**\r\n   * create a 1Bspline1dNd`\r\n   * @param numPoles number of poles\r\n   * @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)\r\n   * @param order number of poles in support for a section of the bspline\r\n   * @param knots KnotVector.  This is captured, not cloned.\r\n   */\r\n  public static create(numPoles: number, poleLength: number, order: number, knots: KnotVector): BSpline1dNd | undefined {\r\n    return new BSpline1dNd(numPoles, poleLength, order, knots);\r\n  }\r\n  /** Map a span index and local fraction to knot value. */\r\n  public spanFractionToKnot(span: number, localFraction: number): number {\r\n    return this.knots.spanFractionToKnot(span, localFraction);\r\n  }\r\n\r\n  /** Evaluate the `order` basis functions (and optionally one or two derivatives) at a given fractional position within indexed span. */\r\n  public evaluateBasisFunctionsInSpan(spanIndex: number, spanFraction: number, f: Float64Array, df?: Float64Array, ddf?: Float64Array) {\r\n    if (spanIndex < 0) spanIndex = 0;\r\n    if (spanIndex >= this.numSpan) spanIndex = this.numSpan - 1;\r\n    const knotIndex0 = spanIndex + this.degree - 1;\r\n    const globalKnot = this.knots.baseKnotFractionToKnot(knotIndex0, spanFraction);\r\n    return df ?\r\n      this.knots.evaluateBasisFunctions1(knotIndex0, globalKnot, f, df, ddf) :\r\n      this.knots.evaluateBasisFunctions(knotIndex0, globalKnot, f);\r\n  }\r\n  /**\r\n   * * Evaluate the basis functions at spanIndex and fraction.\r\n   *   * Evaluations are stored in the preallocated `this.basisBuffer`\r\n   * * Immediately do the summations of the basis values times the respective control points\r\n   *   * Summations are stored in the preallocated `this.poleBuffer`\r\n   * */\r\n  public evaluateBuffersInSpan(spanIndex: number, spanFraction: number) {\r\n    this.evaluateBasisFunctionsInSpan(spanIndex, spanFraction, this.basisBuffer);\r\n    this.sumPoleBufferForSpan(spanIndex);\r\n  }\r\n  /**\r\n   * * Evaluate the basis functions and one derivative at spanIndex and fraction.\r\n   *   * Evaluations are stored in the preallocated `this.basisBuffer`\r\n   * * Immediately do the summations of the basis values times the respective control points\r\n   *   * Summations are stored in the preallocated `this.poleBuffer` and `this.poleBuffer`\r\n   * */\r\n  public evaluateBuffersInSpan1(spanIndex: number, spanFraction: number) {\r\n    this.evaluateBasisFunctionsInSpan(spanIndex, spanFraction, this.basisBuffer, this.basisBuffer1);\r\n    this.sumPoleBufferForSpan(spanIndex);\r\n    this.sumPoleBuffer1ForSpan(spanIndex);\r\n  }\r\n  /** sum poles at span `spanIndex` by the weights in the `poleBuffer` */\r\n  public sumPoleBufferForSpan(spanIndex: number) {\r\n    this.poleBuffer.fill(0);\r\n    let k = spanIndex * this.poleLength;\r\n    for (const f of this.basisBuffer) {\r\n      for (let j = 0; j < this.poleLength; j++) { this.poleBuffer[j] += f * this.packedData[k++]; }\r\n    }\r\n  }\r\n  /** sum poles at span `spanIndex` by the weights in the `poleBuffer1`, i.e. form first derivatives */\r\n  public sumPoleBuffer1ForSpan(spanIndex: number) {\r\n    this.poleBuffer1.fill(0);\r\n    let k = spanIndex * this.poleLength;\r\n    for (const f of this.basisBuffer1) {\r\n      for (let j = 0; j < this.poleLength; j++) {\r\n        this.poleBuffer1[j] += f * this.packedData[k++];\r\n      }\r\n    }\r\n  }\r\n  /** sum poles at span `spanIndex` by the weights in the `poleBuffer2`, i.e. form second derivatives */\r\n  public sumPoleBuffer2ForSpan(spanIndex: number) {\r\n    this.poleBuffer2.fill(0);\r\n    let k = spanIndex * this.poleLength;\r\n    for (const f of this.basisBuffer2) {\r\n      for (let j = 0; j < this.poleLength; j++) {\r\n        this.poleBuffer2[j] += f * this.packedData[k++];\r\n      }\r\n    }\r\n  }\r\n  /** Evaluate the function values and 1 or 2 derivatives into `this.poleBuffer`, `this.poleBuffer1` and `this.poleBuffer2` */\r\n  public evaluateBuffersAtKnot(u: number, numDerivative: number = 0) {\r\n    const knotIndex0 = this.knots.knotToLeftKnotIndex(u);\r\n    if (numDerivative < 1) {\r\n      this.knots.evaluateBasisFunctions(knotIndex0, u, this.basisBuffer);\r\n      this.sumPoleBufferForSpan(knotIndex0 - this.degree + 1);\r\n    } else if (numDerivative === 1) {\r\n      this.knots.evaluateBasisFunctions1(knotIndex0, u, this.basisBuffer, this.basisBuffer1);\r\n      this.sumPoleBufferForSpan(knotIndex0 - this.degree + 1);\r\n      this.sumPoleBuffer1ForSpan(knotIndex0 - this.degree + 1);\r\n    } else {\r\n      this.knots.evaluateBasisFunctions1(knotIndex0, u, this.basisBuffer, this.basisBuffer1, this.basisBuffer2);\r\n      this.sumPoleBufferForSpan(knotIndex0 - this.degree + 1);\r\n      this.sumPoleBuffer1ForSpan(knotIndex0 - this.degree + 1);\r\n      this.sumPoleBuffer2ForSpan(knotIndex0 - this.degree + 1);\r\n    }\r\n  }\r\n  /**\r\n   * Reverse the (blocked) poles (in `this.packedData` in place.\r\n   */\r\n  public reverseInPlace(): void {\r\n    // reverse poles in blocks ...\r\n    const b = this.poleLength;\r\n    const data = this.packedData;\r\n    for (let i0 = 0, j0 = b * (this.numPoles - 1);\r\n      i0 < j0;\r\n      i0 += b, j0 -= b) {\r\n      let t = 0;\r\n      for (let i = 0; i < b; i++) {\r\n        t = data[i0 + i];\r\n        data[i0 + i] = data[j0 + i];\r\n        data[j0 + i] = t;\r\n      }\r\n    }\r\n    this.knots.reflectKnots();\r\n  }\r\n  /**\r\n   * Test if the leading and trailing polygon coordinates are replicated in the manner of a \"closed\" bspline polygon which has been expanded\r\n   * to act as a normal bspline.\r\n   * @returns true if `degree` leading and trailing polygon blocks match\r\n   */\r\n  public testCloseablePolygon(mode?: BSplineWrapMode): boolean {\r\n    if (mode === undefined)\r\n      mode = this.knots.wrappable;\r\n    const degree = this.degree;\r\n    const blockSize = this.poleLength;\r\n    const indexDelta = (this.numPoles - this.degree) * blockSize;\r\n    const data = this.packedData;\r\n    if (mode === BSplineWrapMode.OpenByAddingControlPoints) {\r\n      // expect {degree} matched points.\r\n      const numValuesToTest = degree * blockSize;\r\n      for (let i0 = 0; i0 < numValuesToTest; i0++) {\r\n        if (!Geometry.isSameCoordinate(data[i0], data[i0 + indexDelta]))\r\n          return false;\r\n      }\r\n      return true;\r\n    }\r\n\r\n    if (mode === BSplineWrapMode.OpenByRemovingKnots) {\r\n      // no pole conditions are applied.\r\n      return true;\r\n    }\r\n\r\n    return false;\r\n  }\r\n}\r\n"]}

package/lib/esm/bspline/BSplineCurve.d.ts

@@ -0,0 +1,310 @@
+/** @packageDocumentation
+ * @module Bspline
+ */
+import { CurveLocationDetail } from "../curve/CurveLocationDetail";
+import { CurvePrimitive } from "../curve/CurvePrimitive";
+import { LineString3d } from "../curve/LineString3d";
+import { StrokeCountMap } from "../curve/Query/StrokeCountMap";
+import { StrokeOptions } from "../curve/StrokeOptions";
+import { PlaneAltitudeEvaluator } from "../Geometry";
+import { GeometryHandler, IStrokeHandler } from "../geometry3d/GeometryHandler";
+import { GrowableXYZArray } from "../geometry3d/GrowableXYZArray";
+import { Plane3dByOriginAndUnitNormal } from "../geometry3d/Plane3dByOriginAndUnitNormal";
+import { Plane3dByOriginAndVectors } from "../geometry3d/Plane3dByOriginAndVectors";
+import { Point3d } from "../geometry3d/Point3dVector3d";
+import { Range3d } from "../geometry3d/Range";
+import { Ray3d } from "../geometry3d/Ray3d";
+import { Transform } from "../geometry3d/Transform";
+import { Point4d } from "../geometry4d/Point4d";
+import { AkimaCurve3dOptions } from "./AkimaCurve3d";
+import { BezierCurve3dH } from "./BezierCurve3dH";
+import { BezierCurveBase } from "./BezierCurveBase";
+import { BSpline1dNd } from "./BSpline1dNd";
+import { InterpolationCurve3dOptions } from "./InterpolationCurve3d";
+import { BSplineWrapMode, KnotVector } from "./KnotVector";
+/**
+ * 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.
+ * * 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]
+ *
+ * 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
+ *   * 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 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.
+ *
+ * * 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
+ *     * 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
+ * @public
+ */
+export declare abstract class BSplineCurve3dBase extends CurvePrimitive {
+    /** String name for schema properties */
+    readonly curvePrimitiveType = "bsplineCurve";
+    /** The underlying blocked-pole spline, with simple x,y,z poles */
+    protected _bcurve: BSpline1dNd;
+    private _definitionData?;
+    set definitionData(data: any);
+    get definitionData(): any;
+    protected constructor(poleDimension: number, numPoles: number, order: number, knots: KnotVector);
+    /** Return the degree (one less than the order) of the curve */
+    get degree(): number;
+    /** Return the order (one more than degree) of the curve */
+    get order(): number;
+    /** Return the number of bezier spans in the curve.  Note that this number includes the number of null spans at repeated knows */
+    get numSpan(): number;
+    /** Return the number of poles */
+    get numPoles(): number;
+    /**
+   * return a simple array form of the knots.  optionally replicate the first and last
+   * in classic over-clamped manner
+   */
+    copyKnots(includeExtraEndKnot: boolean): number[];
+    /**
+   * Set the flag indicating the bspline might be suitable for having wrapped "closed" interpretation.
+   */
+    setWrappable(value: BSplineWrapMode): void;
+    /** Evaluate at a position given by fractional position within a span. */
+    abstract evaluatePointInSpan(spanIndex: number, spanFraction: number, result?: Point3d): Point3d;
+    /** Evaluate at a position given by fractional position within a span. */
+    abstract evaluatePointAndDerivativeInSpan(spanIndex: number, spanFraction: number, result?: Ray3d): Ray3d;
+    /** Evaluate xyz at a position given by knot. */
+    abstract knotToPoint(knot: number, result?: Point3d): Point3d;
+    /** Evaluate xyz and derivative at position given by a knot value.  */
+    abstract knotToPointAndDerivative(knot: number, result?: Ray3d): Ray3d;
+    /** Evaluate xyz and 2 derivatives at position given by a knot value.  */
+    abstract knotToPointAnd2Derivatives(knot: number, result?: Plane3dByOriginAndVectors): Plane3dByOriginAndVectors;
+    /** Evaluate the curve point at `fraction` */
+    fractionToPoint(fraction: number, result?: Point3d): Point3d;
+    /** Construct a ray with
+     * * origin at the fractional position along the arc
+     * * direction is the first derivative, i.e. tangent along the curve
+     */
+    fractionToPointAndDerivative(fraction: number, result?: Ray3d): Ray3d;
+    /** 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
+     */
+    fractionToPointAnd2Derivatives(fraction: number, result?: Plane3dByOriginAndVectors): Plane3dByOriginAndVectors;
+    /**
+     * Return the start point of the curve.
+     */
+    startPoint(): Point3d;
+    /**
+     * Return the end point of the curve
+     */
+    endPoint(): Point3d;
+    /** Reverse the curve in place.
+     * * Poles are reversed
+     * * knot values are mirrored around the middle of the
+     */
+    reverseInPlace(): void;
+    /**
+     * Return an array with this curve's bezier fragments.
+     */
+    collectBezierSpans(prefer3dH: boolean): BezierCurveBase[];
+    /**
+      * Return a BezierCurveBase for this curve.  The concrete return type may be BezierCurve3d or BezierCurve3dH according to the instance type and the prefer3dH parameter.
+      * @param spanIndex
+      * @param prefer3dH true to force promotion to homogeneous.
+      * @param result optional reusable curve.  This will only be reused if it is a BezierCurve3d with matching order.
+      */
+    abstract getSaturatedBezierSpan3dOr3dH(spanIndex: number, prefer3dH: boolean, result?: BezierCurveBase): BezierCurveBase | undefined;
+    /** Return a specified pole as a Point4d.
+     * * BSplineCurve3d appends weight 1 to its xyz
+     * * BSplineCurve3dH with pole whose "normalized" point is (x,y,z) but has weight w returns its weighted (wx,wy,wz,w)
+     */
+    abstract getPolePoint4d(poleIndex: number, result?: Point4d): Point4d | undefined;
+    /** Return a specified pole as a Point3d
+     * * BSplineCurve3d returns its simple xyz
+     * * BSplineCurve3dH attempts to normalize its (wx,wy,wz,w) back to (x,y,z), and returns undefined if weight is zero.
+     * @param poleIndex
+     * @param result optional result
+     */
+    abstract getPolePoint3d(poleIndex: number, result?: Point3d): Point3d | undefined;
+    /** Given a pole index, return the starting index for the contiguous array. */
+    poleIndexToDataIndex(poleIndex: number): number | undefined;
+    /** 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
+     * @param extend true to extend the curve (if possible)
+     * @returns Returns a CurveLocationDetail structure that holds the details of the close point.
+     */
+    closestPoint(spacePoint: Point3d, _extend: boolean): CurveLocationDetail | undefined;
+    /** Implement `CurvePrimitive.appendPlaneIntersections`
+     * @param plane A plane (e.g. specific type Plane3dByOriginAndUnitNormal or Point4d)
+     * @param result growing array of plane intersections
+     * @return number of intersections appended to the array.
+    */
+    appendPlaneIntersectionPoints(plane: PlaneAltitudeEvaluator, result: CurveLocationDetail[]): number;
+}
+/**
+ * A BSplineCurve3d is a bspline curve whose poles are Point3d.
+ * See BSplineCurve3dBase for description of knots, order, degree.
+ * @public
+ */
+export declare class BSplineCurve3d extends BSplineCurve3dBase {
+    private _workBezier?;
+    private initializeWorkBezier;
+    /** test of `other` is an instance of BSplineCurve3d */
+    isSameGeometryClass(other: any): boolean;
+    /** Apply `transform` to the poles. */
+    tryTransformInPlace(transform: Transform): boolean;
+    /** Get a pole as simple Point3d. */
+    getPolePoint3d(poleIndex: number, result?: Point3d): Point3d | undefined;
+    /** Get a pole as Point4d with weight 1 */
+    getPolePoint4d(poleIndex: number, result?: Point4d): Point4d | undefined;
+    /** Convert  `spanIndex` and `localFraction` to a knot. */
+    spanFractionToKnot(span: number, localFraction: number): number;
+    private constructor();
+    /** Return a simple array of arrays with the control points as `[[x,y,z],[x,y,z],..]` */
+    copyPoints(): any[];
+    /** Return a simple array of the control points coordinates */
+    copyPointsFloat64Array(): Float64Array;
+    /**
+     * return a simple array form of the knots.  optionally replicate the first and last
+     * in classic over-clamped manner
+     */
+    copyKnots(includeExtraEndKnot: boolean): number[];
+    /** Create a bspline with uniform knots. */
+    static createUniformKnots(poles: Point3d[] | Float64Array | GrowableXYZArray, order: number): BSplineCurve3d | undefined;
+    /**
+     * Create a C2 cubic B-spline curve that interpolates the given points and optional end tangents.
+     * @param options collection of points and end conditions.
+     */
+    static createFromInterpolationCurve3dOptions(options: InterpolationCurve3dOptions): BSplineCurve3d | undefined;
+    /**
+     *
+     * @param options collection of points and end conditions.
+     */
+    static createFromAkimaCurve3dOptions(options: AkimaCurve3dOptions): BSplineCurve3d | undefined;
+    /** Create a bspline with given knots.
+     *
+     * *  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 + 2, the knots are in modern form.
+     *
+     */
+    static create(poleArray: Float64Array | Point3d[], knotArray: Float64Array | number[], order: number): BSplineCurve3d | undefined;
+    /** Return a deep clone */
+    clone(): BSplineCurve3d;
+    /** Return a transformed deep clone. */
+    cloneTransformed(transform: Transform): BSplineCurve3d;
+    /** Evaluate at a position given by fractional position within a span. */
+    evaluatePointInSpan(spanIndex: number, spanFraction: number): Point3d;
+    /** 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)
+     */
+    evaluatePointAndDerivativeInSpan(spanIndex: number, spanFraction: number): Ray3d;
+    /** Evaluate at a position given by a knot value.  */
+    knotToPoint(u: number, result?: Point3d): Point3d;
+    /** Evaluate at a position given by a knot value.  */
+    knotToPointAndDerivative(u: number, result?: Ray3d): Ray3d;
+    /** Evaluate at a position given by a knot value.  Return point with 2 derivatives. */
+    knotToPointAnd2Derivatives(u: number, result?: Plane3dByOriginAndVectors): Plane3dByOriginAndVectors;
+    /** Evaluate the curve point at a fractional of the entire knot range. */
+    fractionToPoint(fraction: number, result?: Point3d): Point3d;
+    /** Evaluate the curve point at a fractional of the entire knot range. */
+    fractionToPointAndDerivative(fraction: number, result?: Ray3d): Ray3d;
+    /** Construct a plane with
+     * * origin at the fractional position along the arc
+     * * x axis is the first derivative, i.e. tangent along the arc
+     * * y axis is the second derivative, i.e. in the plane and on the center side of the tangent.
+     * If the arc is circular, the second derivative is directly towards the center
+     */
+    fractionToPointAnd2Derivatives(fraction: number, result?: Plane3dByOriginAndVectors): Plane3dByOriginAndVectors;
+    /** test if almost the same curve as `other` */
+    isAlmostEqual(other: any): boolean;
+    /** test if this curve is entirely within plane. */
+    isInPlane(plane: Plane3dByOriginAndUnitNormal): boolean;
+    /** Return the control polygon length as approximation (always overestimate) of the curve length. */
+    quickLength(): number;
+    /** Emit beziers or strokes (selected by the stroke options) to the handler. */
+    emitStrokableParts(handler: IStrokeHandler, options?: StrokeOptions): void;
+    /**
+     * Assess length and turn to determine a stroke count.
+     * @param options stroke options structure.
+     */
+    computeStrokeCountForOptions(options?: StrokeOptions): number;
+    /**
+     * Compute individual segment stroke counts.  Attach in a StrokeCountMap.
+     * @param options StrokeOptions that determine count
+     * @param parentStrokeMap evolving parent map.
+     * @alpha
+     */
+    computeAndAttachRecursiveStrokeCounts(options?: StrokeOptions, parentStrokeMap?: StrokeCountMap): void;
+    /** Append strokes to a linestring. */
+    emitStrokes(dest: LineString3d, options?: StrokeOptions): void;
+    /**
+     * Test knots, control points, and wrappable flag to see if all agree for a possible wrapping.
+     * @returns the manner of closing.   Se BSplineWrapMode for particulars of each mode.
+     *
+     */
+    get isClosable(): BSplineWrapMode;
+    /**
+     * 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.
+     */
+    getSaturatedBezierSpan3dOr3dH(spanIndex: number, prefer3dH: boolean, result?: BezierCurveBase): BezierCurveBase | undefined;
+    /**
+     * 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.
+     */
+    getSaturatedBezierSpan3d(spanIndex: number, result?: BezierCurveBase): BezierCurveBase | 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.
+     */
+    getSaturatedBezierSpan3dH(spanIndex: number, result?: BezierCurveBase): BezierCurve3dH | undefined;
+    /**
+     * Set the flag indicating the bspline might be suitable for having wrapped "closed" interpretation.
+     */
+    setWrappable(value: BSplineWrapMode): void;
+    /** Second step of double dispatch:  call `handler.handleBSplineCurve3d(this)` */
+    dispatchToGeometryHandler(handler: GeometryHandler): any;
+    /**
+     * 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.
+     */
+    extendRange(rangeToExtend: Range3d, transform?: Transform): void;
+}
+//# sourceMappingURL=BSplineCurve.d.ts.map

package/lib/esm/bspline/BSplineCurve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BSplineCurve.d.ts","sourceRoot":"","sources":["../../../src/bspline/BSplineCurve.ts"],"names":[],"mappings":"AAIA;;GAEG;AAGH,OAAO,EAAqB,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACtF,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAY,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAChF,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,4BAA4B,EAAE,MAAM,4CAA4C,CAAC;AAC1F,OAAO,EAAE,yBAAyB,EAAE,MAAM,yCAAyC,CAAC;AAEpF,OAAO,EAAE,OAAO,EAAY,MAAM,+BAA+B,CAAC;AAElE,OAAO,EAAW,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAEhD,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAGrD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,OAAO,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AACrE,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,8BAAsB,kBAAmB,SAAQ,cAAc;IAC7D,wCAAwC;IACxC,SAAgB,kBAAkB,kBAAkB;IAEpD,kEAAkE;IAClE,SAAS,CAAC,OAAO,EAAE,WAAW,CAAC;IAC/B,OAAO,CAAC,eAAe,CAAC,CAAM;IAC9B,IAAW,cAAc,CAAC,IAAI,EAAE,GAAG,EAAkC;IACrE,IAAW,cAAc,IAAI,GAAG,CAAiC;IACjE,SAAS,aAAa,aAAa,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU;IAI/F,+DAA+D;IAC/D,IAAW,MAAM,IAAI,MAAM,CAAgC;IAC3D,2DAA2D;IAC3D,IAAW,KAAK,IAAI,MAAM,CAA+B;IACzD,iIAAiI;IACjI,IAAW,OAAO,IAAI,MAAM,CAAiC;IAC7D,iCAAiC;IACjC,IAAW,QAAQ,IAAI,MAAM,CAAkC;IAC/D;;;KAGC;IACM,SAAS,CAAC,mBAAmB,EAAE,OAAO,GAAG,MAAM,EAAE;IAExD;;KAEC;IACM,YAAY,CAAC,KAAK,EAAE,eAAe;IAI1C,yEAAyE;aACzD,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO;IACvG,yEAAyE;aACzD,gCAAgC,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,KAAK,GAAG,KAAK;IAChH,gDAAgD;aAChC,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO;IACpE,sEAAsE;aACtD,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,KAAK,GAAG,KAAK;IAC7E,yEAAyE;aACzD,0BAA0B,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,yBAAyB,GAAG,yBAAyB;IACvH,6CAA6C;IACtC,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO;IAGnE;;;OAGG;IACI,4BAA4B,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,KAAK,GAAG,KAAK;IAO5E;;;;OAIG;IACI,8BAA8B,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,yBAAyB,GAAG,yBAAyB;IAQtH;;OAEG;IACa,UAAU,IAAI,OAAO;IACrC;;OAEG;IACa,QAAQ,IAAI,OAAO;IACnC;;;OAGG;IACI,cAAc,IAAI,IAAI;IAC7B;;OAEG;IACI,kBAAkB,CAAC,SAAS,EAAE,OAAO,GAAG,eAAe,EAAE;IAYhE;;;;;QAKI;aACY,6BAA6B,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,eAAe,GAAG,SAAS;IAC3I;;;OAGG;aACa,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS;IACxF;;;;;OAKG;aACa,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS;IAExF,8EAA8E;IACvE,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAMlE;;;;;;;OAOG;IACa,YAAY,CAAC,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,mBAAmB,GAAG,SAAS;IAsBpG;;;;MAIE;IACc,6BAA6B,CAAC,KAAK,EAAE,sBAAsB,EAAE,MAAM,EAAE,mBAAmB,EAAE,GAAG,MAAM;CAqDpH;AACD;;;;GAIG;AACH,qBAAa,cAAe,SAAQ,kBAAkB;IAEpD,OAAO,CAAC,WAAW,CAAC,CAAiB;IACrC,OAAO,CAAC,oBAAoB;IAK5B,uDAAuD;IAChD,mBAAmB,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO;IAC/C,sCAAsC;IAC/B,mBAAmB,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO;IACzD,oCAAoC;IAC7B,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS;IAQ/E,0CAA0C;IACnC,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS;IAQ/E,0DAA0D;IACnD,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM;IAGtE,OAAO;IAGP,wFAAwF;IACjF,UAAU,IAAI,GAAG,EAAE;IAC1B,8DAA8D;IACvD,sBAAsB,IAAI,YAAY;IAC7C;;;OAGG;IACa,SAAS,CAAC,mBAAmB,EAAE,OAAO,GAAG,MAAM,EAAE;IAEjE,2CAA2C;WAC7B,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,YAAY,GAAG,gBAAgB,EAAE,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;IAkB/H;;;OAGG;WACW,qCAAqC,CAAC,OAAO,EAAE,2BAA2B,GAAG,cAAc,GAAG,SAAS;IAIrH;;;OAGG;WACW,6BAA6B,CAAC,OAAO,EAAE,mBAAmB,GAAG,cAAc,GAAG,SAAS;IAIrG;;;;;;;;OAQG;WACW,MAAM,CAAC,SAAS,EAAE,YAAY,GAAG,OAAO,EAAE,EAAE,SAAS,EAAE,YAAY,GAAG,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;IAqBxI,0BAA0B;IACnB,KAAK,IAAI,cAAc;IAM9B,uCAAuC;IAChC,gBAAgB,CAAC,SAAS,EAAE,SAAS,GAAG,cAAc;IAK7D,yEAAyE;IAClE,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO;IAI5E;;OAEG;IACI,gCAAgC,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,KAAK;IAOvF,qDAAqD;IAC9C,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO;IAIxD,qDAAqD;IAC9C,wBAAwB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,KAAK,GAAG,KAAK;IAUjE,sFAAsF;IAC/E,0BAA0B,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,yBAAyB,GAAG,yBAAyB;IAO3G,yEAAyE;IACzD,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO;IAI5E,yEAAyE;IACzD,4BAA4B,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,KAAK,GAAG,KAAK;IAOrF;;;;;OAKG;IACa,8BAA8B,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,yBAAyB,GAAG,yBAAyB;IAQ/H,+CAA+C;IAC/B,aAAa,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO;IAOlD,mDAAmD;IAC5C,SAAS,CAAC,KAAK,EAAE,4BAA4B,GAAG,OAAO;IAG9D,oGAAoG;IAC7F,WAAW,IAAI,MAAM;IAC5B,+EAA+E;IACxE,kBAAkB,CAAC,OAAO,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,IAAI;IAwBjF;;;OAGG;IACI,4BAA4B,CAAC,OAAO,CAAC,EAAE,aAAa,GAAG,MAAM;IAWpE;;;;;OAKG;IACa,qCAAqC,CAAC,OAAO,CAAC,EAAE,aAAa,EAAE,eAAe,CAAC,EAAE,cAAc;IAe/G,sCAAsC;IAC/B,WAAW,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,IAAI;IASrE;;;;OAIG;IACH,IAAW,UAAU,IAAI,eAAe,CASvC;IACD;;;;OAIG;IACI,6BAA6B,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,eAAe,GAAG,SAAS;IAMlI;;;;OAIG;IACI,wBAAwB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,eAAe,GAAG,SAAS;IAazG;;;;OAIG;IACI,yBAAyB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,cAAc,GAAG,SAAS;IAczG;;OAEG;IACa,YAAY,CAAC,KAAK,EAAE,eAAe;IAGnD,iFAAiF;IAC1E,yBAAyB,CAAC,OAAO,EAAE,eAAe,GAAG,GAAG;IAG/D;;;;;OAKG;IACI,WAAW,CAAC,aAAa,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,SAAS,GAAG,IAAI;CAYxE"}