@itwin/ecschema-rpcinterface-tests 4.0.0-dev.55 → 4.0.0-dev.58

package/lib/dist/bundled-tests.js

@@ -50167,6 +50167,13 @@ class TextureMapping {
             this.weight = props?.textureWeight ?? 1;
             this.mode = props?.mapMode ?? Mode.Parametric;
             this.worldMapping = props?.worldMapping ?? false;
+            this.useConstantLod = props?.useConstantLod ?? false;
+            this.constantLodParams = {
+                repetitions: props?.constantLodParams?.repetitions ?? 1,
+                offset: props?.constantLodParams?.offset ?? { x: 0, y: 0 },
+                minDistClamp: props?.constantLodParams?.minDistClamp ?? 1,
+                maxDistClamp: props?.constantLodParams?.maxDistClamp ?? 4096 * 1024 * 1024,
+            };
         }
         /**
          * Generates UV parameters for textured surfaces. Returns undefined on failure.
@@ -114082,7 +114089,6 @@ class BranchUniforms {
         this._mvp32 = new _Matrix__WEBPACK_IMPORTED_MODULE_4__.Matrix4();
         this._m32 = new _Matrix__WEBPACK_IMPORTED_MODULE_4__.Matrix4();
         this._v32 = new _Matrix__WEBPACK_IMPORTED_MODULE_4__.Matrix3();
-        this._mvn32 = new _Matrix__WEBPACK_IMPORTED_MODULE_4__.Matrix3();
         // Working state
         this._scratchTransform = _itwin_core_geometry__WEBPACK_IMPORTED_MODULE_1__.Transform.createIdentity();
         this._scratchTransform2 = _itwin_core_geometry__WEBPACK_IMPORTED_MODULE_1__.Transform.createIdentity();
@@ -114165,10 +114171,6 @@ class BranchUniforms {
         if (this.update(uniform, geom, isViewCoords))
             uniform.setMatrix3(this._v32);
     }
-    bindModelViewNTransform(uniform, geom, isViewCoords) {
-        if (this.update(uniform, geom, isViewCoords))
-            uniform.setMatrix3(this._mvn32);
-    }
     update(uniform, geometry, isViewCoords) {
         const uniforms = this._target.uniforms[isViewCoords ? "viewRect" : "frustum"];
         if (!(0,_Sync__WEBPACK_IMPORTED_MODULE_6__.sync)(uniforms, this))
@@ -114200,7 +114202,6 @@ class BranchUniforms {
         }
         else {
             const viewMatrix = this._target.uniforms.frustum.viewMatrix;
-            mv = viewMatrix.clone(this._scratchTransform);
             if (undefined !== instancedGeom) {
                 // For instanced geometry, the "model view" matrix is really a transform from center of instanced geometry range to view.
                 // Shader will compute final model-view matrix based on this and the per-instance transform.
@@ -114208,10 +114209,10 @@ class BranchUniforms {
                     const viewToWorldRot = viewMatrix.matrix.inverse(this._scratchViewToWorld);
                     const rotateAboutOrigin = _itwin_core_geometry__WEBPACK_IMPORTED_MODULE_1__.Transform.createFixedPointAndMatrix(vio, viewToWorldRot, this._scratchTransform2);
                     const viModelMatrix = rotateAboutOrigin.multiplyTransformTransform(instancedGeom.getRtcModelTransform(modelMatrix), this._scratchVIModelMatrix);
-                    mv.multiplyTransformTransform(viModelMatrix, mv);
+                    mv = viewMatrix.multiplyTransformTransform(viModelMatrix, this._scratchTransform);
                 }
                 else {
-                    mv.multiplyTransformTransform(instancedGeom.getRtcModelTransform(modelMatrix), mv);
+                    mv = viewMatrix.multiplyTransformTransform(instancedGeom.getRtcModelTransform(modelMatrix), this._scratchTransform);
                 }
             }
             else {
@@ -114219,10 +114220,10 @@ class BranchUniforms {
                     const viewToWorldRot = viewMatrix.matrix.inverse(this._scratchViewToWorld);
                     const rotateAboutOrigin = _itwin_core_geometry__WEBPACK_IMPORTED_MODULE_1__.Transform.createFixedPointAndMatrix(vio, viewToWorldRot, this._scratchTransform2);
                     const viModelMatrix = rotateAboutOrigin.multiplyTransformTransform(modelMatrix, this._scratchVIModelMatrix);
-                    mv.multiplyTransformTransform(viModelMatrix, mv);
+                    mv = viewMatrix.multiplyTransformTransform(viModelMatrix, this._scratchTransform);
                 }
                 else {
-                    mv = mv.multiplyTransformTransform(modelMatrix, mv);
+                    mv = viewMatrix.multiplyTransformTransform(modelMatrix, this._scratchTransform);
                 }
             }
         }
@@ -114230,6 +114231,9 @@ class BranchUniforms {
             this._m32.initFromTransform(modelMatrix);
             this._v32.initFromMatrix3d(this._target.uniforms.frustum.viewMatrix.matrix);
         }
+        else if (undefined !== geometry.asSurface?.mesh.constantLodVParams) {
+            this._m32.initFromTransform(modelMatrix);
+        }
         _itwin_core_geometry__WEBPACK_IMPORTED_MODULE_1__.Matrix4d.createTransform(mv, this._mv);
         this._mv32.initFromTransform(mv);
         // Don't bother computing mvp for instanced geometry - it's not used.
@@ -120131,19 +120135,35 @@ class MeshData {
         this.hasFeatures = _itwin_core_common__WEBPACK_IMPORTED_MODULE_1__.FeatureIndexType.Empty !== params.vertices.featureIndexType;
         if (_itwin_core_common__WEBPACK_IMPORTED_MODULE_1__.FeatureIndexType.Uniform === params.vertices.featureIndexType)
             this.uniformFeatureId = params.vertices.uniformFeatureID;
+        this.textureUsesConstantLod = false;
+        this.normalMapUsesConstantLod = false;
         if (undefined !== params.surface.textureMapping) {
             this.texture = params.surface.textureMapping.texture;
             this._textureAlwaysDisplayed = params.surface.textureMapping.alwaysDisplayed;
             if (undefined !== params.surface.material && !params.surface.material.isAtlas) {
                 const matTM = params.surface.material.material.textureMapping;
-                if (undefined !== matTM && undefined !== matTM.normalMapParams) {
-                    if (undefined !== matTM.normalMapParams.normalMap) {
-                        this.normalMap = matTM.normalMapParams.normalMap;
+                if (undefined !== matTM) {
+                    this.textureUsesConstantLod = this.texture && matTM.params.useConstantLod;
+                    if (undefined !== matTM.normalMapParams) {
+                        this.normalMapUsesConstantLod = matTM.normalMapParams.useConstantLod;
+                        if (undefined !== matTM.normalMapParams.normalMap) {
+                            this.normalMap = matTM.normalMapParams.normalMap;
+                        }
+                        else {
+                            // If there are normal map params but the normal map is not present, use the texture as a normal map instead of a pattern map.
+                            this.normalMap = this.texture;
+                            this.texture = undefined;
+                        }
                     }
-                    else {
-                        // If there are normal map params but the normal map is not present, use the texture as a normal map instead of a pattern map.
-                        this.normalMap = this.texture;
-                        this.texture = undefined;
+                    if (this.normalMapUsesConstantLod || this.textureUsesConstantLod) {
+                        this.constantLodVParams = new Float32Array(3);
+                        this.constantLodVParams[0] = matTM.params.constantLodParams.offset.x; // x offset
+                        this.constantLodVParams[1] = matTM.params.constantLodParams.offset.y; // y offset
+                        this.constantLodVParams[3] = 0.0; // placeholder for orto view distance
+                        this.constantLodFParams = new Float32Array(3);
+                        this.constantLodFParams[0] = matTM.params.constantLodParams.minDistClamp; // Minimum texture size
+                        this.constantLodFParams[1] = matTM.params.constantLodParams.maxDistClamp; // Maximum texture size
+                        this.constantLodFParams[2] = matTM.params.constantLodParams.repetitions; // # repetitions of pattern (to scale it)
                     }
                 }
             }
@@ -127952,6 +127972,8 @@ class SurfaceGeometry extends _MeshGeometry__WEBPACK_IMPORTED_MODULE_7__.MeshGeo
         }
         flags[0 /* SurfaceBitIndex.HasTexture */] = this.useTexture(params) ? 1 : 0;
         flags[8 /* SurfaceBitIndex.HasNormalMap */] = this.useNormalMap(params) ? 1 : 0;
+        flags[10 /* SurfaceBitIndex.UseConstantLodTextureMapping */] = this.mesh.textureUsesConstantLod ? 1 : 0;
+        flags[11 /* SurfaceBitIndex.UseConstantLodNormalMapMapping */] = this.mesh.normalMapUsesConstantLod ? 1 : 0;
         // The transparency threshold controls how transparent a surface must be to allow light to pass through; more opaque surfaces cast shadows.
         flags[4 /* SurfaceBitIndex.TransparencyThreshold */] = params.target.isDrawingShadowMap ? 1 : 0;
         flags[5 /* SurfaceBitIndex.BackgroundFill */] = 0;
@@ -134519,7 +134541,6 @@ function createVolClassCopyZProgram(context) {
             _Texture__WEBPACK_IMPORTED_MODULE_4__.Texture2DHandle.bindSampler(uniform, geom.texture, _RenderFlags__WEBPACK_IMPORTED_MODULE_3__.TextureUnit.Zero);
         });
     });
-    frag.addExtension("GL_EXT_frag_depth");
     frag.set(18 /* FragmentShaderComponent.FinalizeDepth */, depthFromTexture);
     builder.vert.headerComment = "//!V! VolClassCopyZ";
     builder.frag.headerComment = "//!F! VolClassCopyZ";
@@ -138788,6 +138809,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _Vertex__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(/*! ./Vertex */ "../../core/frontend/lib/esm/render/webgl/glsl/Vertex.js");
 /* harmony import */ var _SurfaceGeometry__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(/*! ../SurfaceGeometry */ "../../core/frontend/lib/esm/render/webgl/SurfaceGeometry.js");
 /* harmony import */ var _Wiremesh__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__(/*! ./Wiremesh */ "../../core/frontend/lib/esm/render/webgl/glsl/Wiremesh.js");
+/* harmony import */ var _itwin_core_common__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__(/*! @itwin/core-common */ "../../core/common/lib/esm/core-common.js");
 /*---------------------------------------------------------------------------------------------
 * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
 * See LICENSE.md in the project root for license terms and full copyright notice.
@@ -138818,10 +138840,45 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+
+const constantLodTextureLookup = `
+vec4 constantLodTextureLookup(sampler2D textureSampler) {
+  float logDepth = log2(v_uvCustom.z);
+  float f = fract(logDepth);
+  float p = floor(logDepth);
+  // When p changes, both tc1 and tc2 jumped by a power of 2 at that transition (and f goes from ~1 to 0).
+  // This caused a line to show up with incorrect tex coords, we believe due to a problem with the derivative
+  // that is auto calculated on the tex coords for the mip-map.  The below approach attempts to "smooth"
+  // the transition of the coord in use at the transition by only changing the coord that is not in use
+  // (but by 2 powers of 2) and switching the mix selector to account for it.  It does this by using whether
+  // p is odd or even to select which way it is going, so it alternates at the boundaries.  This fixes the
+  // line problem.
+  float p1, p2;
+  if (0u == (uint(p) & 1u)) { // p is even
+    p1 = p;
+    p2 = p + 1.0;
+  } else { // p is odd
+    p1 = p + 1.0;
+    p2 = p;
+    f = 1.0 - f;
+  }
+
+  vec2 tc1 = v_uvCustom.xy / clamp(pow(2.0, p1), float(u_constantLodFParams.x), float(u_constantLodFParams.y)) * u_constantLodFParams.z;
+  vec2 tc2 = v_uvCustom.xy / clamp(pow(2.0, p2), float(u_constantLodFParams.x), float(u_constantLodFParams.y)) * u_constantLodFParams.z;
+  return mix(TEXTURE(textureSampler, tc1), TEXTURE(textureSampler, tc2), f);
+}
+`;
 // NB: Textures do not contain pre-multiplied alpha.
 const sampleSurfaceTexture = `
 vec4 sampleSurfaceTexture() {
-  return TEXTURE(s_texture, v_texCoord);
+  vec4 clr;
+  if (!isSurfaceBitSet(kSurfaceBit_HasTexture))
+    clr = vec4(1.0, 1.0, 1.0, 1.0);
+  else if (u_surfaceFlags[kSurfaceBitIndex_UseConstantLodTextureMapping])
+    clr = constantLodTextureLookup(s_texture);
+  else
+    clr =  TEXTURE(s_texture, v_texCoord);
+  return clr;
 }
 `;
 const applyMaterialColor = `
@@ -138971,6 +139028,10 @@ const adjustEyeSpace = `
   if (kRenderOrder_BlankingRegion == u_renderOrder)
     v_eyeSpace.z -= blankingRegionOffset * (u_frustum.y - u_frustum.x);
 `;
+const computeConstantLodUvCustom = `
+  vec2 worldpos = (u_modelToWorld * vec4(rawPos.xyz, 0.0)).xy;
+  v_uvCustom = vec3((u_constantLodVParams.xy + worldpos) * vec2(1.0, -1.0), kFrustumType_Perspective == u_frustum.z ? -v_eyeSpace.z : u_constantLodVParams.z);
+`;
 const computePositionPostlude = `
   return u_proj * pos;
 `;
@@ -138985,17 +139046,17 @@ function createCommon(isInstanced, animated, shadowable, isHiliter, positionType
         (0,_SolarShadowMapping__WEBPACK_IMPORTED_MODULE_17__.addSolarShadowMap)(builder);
     (0,_Vertex__WEBPACK_IMPORTED_MODULE_20__.addProjectionMatrix)(vert);
     (0,_Vertex__WEBPACK_IMPORTED_MODULE_20__.addModelViewMatrix)(vert);
-    let computePosition;
-    if (isHiliter && !_System__WEBPACK_IMPORTED_MODULE_5__.System.instance.supportsLogZBuffer) {
-        computePosition = computePositionPrelude + computePositionPostlude;
-    }
-    else {
+    let computePosition = computePositionPrelude;
+    if (!isHiliter || _System__WEBPACK_IMPORTED_MODULE_5__.System.instance.supportsLogZBuffer) {
         (0,_Common__WEBPACK_IMPORTED_MODULE_9__.addFrustum)(builder);
         (0,_FeatureSymbology__WEBPACK_IMPORTED_MODULE_11__.addRenderOrder)(builder.vert);
         (0,_FeatureSymbology__WEBPACK_IMPORTED_MODULE_11__.addRenderOrderConstants)(builder.vert);
         builder.addVarying("v_eyeSpace", 4 /* VariableType.Vec3 */);
-        computePosition = computePositionPrelude + adjustEyeSpace + computePositionPostlude;
+        computePosition += adjustEyeSpace;
     }
+    if (!isHiliter)
+        computePosition += computeConstantLodUvCustom;
+    computePosition += computePositionPostlude;
     vert.set(10 /* VertexShaderComponent.ComputePosition */, computePosition);
     return builder;
 }
@@ -139029,6 +139090,8 @@ function addSurfaceFlagsLookup(builder) {
     builder.addConstant("kSurfaceBitIndex_OverrideRgb", 1 /* VariableType.Int */, 7 /* SurfaceBitIndex.OverrideRgb */.toString());
     builder.addConstant("kSurfaceBitIndex_HasNormalMap", 1 /* VariableType.Int */, 8 /* SurfaceBitIndex.HasNormalMap */.toString());
     builder.addConstant("kSurfaceBitIndex_HasMaterialAtlas", 1 /* VariableType.Int */, 9 /* SurfaceBitIndex.HasMaterialAtlas */.toString());
+    builder.addConstant("kSurfaceBitIndex_UseConstantLodTextureMapping", 1 /* VariableType.Int */, 10 /* SurfaceBitIndex.UseConstantLodTextureMapping */.toString());
+    builder.addConstant("kSurfaceBitIndex_UseConstantLodNormalMapMapping", 1 /* VariableType.Int */, 11 /* SurfaceBitIndex.UseConstantLodNormalMapMapping */.toString());
     // Surface flags which get modified in vertex shader are still passed to fragment shader as a single float & are thus
     // used differently there & so require different constants.  Unused constants are commented out.
     builder.addBitFlagConstant("kSurfaceBit_HasTexture", 0 /* SurfaceBitIndex.HasTexture */);
@@ -139113,7 +139176,11 @@ const finalizeNormalNormalMap = `
     vec3 biTangent = cross (normal, tangent);
     if (flip)
       biTangent = -biTangent;
-    vec3 normM = TEXTURE(s_normalMap, v_texCoord).xyz;
+    vec3 normM;
+    if (u_surfaceFlags[kSurfaceBitIndex_UseConstantLodNormalMapMapping])
+      normM = constantLodTextureLookup(s_normalMap).xyz;
+    else
+      normM = TEXTURE(s_normalMap, v_texCoord).xyz;
     if (length (normM) > 0.0001) { // check for empty normal texture
       normM = (normM - 0.5) * 2.0;
       normM = normalize (normM);
@@ -139177,7 +139244,7 @@ const computeBaseColor = `
   surfaceColor.rgb = (u_reverseWhiteOnWhite && isAlmostWhite.r && isAlmostWhite.g && isAlmostWhite.b ? vec3(0.0, 0.0, 0.0) : surfaceColor.rgb);
   return vec4(surfaceColor.rgb * g_surfaceTexel.rgb, g_surfaceTexel.a);
 `;
-const surfaceFlagArray = new Int32Array(10 /* SurfaceBitIndex.Count */);
+const surfaceFlagArray = new Int32Array(12 /* SurfaceBitIndex.Count */);
 /** @internal */
 function addSurfaceFlags(builder, withFeatureOverrides, withFeatureColor) {
     addSurfaceFlagsLookup(builder.vert);
@@ -139188,7 +139255,7 @@ function addSurfaceFlags(builder, withFeatureOverrides, withFeatureColor) {
     compute += returnSurfaceFlags;
     builder.addFunctionComputedVarying("v_surfaceFlags", 2 /* VariableType.Float */, "computeSurfaceFlags", compute);
     builder.frag.addInitializer("surfaceFlags = uint(floor(v_surfaceFlags + 0.5));");
-    builder.addUniformArray("u_surfaceFlags", 0 /* VariableType.Boolean */, 10 /* SurfaceBitIndex.Count */, (prog) => {
+    builder.addUniformArray("u_surfaceFlags", 0 /* VariableType.Boolean */, 12 /* SurfaceBitIndex.Count */, (prog) => {
         prog.addGraphicUniform("u_surfaceFlags", (uniform, params) => {
             (0,_itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.assert)(undefined !== params.geometry.asSurface);
             const mesh = params.geometry.asSurface;
@@ -139206,17 +139273,19 @@ function addNormal(builder, animated) {
     builder.frag.addGlobal("g_normal", 4 /* VariableType.Vec3 */);
     let finalizeNormal = finalizeNormalPrelude;
     finalizeNormal += finalizeNormalNormalMap;
+    builder.frag.addFunction(constantLodTextureLookup);
     builder.frag.addUniform("u_normalMapScale", 2 /* VariableType.Float */, (prog) => {
         prog.addGraphicUniform("u_normalMapScale", (uniform, params) => {
-            let normalMapScale = 1.0;
-            if (undefined !== params.geometry.materialInfo && !params.geometry.materialInfo.isAtlas &&
-                undefined !== params.geometry.materialInfo.textureMapping &&
-                undefined !== params.geometry.materialInfo.textureMapping.normalMapParams) {
-                normalMapScale = params.geometry.materialInfo.textureMapping.normalMapParams.scale ?? 1.0;
-                if (params.geometry.materialInfo.textureMapping.normalMapParams.greenUp)
-                    normalMapScale = -normalMapScale;
-            }
-            uniform.setUniform1f(normalMapScale);
+            if (undefined !== params.geometry.materialInfo && !params.geometry.materialInfo.isAtlas) {
+                const normalMapParams = params.geometry.materialInfo.textureMapping?.normalMapParams;
+                if (undefined !== normalMapParams) {
+                    let normalMapScale = 1.0;
+                    normalMapScale = normalMapParams.scale ?? 1.0;
+                    if (normalMapParams.greenUp)
+                        normalMapScale = -normalMapScale;
+                    uniform.setUniform1f(normalMapScale);
+                }
+            }
         });
     });
     finalizeNormal += finalizeNormalPostlude;
@@ -139252,7 +139321,6 @@ function addTexture(builder, animated, isThematic, isPointCloud, isHilite) {
                 }
             });
         });
-        builder.frag.addFunction(sampleSurfaceTexture);
     }
     builder.frag.addUniform("s_texture", 8 /* VariableType.Sampler2D */, (prog) => {
         prog.addGraphicUniform("s_texture", (uniform, params) => {
@@ -139331,8 +139399,17 @@ function createSurfaceBuilder(flags) {
         opts &= ~16 /* FeatureSymbologyOptions.Alpha */;
         (0,_PlanarClassification__WEBPACK_IMPORTED_MODULE_15__.addColorPlanarClassifier)(builder, flags.isTranslucent, flags.isThematic);
     }
-    if (flags.isThematic)
+    if (flags.isThematic) {
         (0,_Thematic__WEBPACK_IMPORTED_MODULE_18__.addThematicDisplay)(builder);
+    }
+    else {
+        builder.vert.addUniform("u_modelToWorld", 7 /* VariableType.Mat4 */, (prog) => {
+            prog.addGraphicUniform("u_modelToWorld", (uniform, params) => {
+                if (undefined !== params.geometry.asSurface?.mesh.constantLodVParams)
+                    params.target.uniforms.branch.bindModelToWorldTransform(uniform, params.geometry, false);
+            });
+        });
+    }
     (0,_FeatureSymbology__WEBPACK_IMPORTED_MODULE_11__.addFeatureSymbology)(builder, feat, opts);
     addSurfaceFlags(builder, 2 /* FeatureMode.Overrides */ === feat, true);
     (0,_FeatureSymbology__WEBPACK_IMPORTED_MODULE_11__.addSurfaceDiscard)(builder, flags);
@@ -139376,6 +139453,25 @@ function createSurfaceBuilder(flags) {
                 (0,_Fragment__WEBPACK_IMPORTED_MODULE_12__.addAltPickBufferOutputs)(builder.frag);
         }
     }
+    builder.addVarying("v_uvCustom", 4 /* VariableType.Vec3 */);
+    builder.vert.addUniform("u_constantLodVParams", 4 /* VariableType.Vec3 */, (prog) => {
+        prog.addGraphicUniform("u_constantLodVParams", (uniform, params) => {
+            const vParams = params.geometry.asSurface?.mesh.constantLodVParams;
+            if (undefined !== vParams) {
+                vParams[2] = params.target.planFrustum.points[_itwin_core_common__WEBPACK_IMPORTED_MODULE_23__.Npc.LeftTopRear].distance(params.target.planFrustum.points[_itwin_core_common__WEBPACK_IMPORTED_MODULE_23__.Npc.RightTopRear]);
+                uniform.setUniform3fv(vParams);
+            }
+        });
+    });
+    builder.frag.addUniform("u_constantLodFParams", 4 /* VariableType.Vec3 */, (prog) => {
+        prog.addGraphicUniform("u_constantLodFParams", (uniform, params) => {
+            const fParams = params.geometry.asSurface?.mesh.constantLodFParams;
+            if (undefined !== fParams)
+                uniform.setUniform3fv(fParams);
+        });
+    });
+    builder.frag.addFunction(constantLodTextureLookup);
+    builder.frag.addFunction(sampleSurfaceTexture);
     builder.frag.addGlobal("g_surfaceTexel", 5 /* VariableType.Vec4 */);
     builder.frag.set(1 /* FragmentShaderComponent.ComputeBaseColor */, (flags.isThematic === 0 /* IsThematic.No */) ? computeBaseColor : "return getSurfaceColor();");
     if (flags.isClassified)
@@ -139881,33 +139977,31 @@ const computeLineCode = "\nfloat computeLineCode() { return g_lineCode; }\n";
 function addSamplePosition(vert) {
     vert.addFunction(getSamplePosition(vert.positionType));
 }
+const getSamplePositionPrelude = `
+vec4 samplePosition(float index) {
+  vec2 tc = compute_vert_coords(index);`;
+const getSamplePositionQuantizedPostlude = `
+  vec4 e0 = floor(TEXTURE(u_vertLUT, tc) * 255.0 + 0.5);
+  tc.x += g_vert_stepX;
+  vec4 e1 = floor(TEXTURE(u_vertLUT, tc) * 255.0 + 0.5);
+  vec3 qpos = vec3(decodeUInt16(e0.xy), decodeUInt16(e0.zw), decodeUInt16(e1.xy));
+  return unquantizePosition(qpos, u_qOrigin, u_qScale);
+}
+`;
+const getSamplePositionUnquantizedPostlude = `
+  uvec3 vux = uvec3(floor(TEXTURE(u_vertLUT, tc).xyz * 255.0 + 0.5));
+  tc.x += g_vert_stepX;
+  uvec3 vuy = uvec3(floor(TEXTURE(u_vertLUT, tc).xyz * 255.0 + 0.5));
+  tc.x += g_vert_stepX;
+  uvec3 vuz = uvec3(floor(TEXTURE(u_vertLUT, tc).xyz * 255.0 + 0.5));
+  tc.x += g_vert_stepX;
+  uvec3 vuw = uvec3(floor(TEXTURE(u_vertLUT, tc).xyz * 255.0 + 0.5));
+  uvec3 u = (vuw << 24) | (vuz << 16) | (vuy << 8) | vux;
+  return vec4(uintBitsToFloat(u), 1.0);
+}
+`;
 function getSamplePosition(type) {
-    const prelude = `
-    vec4 samplePosition(float index) {
-      vec2 tc = compute_vert_coords(index);`;
-    if ("quantized" === type) {
-        return `
-    ${prelude}
-      vec4 e0 = floor(TEXTURE(u_vertLUT, tc) * 255.0 + 0.5);
-      tc.x += g_vert_stepX;
-      vec4 e1 = floor(TEXTURE(u_vertLUT, tc) * 255.0 + 0.5);
-      vec3 qpos = vec3(decodeUInt16(e0.xy), decodeUInt16(e0.zw), decodeUInt16(e1.xy));
-      return unquantizePosition(qpos, u_qOrigin, u_qScale);
-    }
-    `;
-    }
-    return `
-  ${prelude}
-    uvec3 vux = uvec3(floor(TEXTURE(u_vertLUT, tc).xyz * 255.0 + 0.5));
-    tc.x += g_vert_stepX;
-    uvec3 vuy = uvec3(floor(TEXTURE(u_vertLUT, tc).xyz * 255.0 + 0.5));
-    tc.x += g_vert_stepX;
-    uvec3 vuz = uvec3(floor(TEXTURE(u_vertLUT, tc).xyz * 255.0 + 0.5));
-    tc.x += g_vert_stepX;
-    uvec3 vuw = uvec3(floor(TEXTURE(u_vertLUT, tc).xyz * 255.0 + 0.5));
-    uvec3 u = (vuw << 24) | (vuz << 16) | (vuy << 8) | vux;
-    return vec4(uintBitsToFloat(u), 1.0);
-  }`;
+    return `${getSamplePositionPrelude}${"quantized" === type ? getSamplePositionQuantizedPostlude : getSamplePositionUnquantizedPostlude}`;
 }
 /** @internal */
 function addModelViewProjectionMatrix(vert) {
@@ -173845,7 +173939,11 @@ class Geometry {
     static resolveToUndefined(value, targetValue) {
         return value === targetValue ? undefined : value;
     }
-    /** Simple interpolation between values, but choosing (based on fraction) a or b as starting point for maximum accuracy. */
+    /**
+     * Simple interpolation between values, but choosing (based on fraction) a or b as starting
+     * point for maximum accuracy.
+     * * If `f = 0`, then `a` is returned and if `f = 1`, then `b` is returned.
+     */
     static interpolate(a, f, b) {
         return f <= 0.5 ? a + f * (b - a) : b - (1.0 - f) * (b - a);
     }
@@ -202672,11 +202770,11 @@ class Angle {
         }
     }
     /**
-   * Create an Angle from a JSON object
-   * @param json object from JSON.parse. If a number, value is in *DEGREES*
-   * @param defaultValRadians if json is undefined, default value in radians.
-   * @return a new Angle
-   */
+     * Create an Angle from a JSON object
+     * @param json object from JSON.parse. If a number, value is in *DEGREES*
+     * @param defaultValRadians if json is undefined, default value in radians.
+     * @return a new Angle
+     */
     static fromJSON(json, defaultValRadians) {
         const val = new Angle();
         val.setFromJSON(json, defaultValRadians);
@@ -202731,21 +202829,15 @@ class Angle {
         // all larger radians reference from 360 degrees (2PI)
         return 360.0 + 180 * ((radians - 2.0 * pi) / pi);
     }
-    /**
-     * Return the cosine of this Angle object's angle.
-     */
+    /** Return the cosine of this Angle object's angle */
     cos() {
         return Math.cos(this._radians);
     }
-    /**
-     * Return the sine of this Angle object's angle.
-     */
+    /** Return the sine of this Angle object's angle */
     sin() {
         return Math.sin(this._radians);
     }
-    /**
-     * Return the tangent of this Angle object's angle.
-     */
+    /** Return the tangent of this Angle object's angle */
     tan() {
         return Math.tan(this._radians);
     }
@@ -202757,11 +202849,11 @@ class Angle {
     static isHalfCircleRadians(radians) {
         return Math.abs(Math.abs(radians) - Math.PI) <= _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.smallAngleRadians;
     }
-    /** test if the angle is a full circle */
+    /** Test if the angle is a full circle */
     get isFullCircle() {
         return Angle.isFullCircleRadians(this._radians);
     }
-    /** test if the angle is a half circle (in either direction) */
+    /** Test if the angle is a half circle (in either direction) */
     get isHalfCircle() {
         return Angle.isHalfCircleRadians(this._radians);
     }
@@ -202830,7 +202922,7 @@ class Angle {
         // fall through for NaN disaster.
         return 0;
     }
-    /** return a (newly allocated) Angle object with value 0 radians */
+    /** Return a (newly allocated) Angle object with value 0 radians */
     static zero() {
         return new Angle(0);
     }
@@ -202984,19 +203076,19 @@ class Angle {
         return value;
     }
     /**
-       * Return the half angle cosine, sine, and radians for given dot products between vectors. The vectors define
-       * an ellipse using x(t) = c + U cos(t) + V sin(t) so U and V are at angle t=0 degree and t=90 degree. The
-       * half angle t0 is an angle such that x(t0) is one of the ellipse semi-axis.
-       * * This construction arises e.g. in `Arc3d.toScaledMatrix3d`.
-       * * Given ellipse x(t) = c + U cos(t) + V sin(t), find t0 such that radial vector W(t0) = x(t0) - c is
-       * perpendicular to the ellipse.
-       * * Then 0 = W(t0).x'(t0) = (U cos(t0) + V sin(t0)).(V cos(t0) - U sin(t0)) = U.V cos(2t0) + 0.5 (V.V - U.U) sin(2t0)
-       * implies sin(2t0) / cos(2t0) = 2 U.V / (U.U - V.V), i.e., t0 can be computed given the three dot products on the RHS.
-       * math details can be found at docs/learning/geometry/Angle.md
-       * @param dotUU dot product of vectorU with itself
-       * @param dotVV dot product of vectorV with itself
-       * @param dotUV dot product of vectorU with vectorV
-       */
+     * Return the half angle cosine, sine, and radians for given dot products between vectors. The vectors define
+     * an ellipse using x(t) = c + U cos(t) + V sin(t) so U and V are at angle t=0 degree and t=90 degree. The
+     * half angle t0 is an angle such that x(t0) is one of the ellipse semi-axis.
+     * * This construction arises e.g. in `Arc3d.toScaledMatrix3d`.
+     * * Given ellipse x(t) = c + U cos(t) + V sin(t), find t0 such that radial vector W(t0) = x(t0) - c is
+     * perpendicular to the ellipse.
+     * * Then 0 = W(t0).x'(t0) = (U cos(t0) + V sin(t0)).(V cos(t0) - U sin(t0)) = U.V cos(2t0) + 0.5 (V.V - U.U) sin(2t0)
+     * implies sin(2t0) / cos(2t0) = 2 U.V / (U.U - V.V), i.e., t0 can be computed given the three dot products on the RHS.
+     * math details can be found at docs/learning/geometry/Angle.md
+     * @param dotUU dot product of vectorU with itself
+     * @param dotVV dot product of vectorV with itself
+     * @param dotUV dot product of vectorU with vectorV
+     */
     static dotProductsToHalfAngleTrigValues(dotUU, dotVV, dotUV, favorZero = true) {
         const cos2t0 = dotUU - dotVV;
         const sin2t0 = 2.0 * dotUV;
@@ -203005,9 +203097,8 @@ class Angle {
         return Angle.trigValuesToHalfAngleTrigValues(cos2t0, sin2t0);
     }
     /**
-     * * Returns the angle between two vectors, with the vectors given as xyz components
+     * Returns the angle between two vectors, with the vectors given as xyz components
      * * The returned angle is between 0 and PI
-     *
      * @param ux x component of vector u
      * @param uy y component of vector u
      * @param uz z component of vector u
@@ -203020,7 +203111,8 @@ class Angle {
         return Math.atan2(_Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.crossProductMagnitude(ux, uy, uz, vx, vy, vz), uDotV);
     }
     /**
-     * * Returns the angle between two vectors, with the vectors given as xyz components, and an up vector to resolve angle to a full 2PI range.
+     * Returns the angle between two vectors, with the vectors given as xyz components, and an up vector to resolve
+     * angle to a full 2PI range.
      * * The returned angle is (-PI < radians <= PI) or (0 <= radians < 2 * PI)
      * * The angle is in the plane of the U and V vectors.
      * * The upVector determines a positive side of the plane but need not be strictly perpendicular to the plane.
@@ -203034,7 +203126,8 @@ class Angle {
      * @param upVectorX x component of vector to positive side of plane.
      * @param upVectorY y component of vector to positive side of plane.
      * @param upVectorZ z component of vector to positive side of plane.
-     * @param adjustToAllPositive if true, return strictly non-negative sweep (0 <= radians < 2*PI).  If false, return signed (-PI < radians <= PI)
+     * @param adjustToAllPositive if true, return strictly non-negative sweep (0 <= radians < 2*PI). If false, return
+     * signed (-PI < radians <= PI)
      */
     static orientedRadiansBetweenVectorsXYZ(ux, uy, uz, vx, vy, vz, upVectorX, upVectorY, upVectorZ, adjustToPositive = false) {
         const uDotV = ux * vx + uy * vy + uz * vz;
@@ -203045,8 +203138,8 @@ class Angle {
         const crossMagnitude = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.hypotenuseXYZ(wx, wy, wz);
         if (upDotW < 0.0) {
             if (adjustToPositive) {
-                // The turn is greater than 180 degrees.  Take a peculiarly oriented atan2 to get the excess-180 part as addition to PI.
-                // This gives the smoothest numerical transition passing PI.
+                // The turn is greater than 180 degrees.  Take a peculiarly oriented atan2 to get the excess-180 part as
+                // addition to PI. This gives the smoothest numerical transition passing PI.
                 return Math.PI + Math.atan2(crossMagnitude, -uDotV);
             }
             else {
@@ -203161,7 +203254,8 @@ class AngleSweep {
     get endAngle() {
         return _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createRadians(this._radians1);
     }
-    /** Create a sweep as one of
+    /**
+     * Create a sweep as one of
      * * A clone of a given sweep
      * * 0 to given angle
      * * full circle if no arg given (sweep 0 to 360 degrees)
@@ -203173,7 +203267,8 @@ class AngleSweep {
             return new AngleSweep(0, data.radians);
         return AngleSweep.create360();
     }
-    /** (private) constructor with start and end angles in radians.
+    /**
+     * (private) constructor with start and end angles in radians.
      * * Use explicitly named static methods to clarify intent and units of inputs:
      *
      * * createStartEndRadians (startRadians:number, endRadians:number)
@@ -203188,9 +203283,9 @@ class AngleSweep {
         this._radians1 = endRadians;
     }
     /**
-     * directly set the start and end angles in radians
+     * Directly set the start and end angles in radians
      * * If the difference between startRadians and endRadians is greater than 360, the function limits the angle sweep to 360.
-     * */
+     */
     setStartEndRadians(startRadians = 0, endRadians = 2.0 * Math.PI) {
         const delta = endRadians - startRadians;
         if (_Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.isFullCircleRadians(delta)) {
@@ -203199,14 +203294,14 @@ class AngleSweep {
         this._radians0 = startRadians;
         this._radians1 = endRadians;
     }
-    /** directly set the start and end angles in degrees */
+    /** Directly set the start and end angles in degrees */
     setStartEndDegrees(startDegrees = 0, endDegrees = 360.0) {
         this.setStartEndRadians(_Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.degreesToRadians(startDegrees), _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.degreesToRadians(endDegrees));
     }
     /**
-     * create an AngleSweep from start and end angles given in radians.
+     * Create an AngleSweep from start and end angles given in radians.
      * * If the difference between startRadians and endRadians is greater than 360, the function limits the angle sweep to 360.
-     * */
+     */
     static createStartEndRadians(startRadians = 0, endRadians = 2.0 * Math.PI, result) {
         result = result ? result : new AngleSweep();
         result.setStartEndRadians(startRadians, endRadians);
@@ -203216,23 +203311,23 @@ class AngleSweep {
     cloneMinusRadians(radians) {
         return new AngleSweep(this._radians0 - radians, this._radians1 - radians);
     }
-    /** create an AngleSweep from start and end angles given in degrees. */
+    /** Create an AngleSweep from start and end angles given in degrees. */
     static createStartEndDegrees(startDegrees = 0, endDegrees = 360, result) {
         return AngleSweep.createStartEndRadians(_Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.degreesToRadians(startDegrees), _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.degreesToRadians(endDegrees), result);
     }
-    /** create an angle sweep from strongly typed start and end angles */
+    /** Create an angle sweep from strongly typed start and end angles */
     static createStartEnd(startAngle, endAngle, result) {
         result = result ? result : new AngleSweep();
         result.setStartEndRadians(startAngle.radians, endAngle.radians);
         return result;
     }
-    /** create an AngleSweep from start and end angles given in radians. */
+    /** Create an AngleSweep from start and end angles given in radians. */
     static createStartSweepRadians(startRadians = 0, sweepRadians = Math.PI, result) {
         result = result ? result : new AngleSweep();
         result.setStartEndRadians(startRadians, startRadians + sweepRadians);
         return result;
     }
-    /** create an AngleSweep from start and sweep given in degrees.  */
+    /** Create an AngleSweep from start and sweep given in degrees.  */
     static createStartSweepDegrees(startDegrees = 0, sweepDegrees = 360, result) {
         return AngleSweep.createStartEndRadians(_Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.degreesToRadians(startDegrees), _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.degreesToRadians(startDegrees + sweepDegrees), result);
     }
@@ -203244,17 +203339,17 @@ class AngleSweep {
     interpolate(fraction, other) {
         return new AngleSweep(_Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.interpolate(this._radians0, fraction, other._radians0), _Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.interpolate(this._radians1, fraction, other._radians1));
     }
-    /** copy from other AngleSweep. */
+    /** Copy from other AngleSweep. */
     setFrom(other) {
         this._radians0 = other._radians0;
         this._radians1 = other._radians1;
     }
-    /** create a full circle sweep (CCW). startRadians defaults to 0 */
+    /** Create a full circle sweep (CCW). startRadians defaults to 0 */
     static create360(startRadians) {
         startRadians = startRadians ? startRadians : 0.0;
         return new AngleSweep(startRadians, startRadians + 2.0 * Math.PI);
     }
-    /** create a sweep from the south pole to the north pole (-90 to +90). */
+    /** Create a sweep from the south pole to the north pole (-90 to +90). */
     static createFullLatitude() {
         return AngleSweep.createStartEndRadians(-0.5 * Math.PI, 0.5 * Math.PI);
     }
@@ -203264,7 +203359,8 @@ class AngleSweep {
         this._radians0 = this._radians1;
         this._radians1 = tmp;
     }
-    /**  return a sweep for the "other" part of the circle.
+    /**
+     * Return a sweep for the "other" part of the circle.
      * @param reverseDirection true to move backwards (CW) from start to end, false to more forwards (CCW) from start to end.
      */
     cloneComplement(reverseDirection = false, result) {
@@ -203274,9 +203370,7 @@ class AngleSweep {
         else
             return AngleSweep.createStartEndRadians(this.endRadians, this.startRadians + s * Math.PI, result);
     }
-    /**
-     * Restrict start and end angles into the range (-90,+90) in degrees.
-     * */
+    /** Restrict start and end angles into the range (-90,+90) in degrees */
     capLatitudeInPlace() {
         const limit = 0.5 * Math.PI;
         this._radians0 = _Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.clampToStartEnd(this._radians0, -limit, limit);
@@ -203296,7 +203390,7 @@ class AngleSweep {
         return _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.isAlmostEqualRadiansNoPeriodShift(this._radians0, -a)
             && _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.isAlmostEqualRadiansNoPeriodShift(this._radians1, a);
     }
-    /** return a clone of this sweep. */
+    /** Return a clone of this sweep. */
     clone() {
         return new AngleSweep(this._radians0, this._radians1);
     }
@@ -203310,15 +203404,16 @@ class AngleSweep {
     fractionToAngle(fraction) {
         return _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createRadians(this.fractionToRadians(fraction));
     }
-    /** return 2PI divided by the sweep radians (i.e. 360 degrees divided by sweep angle).
+    /**
+     * Return 2PI divided by the sweep radians (i.e. 360 degrees divided by sweep angle).
      * * This is the number of fractional intervals required to cover a whole circle.
      */
     fractionPeriod() {
         return _Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.safeDivideFraction(Math.PI * 2.0, Math.abs(this._radians1 - this._radians0), 1.0);
     }
-    /** return the fractionalized position of the given angle (as Angle) computed without consideration of
+    /**
+     * Return the fractionalized position of the given angle (as Angle) computed without consideration of
      * 2PI period and without consideration of angle sweep direction (CW or CCW).
-     *
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
      * *  interior angles are between 0 and 1
@@ -203331,8 +203426,8 @@ class AngleSweep {
     angleToUnboundedFraction(theta) {
         return _Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.safeDivideFraction(theta.radians - this._radians0, this._radians1 - this._radians0, 1.0);
     }
-    /** return the fractionalized position of the given angle (as radians), computed with consideration of 2PI period.
-     *
+    /**
+     * Return the fractionalized position of the given angle (as radians), computed with consideration of 2PI period.
      * *  consider radians0 as `start` angle of the sweep and radians1 as `end` angle of the sweep
      * *  fraction is always positive
      * *  the start angle is at fraction 0
@@ -203357,8 +203452,8 @@ class AngleSweep {
         const fraction2 = _Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.safeDivideFraction(delta2, -sweep, zeroSweepDefault);
         return fraction2;
     }
-    /** return the fractionalized position of the given angle (as radians), computed with consideration of 2PI period.
-     *
+    /**
+     * Return the fractionalized position of the given angle (as radians), computed with consideration of 2PI period.
      * *  fraction is always positive
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
@@ -203369,8 +203464,8 @@ class AngleSweep {
     radiansToPositivePeriodicFraction(radians, zeroSweepDefault = 0.0) {
         return AngleSweep.radiansToPositivePeriodicFractionStartEnd(radians, this._radians0, this._radians1, zeroSweepDefault);
     }
-    /** return the fractionalized position of the given angle (as Angle), computed with consideration of 2PI period.
-     *
+    /**
+     * Return the fractionalized position of the given angle (as Angle), computed with consideration of 2PI period.
      * *  fraction is always positive
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
@@ -203381,8 +203476,8 @@ class AngleSweep {
     angleToPositivePeriodicFraction(theta) {
         return this.radiansToPositivePeriodicFraction(theta.radians);
     }
-    /** return the fractionalized position of the given array of angles (as radian), computed with consideration of 2PI period.
-     *
+    /**
+     * Return the fractionalized position of the given array of angles (as radian), computed with consideration of 2PI period.
      * *  fraction is always positive
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
@@ -203396,9 +203491,9 @@ class AngleSweep {
             data.reassign(i, this.radiansToPositivePeriodicFraction(data.atUncheckedIndex(i)));
         }
     }
-    /** return the fractionalized position of the given angle (as radian) computed with consideration of
+    /**
+     * Return the fractionalized position of the given angle (as radian) computed with consideration of
      * 2PI period and with consideration of angle sweep direction (CW or CCW).
-     *
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
      * *  interior angles are between 0 and 1
@@ -203422,9 +203517,9 @@ class AngleSweep {
         const fraction = 0.5 + _Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.safeDivideFraction(delta2, -sweep, 0.0);
         return fraction;
     }
-    /** return the fractionalized position of the given angle (as Angle) computed with consideration of
+    /**
+     * Return the fractionalized position of the given angle (as Angle) computed with consideration of
      * 2PI period and with consideration of angle sweep direction (CW or CCW).
-     *
      * *  the start angle is at fraction 0
      * *  the end angle is at fraction 1
      * *  interior angles are between 0 and 1
@@ -203435,7 +203530,7 @@ class AngleSweep {
     angleToSignedPeriodicFraction(theta) {
         return this.radiansToSignedPeriodicFraction(theta.radians);
     }
-    /** test if the given angle (as radians) is within sweep (between radians0 and radians1)   */
+    /** Test if the given angle (as radians) is within sweep (between radians0 and radians1)   */
     static isRadiansInStartEnd(radians, radians0, radians1, allowPeriodShift = true) {
         const delta0 = radians - radians0;
         const delta1 = radians - radians1;
@@ -203445,16 +203540,16 @@ class AngleSweep {
             return allowPeriodShift ? _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.isAlmostEqualRadiansAllowPeriodShift(radians, radians0) : _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.isAlmostEqualRadiansNoPeriodShift(radians, radians0);
         return allowPeriodShift ? this.radiansToPositivePeriodicFractionStartEnd(radians, radians0, radians1, 1000.0) <= 1.0 : false;
     }
-    /** test if the given angle (as radians) is within sweep  */
+    /** Test if the given angle (as radians) is within sweep  */
     isRadiansInSweep(radians, allowPeriodShift = true) {
         return AngleSweep.isRadiansInStartEnd(radians, this.startRadians, this.endRadians, allowPeriodShift);
     }
-    /** test if the given angle (as Angle) is within the sweep */
+    /** Test if the given angle (as Angle) is within the sweep */
     isAngleInSweep(angle) {
         return this.isRadiansInSweep(angle.radians);
     }
-    /** set this AngleSweep from various sources:
-     *
+    /**
+     * Set this AngleSweep from various sources:
      * * if json is undefined, a full-circle sweep is returned.
      * * If json is an AngleSweep object, it is cloned
      * * If json is an array of 2 numbers, those numbers are start and end angles in degrees.
@@ -203476,7 +203571,7 @@ class AngleSweep {
         else
             this.setStartEndRadians(); // default full circle
     }
-    /** create an AngleSweep from a json object. */
+    /** Create an AngleSweep from a json object. */
     static fromJSON(json) {
         const result = AngleSweep.create360();
         result.setFromJSON(json);
@@ -203489,7 +203584,8 @@ class AngleSweep {
     toJSON() {
         return [this.startDegrees, this.endDegrees];
     }
-    /** test if this angle sweep and other angle sweep match with radians tolerance.
+    /**
+     * Test if this angle sweep and other angle sweep match with radians tolerance.
      * * Period shifts are allowed.
      */
     isAlmostEqualAllowPeriodShift(other) {
@@ -203498,14 +203594,16 @@ class AngleSweep {
         return _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.isAlmostEqualRadiansAllowPeriodShift(this._radians0, other._radians0)
             && _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.isAlmostEqualRadiansAllowPeriodShift(this._radians1 - this._radians0, other._radians1 - other._radians0);
     }
-    /** test if this angle sweep and other angle sweep match with radians tolerance.
+    /**
+     * Test if this angle sweep and other angle sweep match with radians tolerance.
      * * Period shifts are not allowed.
      */
     isAlmostEqualNoPeriodShift(other) {
         return _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.isAlmostEqualRadiansNoPeriodShift(this._radians0, other._radians0)
             && _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.isAlmostEqualRadiansNoPeriodShift(this._radians1 - this._radians0, other._radians1 - other._radians0);
     }
-    /** test if start and end angles match with radians tolerance.
+    /**
+     * Test if start and end angles match with radians tolerance.
      * * Period shifts are not allowed.
      * * This function is equivalent to isAlmostEqualNoPeriodShift. It is present for consistency with other classes.
      * However, it is recommended to use isAlmostEqualNoPeriodShift which has a clearer name.
@@ -210772,7 +210870,7 @@ class Matrix3d {
         return undefined;
     }
     /**
-     * Multiply `matrixInverse * [x,y,z]` and return result as `Point4d` the with given weight as last element.
+     * Multiply `matrixInverse * [x,y,z]` and return result as a `Point4d` with the given weight as the last coordinate.
      * * Equivalent to solving `matrix * result = [x,y,z]` for an unknown `result`.
      * * Result is `undefined` if the matrix is singular (e.g. has parallel columns or a zero magnitude column)
      * @return result as a Point4d with the same weight.
@@ -210908,20 +211006,17 @@ class Matrix3d {
     }
     /**
      * Multiply `this` Matrix3d (considered to be a Transform with 0 `origin`) times `other` Transform.
-     * **Note:** If `other = [B   b]`, then we promote `this` matrix to be a Transform [A   0].
-     * Then `this * other` is defined as [A*B   Aa]. That's because we create a 4x4 matrix for each Transform
-     * with the 3x3 `matrix` and `origin` as upper 3x4 part of a 4x4 matrix and 0001 as the final row. Then we
-     * multiply those two 4x4 matrixes:
+     * * **Note:** If `this = [A   0]` and `other = [B   b]`, then `this * other` is defined as [A*B   Ab] because:
      * ```
      * equation
      * \begin{matrix}
-     * \text{`this` matrix }\bold{A}\text{ promoted to block Transform} & \blockTransform{A}{0} \\
-     * \text{`other` Transform with `matrix` part }\bold{B}\text{ and `origin` part }\bold{b} & \blockTransform{B}{b}\\
+     * \text{this matrix }\bold{A}\text{ promoted to block Transform} & \blockTransform{A}{0} \\
+     * \text{other Transform with `matrix` part }\bold{B}\text{ and origin part }\bold{b} & \blockTransform{B}{b}\\
      * \text{product}& \blockTransform{A}{0}\blockTransform{B}{b}=\blockTransform{AB}{Ab}
      * \end{matrix}
      * ```
      * @param other the `other` Transform to be multiplied to `this` matrix.
-     * @param result optional preallocated result to reuse.
+     * @param result optional preallocated `result` to reuse.
      */
     multiplyMatrixTransform(other, result) {
         if (!result)
@@ -211704,7 +211799,7 @@ __webpack_require__.r(__webpack_exports__);
 
 /* cspell:word cxcz, cxsz, cxcy, cxsy, sxcz, sxsz, sxcy, sxsy, cycz, cysz, sycz, sysz */
 /**
- * represents a non-trivial rotation using three simple axis rotation angles and an order in which to apply them.
+ * Represents a non-trivial rotation using three simple axis rotation angles and an order in which to apply them.
  * * This class accommodates application-specific interpretation of "multiplying 3 rotation matrices" with regard to
  *   * Whether a "vector" is a "row" or a "column"
  *   * The order in which the X,Y,Z rotations are applied.
@@ -211762,7 +211857,7 @@ class OrderedRotationAngles {
     get zRadians() {
         return this._z.radians;
     }
-    /** the flag controlling whether vectors are treated as rows or as columns */
+    /** The flag controlling whether vectors are treated as rows or as columns */
     static get treatVectorsAsColumns() {
         return OrderedRotationAngles._sTreatVectorsAsColumns;
     }
@@ -211845,7 +211940,7 @@ class OrderedRotationAngles {
      * * In the failure case the method's return value is `undefined`.
      * * In the failure case, if the optional result was supplied, that result will nonetheless be filled with
      * a set of angles.
-     * */
+     */
     static createFromMatrix3d(matrix, order, result) {
         // treat vector as columns
         let m11 = matrix.coffs[0], m12 = matrix.coffs[1], m13 = matrix.coffs[2];
@@ -212642,21 +212737,19 @@ class Point2dArrayCarrier extends _IndexedXYCollection__WEBPACK_IMPORTED_MODULE_
         return undefined;
     }
     /**
-   * Return the cross product of vectors from point at originIndex to points at indexA and indexB
-   * @param originIndex index of origin
-   * @param indexA index of first target within the array
-   * @param indexB index of second target within the array
-   * @param result caller-allocated vector.
-   * @returns return true if indexA, indexB both valid
-   */
+     * Return the cross product of vectors from point at originIndex to points at indexA and indexB
+     * @param originIndex index of origin
+     * @param indexA index of first target within the array
+     * @param indexB index of second target within the array
+     * @param result caller-allocated vector.
+     * @returns return true if indexA, indexB both valid
+     */
     crossProductIndexIndexIndex(originIndex, indexA, indexB) {
         if (this.isValidIndex(originIndex) && this.isValidIndex(indexA) && this.isValidIndex(indexB))
             return _Point2dVector2d__WEBPACK_IMPORTED_MODULE_1__.XY.crossProductToPoints(this.data[originIndex], this.data[indexA], this.data[indexB]);
         return undefined;
     }
-    /**
-     * read-only property for number of XYZ in the collection.
-     */
+    /** Read-only property for number of XYZ in the collection. */
     get length() {
         return this.data.length;
     }
@@ -212702,10 +212795,11 @@ __webpack_require__.r(__webpack_exports__);
  * @module CartesianGeometry
  */
 // cspell:word JSONXY
-// cspell:word CWXY
+// cspell:word CWXY CCWXY
 
 
-/** Minimal object containing x,y and operations that are meaningful without change in both point and vector.
+/**
+ * Minimal object containing x,y and operations that are meaningful without change in both point and vector.
  *  * `XY` is not instantiable.
  *  * The derived (instantiable) classes are
  *    * `Point2d`
@@ -212750,11 +212844,11 @@ class XY {
     isAlmostEqualXY(x, y, tol) {
         return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.isSameCoordinate(this.x, x, tol) && _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.isSameCoordinate(this.y, y, tol);
     }
-    /** return a json array  `[x,y]`   */
+    /** Return a json array  `[x,y]`   */
     toJSON() {
         return [this.x, this.y];
     }
-    /** return a json object `{x: 1, y:2}`  */
+    /** Return a json object `{x: 1, y:2}`  */
     toJSONXY() {
         return { x: this.x, y: this.y };
     }
@@ -212762,7 +212856,7 @@ class XY {
      * Set x and y from a JSON input such as `[1,2]` or `{x:1, y:2}`
      * * If no JSON input is provided, 0 would be used as default values for x and y.
      * @param json the JSON input
-     * */
+     */
     setFromJSON(json) {
         if (Array.isArray(json)) {
             this.set(json[0] || 0, json[1] || 0);
@@ -212790,17 +212884,13 @@ class XY {
     maxDiff(other) {
         return Math.max(Math.abs(this.x - other.x), Math.abs(this.y - other.y));
     }
-    /**
-     * Return the x,y component corresponding to 0,1.
-     */
+    /** Return the x,y component corresponding to 0,1 */
     at(index) {
         if (index < 0.5)
             return this.x;
         return this.y;
     }
-    /**
-     * Set value at index 0 or 1.
-     */
+    /** Set value at index 0 or 1 */
     setAt(index, value) {
         if (index < 0.5)
             this.x = value;
@@ -212817,7 +212907,7 @@ class XY {
         }
         return index;
     }
-    /** returns true if the x,y components are both small by metric metric tolerance */
+    /** Returns true if the x,y components are both small by metric metric tolerance */
     get isAlmostZero() {
         return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.isSmallMetricDistance(this.x) && _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.isSmallMetricDistance(this.y);
     }
@@ -212833,11 +212923,11 @@ class XY {
     magnitudeSquared() {
         return this.x * this.x + this.y * this.y;
     }
-    /** returns true if the x,y components are exactly equal. */
+    /** Returns true if the x,y components are exactly equal. */
     isExactEqual(other) {
         return this.x === other.x && this.y === other.y;
     }
-    /** returns true if x,y match `other` within metric tolerance */
+    /** Returns true if x,y match `other` within metric tolerance */
     isAlmostEqualMetric(other, distanceTol = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.smallMetricDistance) {
         return this.maxDiff(other) <= distanceTol;
     }
@@ -212849,7 +212939,7 @@ class XY {
     unitVectorTo(other, result) {
         return this.vectorTo(other, result).normalize(result);
     }
-    /** cross product of vectors from origin to targets */
+    /** Cross product of vectors from origin to targets */
     static crossProductToPoints(origin, targetA, targetB) {
         return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.crossProductXYXY(targetA.x - origin.x, targetA.y - origin.y, targetB.x - origin.x, targetB.y - origin.y);
     }
@@ -212862,7 +212952,7 @@ class Point2d extends XY {
     constructor(x = 0, y = 0) {
         super(x, y);
     }
-    /** return a new Point2d with x,y coordinates from this. */
+    /** Return a new Point2d with x,y coordinates from this. */
     clone(result) {
         return Point2d.create(this.x, this.y, result);
     }
@@ -212884,7 +212974,7 @@ class Point2d extends XY {
      * Set x and y from a JSON input such as `[1,2]` or `{x:1, y:2}`
      * * If no JSON input is provided, 0 would be used as default values for x and y.
      * @param json the JSON input
-     * */
+     */
     static fromJSON(json) {
         const val = new Point2d();
         val.setFromJSON(json);
@@ -212900,7 +212990,8 @@ class Point2d extends XY {
     static createZero(result) {
         return Point2d.create(0, 0, result);
     }
-    /** Starting at this point, move along vector by tangentFraction of the vector length, and then
+    /**
+     * Starting at this point, move along vector by tangentFraction of the vector length, and then
      * to the left by leftFraction of the perpendicular vector length.
      * @param tangentFraction distance to move along the vector, as a fraction of vector
      * @param leftFraction distance to move perpendicular to the vector, as a fraction of the rotated vector
@@ -212911,7 +213002,8 @@ class Point2d extends XY {
         const dy = vector.y;
         return Point2d.create(this.x + tangentFraction * dx - leftFraction * dy, this.y + tangentFraction * dy + leftFraction * dx);
     }
-    /** Interpolate at tangentFraction between this instance and point, and then Move by leftFraction
+    /**
+     * Interpolate at tangentFraction between this instance and point, and then Move by leftFraction
      * along the xy perpendicular of the vector between the points.
      */
     forwardLeftInterpolate(tangentFraction, leftFraction, point) {
@@ -212974,7 +213066,8 @@ class Point2d extends XY {
         const y2 = target2.y - this.y;
         return x1 * y2 - y1 * x2;
     }
-    /** Return the fractional coordinate of the projection of this instance x,y onto the
+    /**
+     * Return the fractional coordinate of the projection of this instance x,y onto the
      * line from startPoint to endPoint.
      * @param startPoint start point of line
      * @param endPoint end point of line
@@ -212988,7 +213081,8 @@ class Point2d extends XY {
         return numerator / denominator;
     }
 }
-/** 2D vector with `x`,`y` as properties
+/**
+ * 2D vector with `x`,`y` as properties
  * @public
  */
 class Vector2d extends XY {
@@ -213026,7 +213120,7 @@ class Vector2d extends XY {
     static createZero(result) {
         return Vector2d.create(0, 0, result);
     }
-    /** copy contents from another Point3d, Point2d, Vector2d, or Vector3d, or leading entries of Float64Array */
+    /** Copy contents from another Point3d, Point2d, Vector2d, or Vector3d, or leading entries of Float64Array */
     static createFrom(data, result) {
         if (data instanceof Float64Array) {
             if (data.length >= 2)
@@ -213041,7 +213135,7 @@ class Vector2d extends XY {
      * Set x and y from a JSON input such as `[1,2]` or `{x:1, y:2}`
      * * If no JSON input is provided, 0 would be used as default values for x and y.
      * @param json the JSON input
-     * */
+     */
     static fromJSON(json) {
         const val = new Vector2d();
         val.setFromJSON(json);
@@ -213073,7 +213167,8 @@ class Vector2d extends XY {
         }
         return undefined;
     }
-    /** Return a (new or optionally reused) vector which is `this` divided by `denominator`
+    /**
+     * Return a (new or optionally reused) vector which is `this` divided by `denominator`
      * * return undefined if denominator is zero.
      */
     safeDivideOrNull(denominator, result) {
@@ -213094,7 +213189,7 @@ class Vector2d extends XY {
      * it's returning the length of the projection as a fraction of the target magnitude.
      * @param target the target vector
      * @param defaultFraction the returned value in case magnitude square of target vector is very small
-     * */
+     */
     fractionOfProjectionToVector(target, defaultFraction) {
         /*
          * projection length is (this.target)/||target||
@@ -213149,7 +213244,7 @@ class Vector2d extends XY {
         }
         return result;
     }
-    /** return a new Vector2d rotated CCW by given angle */
+    /** Return a new Vector2d rotated CCW by given angle */
     rotateXY(angle, result) {
         const s = angle.sin();
         const c = angle.cos();
@@ -213161,7 +213256,8 @@ class Vector2d extends XY {
         result.y = xx * s + yy * c;
         return result;
     }
-    /** Return a vector computed at fractional position between this vector and vectorB
+    /**
+     * Return a vector computed at fractional position between this vector and vectorB
     * @param fraction fractional position.  0 is at `this`.  1 is at `vectorB`.
     *                 True fractions are "between", negatives are "before this", beyond 1 is "beyond vectorB".
     * @param vectorB second vector
@@ -213184,14 +213280,14 @@ class Vector2d extends XY {
         }
         return result;
     }
-    /** return {this + vector}. */
+    /** Return {this + vector}. */
     plus(vector, result) {
         result = result ? result : new Vector2d();
         result.x = this.x + vector.x;
         result.y = this.y + vector.y;
         return result;
     }
-    /** return {this - vector}. */
+    /** Return {this - vector}. */
     minus(vector, result) {
         result = result ? result : new Vector2d();
         result.x = this.x - vector.x;
@@ -213226,34 +213322,34 @@ class Vector2d extends XY {
         result.y = this.y * scale;
         return result;
     }
-    /** return a vector parallel to this but with specified length */
+    /** Return a vector parallel to this but with specified length */
     scaleToLength(length, result) {
         const mag = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.correctSmallMetricDistance(this.magnitude());
         if (mag === 0)
             return undefined;
         return this.scale(length / mag, result);
     }
-    /** return the dot product of this with vectorB */
+    /** Return the dot product of this with vectorB */
     dotProduct(vectorB) {
         return this.x * vectorB.x + this.y * vectorB.y;
     }
-    /** dot product with vector from pointA to pointB */
+    /** Dot product with vector from pointA to pointB */
     dotProductStartEnd(pointA, pointB) {
         return this.x * (pointB.x - pointA.x) + this.y * (pointB.y - pointA.y);
     }
-    /** vector cross product {this CROSS vectorB} */
+    /** Vector cross product {this CROSS vectorB} */
     crossProduct(vectorB) {
         return this.x * vectorB.y - this.y * vectorB.x;
     }
     /**
-     * return the radians (as a simple number, not strongly typed Angle) signed angle from this to vectorB.
+     * Return the radians (as a simple number, not strongly typed Angle) signed angle from this to vectorB.
      * This is positive if the shortest turn is counterclockwise, negative if clockwise.
      */
     radiansTo(vectorB) {
         return Math.atan2(this.crossProduct(vectorB), this.dotProduct(vectorB));
     }
     /**
-     * return the (strongly typed) signed angle from this to vectorB.
+     * Return the (strongly typed) signed angle from this to vectorB.
      * This is positive if the shortest turn is counterclockwise, negative if clockwise.
      */
     angleTo(vectorB) {
@@ -213341,7 +213437,7 @@ class Point3dArrayCarrier extends _IndexedXYZCollection__WEBPACK_IMPORTED_MODULE
         super();
         this.data = data;
     }
-    /** test if `index` is a valid index into the array. */
+    /** Test if `index` is a valid index into the array. */
     isValidIndex(index) {
         return index >= 0 && index < this.data.length;
     }
@@ -213383,23 +213479,23 @@ class Point3dArrayCarrier extends _IndexedXYZCollection__WEBPACK_IMPORTED_MODULE
         return undefined;
     }
     /**
-     * access x of indexed point
+     * Access x of indexed point
      * * WARNING: make sure `pointIndex` is a valid index, otherwise, you get random results
-     * */
+     */
     getXAtUncheckedPointIndex(pointIndex) {
         return this.data[pointIndex].x;
     }
     /**
-     * access y of indexed point
+     * Access y of indexed point
      * * WARNING: make sure `pointIndex` is a valid index, otherwise, you get random results
-     * */
+     */
     getYAtUncheckedPointIndex(pointIndex) {
         return this.data[pointIndex].y;
     }
     /**
-     * access z of indexed point
+     * Access z of indexed point
      * * WARNING: make sure `pointIndex` is a valid index, otherwise, you get random results
-     * */
+     */
     getZAtUncheckedPointIndex(pointIndex) {
         return this.data[pointIndex].z;
     }
@@ -213466,10 +213562,7 @@ class Point3dArrayCarrier extends _IndexedXYZCollection__WEBPACK_IMPORTED_MODULE
         if (this.isValidIndex(originIndex) && this.isValidIndex(indexA) && this.isValidIndex(indexB))
             result.addCrossProductToTargetsInPlace(data[originIndex].x, data[originIndex].y, data[originIndex].z, data[indexA].x, data[indexA].y, data[indexA].z, data[indexB].x, data[indexB].y, data[indexB].z);
     }
-    /**
-     * Accumulate scale times the x,y,z values at index to the sum.
-     * No action if index is out of bounds.
-     */
+    /** Accumulate scale times the x,y,z values at index to the sum. No action if index is out of bounds */
     accumulateScaledXYZ(index, scale, sum) {
         if (this.isValidIndex(index)) {
             const point = this.data[index];
@@ -213478,20 +213571,19 @@ class Point3dArrayCarrier extends _IndexedXYZCollection__WEBPACK_IMPORTED_MODULE
             sum.z += scale * point.z;
         }
     }
-    /**
-     * read-only property for number of XYZ in the collection.
-     */
+    /** Read-only property for number of XYZ in the collection */
     get length() {
         return this.data.length;
     }
-    /** push a (clone of) point onto the collection
+    /**
+     * Push a (clone of) point onto the collection
      * * point itself is not pushed -- xyz data is extracted into the native form of the collection.
      */
     push(data) {
         this.data.push(data.clone());
     }
     /**
-     * push a new point (given by coordinates) onto the collection
+     * Push a new point (given by coordinates) onto the collection
      * @param x x coordinate
      * @param y y coordinate
      * @param z z coordinate
@@ -213499,26 +213591,26 @@ class Point3dArrayCarrier extends _IndexedXYZCollection__WEBPACK_IMPORTED_MODULE
     pushXYZ(x, y, z) {
         this.data.push(_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(x === undefined ? 0.0 : x, y === undefined ? 0.0 : y, z === undefined ? 0.0 : z));
     }
-    /** extract (copy) the final point */
+    /** Extract (copy) the final point */
     back(result) {
         if (this.data.length > 0) {
             return this.data[this.data.length - 1].clone(result);
         }
         return undefined;
     }
-    /** extract (copy) the first point */
+    /** Extract (copy) the first point */
     front(result) {
         if (this.data.length > 0) {
             return this.data[0].clone(result);
         }
         return undefined;
     }
-    /** remove the final point. */
+    /** Remove the final point. */
     pop() {
         if (this.data.length > 0)
             this.data.pop();
     }
-    /** remove all points. */
+    /** Remove all points. */
     clear() {
         this.data.length = 0;
     }
@@ -213587,7 +213679,8 @@ __webpack_require__.r(__webpack_exports__);
 
 // cspell:words CWXY CCWXY arctan Rodrigues
 /**
- *  * `XYZ` is a minimal object containing x,y,z and operations that are meaningful without change in both point and vector.
+ * * `XYZ` is a minimal object containing x,y,z and operations that are meaningful without change in both
+ * point and vector.
  *  * `XYZ` is not instantiable.
  *  * The derived (instantiable) classes are
  *    * `Point3d`
@@ -213631,7 +213724,8 @@ class XYZ {
     static isXYAndZ(arg) {
         return this.isXAndY(arg) && this.hasZ(arg);
     }
-    /** Test if arg is any of:
+    /**
+     * Test if arg is any of:
      * * XAndY
      * * XYAndZ
      * * [number,number]
@@ -213640,7 +213734,8 @@ class XYZ {
     static isAnyImmediatePointType(arg) {
         return Point3d.isXAndY(arg) || _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.isNumberArray(arg, 2);
     }
-    /** Look for (in order) an x coordinate present as:
+    /**
+     * Look for (in order) an x coordinate present as:
      * * arg.x
      * * arg[0]
      */
@@ -213651,7 +213746,8 @@ class XYZ {
             return arg[0];
         return defaultValue;
     }
-    /** Look for (in order) an x coordinate present as:
+    /**
+     * Look for (in order) an x coordinate present as:
      * * arg.y
      * * arg[1]
      */
@@ -213662,7 +213758,8 @@ class XYZ {
             return arg[1];
         return defaultValue;
     }
-    /** Look for (in order) an x coordinate present as:
+    /**
+     * Look for (in order) an x coordinate present as:
      * * arg.z
      * * arg[2]
      */
@@ -213725,7 +213822,8 @@ class XYZ {
             this.setZero();
         }
     }
-    /** Returns true if this and other have equal x,y,z parts within Geometry.smallMetricDistance.
+    /**
+     * Returns true if this and other have equal x,y,z parts within Geometry.smallMetricDistance.
      * @param other The other XYAndZ to compare
      * @param tol The tolerance for the comparison. If undefined, use [[Geometry.smallMetricDistance]]
      */
@@ -213806,9 +213904,7 @@ class XYZ {
     maxDiff(other) {
         return Math.max(Math.abs(this.x - other.x), Math.abs(this.y - other.y), Math.abs(this.z - other.z));
     }
-    /**
-     * Return the x,y, z component corresponding to 0,1,2.
-     */
+    /** Return the x,y, z component corresponding to 0,1,2 */
     at(index) {
         if (index < 0.5)
             return this.x;
@@ -213816,9 +213912,7 @@ class XYZ {
             return this.z;
         return this.y;
     }
-    /**
-     * Set value at index 0 or 1 or 2.
-     */
+    /** Set value at index 0 or 1 or 2 */
     setAt(index, value) {
         if (index < 0.5)
             this.x = value;
@@ -213872,27 +213966,27 @@ class XYZ {
     magnitudeSquaredXY() {
         return this.x * this.x + this.y * this.y;
     }
-    /** exact equality test. */
+    /** Exact equality test. */
     isExactEqual(other) {
         return this.x === other.x && this.y === other.y && this.z === other.z;
     }
-    /** equality test with Geometry.smallMetricDistance tolerance */
+    /** Equality test with Geometry.smallMetricDistance tolerance */
     isAlmostEqualMetric(other) {
         return this.maxDiff(other) <= _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.smallMetricDistance;
     }
-    /** add x,y,z from other in place. */
+    /** Add x,y,z from other in place. */
     addInPlace(other) {
         this.x += other.x;
         this.y += other.y;
         this.z += other.z;
     }
-    /** add x,y,z from other in place. */
+    /** Add x,y,z from other in place. */
     subtractInPlace(other) {
         this.x -= other.x;
         this.y -= other.y;
         this.z -= other.z;
     }
-    /** add (in place) the scaled x,y,z of other */
+    /** Add (in place) the scaled x,y,z of other */
     addScaledInPlace(other, scale) {
         this.x += scale * other.x;
         this.y += scale * other.y;
@@ -213904,7 +213998,7 @@ class XYZ {
         this.y *= scale;
         this.z *= scale;
     }
-    /** add to x, y, z parts */
+    /** Add to x, y, z parts */
     addXYZInPlace(dx = 0.0, dy = 0.0, dz = 0.0) {
         this.x += dx;
         this.y += dy;
@@ -213922,7 +214016,8 @@ class XYZ {
     scaledVectorTo(other, scale, result) {
         return Vector3d.create(scale * (other.x - this.x), scale * (other.y - this.y), scale * (other.z - this.z), result);
     }
-    /** Return a unit vector from this vector to other. Return a 000 vector if the input is too small to normalize.
+    /**
+     * Return a unit vector from this vector to other. Return a 000 vector if the input is too small to normalize.
      * @param other target of created vector.
      * @param result optional result vector.
      */
@@ -213933,7 +214028,7 @@ class XYZ {
     freeze() {
         return Object.freeze(this);
     }
-    /** access x part of XYZProps (which may be .x or [0]) */
+    /** Access x part of XYZProps (which may be .x or [0]) */
     static x(xyz, defaultValue = 0) {
         if (xyz === undefined)
             return defaultValue;
@@ -213943,7 +214038,7 @@ class XYZ {
             return xyz.x;
         return defaultValue;
     }
-    /** access x part of XYZProps (which may be .x or [0]) */
+    /** Access x part of XYZProps (which may be .x or [0]) */
     static y(xyz, defaultValue = 0) {
         if (xyz === undefined)
             return defaultValue;
@@ -213953,7 +214048,7 @@ class XYZ {
             return xyz.y;
         return defaultValue;
     }
-    /** access x part of XYZProps (which may be .x or [0]) */
+    /** Access x part of XYZProps (which may be .x or [0]) */
     static z(xyz, defaultValue = 0) {
         if (xyz === undefined)
             return defaultValue;
@@ -213988,7 +214083,8 @@ class Point3d extends XYZ {
     clone(result) {
         return Point3d.create(this.x, this.y, this.z, result);
     }
-    /** Create a new Point3d with given coordinates
+    /**
+     * Create a new Point3d with given coordinates
      * @param x x part
      * @param y y part
      * @param z z part
@@ -214061,8 +214157,8 @@ class Point3d extends XYZ {
     static createZero(result) {
         return Point3d.create(0, 0, 0, result);
     }
-    /** Return the cross product of the vectors from this to pointA and pointB
-     *
+    /**
+     * Return the cross product of the vectors from this to pointA and pointB
      * *  the result is a vector
      * *  the result is perpendicular to both vectors, with right hand orientation
      * *  the magnitude of the vector is twice the area of the triangle.
@@ -214070,21 +214166,20 @@ class Point3d extends XYZ {
     crossProductToPoints(pointA, pointB, result) {
         return Vector3d.createCrossProduct(pointA.x - this.x, pointA.y - this.y, pointA.z - this.z, pointB.x - this.x, pointB.y - this.y, pointB.z - this.z, result);
     }
-    /** Return the magnitude of the cross product of the vectors from this to pointA and pointB
-     */
+    /** Return the magnitude of the cross product of the vectors from this to pointA and pointB */
     crossProductToPointsMagnitude(pointA, pointB) {
         return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.crossProductMagnitude(pointA.x - this.x, pointA.y - this.y, pointA.z - this.z, pointB.x - this.x, pointB.y - this.y, pointB.z - this.z);
     }
-    /** Return the triple product of the vectors from this to pointA, pointB, pointC
-     *
+    /**
+     * Return the triple product of the vectors from this to pointA, pointB, pointC
      * * This is a scalar (number)
      * * This is 6 times the (signed) volume of the tetrahedron on the 4 points.
      */
     tripleProductToPoints(pointA, pointB, pointC) {
         return _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.tripleProduct(pointA.x - this.x, pointA.y - this.y, pointA.z - this.z, pointB.x - this.x, pointB.y - this.y, pointB.z - this.z, pointC.x - this.x, pointC.y - this.y, pointC.z - this.z);
     }
-    /** Return the cross product of the vectors from this to pointA and pointB
-     *
+    /**
+     * Return the cross product of the vectors from this to pointA and pointB
      * *  the result is a scalar
      * *  the magnitude of the vector is twice the signed area of the triangle.
      * *  this is positive for counter-clockwise order of the points, negative for clockwise.
@@ -214094,8 +214189,8 @@ class Point3d extends XYZ {
     }
     /**
      * Return a point interpolated between `this` point and the `other` point.
-     * * fraction specifies where the interpolated point is located on the line passing `this` and `other`.
-     * */
+     * * Fraction specifies where the interpolated point is located on the line passing `this` and `other`.
+     */
     interpolate(fraction, other, result) {
         if (fraction <= 0.5)
             return Point3d.create(this.x + fraction * (other.x - this.x), this.y + fraction * (other.y - this.y), this.z + fraction * (other.z - this.z), result);
@@ -214148,7 +214243,8 @@ class Point3d extends XYZ {
     static createScale(source, scale, result) {
         return Point3d.create(source.x * scale, source.y * scale, source.z * scale, result);
     }
-    /** create a point that is a linear combination (weighted sum) of 2 input points.
+    /**
+     * Create a point that is a linear combination (weighted sum) of 2 input points.
      * @param pointA first input point
      * @param scaleA scale factor for pointA
      * @param pointB second input point
@@ -214186,7 +214282,8 @@ class Point3d extends XYZ {
         return startPoint.dotVectorsToTargets(endPoint, this) / denominator;
     }
 }
-/** 3D vector with `x`,`y`,`z` as properties
+/**
+ * 3D vector with `x`,`y`,`z` as properties
  * @public
  */
 class Vector3d extends XYZ {
@@ -214211,7 +214308,7 @@ class Vector3d extends XYZ {
         return Vector3d.create(this.x, this.y, this.z, result);
     }
     /**
-     * return a Vector3d (new or reused from optional result)
+     * Return a Vector3d (new or reused from optional result)
      * @param x x component
      * @param y y component
      * @param z z component
@@ -214264,7 +214361,6 @@ class Vector3d extends XYZ {
     }
     /**
      * Return the cross product of the vectors from origin to pointA and pointB.
-     *
      * * the result is a vector
      * * the result is perpendicular to both vectors, with right hand orientation
      * * the magnitude of the vector is twice the area of the triangle.
@@ -214441,7 +214537,8 @@ class Vector3d extends XYZ {
         this.z *= a;
         return true;
     }
-    /** Create a normalized vector from the inputs.
+    /**
+     * Create a normalized vector from the inputs.
      * @param result optional result
      * @returns undefined if and only if normalization fails
     */
@@ -214475,7 +214572,8 @@ class Vector3d extends XYZ {
             return defaultFraction;
         return numerator / denominator;
     }
-    /** Return a new vector with components negated from the calling instance.
+    /**
+     * Return a new vector with components negated from the calling instance.
      * @param result optional result vector.
      */
     negate(result) {
@@ -214557,7 +214655,8 @@ class Vector3d extends XYZ {
         const normal = this.crossProduct(target).normalize();
         return normal ? normal.crossProduct(this, result) : undefined;
     }
-    /** Rotate this vector 90 degrees around an axis vector.
+    /**
+     * Rotate this vector 90 degrees around an axis vector.
      * * Note that simple cross is in the plane perpendicular to axis -- it loses the part
      * of "this" that is along the axis. The unit and scale is supposed to fix that.
      * This matches with Rodrigues' rotation formula because cos(theta) = 0 and sin(theta) = 1
@@ -214646,8 +214745,10 @@ class Vector3d extends XYZ {
     static createAdd2Scaled(vectorA, scaleA, vectorB, scaleB, result) {
         return Vector3d.create(vectorA.x * scaleA + vectorB.x * scaleB, vectorA.y * scaleA + vectorB.y * scaleB, vectorA.z * scaleA + vectorB.z * scaleB, result);
     }
-    /** Return the (strongly typed Vector3d) `thisVector3d + vectorA * scalarA + vectorB * scalarB`
-     * with all components presented as numbers */
+    /**
+     * Return the (strongly typed Vector3d) `thisVector3d + vectorA * scalarA + vectorB * scalarB`
+     * with all components presented as numbers
+     */
     static createAdd2ScaledXYZ(ax, ay, az, scaleA, bx, by, bz, scaleB, result) {
         return Vector3d.create(ax * scaleA + bx * scaleB, ay * scaleA + by * scaleB, az * scaleA + bz * scaleB, result);
     }
@@ -214674,7 +214775,8 @@ class Vector3d extends XYZ {
             return undefined;
         return this.scale(length / mag, result);
     }
-    /** Compute the cross product of this vector with `vectorB`.   Immediately pass it to `normalize`.
+    /**
+     * Compute the cross product of this vector with `vectorB`.   Immediately pass it to `normalize`.
      * @param vectorB second vector for cross product.
      * @returns see `Vector3d` method `normalize()` for error condition.
      */
@@ -214761,7 +214863,8 @@ class Vector3d extends XYZ {
     crossProductMagnitude(vectorB) {
         return Math.sqrt(this.crossProductMagnitudeSquared(vectorB));
     }
-    /** Return the dot product of this vector with vectorB.
+    /**
+     * Return the dot product of this vector with vectorB.
      * @param vectorB second vector of cross product
      * @returns the dot product of this instance with vectorB
      */
@@ -214817,7 +214920,8 @@ class Vector3d extends XYZ {
         return this.x * (pointB.x - pointA.x)
             + this.y * (pointB.y - pointA.y);
     }
-    /** Dot product with vector from pointA to pointB, with pointB given as (weighted) wx,wy,wz,w
+    /**
+     * Dot product with vector from pointA to pointB, with pointB given as (weighted) wx,wy,wz,w
      * * We need to unweight pointB (which is a homogeneous point) to be able to participate in the
      * vector dot product
      * * if the weight is near zero metric, the return is zero.
@@ -214861,7 +214965,7 @@ class Vector3d extends XYZ {
         return Vector3d.createCrossProduct(this.x, this.y, this.z, vectorB.x, vectorB.y, vectorB.z, result);
     }
     /**
-     * return cross product of `this` with the vector `(x, y, z)`
+     * Return cross product of `this` with the vector `(x, y, z)`
      * @param x x component of second vector
      * @param y y component of second vector
      * @param z z component of second vector
@@ -214871,12 +214975,12 @@ class Vector3d extends XYZ {
         return Vector3d.createCrossProduct(this.x, this.y, this.z, x, y, z, result);
     }
     /**
-   * Return the angle in radians (not as strongly typed Angle) from this vector to vectorB.
-   * * The returned angle is between 0 and `Math.PI`.
-   * * The returned angle is measured in the plane containing the two vectors.
-   * * Use `planarRadiansTo` and `signedRadiansTo` to return an angle measured in a specific plane.
-   * @param vectorB target vector.
-   */
+     * Return the angle in radians (not as strongly typed Angle) from this vector to vectorB.
+     * * The returned angle is between 0 and `Math.PI`.
+     * * The returned angle is measured in the plane containing the two vectors.
+     * * Use `planarRadiansTo` and `signedRadiansTo` to return an angle measured in a specific plane.
+     * @param vectorB target vector.
+     */
     radiansTo(vectorB) {
         // ||axb|| = ||a|| ||b|| |sin(t)| and a.b = ||a|| ||b|| cos(t) ==>
         // ||axb|| / a.b = sin(t)/cos(t) = tan(t) ==> t = arctan(||axb|| / a.b).
@@ -214912,16 +215016,16 @@ class Vector3d extends XYZ {
         return _Angle__WEBPACK_IMPORTED_MODULE_2__.Angle.createAtan2(this.crossProductXY(vectorB), this.dotProductXY(vectorB));
     }
     /**
-   * Return the angle in radians (not as strongly-typed Angle) from this vector to vectorB, measured
-   * in their containing plane whose normal lies in the same half-space as vectorW.
-   * * The returned angle is between `-Math.PI` and `Math.PI`.
-   * * If the cross product of this vector and vectorB lies on the same side of the plane as vectorW,
-   * this function returns `radiansTo(vectorB)`; otherwise, it returns `-radiansTo(vectorB)`.
-   * * `vectorW` does not have to be perpendicular to the plane.
-   * * Use `planarRadiansTo` to measure the angle between vectors that are projected to another plane.
-   * @param vectorB target vector.
-   * @param vectorW determines the side of the plane in which the returned angle is measured
-   */
+     * Return the angle in radians (not as strongly-typed Angle) from this vector to vectorB, measured
+     * in their containing plane whose normal lies in the same half-space as vectorW.
+     * * The returned angle is between `-Math.PI` and `Math.PI`.
+     * * If the cross product of this vector and vectorB lies on the same side of the plane as vectorW,
+     * this function returns `radiansTo(vectorB)`; otherwise, it returns `-radiansTo(vectorB)`.
+     * * `vectorW` does not have to be perpendicular to the plane.
+     * * Use `planarRadiansTo` to measure the angle between vectors that are projected to another plane.
+     * @param vectorB target vector.
+     * @param vectorW determines the side of the plane in which the returned angle is measured
+     */
     signedRadiansTo(vectorB, vectorW) {
         const p = this.crossProduct(vectorB);
         const theta = Math.atan2(p.magnitude(), this.dotProduct(vectorB));
@@ -214930,7 +215034,8 @@ class Vector3d extends XYZ {
         else
             return theta;
     }
-    /** Return the (strongly-typed) angle from this vector to vectorB, measured
+    /**
+     * Return the (strongly-typed) angle from this vector to vectorB, measured
      * in their containing plane whose normal lies in the same half-space as vectorW.
      * * The returned angle is between -180 and 180 degrees.
      * * If the cross product of this vector and vectorB lies on the same side of the plane as vectorW,
@@ -214973,15 +215078,19 @@ class Vector3d extends XYZ {
     planarAngleTo(vectorB, planeNormal) {
         return _Angle__WEBPACK_IMPORTED_MODULE_2__.Angle.createRadians(this.planarRadiansTo(vectorB, planeNormal));
     }
-    /** Return the smallest angle (in radians) from the (bidirectional) line containing `this`
-   * to the (bidirectional) line containing `vectorB` */
+    /**
+     * Return the smallest angle (in radians) from the (bidirectional) line containing `this`
+     * to the (bidirectional) line containing `vectorB`
+     */
     smallerUnorientedRadiansTo(vectorB) {
         const c = this.dotProduct(vectorB);
         const s = this.crossProductMagnitude(vectorB);
         return Math.atan2(Math.abs(s), Math.abs(c));
     }
-    /** Return the smallest (strongly typed) angle from the (bidirectional) line containing `this`
-     * to the (bidirectional) line containing `vectorB` */
+    /**
+     * Return the smallest (strongly typed) angle from the (bidirectional) line containing `this`
+     * to the (bidirectional) line containing `vectorB`
+     */
     smallerUnorientedAngleTo(vectorB) {
         return _Angle__WEBPACK_IMPORTED_MODULE_2__.Angle.createRadians(this.smallerUnorientedRadiansTo(vectorB));
     }
@@ -220882,7 +220991,7 @@ class Transform {
     }
     /**
      * Return a modified copy of `this` Transform so that its `matrix` part is rigid (`origin` part is untouched).
-     * * For details of how the matrix is modified to rigid, see documentation of `Matrix3d.axisOrderCrossProductsInPlace`
+     * * @see [[Matrix3d.axisOrderCrossProductsInPlace]] documentation for details of how the matrix is modified to rigid.
      */
     cloneRigid(axisOrder = _Geometry__WEBPACK_IMPORTED_MODULE_0__.AxisOrder.XYZ) {
         const modifiedMatrix = _Matrix3d__WEBPACK_IMPORTED_MODULE_2__.Matrix3d.createRigidFromMatrix3d(this.matrix, axisOrder);
@@ -220890,7 +220999,7 @@ class Transform {
             return undefined;
         return new Transform(this.origin.cloneAsPoint3d(), modifiedMatrix);
     }
-    /** Create a Transform with the given `origin` and `matrix`. */
+    /** Create a Transform with the given `origin` and `matrix`. Inputs are captured, not cloned. */
     static createRefs(origin, matrix, result) {
         if (!origin)
             origin = _Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.createZero();
@@ -220901,7 +221010,7 @@ class Transform {
         }
         return new Transform(origin, matrix);
     }
-    /** Create a Transform with complete contents given */
+    /** Create a Transform with complete contents given. `q` inputs make the matrix and `a` inputs make the origin */
     static createRowValues(qxx, qxy, qxz, ax, qyx, qyy, qyz, ay, qzx, qzy, qzz, az, result) {
         if (result) {
             result._origin.set(ax, ay, az);
@@ -220916,6 +221025,8 @@ class Transform {
     }
     /**
      * Create a Transform with translation provided by x,y,z parts.
+     * * Translation Transform maps any vector `v` to `v + p` where `p = (x,y,z)`
+     * * Visualization can be found at https://www.itwinjs.org/sandbox/SaeedTorabi/MoveCube
      * @param x x part of translation
      * @param y y part of translation
      * @param z z part of translation
@@ -220927,6 +221038,8 @@ class Transform {
     }
     /**
      * Create a Transform with specified `translation` part.
+     * * Translation Transform maps any vector `v` to `v + translation`
+     * * Visualization can be found at https://www.itwinjs.org/sandbox/SaeedTorabi/MoveCube
      * @param translation x,y,z parts of the translation
      * @param result optional pre-allocated Transform
      * @returns new or updated transform
@@ -220973,6 +221086,7 @@ class Transform {
      * local-to-world mapping.
      * * This function is a closely related to `createFixedPointAndMatrix` whose point input is the fixed point
      * of the world-to-world transformation.
+     * * If origin is `undefined`, (0,0,0) is used. If matrix is `undefined` the identity matrix is used.
      */
     static createOriginAndMatrix(origin, matrix, result) {
         if (result) {
@@ -220998,7 +221112,7 @@ class Transform {
     }
     /**
      * Create a Transform such that its `matrix` part is rigid.
-     * * For details of how the matrix is created to be rigid, see documentation of `Matrix3d.createRigidFromColumns`
+     * @see [[Matrix3d.createRigidFromColumns]] for details of how the matrix is created to be rigid.
      */
     static createRigidFromOriginAndColumns(origin, vectorX, vectorY, axisOrder, result) {
         const matrix = _Matrix3d__WEBPACK_IMPORTED_MODULE_2__.Matrix3d.createRigidFromColumns(vectorX, vectorY, axisOrder, result ? result._matrix : undefined);
@@ -221010,10 +221124,10 @@ class Transform {
             return result;
         }
         /**
-         * We don't want to pass "origin" to createRefs because createRefs does not clone "origin" and use its reference.
-         * That means if "origin" is changed via Transform at any point, the initial "origin" passed by the user is also
-         * changed. To avoid that, we pass undefined to createRefs. This would cause createRefs to create a new "origin"
-         * equals (0,0,0) which then we set it to the "origin" passed by user in the next line.
+         * We don't want to pass "origin" to createRefs because createRefs does not clone "origin". That means if "origin"
+         * is changed via Transform at any point, the initial "origin" passed by the user is also changed. To avoid that,
+         * we pass "undefined" to createRefs so that it allocates a new point which then we set it to the "origin" which
+         * is passed by user in the next line.
          */
         result = Transform.createRefs(undefined, matrix);
         result._origin.setFromPoint3d(origin);
@@ -221036,18 +221150,19 @@ class Transform {
         return Transform.createRefs(undefined, matrix.clone());
     }
     /**
-     * Create a transform with the specified `matrix` and points `a` and `b`. The returned Transform, transforms
-     * point `p` to `M*(p-a) + b` (i.e., `Tp = M*(p-a) + b`) so transforms point `a` to 'b'.
+     * Create a transform with the specified `matrix` and points `a` and `b`. The returned Transform maps
+     * point `p` to `M*(p-a) + b` (i.e., `Tp = M*(p-a) + b`), so maps `a` to 'b'.
      */
     static createMatrixPickupPutdown(matrix, a, b, result) {
-        // we define the origin o = b - M*a so Tp = M*p + o = M*p + (b - M*a) = M*(x-a) + b
+        // we define the origin o = b - M*a so Tp = M*p + o = M*p + (b - M*a) = M*(p-a) + b
         const origin = _Matrix3d__WEBPACK_IMPORTED_MODULE_2__.Matrix3d.xyzMinusMatrixTimesXYZ(b, matrix, a);
         return Transform.createRefs(origin, matrix.clone(), result);
     }
     /**
      * Create a Transform which leaves the fixedPoint unchanged and scales everything else around it by
-     * a single scale factor. The returned Transform, transforms a point `p` to `M*p + (f - M*f)`
+     * a single scale factor. The returned Transform maps a point `p` to `M*p + (f - M*f)`
      * where `f` is the fixedPoint and M is the scale matrix (i.e., `Tp = M*(p-f) + f`).
+     * * Visualization can be found at https://www.itwinjs.org/sandbox/SaeedTorabi/ScaleCube
      */
     static createScaleAboutPoint(fixedPoint, scale, result) {
         const matrix = _Matrix3d__WEBPACK_IMPORTED_MODULE_2__.Matrix3d.createScale(scale, scale, scale);
@@ -221089,8 +221204,7 @@ class Transform {
         return _Matrix3d__WEBPACK_IMPORTED_MODULE_2__.Matrix3d.xyzPlusMatrixTimesCoordinates(this._origin, this._matrix, x, y, z, result);
     }
     /**
-     * Multiply a specific row (component) of the transform matrix times xyz and add it to the origin element
-     * at the same row. Return the result.
+     * Multiply a specific row (component) of the 3x4 instance times (x,y,z,1). Return the result.
      */
     multiplyComponentXYZ(componentIndex, x, y, z = 0) {
         const coffs = this._matrix.coffs;
@@ -221098,8 +221212,7 @@ class Transform {
         return this.origin.at(componentIndex) + (coffs[idx] * x) + (coffs[idx + 1] * y) + (coffs[idx + 2] * z);
     }
     /**
-     * Multiply a specific row (component) of the transform matrix times xyz and add it to the origin element
-     * at the same row times w. Return the result.
+     * Multiply a specific row (component) of the 3x4 instance times (x,y,z,w). Return the result.
      */
     multiplyComponentXYZW(componentIndex, x, y, z, w) {
         const coffs = this._matrix.coffs;
@@ -221107,31 +221220,38 @@ class Transform {
         return (this.origin.at(componentIndex) * w) + (coffs[idx] * x) + (coffs[idx + 1] * y) + (coffs[idx + 2] * z);
     }
     /**
-     * If `p = (x,y,z)` then transform is `Tp = M*p + o*w`. This function returns the transformed point as a new
-     * point4d (`Tp` as first 3 elements and `w` as last element) or in the pre-allocated result (if result is given).
+     * Transform the homogeneous point. Return as a new `Point4d`, or in the pre-allocated result (if result is given).
+     * * If `p = (x,y,z)` then this method computes `Tp = M*p + o*w` and returns the `Point4d` formed by `Tp` in the
+     * first three coordinates, and `w` in the fourth.
+     * * Logically, this is multiplication by the 4x4 matrix formed from the 3x4 instance augmented with fourth row 0001.
      */
     multiplyXYZW(x, y, z, w, result) {
         return _Matrix3d__WEBPACK_IMPORTED_MODULE_2__.Matrix3d.xyzPlusMatrixTimesWeightedCoordinates(this._origin, this._matrix, x, y, z, w, result);
     }
     /**
-     * If `p = (x,y,z)` then transform is `Tp = M*p + o*w`. This function returns the transformed point as a new
-     * Float64Array with size 4 (`Tp` as first 3 elements and `w` as last element) or in the pre-allocated result
-     * (if result is given).
+     * Transform the homogeneous point. Return as new `Float64Array` with size 4, or in the pre-allocated result (if
+     * result is given).
+     * * If `p = (x,y,z)` then this method computes `Tp = M*p + o*w` and returns the `Float64Array` formed by `Tp`
+     * in the first 3 numbers of the array and `w` as the fourth.
+     * * Logically, this is multiplication by the 4x4 matrix formed from the 3x4 instance augmented with fourth row 0001.
      */
     multiplyXYZWToFloat64Array(x, y, z, w, result) {
         return _Matrix3d__WEBPACK_IMPORTED_MODULE_2__.Matrix3d.xyzPlusMatrixTimesWeightedCoordinatesToFloat64Array(this._origin, this._matrix, x, y, z, w, result);
     }
     /**
-     * If `p = (x,y,z)` then transform is `Tp = M*p + o`. This function returns the transformed point as a new
-     * Float64Array with size 3 (`Tp` as 3 elements) or in the pre-allocated result (if result is given).
+     * * Transform the point. Return as new `Float64Array` with size 3, or in the pre-allocated result (if result is given).
+     * * If `p = (x,y,z)` then this method computes `Tp = M*p + o` and returns it as the first 3 elements of the array.
      */
     multiplyXYZToFloat64Array(x, y, z, result) {
         return _Matrix3d__WEBPACK_IMPORTED_MODULE_2__.Matrix3d.xyzPlusMatrixTimesCoordinatesToFloat64Array(this._origin, this._matrix, x, y, z, result);
     }
     /**
-     * Treat the 3x3 `matrix` and `origin` as upper 3x4 part of a 4x4 matrix, with 0001 as the final row. Now multiply
-     * the transposed of this 4x4 matrix by Point4d given as xyzw. Return as a new point4d (`M*p` as first 3 elements
-     * and `o*p + w` as last element where `p = (x,y,z)`) or in the pre-allocated result (if result is given).
+     * Multiply the homogeneous point by the transpose of `this` Transform. Return as a new `Point4d` or in the
+     * pre-allocated result (if result is given).
+     * * If `p = (x,y,z)` then this method computes `M^t*p` and returns it in the first three coordinates of the `Point4d`,
+     * and `o*p + w` in the fourth.
+     * * Logically, this is multiplication by the transpose of the 4x4 matrix formed from the 3x4 instance augmented with
+     * fourth row 0001.
      */
     multiplyTransposeXYZW(x, y, z, w, result) {
         const coffs = this._matrix.coffs;
@@ -221150,9 +221270,9 @@ class Transform {
             this.multiplyPoint3dArrayInPlace(chain);
     }
     /**
-     * If for a point `p` we have `Tp = M*p + o = point` (where `point` is the transformed point), then
-     * `p = MInverse * (point - o)`. This function returns the original point `p` if `point` is the
-     * transformed point (`Tp = point`).
+     * Multiply the point by the inverse Transform.
+     * * If for a point `p` we have `Tp = M*p + o = q`, then `p = MInverse*(q - o) = TInverse q` so `TInverse`
+     * Transform has matrix part `MInverse` and origin part `-MInverse*o`.
      * * Return as a new point or in the optional `result`.
      * * Returns `undefined` if the `matrix` part if this Transform is singular.
      */
@@ -221160,9 +221280,13 @@ class Transform {
         return this._matrix.multiplyInverseXYZAsPoint3d(point.x - this._origin.x, point.y - this._origin.y, point.z - this._origin.z, result);
     }
     /**
-     * If for a point `p` we have `Tp = M*p + w*o = weightedPoint` (where `weightedPoint` is the transformed point), then
-     * `p = MInverse * (weightedPoint - w*o)`. This function returns a Point4d where first 3 elements are the original
-     *  point `p` if `weightedPoint` is the transformed point (`Tp = weightedPoint`) and the last element is `w`.
+     * Multiply the homogenous point by the inverse Transform.
+     * * If for a point `p` we have `Tp = M*p + o = q`, then `p = MInverse*(q - o) = TInverse q` so `TInverse` Transform
+     * has matrix part `MInverse` and origin part `-MInverse*o`.
+     * * This method computes `TInverse p = MInverse*p - w*MInverse*o` and returns the `Point4d` formed by `TInverse*p`
+     * in the first three coordinates, and `w` in the fourth.
+     * * Logically, this is multiplication by the inverse of the 4x4 matrix formed from the 3x4 instance augmented with
+     * fourth row 0001. This is equivalent to the 4x4 matrix formed in similar fashion from the inverse of this instance.
      * * Return as a new point or in the optional `result`.
      * * Returns `undefined` if the `matrix` part if this Transform is singular.
      */
@@ -221171,9 +221295,9 @@ class Transform {
         return this._matrix.multiplyInverseXYZW(weightedPoint.x - w * this.origin.x, weightedPoint.y - w * this.origin.y, weightedPoint.z - w * this.origin.z, w, result);
     }
     /**
-     * If for a point `p = (x,y,z)` we have `Tp = M*p + o = point` (where `point` is the transformed point), then
-     * `p = MInverse * (point - o)`. This function returns the original point `p` if `point` is the transformed
-     * point (`Tp = point`).
+     * Multiply the point by the inverse Transform.
+     * * If for a point `p` we have `Tp = M*p + o = q`, then `p = MInverse*(q - o) = TInverse q` so `TInverse` Transform
+     * has matrix part `MInverse` and origin part `-MInverse*o`.
      * * Return as a new point or in the optional `result`.
      * * Returns `undefined` if the `matrix` part if this Transform is singular.
      */
@@ -221212,35 +221336,35 @@ class Transform {
         return numSource;
     }
     /**
-     * If for each point `p` we have `Tp = M*p + o = point` (where `point` is the transformed point), then
-     * `p = MInverse * (point - o)`. This function returns the array of original points `p[]` if `points`
-     * is the array of transformed point (`Tp = point` for each `p` and `point`).
-     * * If `results` is given, resize it to match the input `points` array and update it with original points `p[]`.
-     * * If `results` is not given, return a new array.
+     * Multiply each point in the array by the inverse of `this` Transform.
+     * * For a transform `T = [M o]` the inverse transform `T' = [M' -M'o]` exists if and only if `M` has an inverse
+     * `M'`. Indeed, for any point `p`, we have `T'Tp = T'(Mp + o) = M'(Mp + o) - M'o = M'Mp + M'o - M'o = p.`
+     * * If `result` is given, resize it to match the input `points` array and update it with original points `p[]`.
+     * * If `result` is not given, return a new array.
      * * Returns `undefined` if the `matrix` part if this Transform is singular.
      */
-    multiplyInversePoint3dArray(points, results) {
+    multiplyInversePoint3dArray(points, result) {
         if (!this._matrix.computeCachedInverse(true))
             return undefined;
         const originX = this.origin.x;
         const originY = this.origin.y;
         const originZ = this.origin.z;
-        if (results) {
-            const n = Transform.matchArrayLengths(points, results, _Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.createZero);
+        if (result) {
+            const n = Transform.matchArrayLengths(points, result, _Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.createZero);
             for (let i = 0; i < n; i++)
-                this._matrix.multiplyInverseXYZAsPoint3d(points[i].x - originX, points[i].y - originY, points[i].z - originZ, results[i]);
+                this._matrix.multiplyInverseXYZAsPoint3d(points[i].x - originX, points[i].y - originY, points[i].z - originZ, result[i]);
+            return result;
         }
-        results = [];
+        result = [];
         for (const point of points)
-            results.push(this._matrix.multiplyInverseXYZAsPoint3d(point.x - originX, point.y - originY, point.z - originZ));
-        return results;
+            result.push(this._matrix.multiplyInverseXYZAsPoint3d(point.x - originX, point.y - originY, point.z - originZ));
+        return result;
     }
     /**
-     * If for each point `p` we have `Tp = M*p + o = point` (where `point` is the transformed point), then
-     * `p = MInverse * (point - o)`. This function calculates the array of original points `p[]` if `points`
-     * is the array of transformed point (`Tp = point` for each `p` and `point`) and replaces `points`
-     * with the array of original points.
-     * * Returns `true` if the `matrix` part if this Transform is invertible and `false if singular.
+     * Multiply each point in the array by the inverse of `this` Transform in place.
+     * * For a transform `T = [M o]` the inverse transform `T' = [M' -M'o]` exists if and only if `M` has an inverse
+     * `M'`. Indeed, for any point `p`, we have `T'Tp = T'(Mp + o) = M'(Mp + o) - M'o = M'Mp + M'o - M'o = p.`
+     * * Returns `true` if the `matrix` part if this Transform is invertible and `false` if singular.
      */
     multiplyInversePoint3dArrayInPlace(points) {
         if (!this._matrix.computeCachedInverse(true))
@@ -221309,7 +221433,8 @@ class Transform {
     /**
      * Calculate `transformA * transformB` and store it into the calling instance (`this`).
      * * **Note:** If `transformA = [A   a]` and `transformB = [B   b]` then `transformA * transformB` is defined as
-     * `[A*B   Ab+a]`. See `multiplyTransformTransform` doc for math details.
+     * `[A*B   Ab+a]`.
+     * * @see [[multiplyTransformTransform]] documentation for math details.
      * @param transformA first operand
      * @param transformB second operand
      */
@@ -221319,19 +221444,17 @@ class Transform {
     }
     /**
      * Multiply `this` Transform times `other` Transform.
-     * **Note:** If `this = [A   a]` and `other = [B   b]` then `this * other` is defined as [A*B   Ab+a].
-     * That's because we create a 4x4 matrix for each Transform with the 3x3 `matrix` and `origin`
-     * as upper 3x4 part of a 4x4 matrix and 0001 as the final row. Then we multiply those two 4x4 matrixes:
+     * * **Note:** If `this = [A   a]` and `other = [B   b]` then `this * other` is defined as [A*B   Ab+a] because:
      * ```
      * equation
      * \begin{matrix}
-     *    \text{`this` Transform with `matrix` part }\bold{A}\text{ and `origin` part }\bold{a} & \blockTransform{A}{a}\\
-     *    \text{`other` Transform with `matrix` part }\bold{B}\text{ and `origin` part }\bold{b} & \blockTransform{B}{b} \\
+     *    \text{this Transform with matrix part }\bold{A}\text{ and origin part }\bold{a} & \blockTransform{A}{a}\\
+     *    \text{other Transform with matrix part }\bold{B}\text{ and origin part }\bold{b} & \blockTransform{B}{b} \\
      * \text{product}& \blockTransform{A}{a}\blockTransform{B}{b}=\blockTransform{AB}{Ab + a}
      * \end{matrix}
      * ```
      * @param other the 'other` Transform to be multiplied to `this` Transform.
-     * @param result optional preallocated result to reuse.
+     * @param result optional preallocated `result` to reuse.
      */
     multiplyTransformTransform(other, result) {
         if (!result)
@@ -221341,20 +221464,17 @@ class Transform {
     }
     /**
      * Multiply `this` Transform times `other` Matrix3d (considered to be a Transform with 0 `origin`).
-     * **Note:** If `this = [A   a]`, then we promote `other` matrix to be a Transform [B   0].
-     * Then `this * other` is defined as [A*B   a]. That's because we create a 4x4 matrix for each Transform
-     * with the 3x3 `matrix` and `origin` as upper 3x4 part of a 4x4 matrix and 0001 as the final row. Then we
-     * multiply those two 4x4 matrixes:
+     * * **Note:** If `this = [A   a]` and `other = [B   0]`, then `this * other` is defined as [A*B   a] because:
      * ```
      * equation
      * \begin{matrix}
-     *    \text{`this` Transform with `matrix` part }\bold{A}\text{ and `origin` part }\bold{a} & \blockTransform{A}{a}\\
-     *    \text{`other` matrix }\bold{B}\text{ promoted to block Transform} & \blockTransform{B}{0} \\
+     *    \text{this Transform with matrix part }\bold{A}\text{ and origin part }\bold{a} & \blockTransform{A}{a}\\
+     *    \text{other matrix }\bold{B}\text{ promoted to block Transform} & \blockTransform{B}{0} \\
      * \text{product}& \blockTransform{A}{a}\blockTransform{B}{0}=\blockTransform{AB}{a}
      * \end{matrix}
      * ```
      * @param other the `other` Matrix3d to be multiplied to `this` Transform.
-     * @param result optional preallocated result to reuse.
+     * @param result optional preallocated `result` to reuse.
      */
     multiplyTransformMatrix3d(other, result) {
         if (!result)
@@ -221364,13 +221484,13 @@ class Transform {
         return result;
     }
     /**
-     * Return the Range of the transformed corners.
+     * Return the range of the transformed corners.
      * * The 8 corners are transformed individually.
      * * **Note:** Suppose you have a geometry, a range box around that geometry, and your Transform is a rotation.
      * If you rotate the range box and recompute a new range box around the rotated range box, then the new range
      * box will have a larger volume than the original range box. However, if you rotate the geometry itself and
      * then recompute the range box, it will be a tighter range box around the rotated geometry. `multiplyRange`
-     * function creates the larger range box because it only has access to the range box and the geometry itself.
+     * function creates the larger range box because it only has access to the range box and not the geometry itself.
      */
     multiplyRange(range, result) {
         if (range.isNull)
@@ -221394,7 +221514,7 @@ class Transform {
     }
     /**
      * Return a Transform which is the inverse of `this` Transform.
-     * * If `transform = [M   o]` then `transformInverse = [MInverse   MInverse*-o]`
+     * * If `transform = [M   o]` then `transformInverse = [MInverse   -MInverse*o]`
      * * Return `undefined` if this Transform's matrix is singular.
      */
     inverse(result) {
@@ -221409,14 +221529,14 @@ class Transform {
         return Transform.createRefs(matrixInverse.multiplyXYZ(-this._origin.x, -this._origin.y, -this._origin.z), matrixInverse);
     }
     /**
-     * Initialize 2 Transforms: First Transform maps a box (axis aligned) specified by `min` and `max` to
-     * the unit box specified by 000 and 111 and inverse of it. Second Transform is the reverse of first.
-     * @param min the min corner of the box
-     * @param max the max corner of the box
-     * @param npcToGlobal maps global (the unit box specified by 000 and 111) to NPC (a box specified by `min`
-     * and `max`). Object created by caller, re-initialized here.
-     * @param globalToNpc maps NPC (a box specified by `min` and `max`) to global (the unit box specified by
-     * 000 and 111). Object created by caller, re-initialized here.
+     * Initialize 2 Transforms that map between the unit box (specified by 000 and 111) and the range box specified
+     * by the input points.
+     * @param min the min corner of the range box
+     * @param max the max corner of the range box
+     * @param npcToGlobal maps NPC coordinates into range box coordinates. Specifically, maps 000 to `min` and maps
+     * 111 to `max`. This Transform is the inverse of `globalToNpc`. Object created by caller, re-initialized here.
+     * @param globalToNpc maps range box coordinates into NPC coordinates. Specifically, maps `min` to 000 and maps
+     * `max` to 111. This Transform is the inverse of `npcToGlobal`. Object created by caller, re-initialized here.
      * * NPC stands for `Normalized Projection Coordinate`
      */
     static initFromRange(min, max, npcToGlobal, globalToNpc) {
@@ -221669,11 +221789,11 @@ __webpack_require__.r(__webpack_exports__);
  */
 class YawPitchRollAngles {
     /**
-     * constructor
+     * Constructor
      * @param yaw counterclockwise rotation angle around z
      * @param pitch **clockwise** rotation angle around y
      * @param roll counterclockwise rotation angle around x
-     * */
+     */
     constructor(yaw = _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.zero(), pitch = _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.zero(), roll = _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.zero()) {
         this.yaw = yaw;
         this.pitch = pitch;
@@ -221687,29 +221807,29 @@ class YawPitchRollAngles {
         return Object.freeze(this);
     }
     /**
-     * constructor for YawPitchRollAngles with angles in degrees.
+     * Constructor for YawPitchRollAngles with angles in degrees.
      * @param yawDegrees counterclockwise rotation angle (in degrees) around z
      * @param pitchDegrees **clockwise** rotation angle (in degrees) around y
      * @param rollDegrees counterclockwise rotation angle (in degrees) around x
-     * */
+     */
     static createDegrees(yawDegrees, pitchDegrees, rollDegrees) {
         return new YawPitchRollAngles(_Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createDegrees(yawDegrees), _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createDegrees(pitchDegrees), _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createDegrees(rollDegrees));
     }
     /**
-     * constructor for YawPitchRollAngles with angles in radians.
+     * Constructor for YawPitchRollAngles with angles in radians.
      * @param yawRadians counterclockwise rotation angle (in radians) around z
      * @param pitchRadians **clockwise** rotation angle (in radians) around y
      * @param rollRadians counterclockwise rotation angle (in radians) around x
-     * */
+     */
     static createRadians(yawRadians, pitchRadians, rollRadians) {
         return new YawPitchRollAngles(_Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createRadians(yawRadians), _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createRadians(pitchRadians), _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createRadians(rollRadians));
     }
-    /** construct a `YawPitchRoll` object from an object with 3 named angles */
+    /** Construct a `YawPitchRoll` object from an object with 3 named angles */
     static fromJSON(json) {
         json = json ? json : {};
         return new YawPitchRollAngles(_Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.fromJSON(json.yaw), _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.fromJSON(json.pitch), _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.fromJSON(json.roll));
     }
-    /** populate yaw, pitch and roll fields using `Angle.fromJSON` */
+    /** Populate yaw, pitch and roll fields using `Angle.fromJSON` */
     setFromJSON(json) {
         json = json ? json : {};
         this.yaw = _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.fromJSON(json.yaw);
@@ -221719,7 +221839,7 @@ class YawPitchRollAngles {
     /**
      * Convert to a JSON object of form { pitch: 20 , roll: 30 , yaw: 10 }. Angles are in degrees.
      * Any values that are exactly zero (with tolerance `Geometry.smallAngleRadians`) are omitted.
-     **/
+     */
     toJSON() {
         const val = {};
         if (!this.pitch.isAlmostZero)
@@ -221749,15 +221869,12 @@ class YawPitchRollAngles {
             && this.pitch.isAlmostEqualAllowPeriodShift(other.pitch)
             && this.roll.isAlmostEqualAllowPeriodShift(other.roll);
     }
-    /**
-     * Make a copy of this YawPitchRollAngles.
-     */
+    /** Make a copy of this YawPitchRollAngles */
     clone() {
         return new YawPitchRollAngles(this.yaw.clone(), this.pitch.clone(), this.roll.clone());
     }
     /**
      * Expand the angles into a (rigid rotation) matrix.
-     *
      * * The returned matrix is "rigid" (i.e., it has unit length rows and columns, and its transpose is its inverse).
      * * The rigid matrix is always a right handed coordinate system.
      * @param result optional pre-allocated `Matrix3d`
@@ -221794,7 +221911,8 @@ class YawPitchRollAngles {
         */
         return _Matrix3d__WEBPACK_IMPORTED_MODULE_1__.Matrix3d.createRowValues(cz * cy, -(sz * cx + cz * sy * sx), (sz * sx - cz * sy * cx), sz * cy, (cz * cx - sz * sy * sx), -(cz * sx + sz * sy * cx), sy, cy * sx, cy * cx, result);
     }
-    /** Returns true if this rotation does nothing.
+    /**
+     * Returns true if this rotation does nothing.
      * * If allowPeriodShift is false, any nonzero angle is considered a non-identity
      * * If allowPeriodShift is true, all angles are individually allowed to be any multiple of 360 degrees.
      */
@@ -221839,7 +221957,8 @@ class YawPitchRollAngles {
             angles: YawPitchRollAngles.createFromMatrix3d(transform.matrix),
         };
     }
-    /** Attempts to create a YawPitchRollAngles object from a Matrix3d
+    /**
+     * Attempts to create a YawPitchRollAngles object from a Matrix3d
      * * This conversion fails if the matrix is not rigid (unit rows and columns, and transpose is inverse)
      * * In the failure case the method's return value is `undefined`.
      * * In the failure case, if the optional result was supplied, that result will nonetheless be filled with
@@ -246151,19 +246270,22 @@ class SteppedIndexFunctionFactory {
     static createConstant(value = 0) {
         return (_i, _n) => value;
     }
-    /** Return a function that steps linearly
+    /**
+     * Return a function that steps linearly
      * *  f(i,n) = y0 + (i/n) * a
      */
     static createLinear(a, f0 = 0) {
         return (i, n) => (f0 + a * (i / n));
     }
-    /** Return a function that steps with cosine of angles in sweep
+    /**
+     * Return a function that steps with cosine of angles in sweep
      * *  f(i,n) = y0 + amplitude * cos(i/n)
      */
     static createCosine(amplitude, sweep = _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.create360(), f0 = 0) {
         return (i, n) => (f0 + amplitude * Math.cos(sweep.fractionToRadians(i / n)));
     }
-    /** Return a function that steps with cosine of angles in sweep.
+    /**
+     * Return a function that steps with cosine of angles in sweep.
      * *  f(i,n) = y0 + amplitude * sin(i/n)
      */
     static createSine(amplitude, sweep = _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.create360(), f0 = 0) {
@@ -246175,7 +246297,8 @@ class SteppedIndexFunctionFactory {
  * @alpha
  */
 class Sample {
-    /** Return an array of Point3d, with x,y,z all stepping through a range of values.
+    /**
+     * Return an array of Point3d, with x,y,z all stepping through a range of values.
      * x varies fastest, then y then z
      */
     static createPoint3dLattice(low, step, high) {
@@ -246186,7 +246309,8 @@ class Sample {
                     points.push(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(x, y, z));
         return points;
     }
-    /** Return an array of Point2d, with x,y all stepping through a range of values.
+    /**
+     * Return an array of Point2d, with x,y all stepping through a range of values.
      * x varies fastest, then y
      */
     static createPoint2dLattice(low, step, high) {
@@ -246234,7 +246358,8 @@ class Sample {
     static createCenteredRectangleXY(cx, cy, ax, ay, z = 0) {
         return this.createRectangleXY(cx - ax, cy - ay, 2 * ax, 2 * ay, z);
     }
-    /** Access the last point in the array. push another shifted by dx,dy,dz.
+    /**
+     * Access the last point in the array. push another shifted by dx,dy,dz.
      * * No push if all are 0.
      * * If array is empty, push a leading 000
      */
@@ -246256,7 +246381,8 @@ class Sample {
         points.push(points[0].clone());
         return points;
     }
-    /** Create points for an L shaped polygon
+    /**
+     * Create points for an L shaped polygon
      * * lower left at x0,y0.
      * * ax,ay are larger side lengths (lower left to corners along x and y directions)
      * * bx,by are smaller side lengths (inner corner to points along x and y directions)
@@ -246281,7 +246407,7 @@ class Sample {
         return [
             plane0, plane1, plane2,
             _clipping_ClipPlane__WEBPACK_IMPORTED_MODULE_6__.ClipPlane.createNormalAndDistance(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.create(3, 4, 0), 2.0),
-            _clipping_ClipPlane__WEBPACK_IMPORTED_MODULE_6__.ClipPlane.createEdgeXY(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 0, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(24, 32, 0))
+            _clipping_ClipPlane__WEBPACK_IMPORTED_MODULE_6__.ClipPlane.createEdgeXY(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 0, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(24, 32, 0)),
         ];
     }
     /**
@@ -246297,16 +246423,17 @@ class Sample {
         const quadrant4 = _clipping_ConvexClipPlaneSet__WEBPACK_IMPORTED_MODULE_7__.ConvexClipPlaneSet.createXYBox(0, -1, 1, 0);
         result.push(_clipping_UnionOfConvexClipPlaneSets__WEBPACK_IMPORTED_MODULE_8__.UnionOfConvexClipPlaneSets.createConvexSets([
             quadrant1.clone(),
-            quadrant4.clone()
+            quadrant4.clone(),
         ]));
         result.push(_clipping_UnionOfConvexClipPlaneSets__WEBPACK_IMPORTED_MODULE_8__.UnionOfConvexClipPlaneSets.createConvexSets([
             quadrant1.clone(),
             quadrant2.clone(),
-            quadrant4.clone()
+            quadrant4.clone(),
         ]));
         return result;
     }
-    /** Create (unweighted) bspline curves.
+    /**
+     * Create (unweighted) bspline curves.
      * order varies from 2 to 5
      */
     static createBsplineCurves(includeMultipleKnots = false) {
@@ -246343,7 +246470,8 @@ class Sample {
         }
         return result;
     }
-    /** Create weighted bspline curves.
+    /**
+     * Create weighted bspline curves.
      * order varies from 2 to 5
      */
     static createBspline3dHCurves() {
@@ -246381,8 +246509,7 @@ class Sample {
         }
         return result;
     }
-    /** Create weighted bsplines for circular arcs.
-     */
+    /** Create weighted bsplines for circular arcs. */
     static createBspline3dHArcs() {
         const result = [];
         const halfRadians = _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.degreesToRadians(60.0);
@@ -246397,14 +246524,15 @@ class Sample {
             _geometry4d_Point4d__WEBPACK_IMPORTED_MODULE_10__.Point4d.create(-1, 0, 0, c),
             _geometry4d_Point4d__WEBPACK_IMPORTED_MODULE_10__.Point4d.create(-c, -s, 0, 1),
             _geometry4d_Point4d__WEBPACK_IMPORTED_MODULE_10__.Point4d.create(c, -s, 0, c),
-            _geometry4d_Point4d__WEBPACK_IMPORTED_MODULE_10__.Point4d.create(1, 0, 0, 1)
+            _geometry4d_Point4d__WEBPACK_IMPORTED_MODULE_10__.Point4d.create(1, 0, 0, 1),
         ];
         const knots = [0, 0, 1, 1, 2, 2, 3, 3];
         const curve = _bspline_BSplineCurve3dH__WEBPACK_IMPORTED_MODULE_11__.BSplineCurve3dH.create(points, knots, 3);
         result.push(curve);
         return result;
     }
-    /** Return array   [x,y,z,w] bspline control points for an arc in 90 degree bspline spans.
+    /**
+     * Return array   [x,y,z,w] bspline control points for an arc in 90 degree bspline spans.
      * @param points array of [x,y,z,w]
      * @param center center of arc
      * @param axes matrix with 0 and 90 degree axes
@@ -246450,7 +246578,7 @@ class Sample {
             result.push(b);
         return result;
     }
-    /** create a plane from origin and normal coordinates -- default to 001 normal if needed. */
+    /** Create a plane from origin and normal coordinates -- default to 001 normal if needed. */
     static createPlane(x, y, z, u, v, w) {
         const point = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(x, y, z);
         const vector = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.create(u, v, w).normalize();
@@ -246470,22 +246598,23 @@ class Sample {
         return [
             _curve_LineString3d__WEBPACK_IMPORTED_MODULE_15__.LineString3d.createPoints([
                 _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0),
-                _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 0, 0)
+                _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 0, 0),
             ]),
             _curve_LineString3d__WEBPACK_IMPORTED_MODULE_15__.LineString3d.createPoints([
                 _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0),
                 _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 0, 0),
-                _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 1, 0)
+                _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 1, 0),
             ]),
             _curve_LineString3d__WEBPACK_IMPORTED_MODULE_15__.LineString3d.createPoints([
                 _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0),
                 _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 0, 0),
                 _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 1, 0),
-                _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(2, 2, 0)
-            ])
+                _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(2, 2, 0),
+            ]),
         ];
     }
-    /** Assorted Matrix3d:
+    /**
+     * Assorted Matrix3d:
      * * identity
      * * rotation around x
      * * rotation around general vector
@@ -246510,10 +246639,11 @@ class Sample {
             _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createTranslationXYZ(1, 2, 0),
             _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createTranslationXYZ(1, 2, 3),
             _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createFixedPointAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(4, 1, -2), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createUniformScale(2.0)),
-            _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createFixedPointAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(4, 1, -2), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRotationAroundVector(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.create(1, 2, 3), _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createRadians(10)))
+            _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createFixedPointAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(4, 1, -2), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRotationAroundVector(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.create(1, 2, 3), _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createRadians(10))),
         ];
     }
-    /** Return an array of Matrix3d with various skew and scale.  This includes at least:
+    /**
+     * Return an array of Matrix3d with various skew and scale.  This includes at least:
      * * identity
      * * 3 distinct diagonals.
      * * The distinct diagonal base with smaller value added to other 6 spots in succession.
@@ -246532,9 +246662,10 @@ class Sample {
             _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRowValues(5, 2, 3, 2, 6, 1, -1, 2, 7),
         ];
     }
-    /** Return an array of singular Matrix3d.  This includes at least:
+    /**
+     * Return an array of singular Matrix3d. This includes at least:
      * * all zeros
-     * * one nonzero column
+     * * one non-zero column
      * * two independent columns, third is zero
      * * two independent columns, third is sum of those
      * * two independent columns, third is copy of one
@@ -246546,26 +246677,26 @@ class Sample {
         const vector0 = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.createZero();
         return [
             _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createZero(),
-            // one nonzero column
+            // one non-zero column
             _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vectorU, vector0, vector0),
             _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vector0, vectorU, vector0),
-            _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vector0, vector0, vector0),
-            // two independent nonzero columns with zero
+            _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vector0, vector0, vectorU),
+            // two independent non-zero columns with one zero column
             _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vectorU, vectorV, vector0),
             _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vector0, vectorU, vectorV),
-            _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vectorV, vector0, vector0),
-            // third column dependent
+            _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vectorU, vector0, vectorV),
+            // two independent columns with one dependent column
             _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vectorU, vectorV, vectorUPlusV),
             _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vectorU, vectorUPlusV, vectorV),
-            _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vectorUPlusV, vectorV, vectorU),
-            // two independent with duplicate
-            _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vectorU, vectorV, vectorU),
+            _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vectorUPlusV, vectorU, vectorV),
+            // two independent with columns with one duplicate column
             _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vectorU, vectorU, vectorV),
-            _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vectorV, vectorV, vectorU)
+            _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vectorU, vectorV, vectorU),
+            _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createColumns(vectorV, vectorU, vectorU),
         ];
     }
     /**
-     * * Return an array of rigid transforms.  This includes (at least)
+     * Return an array of rigid transforms. This includes (at least)
      *   * Identity
      *   * translation with identity matrix
      *   * rotation around origin and arbitrary vector
@@ -246580,16 +246711,15 @@ class Sample {
             _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createTranslationXYZ(distanceScale3 * 1, distanceScale3 * 2, distanceScale3 * 3),
             _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createFixedPointAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRotationAroundVector(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.unitY(), _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(10))),
             _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createFixedPointAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(distanceScale4 * 4, distanceScale4 * 1, -distanceScale4 * 2), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRotationAroundVector(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.create(1, 2, 3), _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(10))),
-            _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createFixedPointAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(distanceScale4 * 4, distanceScale4 * 1, -distanceScale4 * 2), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRotationAroundVector(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.create(-2, 1, 4), _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(35)))
+            _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createFixedPointAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(distanceScale4 * 4, distanceScale4 * 1, -distanceScale4 * 2), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRotationAroundVector(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.create(-2, 1, 4), _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(35))),
         ];
     }
-    /**
-     * Return a single rigid transform with all terms nonzero.
-     */
+    /** Return a single rigid transform with all terms nonzero. */
     static createMessyRigidTransform(fixedPoint) {
         return _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createFixedPointAndMatrix(fixedPoint ? fixedPoint : _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 2, 3), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRotationAroundVector(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.create(0.3, -0.2, 1.2), _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(15.7)));
     }
-    /** Return various rigid matrices:
+    /**
+     * Return various rigid matrices:
      * * identity
      * * small rotations around x, y, z
      * * small rotation around (1,2,3)
@@ -246619,9 +246749,7 @@ class Sample {
         }
         return result;
     }
-    /**
-     * Create full Map4d for each `Sample.createInvertibleTransforms ()`
-     */
+    /** Create full Map4d for each `Sample.createInvertibleTransforms()` */
     static createMap4ds() {
         const result = [];
         let transform;
@@ -246639,7 +246767,12 @@ class Sample {
     static createSimplePaths(withGaps = false) {
         const point0 = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0);
         const point1 = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(10, 0, 0);
-        const p1 = [point1, _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 10, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(6, 10, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(6, 10, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 10, 0)];
+        const p1 = [
+            point1, _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 10, 0),
+            _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(6, 10, 0),
+            _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(6, 10, 0),
+            _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 10, 0),
+        ];
         const segment1 = _curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_19__.LineSegment3d.create(point0, point1);
         const vectorU = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.unitX(3);
         const vectorV = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.unitY(3);
@@ -246654,7 +246787,8 @@ class Sample {
             simplePaths.push(_curve_Path__WEBPACK_IMPORTED_MODULE_21__.Path.create(_curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_19__.LineSegment3d.create(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(10, 0, 0)), _curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_19__.LineSegment3d.create(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(10, 10, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(5, 0, 0))));
         return simplePaths;
     }
-    /** Assorted `Path` with lines and arcs.
+    /**
+     * Assorted `Path` with lines and arcs.
      * Specifically useful for offset tests.
      */
     static createLineArcPaths() {
@@ -246683,12 +246817,16 @@ class Sample {
     }
     /** Assorted `PointString3d` objects. */
     static createSimplePointStrings() {
-        const p1 = [[_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 10, 0)], [_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(6, 10, 0)], [_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(6, 10, 0), [_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(6, 10, 0)]]];
+        const p1 = [
+            [_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 10, 0)],
+            [_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(6, 10, 0)],
+            [_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(6, 10, 0), [_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(6, 10, 0)]],
+        ];
         const simplePaths = [
             _curve_PointString3d__WEBPACK_IMPORTED_MODULE_22__.PointString3d.create(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 2, 0)),
             _curve_PointString3d__WEBPACK_IMPORTED_MODULE_22__.PointString3d.create(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(10, 0, 0)),
             _curve_PointString3d__WEBPACK_IMPORTED_MODULE_22__.PointString3d.create(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(10, 0, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(10, 5, 0)),
-            _curve_PointString3d__WEBPACK_IMPORTED_MODULE_22__.PointString3d.create(p1)
+            _curve_PointString3d__WEBPACK_IMPORTED_MODULE_22__.PointString3d.create(p1),
         ];
         return simplePaths;
     }
@@ -246717,8 +246855,7 @@ class Sample {
      * @param dx1 distance along x axis at y=dy
      * @param numPhase number of phases of the jump.
      * @param dyReturn y value for return to origin.  If 0, the wave ends at y=0 after then final "down" with one extra horizontal dx0
-     *     If nonzero, rise to that y value, return to x=0, and return down to origin.
-     *
+     * If nonzero, rise to that y value, return to x=0, and return down to origin.
      */
     static createSquareWave(origin, dx0, dy, dx1, numPhase, dyReturn) {
         const result = [origin.clone()];
@@ -246779,7 +246916,7 @@ class Sample {
         }
         return points;
     }
-    /** append sawtooth with x distances successively scaled by xFactor */
+    /** Append sawtooth with x distances successively scaled by xFactor */
     static appendVariableSawTooth(points, dxLow, riseX, riseY, dxHigh, numPhase, xFactor) {
         let factor = 1.0;
         for (let i = 0; i < numPhase; i++) {
@@ -246820,7 +246957,8 @@ class Sample {
         data.push(data[0].clone());
         return data;
     }
-    /** append to a linestring, taking steps along given vector directions
+    /**
+     * Append to a linestring, taking steps along given vector directions
      * If the linestring is empty, a 000 point is added.
      * @param linestring LineString3d to receive points.
      * @param numPhase number of phases of the sawtooth
@@ -246837,7 +246975,8 @@ class Sample {
             }
         }
     }
-    /** Assorted regions with arc boundaries
+    /**
+     * Assorted regions with arc boundaries
      * * full circle
      * * with varying sweep:
      *    * partial arc with single chord closure
@@ -246864,7 +247003,8 @@ class Sample {
         }
         return result;
     }
-    /** Assorted loops in xy plane:
+    /**
+     * Assorted loops in xy plane:
      * * unit square
      * * rectangle
      * * L shape
@@ -246904,10 +247044,14 @@ class Sample {
         ];
         if (includeBCurves) {
             const ey = 1.0;
-            result.push(_curve_ParityRegion__WEBPACK_IMPORTED_MODULE_24__.ParityRegion.create(_curve_Loop__WEBPACK_IMPORTED_MODULE_23__.Loop.create(_curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_19__.LineSegment3d.create(point0, pointA), _bspline_BSplineCurve__WEBPACK_IMPORTED_MODULE_9__.BSplineCurve3d.createUniformKnots([pointA, _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(ax + 1, ey),
+            result.push(_curve_ParityRegion__WEBPACK_IMPORTED_MODULE_24__.ParityRegion.create(_curve_Loop__WEBPACK_IMPORTED_MODULE_23__.Loop.create(_curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_19__.LineSegment3d.create(point0, pointA), _bspline_BSplineCurve__WEBPACK_IMPORTED_MODULE_9__.BSplineCurve3d.createUniformKnots([
+                pointA,
+                _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(ax + 1, ey),
                 _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(ax + 1, 2 * ey),
                 _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(ax + 2, 3 * ey),
-                _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(ax + 1, 4 * ey), pointB], 3), _curve_Arc3d__WEBPACK_IMPORTED_MODULE_20__.Arc3d.createCircularStartMiddleEnd(pointB, pointC1, point0))));
+                _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(ax + 1, 4 * ey),
+                pointB,
+            ], 3), _curve_Arc3d__WEBPACK_IMPORTED_MODULE_20__.Arc3d.createCircularStartMiddleEnd(pointB, pointC1, point0))));
         }
         return result;
     }
@@ -246921,7 +247065,7 @@ class Sample {
         const by = 2.0;
         const result = [
             _curve_UnionRegion__WEBPACK_IMPORTED_MODULE_25__.UnionRegion.create(_curve_Loop__WEBPACK_IMPORTED_MODULE_23__.Loop.create(_curve_LineString3d__WEBPACK_IMPORTED_MODULE_15__.LineString3d.createRectangleXY(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0), ax, ay)), _curve_Loop__WEBPACK_IMPORTED_MODULE_23__.Loop.create(_curve_LineString3d__WEBPACK_IMPORTED_MODULE_15__.LineString3d.createRectangleXY(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 2 * ay, 0), bx, by))),
-            _curve_UnionRegion__WEBPACK_IMPORTED_MODULE_25__.UnionRegion.create(_curve_Loop__WEBPACK_IMPORTED_MODULE_23__.Loop.create(_curve_LineString3d__WEBPACK_IMPORTED_MODULE_15__.LineString3d.create(Sample.createRectangleXY(parityRange.low.x, parityRange.high.y + 0.5, parityRange.xLength(), parityRange.yLength()))), parityRegions[0])
+            _curve_UnionRegion__WEBPACK_IMPORTED_MODULE_25__.UnionRegion.create(_curve_Loop__WEBPACK_IMPORTED_MODULE_23__.Loop.create(_curve_LineString3d__WEBPACK_IMPORTED_MODULE_15__.LineString3d.create(Sample.createRectangleXY(parityRange.low.x, parityRange.high.y + 0.5, parityRange.xLength(), parityRange.yLength()))), parityRegions[0]),
         ];
         return result;
     }
@@ -246940,7 +247084,8 @@ class Sample {
         ];
         return result;
     }
-    /** Assorted smooth curve primitives:
+    /**
+     * Assorted smooth curve primitives:
      * * line segments
      * * arcs
      */
@@ -246955,7 +247100,7 @@ class Sample {
             _curve_Arc3d__WEBPACK_IMPORTED_MODULE_20__.Arc3d.create(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.create(size, alpha * size, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.create(-alpha * beta * size, beta * size, 0), _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createStartEndDegrees(-40, 270)),
         ];
     }
-    /** assorted small polyface grids, possibly expanded by gridMultiplier */
+    /** Assorted small polyface grids, possibly expanded by gridMultiplier */
     static createSimpleIndexedPolyfaces(gridMultiplier) {
         const meshes = [
             Sample.createTriangularUnitGridPolyface(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.unitX(), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.unitY(), gridMultiplier * 3, 2 * gridMultiplier, false, false, false),
@@ -247186,7 +247331,7 @@ class Sample {
             }
         return _bspline_BSplineSurface__WEBPACK_IMPORTED_MODULE_28__.BSplineSurface3dH.create(xyzPoles, weights, numU, orderU, undefined, numV, orderV, undefined);
     }
-    /** assorted linear sweeps */
+    /** Assorted linear sweeps */
     static createSimpleLinearSweeps() {
         const result = [];
         const base = _curve_Loop__WEBPACK_IMPORTED_MODULE_23__.Loop.create(_curve_LineString3d__WEBPACK_IMPORTED_MODULE_15__.LineString3d.createRectangleXY(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(), 2, 3));
@@ -247205,7 +247350,7 @@ class Sample {
         const xyPoints = [
             _geometry3d_Point2dVector2d__WEBPACK_IMPORTED_MODULE_2__.Point2d.create(0, 0),
             _geometry3d_Point2dVector2d__WEBPACK_IMPORTED_MODULE_2__.Point2d.create(1, 0),
-            _geometry3d_Point2dVector2d__WEBPACK_IMPORTED_MODULE_2__.Point2d.create(1, 1)
+            _geometry3d_Point2dVector2d__WEBPACK_IMPORTED_MODULE_2__.Point2d.create(1, 1),
         ];
         result.push(_solid_LinearSweep__WEBPACK_IMPORTED_MODULE_30__.LinearSweep.createZSweep(xyPoints, 1, 3, false));
         // this forces artificial closure point . . .
@@ -247249,7 +247394,7 @@ class Sample {
         for (const axis of [
             _geometry3d_Ray3d__WEBPACK_IMPORTED_MODULE_14__.Ray3d.createXYZUVW(0, 0, 0, 0, 1, 0),
             _geometry3d_Ray3d__WEBPACK_IMPORTED_MODULE_14__.Ray3d.createXYZUVW(5, 0, 0, 0, 1, 0),
-            _geometry3d_Ray3d__WEBPACK_IMPORTED_MODULE_14__.Ray3d.createXYZUVW(-1, 0, 0, -1, 1, 0)
+            _geometry3d_Ray3d__WEBPACK_IMPORTED_MODULE_14__.Ray3d.createXYZUVW(-1, 0, 0, -1, 1, 0),
         ]) {
             result.push(_solid_RotationalSweep__WEBPACK_IMPORTED_MODULE_31__.RotationalSweep.create(base, axis, _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(45.0), false));
             result.push(_solid_RotationalSweep__WEBPACK_IMPORTED_MODULE_31__.RotationalSweep.create(base, axis, _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(150.0), true));
@@ -247274,7 +247419,7 @@ class Sample {
     /** Create true (non-spherical) ellipsoids. */
     static createEllipsoids() {
         return [
-            _solid_Sphere__WEBPACK_IMPORTED_MODULE_32__.Sphere.createEllipsoid(_geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createOriginAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRowValues(4, 1, 1, 1, 4, 1, 0.5, 0.2, 5)), _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createFullLatitude(), true)
+            _solid_Sphere__WEBPACK_IMPORTED_MODULE_32__.Sphere.createEllipsoid(_geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createOriginAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRowValues(4, 1, 1, 1, 4, 1, 0.5, 0.2, 5)), _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createFullLatitude(), true),
         ];
     }
     /** Create assorted cones. */
@@ -247332,8 +247477,7 @@ class Sample {
         result.push(_solid_Box__WEBPACK_IMPORTED_MODULE_35__.Box.createDgnBox(cornerA, frameY.columnX(), frameY.columnY(), cornerA.plusScaled(frameY.columnZ(), h), aX, aY, bX, bY, capped));
         return result;
     }
-    /** create an array of points for a rectangle with corners (x0,y0,z) and (x1,y1,z)
-     */
+    /** Create an array of points for a rectangle with corners (x0,y0,z) and (x1,y1,z) */
     static createRectangle(x0, y0, x1, y1, z = 0.0, closed = false) {
         const points = [
             _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(x0, y0, z),
@@ -247345,8 +247489,7 @@ class Sample {
             points.push(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(x0, y0, z));
         return points;
     }
-    /** create an array of points for a rectangle with corners of a Range2d.
-     */
+    /** Create an array of points for a rectangle with corners of a Range2d. */
     static createRectangleInRange2d(range, z = 0.0, closed = false) {
         const x0 = range.low.x;
         const x1 = range.high.x;
@@ -247455,8 +247598,9 @@ class Sample {
         }
         return points;
     }
-    /** Primary shape is a "triangle" with lower edge pushed in so it becomes a mild nonconvex quad.
-     *  Fractal effects are gentle.
+    /**
+     * Primary shape is a "triangle" with lower edge pushed in so it becomes a mild nonconvex quad.
+     * Fractal effects are gentle.
      */
     static nonConvexQuadSimpleFractal(numRecursion, perpendicularFactor) {
         const pattern = [
@@ -247473,7 +247617,7 @@ class Sample {
         ];
         return Sample.createRecursiveFractalPolygon(poles, pattern, numRecursion, perpendicularFactor);
     }
-    /** create a diamond with convex fractal */
+    /** Create a diamond with convex fractal */
     static createFractalDiamondConvexPattern(numRecursion, perpendicularFactor) {
         const pattern = [
             _geometry3d_Point2dVector2d__WEBPACK_IMPORTED_MODULE_2__.Point2d.create(),
@@ -247570,7 +247714,7 @@ class Sample {
         ];
         return Sample.createRecursiveFractalPolygon(poles, pattern, numRecursion, perpendicularFactor);
     }
-    /** append interpolated points from the array tail to the target. */
+    /** Append interpolated points from the array tail to the target. */
     static appendSplits(points, target, numSplit, includeTarget) {
         const pointA = points[points.length - 1];
         for (let i = 0; i < numSplit; i++)
@@ -247614,7 +247758,8 @@ class Sample {
         geometry.push(_curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_19__.LineSegment3d.createXYZXYZ(x0, y1, z0, x0, y1, z1));
         return geometry;
     }
-    /** Assorted transition spirals
+    /**
+     * Assorted transition spirals
      * * (All combinations of bearing radius bearing radius length subsets.)
      */
     static createSimpleTransitionSpirals() {
@@ -247635,10 +247780,11 @@ class Sample {
             _curve_spiral_DirectSpiral3d__WEBPACK_IMPORTED_MODULE_41__.DirectSpiral3d.createFromLengthAndRadius("ChineseCubic", r0, r1, _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(0), undefined, arcLength, undefined, _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createOriginAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 2, 0), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRotationAroundVector(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.unitZ(), _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(15)))),
             _curve_spiral_DirectSpiral3d__WEBPACK_IMPORTED_MODULE_41__.DirectSpiral3d.createFromLengthAndRadius("JapaneseCubic", r0, r1, _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(0), undefined, arcLength, undefined, _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createOriginAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 2, 0), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRotationAroundVector(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.unitZ(), _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(15)))),
             _curve_spiral_DirectSpiral3d__WEBPACK_IMPORTED_MODULE_41__.DirectSpiral3d.createFromLengthAndRadius("DirectHalfCosine", r0, r1, _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(0), undefined, arcLength, undefined, _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createOriginAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 2, 0), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRotationAroundVector(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Vector3d.unitZ(), _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(15)))),
-            _curve_spiral_DirectSpiral3d__WEBPACK_IMPORTED_MODULE_41__.DirectSpiral3d.createCzechCubic(_geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createIdentity(), arcLength, r1)
+            _curve_spiral_DirectSpiral3d__WEBPACK_IMPORTED_MODULE_41__.DirectSpiral3d.createCzechCubic(_geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createIdentity(), arcLength, r1),
         ];
     }
-    /** Create a Bezier curve with significant twist effects
+    /**
+     * Create a Bezier curve with significant twist effects
      * * r and theta are circle in xy plane at steps in thetaStepper
      * * z varies with sin(phi) at steps in phiStepper.
      */
@@ -247694,18 +247840,10 @@ class Sample {
         result.push(_curve_CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_44__.CurveChainWithDistanceIndex.createCapture(_curve_Path__WEBPACK_IMPORTED_MODULE_21__.Path.create(// arc spline with smooth joins
         _curve_Arc3d__WEBPACK_IMPORTED_MODULE_20__.Arc3d.createXY(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(5, 0), 5, _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createStartEndDegrees(180, 0)), _curve_Arc3d__WEBPACK_IMPORTED_MODULE_20__.Arc3d.createXY(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(15, 0), 5, _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createStartEndDegrees(180, 360)), _curve_Arc3d__WEBPACK_IMPORTED_MODULE_20__.Arc3d.createXY(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(25, 0), 5, _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createStartEndDegrees(180, 0)))));
         result.push(_curve_CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_44__.CurveChainWithDistanceIndex.createCapture(_curve_Path__WEBPACK_IMPORTED_MODULE_21__.Path.create(// 2-pt Interpolation Curve
-        _bspline_InterpolationCurve3d__WEBPACK_IMPORTED_MODULE_45__.InterpolationCurve3d.createCapture(_bspline_InterpolationCurve3d__WEBPACK_IMPORTED_MODULE_45__.InterpolationCurve3dOptions.create({
-            fitPoints: [pointsA[0], pointsA[1]],
-        })))));
+        _bspline_InterpolationCurve3d__WEBPACK_IMPORTED_MODULE_45__.InterpolationCurve3d.createCapture(_bspline_InterpolationCurve3d__WEBPACK_IMPORTED_MODULE_45__.InterpolationCurve3dOptions.create({ fitPoints: [pointsA[0], pointsA[1]] })))));
         result.push(_curve_CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_44__.CurveChainWithDistanceIndex.createCapture(_curve_Path__WEBPACK_IMPORTED_MODULE_21__.Path.create(// 3-pt Interpolation Curve
-        _bspline_InterpolationCurve3d__WEBPACK_IMPORTED_MODULE_45__.InterpolationCurve3d.createCapture(_bspline_InterpolationCurve3d__WEBPACK_IMPORTED_MODULE_45__.InterpolationCurve3dOptions.create({
-            fitPoints: [pointsA[0], pointsA[1], pointsA[2]],
-        })))));
-        result.push(_curve_CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_44__.CurveChainWithDistanceIndex.createCapture(_curve_Path__WEBPACK_IMPORTED_MODULE_21__.Path.create(_bspline_InterpolationCurve3d__WEBPACK_IMPORTED_MODULE_45__.InterpolationCurve3d.createCapture(_bspline_InterpolationCurve3d__WEBPACK_IMPORTED_MODULE_45__.InterpolationCurve3dOptions.create({
-            fitPoints: pointsA,
-            startTangent: _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, -1),
-            endTangent: _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(-1, -1),
-        })))));
+        _bspline_InterpolationCurve3d__WEBPACK_IMPORTED_MODULE_45__.InterpolationCurve3d.createCapture(_bspline_InterpolationCurve3d__WEBPACK_IMPORTED_MODULE_45__.InterpolationCurve3dOptions.create({ fitPoints: [pointsA[0], pointsA[1], pointsA[2]] })))));
+        result.push(_curve_CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_44__.CurveChainWithDistanceIndex.createCapture(_curve_Path__WEBPACK_IMPORTED_MODULE_21__.Path.create(_bspline_InterpolationCurve3d__WEBPACK_IMPORTED_MODULE_45__.InterpolationCurve3d.createCapture(_bspline_InterpolationCurve3d__WEBPACK_IMPORTED_MODULE_45__.InterpolationCurve3dOptions.create({ fitPoints: pointsA, startTangent: _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, -1), endTangent: _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(-1, -1) })))));
         result.push(_curve_CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_44__.CurveChainWithDistanceIndex.createCapture(_curve_Path__WEBPACK_IMPORTED_MODULE_21__.Path.create(_curve_spiral_IntegratedSpiral3d__WEBPACK_IMPORTED_MODULE_39__.IntegratedSpiral3d.createRadiusRadiusBearingBearing(_geometry3d_Segment1d__WEBPACK_IMPORTED_MODULE_40__.Segment1d.create(0, 100), _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createStartEndDegrees(10, 75), _geometry3d_Segment1d__WEBPACK_IMPORTED_MODULE_40__.Segment1d.create(0, 1), _geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createOriginAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.createZero(), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRotationAroundAxisIndex(2, _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(30))), "bloss"))));
         result.push(_curve_CurveChainWithDistanceIndex__WEBPACK_IMPORTED_MODULE_44__.CurveChainWithDistanceIndex.createCapture(_curve_Path__WEBPACK_IMPORTED_MODULE_21__.Path.create(_curve_spiral_DirectSpiral3d__WEBPACK_IMPORTED_MODULE_41__.DirectSpiral3d.createDirectHalfCosine(_geometry3d_Transform__WEBPACK_IMPORTED_MODULE_16__.Transform.createOriginAndMatrix(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.createZero(), _geometry3d_Matrix3d__WEBPACK_IMPORTED_MODULE_12__.Matrix3d.createRotationAroundAxisIndex(2, _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(110))), 50, 350, _geometry3d_Segment1d__WEBPACK_IMPORTED_MODULE_40__.Segment1d.create(0, 1)))));
         return result;
@@ -247789,7 +247927,7 @@ class Sample {
         const sweep2 = _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createStartEndDegrees(160.0, 380.0);
         for (const arcs of [
             Sample.createArcs(1.0), Sample.createArcs(0.5),
-            Sample.createArcs(1.0, sweep1), Sample.createArcs(0.3, sweep2)
+            Sample.createArcs(1.0, sweep1), Sample.createArcs(0.3, sweep2),
         ]) {
             for (const arc of arcs)
                 result.push(arc);
@@ -247892,10 +248030,10 @@ class Sample {
         return points;
     }
     /**
-     * * let ay = 4
-     * * base polygon has vertices (0,0), (ax,0), (2*ax,0), (2* ax,ay), (ax,ay), (0,ay), (0,0).
-     * * shift the x coordinates of vertices 1,4 by indicated amounts (0-based numbering)
-     * * shift the y coordinates for points 1,2,3,4 by indicated amounts (in 0-based numbering)
+     * * Let ay = 4
+     * * Base polygon has vertices (0,0), (ax,0), (2*ax,0), (2* ax,ay), (ax,ay), (0,ay), (0,0).
+     * * Shift the x coordinates of vertices 1,4 by indicated amounts (0-based numbering)
+     * * Shift the y coordinates for points 1,2,3,4 by indicated amounts (in 0-based numbering)
      * * This is useful for testing non-y-monotonic face situations.
      * * Return as points.
      * @param dy1
@@ -247915,7 +248053,7 @@ class Sample {
         return points;
     }
     /**
-     * make line segments for each pair of adjacent points.
+     * Make line segments for each pair of adjacent points.
      * @param points array of points
      * @param forceClosure if true, inspect coordinates to determine if a closure edge is needed.
      */
@@ -248031,7 +248169,8 @@ class Sample {
         this.appendGeometry(this.createBagOfCurves(), result);
         return result;
     }
-    /** Create points on a sine wave
+    /**
+     * Create points on a sine wave
      * Point i is origin + (i * xStep, a *sin(theta0 + i * dTheta), b * sin(beta0 + i * dBeta))
      * * Default b is zero, so it is a simple sine wave
      * * If the dTheta and dBeta are equal, it is a sine wave in a tilted plane.
@@ -248040,8 +248179,9 @@ class Sample {
     static createPointSineWave(origin, numInterval = 24, xStep = Math.PI / 12, a = 1, thetaSweep = _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createStartEndDegrees(0, 360), b = 0, betaSweep = _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createStartEndDegrees(0, 180)) {
         return this.createPointsByIndexFunctions(numInterval, SteppedIndexFunctionFactory.createLinear(xStep, origin ? origin.x : 0), SteppedIndexFunctionFactory.createCosine(a, thetaSweep, origin ? origin.y : 0), SteppedIndexFunctionFactory.createCosine(b, betaSweep, origin ? origin.z : 0));
     }
-    /** Create points with x,y,z independent functions of i and numInterval,
-     *    Point3d.create (fx(i,numInterval), fy(i,numInterval), fz(i, numInterval));
+    /**
+     * Create points with x,y,z independent functions of i and numInterval,
+     * Point3d.create (fx(i,numInterval), fy(i,numInterval), fz(i, numInterval));
      */
     static createPointsByIndexFunctions(numInterval, fx, fy, fz) {
         const points = [];
@@ -248112,9 +248252,7 @@ class Sample {
         builder.addGreedyTriangulationBetweenLineStrings(point0, point1);
         return builder.claimPolyface();
     }
-    /**
-     *  create strokes on an arc at radius r0, then returning at radius r1.
-     */
+    /** Create strokes on an arc at radius r0, then returning at radius r1. */
     static createAnnulusPolyline(edgesPerQuadrant, center, r0, r1, theta0, theta1, addClosure) {
         const point0 = [];
         const point1 = [];
@@ -248184,7 +248322,12 @@ class Sample {
                 for (let yC = 0; yC + 1 <= ySweep; yC++) {
                     const yD = yC + 1;
                     if (acceptFunction(xA, yC))
-                        builder.addPolygon([_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(xA, yC, zA), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(xB, yC, zB), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(xB, yD, zB), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(xA, yD, zA)]);
+                        builder.addPolygon([
+                            _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(xA, yC, zA),
+                            _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(xB, yC, zB),
+                            _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(xB, yD, zB),
+                            _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(xA, yD, zA),
+                        ]);
                 }
             }
         }
@@ -248242,7 +248385,7 @@ Sample.plane3dByOriginAndUnitNormal = [
     _geometry3d_Plane3dByOriginAndUnitNormal__WEBPACK_IMPORTED_MODULE_13__.Plane3dByOriginAndUnitNormal.createYZPlane(),
     _geometry3d_Plane3dByOriginAndUnitNormal__WEBPACK_IMPORTED_MODULE_13__.Plane3dByOriginAndUnitNormal.createZXPlane(),
     Sample.createPlane(0, 0, 0, 3, 0, 1),
-    Sample.createPlane(1, 2, 3, 2, 4, -1)
+    Sample.createPlane(1, 2, 3, 2, 4, -1),
 ];
 /** Assorted Ray3d, not all unit direction vectors. */
 Sample.ray3d = [
@@ -248250,7 +248393,7 @@ Sample.ray3d = [
     Sample.createRay(0, 0, 0, 0, 1, 0),
     Sample.createRay(0, 0, 0, 0, 0, 1),
     Sample.createRay(0, 0, 0, 1, 2, 0),
-    Sample.createRay(1, 2, 3, 4, 2, -1)
+    Sample.createRay(1, 2, 3, 4, 2, -1),
 ];
 /** Assorted angles.  All principal directions, some others included. */
 Sample.angle = [
@@ -248259,7 +248402,7 @@ Sample.angle = [
     _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(180),
     _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(-90),
     _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(30),
-    _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(-105)
+    _geometry3d_Angle__WEBPACK_IMPORTED_MODULE_3__.Angle.createDegrees(-105),
 ];
 /** Assorted angle sweeps */
 Sample.angleSweep = [
@@ -248268,35 +248411,35 @@ Sample.angleSweep = [
     _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createStartEndDegrees(-90, 0),
     _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createStartEndDegrees(0, -90),
     _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createStartEndDegrees(0, 30),
-    _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createStartEndDegrees(45, 110)
+    _geometry3d_AngleSweep__WEBPACK_IMPORTED_MODULE_0__.AngleSweep.createStartEndDegrees(45, 110),
 ];
-/** assorted line segments */
+/** Assorted line segments */
 Sample.lineSegment3d = [
     _curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_19__.LineSegment3d.create(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 0, 0)),
     _curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_19__.LineSegment3d.create(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 1, 0)),
     _curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_19__.LineSegment3d.create(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 0), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(0, 0, 1)),
-    _curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_19__.LineSegment3d.create(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 2, 3), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(-2, -3, 0.5))
+    _curve_LineSegment3d__WEBPACK_IMPORTED_MODULE_19__.LineSegment3d.create(_geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(1, 2, 3), _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_1__.Point3d.create(-2, -3, 0.5)),
 ];
-/** Assorted Range1d:   single point, null, simple forward, simple reverse */
+/** Assorted Range1d: single point, null, simple forward, simple reverse */
 Sample.range1d = [
     _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range1d.createX(1),
     _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range1d.createNull(),
     _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range1d.createXX(1, 2),
-    _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range1d.createXX(2, 1)
+    _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range1d.createXX(2, 1),
 ];
 /** Assorted range2d: single point, null, 2 point with various creation orders. */
 Sample.range2d = [
     _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range2d.createXY(1, 2),
     _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range2d.createNull(),
     _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range2d.createXYXY(1, 2, 0, 3),
-    _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range2d.createXYXY(1, 2, 3, 4)
+    _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range2d.createXYXY(1, 2, 3, 4),
 ];
 /** Assorted range2d: single point, null, 2 point with various creation orders. */
 Sample.range3d = [
     _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range3d.createXYZ(1, 2, 3),
     _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range3d.createNull(),
     _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range3d.createXYZXYZ(1, 2, 0, 3, 4, 7),
-    _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range3d.createXYZXYZ(1, 2, 3, -2, -4, -1)
+    _geometry3d_Range__WEBPACK_IMPORTED_MODULE_4__.Range3d.createXYZXYZ(1, 2, 3, -2, -4, -1),
 ];
 
 
@@ -288775,7 +288918,7 @@ module.exports = JSON.parse('{"name":"axios","version":"0.21.4","description":"P
 /***/ ((module) => {
 
 "use strict";
-module.exports = JSON.parse('{"name":"@itwin/core-frontend","version":"4.0.0-dev.55","description":"iTwin.js frontend components","main":"lib/cjs/core-frontend.js","module":"lib/esm/core-frontend.js","typings":"lib/cjs/core-frontend","license":"MIT","scripts":{"build":"npm run -s copy:public && npm run -s build:cjs","build:ci":"npm run -s build && npm run -s build:esm","build:cjs":"npm run -s copy:js:cjs && tsc 1>&2 --outDir lib/cjs","build:esm":"npm run -s copy:js:esm && tsc 1>&2 --module ES2020 --outDir lib/esm","clean":"rimraf lib .rush/temp/package-deps*.json","copy:public":"cpx \\"./src/public/**/*\\" ./lib/public","copy:js:cjs":"cpx \\"./src/**/*.js\\" ./lib/cjs","copy:js:esm":"cpx \\"./src/**/*.js\\" ./lib/esm","docs":"betools docs --includes=../../generated-docs/extract --json=../../generated-docs/core/core-frontend/file.json --tsIndexFile=./core-frontend.ts --onlyJson --excludes=webgl/**/*,**/primitives,**/map/*.d.ts,**/tile/*.d.ts,**/*-css.ts","extract-api":"betools extract-api --entry=core-frontend && npm run extract-extension-api","extract-extension-api":"eslint --no-eslintrc -c \\"./node_modules/@itwin/eslint-plugin/dist/configs/extension-exports-config.js\\" \\"./src/**/*.ts\\" 1>&2","lint":"eslint -f visualstudio \\"./src/**/*.ts\\" 1>&2","pseudolocalize":"betools pseudolocalize --englishDir ./src/public/locales/en --out ./public/locales/en-PSEUDO","test":"npm run -s webpackTests && certa -r chrome","cover":"npm -s test","test:debug":"certa -r chrome --debug","webpackTests":"webpack --config ./src/test/utils/webpack.config.js 1>&2"},"repository":{"type":"git","url":"https://github.com/iTwin/itwinjs-core/tree/master/core/frontend"},"keywords":["Bentley","BIM","iModel","digital-twin","iTwin"],"author":{"name":"Bentley Systems, Inc.","url":"http://www.bentley.com"},"peerDependencies":{"@itwin/appui-abstract":"workspace:^4.0.0-dev.55","@itwin/core-bentley":"workspace:^4.0.0-dev.55","@itwin/core-common":"workspace:^4.0.0-dev.55","@itwin/core-geometry":"workspace:^4.0.0-dev.55","@itwin/core-orbitgt":"workspace:^4.0.0-dev.55","@itwin/core-quantity":"workspace:^4.0.0-dev.55"},"//devDependencies":["NOTE: All peerDependencies should also be listed as devDependencies since peerDependencies are not considered by npm install","NOTE: All tools used by scripts in this package must be listed as devDependencies"],"devDependencies":{"@itwin/appui-abstract":"workspace:*","@itwin/build-tools":"workspace:*","@itwin/core-bentley":"workspace:*","@itwin/core-common":"workspace:*","@itwin/core-geometry":"workspace:*","@itwin/core-orbitgt":"workspace:*","@itwin/core-quantity":"workspace:*","@itwin/certa":"workspace:*","@itwin/eslint-plugin":"^4.0.0-dev.32","@itwin/webgl-compatibility":"workspace:*","@types/chai":"4.3.1","@types/chai-as-promised":"^7","@types/deep-assign":"^0.1.0","@types/mocha":"^8.2.2","@types/node":"^18.11.5","@types/qs":"^6.5.0","@types/semver":"7.3.10","@types/superagent":"^4.1.14","@types/sinon":"^9.0.0","babel-loader":"~8.2.5","babel-plugin-istanbul":"~6.1.1","chai":"^4.1.2","chai-as-promised":"^7","cpx2":"^3.0.0","eslint":"^7.11.0","glob":"^7.1.2","mocha":"^10.0.0","nyc":"^15.1.0","rimraf":"^3.0.2","sinon":"^9.0.2","source-map-loader":"^4.0.0","typescript":"~5.0.2","webpack":"^5.76.0"},"//dependencies":["NOTE: these dependencies should be only for things that DO NOT APPEAR IN THE API","NOTE: core-frontend should remain UI technology agnostic, so no react/angular dependencies are allowed"],"dependencies":{"@itwin/object-storage-azure":"^1.5.0","@itwin/cloud-agnostic-core":"^1.5.0","@itwin/object-storage-core":"^1.5.0","@itwin/core-i18n":"workspace:*","@itwin/core-telemetry":"workspace:*","@itwin/webgl-compatibility":"workspace:*","@loaders.gl/core":"^3.1.6","@loaders.gl/draco":"^3.1.6","deep-assign":"^2.0.0","fuse.js":"^3.3.0","qs":"^6.5.3","semver":"^7.3.5","superagent":"^7.1.5","wms-capabilities":"0.4.0","reflect-metadata":"0.1.13"},"nyc":{"extends":"./node_modules/@itwin/build-tools/.nycrc"},"eslintConfig":{"plugins":["@itwin"],"extends":"plugin:@itwin/itwinjs-recommended","rules":{"@itwin/no-internal-barrel-imports":["error",{"required-barrel-modules":["./src/tile/internal.ts"]}],"@itwin/public-extension-exports":["error",{"releaseTags":["public","preview"],"outputApiFile":false}]},"overrides":[{"files":["*.test.ts","*.test.tsx","**/test/**/*.ts"],"rules":{"@itwin/no-internal-barrel-imports":"off"}}]}}');
+module.exports = JSON.parse('{"name":"@itwin/core-frontend","version":"4.0.0-dev.58","description":"iTwin.js frontend components","main":"lib/cjs/core-frontend.js","module":"lib/esm/core-frontend.js","typings":"lib/cjs/core-frontend","license":"MIT","scripts":{"build":"npm run -s copy:public && npm run -s build:cjs","build:ci":"npm run -s build && npm run -s build:esm","build:cjs":"npm run -s copy:js:cjs && tsc 1>&2 --outDir lib/cjs","build:esm":"npm run -s copy:js:esm && tsc 1>&2 --module ES2020 --outDir lib/esm","clean":"rimraf lib .rush/temp/package-deps*.json","copy:public":"cpx \\"./src/public/**/*\\" ./lib/public","copy:js:cjs":"cpx \\"./src/**/*.js\\" ./lib/cjs","copy:js:esm":"cpx \\"./src/**/*.js\\" ./lib/esm","docs":"betools docs --includes=../../generated-docs/extract --json=../../generated-docs/core/core-frontend/file.json --tsIndexFile=./core-frontend.ts --onlyJson --excludes=webgl/**/*,**/primitives,**/map/*.d.ts,**/tile/*.d.ts,**/*-css.ts","extract-api":"betools extract-api --entry=core-frontend && npm run extract-extension-api","extract-extension-api":"eslint --no-eslintrc -c \\"./node_modules/@itwin/eslint-plugin/dist/configs/extension-exports-config.js\\" \\"./src/**/*.ts\\" 1>&2","lint":"eslint -f visualstudio \\"./src/**/*.ts\\" 1>&2","pseudolocalize":"betools pseudolocalize --englishDir ./src/public/locales/en --out ./public/locales/en-PSEUDO","test":"npm run -s webpackTests && certa -r chrome","cover":"npm -s test","test:debug":"certa -r chrome --debug","webpackTests":"webpack --config ./src/test/utils/webpack.config.js 1>&2"},"repository":{"type":"git","url":"https://github.com/iTwin/itwinjs-core/tree/master/core/frontend"},"keywords":["Bentley","BIM","iModel","digital-twin","iTwin"],"author":{"name":"Bentley Systems, Inc.","url":"http://www.bentley.com"},"peerDependencies":{"@itwin/appui-abstract":"workspace:^4.0.0-dev.58","@itwin/core-bentley":"workspace:^4.0.0-dev.58","@itwin/core-common":"workspace:^4.0.0-dev.58","@itwin/core-geometry":"workspace:^4.0.0-dev.58","@itwin/core-orbitgt":"workspace:^4.0.0-dev.58","@itwin/core-quantity":"workspace:^4.0.0-dev.58"},"//devDependencies":["NOTE: All peerDependencies should also be listed as devDependencies since peerDependencies are not considered by npm install","NOTE: All tools used by scripts in this package must be listed as devDependencies"],"devDependencies":{"@itwin/appui-abstract":"workspace:*","@itwin/build-tools":"workspace:*","@itwin/core-bentley":"workspace:*","@itwin/core-common":"workspace:*","@itwin/core-geometry":"workspace:*","@itwin/core-orbitgt":"workspace:*","@itwin/core-quantity":"workspace:*","@itwin/certa":"workspace:*","@itwin/eslint-plugin":"^4.0.0-dev.32","@itwin/webgl-compatibility":"workspace:*","@types/chai":"4.3.1","@types/chai-as-promised":"^7","@types/deep-assign":"^0.1.0","@types/mocha":"^8.2.2","@types/node":"^18.11.5","@types/qs":"^6.5.0","@types/semver":"7.3.10","@types/superagent":"^4.1.14","@types/sinon":"^9.0.0","babel-loader":"~8.2.5","babel-plugin-istanbul":"~6.1.1","chai":"^4.1.2","chai-as-promised":"^7","cpx2":"^3.0.0","eslint":"^7.11.0","glob":"^7.1.2","mocha":"^10.0.0","nyc":"^15.1.0","rimraf":"^3.0.2","sinon":"^9.0.2","source-map-loader":"^4.0.0","typescript":"~5.0.2","webpack":"^5.76.0"},"//dependencies":["NOTE: these dependencies should be only for things that DO NOT APPEAR IN THE API","NOTE: core-frontend should remain UI technology agnostic, so no react/angular dependencies are allowed"],"dependencies":{"@itwin/object-storage-azure":"^1.5.0","@itwin/cloud-agnostic-core":"^1.5.0","@itwin/object-storage-core":"^1.5.0","@itwin/core-i18n":"workspace:*","@itwin/core-telemetry":"workspace:*","@itwin/webgl-compatibility":"workspace:*","@loaders.gl/core":"^3.1.6","@loaders.gl/draco":"^3.1.6","deep-assign":"^2.0.0","fuse.js":"^3.3.0","qs":"^6.5.3","semver":"^7.3.5","superagent":"^7.1.5","wms-capabilities":"0.4.0","reflect-metadata":"0.1.13"},"nyc":{"extends":"./node_modules/@itwin/build-tools/.nycrc"},"eslintConfig":{"plugins":["@itwin"],"extends":"plugin:@itwin/itwinjs-recommended","rules":{"@itwin/no-internal-barrel-imports":["error",{"required-barrel-modules":["./src/tile/internal.ts"]}],"@itwin/public-extension-exports":["error",{"releaseTags":["public","preview"],"outputApiFile":false}]},"overrides":[{"files":["*.test.ts","*.test.tsx","**/test/**/*.ts"],"rules":{"@itwin/no-internal-barrel-imports":"off"}}]}}');
 
 /***/ })