@itwin/ecschema-rpcinterface-tests 3.6.0-dev.14 → 3.6.0-dev.22

package/lib/dist/bundled-tests.js

@@ -21,9 +21,9 @@
 
 /***/ }),
 
-/***/ "../../common/temp/node_modules/.pnpm/@itwin+certa@3.4.7/node_modules/@itwin/certa/lib/utils/CallbackUtils.js":
+/***/ "../../common/temp/node_modules/.pnpm/@itwin+certa@3.5.1/node_modules/@itwin/certa/lib/utils/CallbackUtils.js":
 /*!********************************************************************************************************************!*\
-  !*** ../../common/temp/node_modules/.pnpm/@itwin+certa@3.4.7/node_modules/@itwin/certa/lib/utils/CallbackUtils.js ***!
+  !*** ../../common/temp/node_modules/.pnpm/@itwin+certa@3.5.1/node_modules/@itwin/certa/lib/utils/CallbackUtils.js ***!
   \********************************************************************************************************************/
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
@@ -2772,7 +2772,7 @@ exports.getAccessTokenFromBackend = exports.getTokenCallbackName = void 0;
 * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
 * See LICENSE.md in the project root for license terms and full copyright notice.
 *--------------------------------------------------------------------------------------------*/
-const CallbackUtils_1 = __webpack_require__(/*! @itwin/certa/lib/utils/CallbackUtils */ "../../common/temp/node_modules/.pnpm/@itwin+certa@3.4.7/node_modules/@itwin/certa/lib/utils/CallbackUtils.js");
+const CallbackUtils_1 = __webpack_require__(/*! @itwin/certa/lib/utils/CallbackUtils */ "../../common/temp/node_modules/.pnpm/@itwin+certa@3.5.1/node_modules/@itwin/certa/lib/utils/CallbackUtils.js");
 // Shared by both the frontend and backend side of the tests
 exports.getTokenCallbackName = "getToken";
 async function getAccessTokenFromBackend(user, oidcConfig) {
@@ -49015,8 +49015,16 @@ class TransientIdSequence {
     constructor() {
         this._localId = 0;
     }
+    /** Generate and return the next transient Id64String in the sequence.
+     * @deprecated Use [[getNext]].
+     */
+    get next() {
+        return this.getNext();
+    }
     /** Generate and return the next transient Id64String in the sequence. */
-    get next() { return Id64.fromLocalAndBriefcaseIds(++this._localId, 0xffffff); }
+    getNext() {
+        return Id64.fromLocalAndBriefcaseIds(++this._localId, 0xffffff);
+    }
 }
 /**
  * The Guid namespace provides facilities for working with GUID strings using the "8-4-4-4-12" pattern.
@@ -95483,7 +95491,7 @@ class AccuDraw {
         if (context.viewport.viewFlags.acsTriad) {
             context.viewport.view.auxiliaryCoordinateSystem.display(context, (_AuxCoordSys__WEBPACK_IMPORTED_MODULE_4__.ACSDisplayOptions.CheckVisible | _AuxCoordSys__WEBPACK_IMPORTED_MODULE_4__.ACSDisplayOptions.Active));
             if (undefined === this._acsPickId)
-                this._acsPickId = context.viewport.iModel.transientIds.next;
+                this._acsPickId = context.viewport.iModel.transientIds.getNext();
             const acsPickBuilder = context.createGraphicBuilder(_render_GraphicBuilder__WEBPACK_IMPORTED_MODULE_7__.GraphicType.WorldDecoration, undefined, this._acsPickId);
             const color = _itwin_core_common__WEBPACK_IMPORTED_MODULE_2__.ColorDef.blue.adjustedForContrast(context.viewport.view.backgroundColor, 50);
             acsPickBuilder.setSymbology(color, color, 6);
@@ -123862,7 +123870,6 @@ class RealityMeshParamsBuilder {
      * @returns the index of the new vertex in [[positions]].
      */
     addQuantizedVertex(position, uv, normal) {
-        (0,_itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.assert)(this.positions.length < 0xffff, "RealityMeshParams supports no more than 64k vertices");
         (0,_itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.assert)((undefined === normal) === (undefined === this.normals), "RealityMeshParams requires all vertices to have normals, or none.");
         this.positions.push(position);
         this.uvs.push(uv);
@@ -123889,7 +123896,6 @@ class RealityMeshParamsBuilder {
             this.addIndex(index);
     }
     addIndex(index) {
-        (0,_itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.assert)(index <= 0xffff, "RealityMeshParams supports no more than 64k vertices");
         this.indices.push(index);
     }
     /** Extract the finished [[RealityMeshParams]]. */
@@ -130694,6 +130700,7 @@ class BranchState {
     get viewFlags() { return this._opts.viewFlags; }
     set viewFlags(vf) { this._opts.viewFlags = vf.normalize(); }
     get clipVolume() { return this._opts.clipVolume; }
+    get forceViewCoords() { return true === this._opts.forceViewCoords; }
     get planarClassifier() { return this._opts.planarClassifier; }
     get textureDrape() { return this._opts.textureDrape; }
     get edgeSettings() { return this._opts.edgeSettings; }
@@ -130725,6 +130732,7 @@ class BranchState {
             planarClassifier: (undefined !== branch.planarClassifier && undefined !== branch.planarClassifier.texture) ? branch.planarClassifier : prev.planarClassifier,
             textureDrape: (_c = branch.textureDrape) !== null && _c !== void 0 ? _c : prev.textureDrape,
             clipVolume: branch.clips,
+            forceViewCoords: prev.forceViewCoords,
             edgeSettings: (_d = branch.edgeSettings) !== null && _d !== void 0 ? _d : prev.edgeSettings,
             is3d: (_f = (_e = branch.frustum) === null || _e === void 0 ? void 0 : _e.is3d) !== null && _f !== void 0 ? _f : prev.is3d,
             frustumScale: (_h = (_g = branch.frustum) === null || _g === void 0 ? void 0 : _g.scale) !== null && _h !== void 0 ? _h : prev.frustumScale,
@@ -130743,6 +130751,9 @@ class BranchState {
         const vf = new _itwin_core_common__WEBPACK_IMPORTED_MODULE_1__.ViewFlags({ renderMode: _itwin_core_common__WEBPACK_IMPORTED_MODULE_1__.RenderMode.SmoothShade, lighting: false, whiteOnWhiteReversal: false });
         return new BranchState({ viewFlags: vf, transform: _itwin_core_geometry__WEBPACK_IMPORTED_MODULE_0__.Transform.createIdentity(), symbologyOverrides: new _FeatureSymbology__WEBPACK_IMPORTED_MODULE_2__.FeatureSymbology.Overrides(), edgeSettings: _EdgeSettings__WEBPACK_IMPORTED_MODULE_3__.EdgeSettings.create(undefined), is3d: true });
     }
+    withViewCoords() {
+        return new BranchState({ ...this._opts, forceViewCoords: true });
+    }
 }
 
 
@@ -132643,7 +132654,9 @@ class DrawParams {
     get target() { return this.programParams.target; }
     get renderPass() { return this.programParams.renderPass; }
     get projectionMatrix() { return this.programParams.projectionMatrix; }
-    get isViewCoords() { return this.programParams.isViewCoords; }
+    get isViewCoords() {
+        return this.programParams.isViewCoords || this.target.currentBranch.forceViewCoords;
+    }
     get isOverlayPass() { return this.programParams.isOverlayPass; }
     get context() { return this.programParams.context; }
     init(programParams, geometry) {
@@ -139560,18 +139573,26 @@ class RenderCommands {
         this._commands.forEach((cmds) => cmds.splice(0));
         this._layers.clear();
     }
-    initForPickOverlays(sceneOverlays, overlayDecorations) {
+    initForPickOverlayDecorations(overlays) {
+        for (const overlay of overlays) {
+            const gf = overlay;
+            if (gf.isPickable)
+                gf.addCommands(this);
+        }
+    }
+    initForPickOverlays(sceneOverlays, worldOverlayDecorations, viewOverlayDecorations) {
         this._clearCommands();
         this._addTranslucentAsOpaque = true;
         for (const sceneGf of sceneOverlays)
             sceneGf.addCommands(this);
-        if (undefined !== overlayDecorations) {
+        if (worldOverlayDecorations === null || worldOverlayDecorations === void 0 ? void 0 : worldOverlayDecorations.length) {
             this.pushAndPopState(this.target.decorationsState, () => {
-                for (const overlay of overlayDecorations) {
-                    const gf = overlay;
-                    if (gf.isPickable)
-                        gf.addCommands(this);
-                }
+                this.initForPickOverlayDecorations(worldOverlayDecorations);
+            });
+        }
+        if (viewOverlayDecorations === null || viewOverlayDecorations === void 0 ? void 0 : viewOverlayDecorations.length) {
+            this.pushAndPopState(this.target.decorationsState.withViewCoords(), () => {
+                this.initForPickOverlayDecorations(viewOverlayDecorations);
             });
         }
         this._addTranslucentAsOpaque = false;
@@ -141154,7 +141175,7 @@ class Compositor extends SceneCompositor {
         this.target.popViewClip();
     }
     get fullHeight() { return this.target.viewRect.height; }
-    drawForReadPixels(commands, sceneOverlays, overlayDecorations) {
+    drawForReadPixels(commands, sceneOverlays, worldOverlayDecorations, viewOverlayDecorations) {
         this.target.beginPerfMetricRecord("Render Background", true);
         if (!this.preDraw()) {
             this.target.endPerfMetricRecord(true); // End Render Background record if returning
@@ -141195,11 +141216,11 @@ class Compositor extends SceneCompositor {
             this.target.endPerfMetricRecord(true);
             this.target.popViewClip();
         }
-        if (0 === sceneOverlays.length && (undefined === overlayDecorations || 0 === overlayDecorations.length))
+        if (!sceneOverlays.length && !(worldOverlayDecorations === null || worldOverlayDecorations === void 0 ? void 0 : worldOverlayDecorations.length) && !(viewOverlayDecorations === null || viewOverlayDecorations === void 0 ? void 0 : viewOverlayDecorations.length))
             return;
         // Now populate the opaque passes with any pickable world overlays
         this.target.beginPerfMetricRecord("Overlay Draws", true);
-        commands.initForPickOverlays(sceneOverlays, overlayDecorations);
+        commands.initForPickOverlays(sceneOverlays, worldOverlayDecorations, viewOverlayDecorations);
         if (commands.isEmpty) {
             this.target.endPerfMetricRecord(true); // End Overlay Draws record if returning
             return;
@@ -146730,7 +146751,7 @@ class Target extends _RenderTarget__WEBPACK_IMPORTED_MODULE_8__.RenderTarget {
     get frameStatsCollector() { return this._frameStatsCollector; }
     assignFrameStatsCollector(collector) { this._frameStatsCollector = collector; }
     paintScene(sceneMilSecElapsed) {
-        var _a;
+        var _a, _b;
         if (!this._dcAssigned)
             return;
         this._frameStatsCollector.beginTime("totalFrameTime");
@@ -146745,7 +146766,7 @@ class Target extends _RenderTarget__WEBPACK_IMPORTED_MODULE_8__.RenderTarget {
         // Set this to true to visualize the output of readPixels()...useful for debugging pick.
         if (this.drawForReadPixels) {
             this.beginReadPixels(_Pixel__WEBPACK_IMPORTED_MODULE_6__.Pixel.Selector.Feature);
-            this.compositor.drawForReadPixels(this._renderCommands, this.graphics.overlays, (_a = this.graphics.decorations) === null || _a === void 0 ? void 0 : _a.worldOverlay);
+            this.compositor.drawForReadPixels(this._renderCommands, this.graphics.overlays, (_a = this.graphics.decorations) === null || _a === void 0 ? void 0 : _a.worldOverlay, (_b = this.graphics.decorations) === null || _b === void 0 ? void 0 : _b.viewOverlay);
             this.endReadPixels();
         }
         else {
@@ -146931,7 +146952,7 @@ class Target extends _RenderTarget__WEBPACK_IMPORTED_MODULE_8__.RenderTarget {
         this._isReadPixelsInProgress = false;
     }
     readPixelsFromFbo(rect, selector) {
-        var _a;
+        var _a, _b;
         // Create a culling frustum based on the input rect. We can't do this if a screen-space effect is going to move pixels around.
         let rectFrust;
         if (!this.renderSystem.screenSpaceEffects.shouldApply(this)) {
@@ -146962,7 +146983,7 @@ class Target extends _RenderTarget__WEBPACK_IMPORTED_MODULE_8__.RenderTarget {
         }
         this.beginReadPixels(selector, rectFrust);
         // Draw the scene
-        this.compositor.drawForReadPixels(this._renderCommands, this.graphics.overlays, (_a = this.graphics.decorations) === null || _a === void 0 ? void 0 : _a.worldOverlay);
+        this.compositor.drawForReadPixels(this._renderCommands, this.graphics.overlays, (_a = this.graphics.decorations) === null || _a === void 0 ? void 0 : _a.worldOverlay, (_b = this.graphics.decorations) === null || _b === void 0 ? void 0 : _b.viewOverlay);
         if (this.performanceMetrics && !this.performanceMetrics.gatherCurPerformanceMetrics) { // Only collect readPixels data if in disp-perf-test-app
             this.performanceMetrics.endOperation(); // End the 'CPU Total Time' operation
             if (this.performanceMetrics.gatherGlFinish && !this.renderSystem.isGLTimerSupported) {
@@ -158700,7 +158721,7 @@ class BatchedTileIdMap {
         const key = JSON.stringify(properties);
         let entry = this._featureMap.get(key);
         if (undefined === entry) {
-            const id = this._iModel.transientIds.next;
+            const id = this._iModel.transientIds.getNext();
             entry = { id, properties };
             this._featureMap.set(key, entry);
             this._idMap.set(id, properties);
@@ -165061,7 +165082,7 @@ class RealityModelTileTree extends _internal__WEBPACK_IMPORTED_MODULE_7__.Realit
         constructor(props) {
             super();
             this._name = undefined !== props.name ? props.name : "";
-            this._modelId = props.modelId ? props.modelId : props.iModel.transientIds.next;
+            this._modelId = props.modelId ? props.modelId : props.iModel.transientIds.getNext();
             let transform;
             if (undefined !== props.tilesetToDbTransform) {
                 const tf = _itwin_core_geometry__WEBPACK_IMPORTED_MODULE_2__.Transform.fromJSON(props.tilesetToDbTransform);
@@ -172795,7 +172816,7 @@ class ImageryMapLayerTreeSupplier {
         if (undefined === imageryProvider)
             return undefined;
         await imageryProvider.initialize();
-        const modelId = iModel.transientIds.next;
+        const modelId = iModel.transientIds.getNext();
         const tilingScheme = imageryProvider.tilingScheme;
         const rootLevel = (1 === tilingScheme.numberOfLevelZeroTilesX && 1 === tilingScheme.numberOfLevelZeroTilesY) ? 0 : -1;
         const rootTileId = new _internal__WEBPACK_IMPORTED_MODULE_4__.QuadId(rootLevel, 0, 0).contentId;
@@ -175359,7 +175380,7 @@ class MapTreeSupplier {
     async createTileTree(id, iModel) {
         let bimElevationBias = 0, terrainProvider, geodeticOffset = 0;
         let applyTerrain = id.applyTerrain;
-        const modelId = iModel.transientIds.next;
+        const modelId = iModel.transientIds.getNext();
         const gcsConverterAvailable = await getGcsConverterAvailable(iModel);
         const terrainOpts = {
             wantSkirts: id.wantSkirts,
@@ -179409,7 +179430,7 @@ class ViewClipDecoration extends _EditManipulator__WEBPACK_IMPORTED_MODULE_8__.E
         this._suspendDecorator = false;
         if (!this.getClipData())
             return;
-        this._clipId = this.iModel.transientIds.next;
+        this._clipId = this.iModel.transientIds.getNext();
         this.updateDecorationListener(true);
         this._removeViewCloseListener = _IModelApp__WEBPACK_IMPORTED_MODULE_6__.IModelApp.viewManager.onViewClose.addListener(this.onViewClose, this); // eslint-disable-line @typescript-eslint/unbound-method
         if (undefined !== this._clipEventHandler && this._clipEventHandler.selectOnCreate())
@@ -179491,7 +179512,7 @@ class ViewClipDecoration extends _EditManipulator__WEBPACK_IMPORTED_MODULE_8__.E
         if (numCurrent < numReqControls) {
             const transientIds = this.iModel.transientIds;
             for (let i = numCurrent; i < numReqControls; i++)
-                this._controlIds[i] = transientIds.next;
+                this._controlIds[i] = transientIds.getNext();
         }
         else if (numCurrent > numReqControls) {
             this._controlIds.length = numReqControls;
@@ -181796,7 +181817,7 @@ class MeasureDistanceTool extends _PrimitiveTool__WEBPACK_IMPORTED_MODULE_11__.P
         if (undefined === snapPoints)
             return;
         if (undefined === this._snapGeomId)
-            this._snapGeomId = this.iModel.transientIds.next;
+            this._snapGeomId = this.iModel.transientIds.getNext();
         const builderSnapPts = context.createGraphicBuilder(_render_GraphicBuilder__WEBPACK_IMPORTED_MODULE_10__.GraphicType.WorldOverlay, undefined, this._snapGeomId);
         const colorAccPts = _itwin_core_common__WEBPACK_IMPORTED_MODULE_2__.ColorDef.white.adjustedForContrast(context.viewport.view.backgroundColor);
         builderSnapPts.setSymbology(colorAccPts, _itwin_core_common__WEBPACK_IMPORTED_MODULE_2__.ColorDef.black, 7);
@@ -228066,11 +228087,13 @@ __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.
+ * * This class bakes in angle rotation directions via create functions (i.e., createRadians, createDegrees, and
+ * createAngles) so you can define each of the 3 rotations to be clockwise or counterclockwise. The default
+ * rotation is counterclockwise.
  * * Within the imodel geometry library, the preferred rotation order is encapsulated in `YawPitchRollAngles`.
  * @alpha
  */
@@ -228122,7 +228145,7 @@ class OrderedRotationAngles {
     get zRadians() {
         return this._z.radians;
     }
-    /** 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;
     }
@@ -228130,68 +228153,81 @@ class OrderedRotationAngles {
         OrderedRotationAngles._sTreatVectorsAsColumns = value;
     }
     /**
-     * Create an OrderedRotationAngles from three angles and an ordering in which to apply them when rotating.
-     * @param xRotation rotation around x
-     * @param yRotation rotation around y
-     * @param zRotation rotation around z
+     * Create an OrderedRotationAngles from three angles (in radians), an ordering in which to apply them when
+     * rotating, and a flag triple controlling whether direction of x,y,z is clockwise or counterclockwise.
+     * @param xRadians rotation around x
+     * @param yRadians rotation around y
+     * @param zRadians rotation around z
      * @param order left to right order of axis names identifies the order that rotations are applied.
      * For example XYZ means to rotate around x axis first, then y axis, and finally Z axis.
      * * Note that rotation order is reverse of rotation matrix multiplication so for XYZ the rotation
      * matrix multiplication would be zRot*yRot*xRot
-     */
-    static createAngles(xRotation, yRotation, zRotation, order, result) {
+     * @param xyzRotationIsClockwise the flags controlling whether direction of x,y,z is clockwise or counterclockwise.
+     * rotation direction of x,y,z: true ---> clockwise - false ---> counterclockwise.
+     * * if xyzRotationIsClockwise is undefined it's set to [false, false, false].
+     * @param result caller-allocated OrderedRotationAngles
+     */
+    static createRadians(xRadians, yRadians, zRadians, order, xyzRotationIsClockwise, result) {
+        if (!xyzRotationIsClockwise) {
+            xyzRotationIsClockwise = [false, false, false];
+        }
+        const xRadian = xyzRotationIsClockwise[0] ? -xRadians : xRadians;
+        const yRadian = xyzRotationIsClockwise[1] ? -yRadians : yRadians;
+        const zRadian = xyzRotationIsClockwise[2] ? -zRadians : zRadians;
         if (result) {
-            result._x.setFrom(xRotation);
-            result._y.setFrom(yRotation);
-            result._z.setFrom(zRotation);
+            result._x.setRadians(xRadian);
+            result._y.setRadians(yRadian);
+            result._z.setRadians(zRadian);
             result._order = order;
             return result;
         }
-        return new OrderedRotationAngles(xRotation.clone(), yRotation.clone(), zRotation.clone(), order);
+        return new OrderedRotationAngles(_Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createRadians(xRadian), _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createRadians(yRadian), _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createRadians(zRadian), order);
     }
     /**
-     * Create an OrderedRotationAngles from three angles (in radians) and an ordering in which to apply
+     * Create an OrderedRotationAngles from three angles (in degrees) and an ordering in which to apply
      * them when rotating.
-     * @param xRadians rotation around x
-     * @param yRadians rotation around y
-     * @param zRadians rotation around z
+     * @param xDegrees rotation around x
+     * @param yDegrees rotation around y
+     * @param zDegrees rotation around z
      * @param order left to right order of axis names identifies the order that rotations are applied.
      * For example XYZ means to rotate around x axis first, then y axis, and finally Z axis.
      * * Note that rotation order is reverse of rotation matrix multiplication so for XYZ the rotation
      * matrix multiplication would be zRot*yRot*xRot
+     * @param xyzRotationIsClockwise the flags controlling whether direction of x,y,z is clockwise or counterclockwise.
+     * rotation direction of x,y,z: true ---> clockwise - false ---> counterclockwise.
+     * * if xyzRotationIsClockwise is undefined it's set to [false, false, false].
+     * @param result caller-allocated OrderedRotationAngles
      */
-    static createRadians(xRadians, yRadians, zRadians, order, result) {
-        if (result) {
-            result._x.setRadians(xRadians);
-            result._y.setRadians(yRadians);
-            result._z.setRadians(zRadians);
-            result._order = order;
-            return result;
-        }
-        return new OrderedRotationAngles(_Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createRadians(xRadians), _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createRadians(yRadians), _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createRadians(zRadians), order);
+    static createDegrees(xDegrees, yDegrees, zDegrees, order, xyzRotationIsClockwise, result) {
+        return OrderedRotationAngles.createRadians(_Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.degreesToRadians(xDegrees), _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.degreesToRadians(yDegrees), _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.degreesToRadians(zDegrees), order, xyzRotationIsClockwise, result);
     }
     /**
-     * Create an OrderedRotationAngles from three angles (in degrees) and an ordering in which to apply
-     * them when rotating.
-     * @param xRadians rotation around x
-     * @param yRadians rotation around y
-     * @param zRadians rotation around z
-     * @param order left to right order of axis names identifies the order that rotations are applied.
+     * Create an OrderedRotationAngles from three angles, an ordering in which to apply them when rotating,
+     * and a flag triple controlling whether direction of x,y,z is clockwise or counterclockwise.
+     * @param xRotation rotation around x
+     * @param yRotation rotation around y
+     * @param zRotation rotation around z
+     * @param order left to right order of axis names identifies the order that rotations are applied
      * For example XYZ means to rotate around x axis first, then y axis, and finally Z axis.
      * * Note that rotation order is reverse of rotation matrix multiplication so for XYZ the rotation
      * matrix multiplication would be zRot*yRot*xRot
+     * @param xyzRotationIsClockwise the flags controlling whether direction of x,y,z is clockwise or counterclockwise.
+     * rotation direction of x,y,z: true ---> clockwise - false ---> counterclockwise.
+     * * if xyzRotationIsClockwise is undefined it's set to [false, false, false].
+     * @param result caller-allocated OrderedRotationAngles
      */
-    static createDegrees(xDegrees, yDegrees, zDegrees, order, result) {
-        if (result) {
-            result._x.setDegrees(xDegrees);
-            result._y.setDegrees(yDegrees);
-            result._z.setDegrees(zDegrees);
-            result._order = order;
-            return result;
-        }
-        return new OrderedRotationAngles(_Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createDegrees(xDegrees), _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createDegrees(yDegrees), _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createDegrees(zDegrees), order);
+    static createAngles(xRotation, yRotation, zRotation, order, xyzRotationIsClockwise, result) {
+        return OrderedRotationAngles.createRadians(xRotation.radians, yRotation.radians, zRotation.radians, order, xyzRotationIsClockwise, result);
     }
-    /** Create an OrderedRotationAngles from a 3x3 rotational matrix, given the ordering of axis rotations that the matrix derives from. */
+    /**
+     * Create an OrderedRotationAngles from a 3x3 rotational matrix, given the ordering of axis rotations
+     * that the matrix derives from.
+     * * This function creates an OrderedRotationAngles with default angle rotation directions, i.e.,
+     * it assumes all x, y, and z rotations are counterclockwise.
+     * * 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];
@@ -228214,13 +228250,19 @@ class OrderedRotationAngles {
                     zRad = Math.atan2(m21, m11);
                 }
                 else {
-                    /*
-                    * If Math.abs(m31) = 1 then yRad = 90 degrees and therefore, we have a gimbal lock.
-                    * This means xRad and zRad can be anything as long as their sum xRad + zRad is constant.
-                    * so we can pick zRad = 0 and calculate xRad (or pick xRad = 0 and calculate zRad).
-                    * Math details can be found
-                    * https://en.wikipedia.org/wiki/Gimbal_lock#Loss_of_a_degree_of_freedom_with_Euler_angles
-                    */
+                    /**
+                     * If Math.abs(m31) = 1 then yRad = +-90 degrees and therefore, we have a gimbal lock.
+                     * This means xRad and zRad can be anything as long as their sum xRad + zRad is constant.
+                     * so we can pick zRad = 0 and calculate xRad (or pick xRad = 0 and calculate zRad).
+                     * Therefore, rotation matrix becomes
+                     *        Matrix3d.createRowValues(
+                     *             0, +-sx, +-cx,
+                     *             0, cx, -sx,
+                     *             -+1, 0, 0
+                     *        );
+                     * Math details can be found
+                     * https://en.wikipedia.org/wiki/Gimbal_lock#Loss_of_a_degree_of_freedom_with_Euler_angles
+                     */
                     xRad = Math.atan2(-m23, m22);
                     zRad = 0;
                 }
@@ -228290,7 +228332,21 @@ class OrderedRotationAngles {
                 xRad = yRad = zRad = 0;
             }
         }
-        return OrderedRotationAngles.createRadians(xRad, yRad, zRad, order, result);
+        const xyzRotationIsClockwise = [false, false, false];
+        const angles = OrderedRotationAngles.createRadians(xRad, yRad, zRad, order, xyzRotationIsClockwise, result);
+        // sanity check
+        const matrix1 = angles.toMatrix3d();
+        /**
+         * Below tolerance loosened to allow sanity check to pass for
+         *
+         * OrderedRotationAngles.createFromMatrix3d(
+         *       OrderedRotationAngles.createDegrees(0, 89.999, 0.001, AxisOrder.XYZ).toMatrix3d(),
+         *       AxisOrder.XYZ
+         * );
+         *
+         * with treatVectorsAsColumns = true.
+         */
+        return (matrix.maxDiff(matrix1) < 10 * _Geometry__WEBPACK_IMPORTED_MODULE_1__.Geometry.smallFraction) ? angles : undefined;
     }
     /**
      * Create a 3x3 rotational matrix from this OrderedRotationAngles.
@@ -237385,39 +237441,62 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
-// cspell:word Tait
-/** Three angles that determine the orientation of an object in space. Sometimes referred to as [Tait–Bryan angles](https://en.wikipedia.org/wiki/Euler_angles).
+/**
+ * Three angles that determine the orientation of an object in space, sometimes referred to as [Tait–Bryan angles]
+ * (https://en.wikipedia.org/wiki/Euler_angles).
  * * The matrix construction can be replicated by this logic:
  * * xyz coordinates have
  *   * x forward
  *   * y to left
  *   * z up
- *   * Note that this is a right handed coordinate system.
- *   * yaw is a rotation of x towards y, i.e. around positive z:
+ * * Note that this is a right handed coordinate system.
+ * * yaw is a rotation of x towards y, i.e. around positive z (counterclockwise):
  *     * `yawMatrix = Matrix3d.createRotationAroundAxisIndex(2, Angle.createDegrees(yawDegrees));`
- *   * pitch is a rotation that raises x towards z, i.e. rotation around negative y:
+ * * pitch is a rotation that raises x towards z, i.e. rotation around **negative y** (**clockwise**):
  *     * `pitchMatrix = Matrix3d.createRotationAroundAxisIndex(1, Angle.createDegrees(-pitchDegrees));`
- *   * roll is rotation of y towards z, i.e. rotation around positive x:
+ * * roll is rotation of y towards z, i.e. rotation around positive x (counterclockwise):
  *     * `rollMatrix = Matrix3d.createRotationAroundAxisIndex(0, Angle.createDegrees(rollDegrees));`
- *   * The YPR matrix is the product
+ * * The YPR matrix is the product
  *     * `result = yawMatrix.multiplyMatrixMatrix(pitchMatrix.multiplyMatrixMatrix(rollMatrix));`
- *   * Note that this is for "column based" matrix, with vectors appearing to the right
- *     * Hence a vector is first rotated by roll, then the pitch, finally yaw.
+ * * Note that this is for "column based" matrix with vectors multiplying on the right of the matrix.
+ * Hence a vector is first rotated by roll, then the pitch, finally yaw. So multiplication order in
+ * the sense of AxisOrder is `RPY` (i.e., XYZ), in contrast to the familiar name `YPR`.
  * @public
  */
 class YawPitchRollAngles {
+    /**
+     * 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;
         this.roll = roll;
     }
     /** Freeze this YawPitchRollAngles */
-    freeze() { this.yaw.freeze(); this.pitch.freeze(); this.roll.freeze(); return Object.freeze(this); }
-    /** constructor for YawPitchRollAngles with angles in degrees. */
+    freeze() {
+        this.yaw.freeze();
+        this.pitch.freeze();
+        this.roll.freeze();
+        return Object.freeze(this);
+    }
+    /**
+     * 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));
     }
@@ -237433,7 +237512,10 @@ class YawPitchRollAngles {
         this.pitch = _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.fromJSON(json.pitch);
         this.roll = _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.fromJSON(json.roll);
     }
-    /** Convert to a JSON object of form { pitch: 20 , roll: 29.999999999999996 , yaw: 10 }. Any values that are exactly zero (with tolerance `Geometry.smallAngleRadians`) are omitted. */
+    /**
+     * 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)
@@ -237454,7 +237536,7 @@ class YawPitchRollAngles {
         this.roll.setFrom(other.roll);
     }
     /**
-     * * Compare angles between `this` and `other`.
+     * Compare angles between `this` and `other`.
      * * Comparisons are via `isAlmostEqualAllowPeriodShift`.
      * @param other YawPitchRollAngles source
      */
@@ -237466,30 +237548,47 @@ class YawPitchRollAngles {
     /**
      * Make a copy of this YawPitchRollAngles.
      */
-    clone() { return new YawPitchRollAngles(this.yaw.clone(), this.pitch.clone(), this.roll.clone()); }
+    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" -- unit length rows and columns, and its transpose is its inverse.
-     * * The "rigid" matrix is always a right handed coordinate system.
+     * * 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`
      */
     toMatrix3d(result) {
-        const c0 = Math.cos(this.yaw.radians);
-        const s0 = Math.sin(this.yaw.radians);
-        const c1 = Math.cos(this.pitch.radians);
-        const s1 = Math.sin(this.pitch.radians);
-        const c2 = Math.cos(this.roll.radians);
-        const s2 = Math.sin(this.roll.radians);
-        return _Matrix3d__WEBPACK_IMPORTED_MODULE_1__.Matrix3d.createRowValues(c0 * c1, -(s0 * c2 + c0 * s1 * s2), (s0 * s2 - c0 * s1 * c2), s0 * c1, (c0 * c2 - s0 * s1 * s2), -(c0 * s2 + s0 * s1 * c2), s1, c1 * s2, c1 * c2, result);
-    }
-    /** Return the largest angle in radians */
-    maxAbsRadians() {
-        return _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.maxAbsXYZ(this.yaw.radians, this.pitch.radians, this.roll.radians);
-    }
-    /** Return the sum of the angles in squared radians */
-    sumSquaredRadians() {
-        return _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.hypotenuseSquaredXYZ(this.yaw.radians, this.pitch.radians, this.roll.radians);
+        const cz = Math.cos(this.yaw.radians);
+        const sz = Math.sin(this.yaw.radians);
+        const cy = Math.cos(this.pitch.radians);
+        const sy = Math.sin(this.pitch.radians);
+        const cx = Math.cos(this.roll.radians);
+        const sx = Math.sin(this.roll.radians);
+        /**
+        * The axis order is XYZ (i.e., RPY) so the rotation matrix is calculated via rZ*rY*rX where
+        * rX, rY, and rZ are base rotation matrixes:
+        *
+        *     const rX = Matrix3d.createRowValues(
+        *        1, 0, 0,
+        *        0, Math.cos(x), -Math.sin(x),
+        *        0, Math.sin(x), Math.cos(x),
+        *      );
+        *      const rY = Matrix3d.createRowValues(
+        *        Math.cos(y), 0, Math.sin(y),
+        *        0, 1, 0,
+        *        -Math.sin(y), 0, Math.cos(y),
+        *      );
+        *      const rZ = Matrix3d.createRowValues(
+        *        Math.cos(z), -Math.sin(z), 0,
+        *        Math.sin(z), Math.cos(z), 0,
+        *        0, 0, 1,
+        *      );
+        *
+        * Then we replace sin(y) with -sin(y) because y rotation (i.e., pitch) is clockwise (alternatively, you
+        * can use transpose of rY in the matrix multiplication to get the same result)
+        */
+        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.
      * * If allowPeriodShift is false, any nonzero angle is considered a non-identity
@@ -237505,52 +237604,104 @@ class YawPitchRollAngles {
                 && _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.isAlmostEqualRadiansNoPeriodShift(0.0, this.pitch.radians)
                 && _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.isAlmostEqualRadiansNoPeriodShift(0.0, this.roll.radians);
     }
+    /** Return the largest angle in radians */
+    maxAbsRadians() {
+        return _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.maxAbsXYZ(this.yaw.radians, this.pitch.radians, this.roll.radians);
+    }
+    /** Return the sum of the angles in squared radians */
+    sumSquaredRadians() {
+        return _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.hypotenuseSquaredXYZ(this.yaw.radians, this.pitch.radians, this.roll.radians);
+    }
     /** Return the largest difference of angles (in radians) between this and other */
     maxDiffRadians(other) {
         return Math.max(this.yaw.radians - other.yaw.radians, this.pitch.radians - other.pitch.radians, this.roll.radians - other.roll.radians);
     }
     /** Return the largest angle in degrees. */
-    maxAbsDegrees() { return _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.maxAbsXYZ(this.yaw.degrees, this.pitch.degrees, this.roll.degrees); }
+    maxAbsDegrees() {
+        return _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.maxAbsXYZ(this.yaw.degrees, this.pitch.degrees, this.roll.degrees);
+    }
     /** Return the sum of squared angles in degrees. */
-    sumSquaredDegrees() { return _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.hypotenuseSquaredXYZ(this.yaw.degrees, this.pitch.degrees, this.roll.degrees); }
+    sumSquaredDegrees() {
+        return _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.hypotenuseSquaredXYZ(this.yaw.degrees, this.pitch.degrees, this.roll.degrees);
+    }
+    /** Return the largest difference of angles (in degrees) between this and other */
+    maxDiffDegrees(other) {
+        return Math.max(this.yaw.degrees - other.yaw.degrees, this.pitch.degrees - other.pitch.degrees, this.roll.degrees - other.roll.degrees);
+    }
     /** Return an object from a Transform as an origin and YawPitchRollAngles. */
     static tryFromTransform(transform) {
-        // bundle up the transform's origin with the angle data extracted from the transform
         return {
-            angles: YawPitchRollAngles.createFromMatrix3d(transform.matrix),
             origin: _Point3dVector3d__WEBPACK_IMPORTED_MODULE_3__.Point3d.createFrom(transform.origin),
+            angles: YawPitchRollAngles.createFromMatrix3d(transform.matrix),
         };
     }
-    /** Attempts to create a YawPitchRollAngles object from an Matrix3d
-     * * This conversion fails if the matrix is not rigid (unit rows and columns, transpose is inverse)
+    /** 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 a set of angles.
+     * * In the failure case, if the optional result was supplied, that result will nonetheless be filled with
+     * a set of angles.
      */
     static createFromMatrix3d(matrix, result) {
-        const s1 = matrix.at(2, 0);
-        const c1 = Math.sqrt(matrix.at(2, 1) * matrix.at(2, 1) + matrix.at(2, 2) * matrix.at(2, 2));
-        const pitchA = _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createAtan2(s1, c1); // with positive cosine
-        const pitchB = _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createAtan2(s1, -c1); // with negative cosine
-        const angles = result ? result : new YawPitchRollAngles(); // default undefined . . .
-        if (c1 < _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.smallAngleRadians) { // This is a radians test !!!
+        /**
+         * The rotation matrix for is
+         *
+         * 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
+         * );
+         *
+         * where cx = cos(x), sx = sin(x), cy = cos(y), sy = sin(y), cz = cos(z), and sz = sin(z)
+         */
+        const sy = matrix.at(2, 0); // sin(y)
+        const cy = Math.sqrt(matrix.at(2, 1) * matrix.at(2, 1) + matrix.at(2, 2) * matrix.at(2, 2)); // |cos(y)|
+        const pitchA = _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createAtan2(sy, cy); // with positive cosine
+        const pitchB = _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createAtan2(sy, -cy); // with negative cosine
+        const angles = result ? result : new YawPitchRollAngles();
+        /**
+         * If cos(y) = 0 then y = +-90 degrees so we have a gimbal lock.
+         * This means x and z can be anything as long as their sum x + z is constant.
+         * so we can pick z = 0 and calculate x (or pick x = 0 and calculate z).
+         * Math details can be found
+         * https://en.wikipedia.org/wiki/Gimbal_lock#Loss_of_a_degree_of_freedom_with_Euler_angles
+         *
+         * The rotation matrix for y = +-90 degrees and x = 0 becomes
+         *
+         * Matrix3d.createRowValues(
+         *      0, -sz, -+cz,
+         *      0, cz, -+sz,
+         *      +-1, 0, 0
+         * );
+         *
+         * so z = atan(sz/cz) = atan(-matrix.at(0, 1), matrix.at(1, 1))
+         */
+        if (cy < _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.smallAngleRadians) {
             angles.yaw = _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createAtan2(-matrix.at(0, 1), matrix.at(1, 1));
-            angles.pitch = pitchA;
+            angles.pitch = pitchA; // this is an arbitrary choice. can pick pitchB instead.
             angles.roll = _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createRadians(0.0);
         }
         else {
+            /**
+             * positive cosine
+             * z = atan(sz/cz) = atan(matrix.at(1, 0), matrix.at(0, 0))
+             * x = atan(sx/cx) = atan(matrix.at(2, 1), matrix.at(2, 2))
+             */
             const yawA = _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createAtan2(matrix.at(1, 0), matrix.at(0, 0));
             const rollA = _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createAtan2(matrix.at(2, 1), matrix.at(2, 2));
+            // similar with negative cosine
             const yawB = _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createAtan2(-matrix.at(1, 0), -matrix.at(0, 0));
             const rollB = _Angle__WEBPACK_IMPORTED_MODULE_0__.Angle.createAtan2(-matrix.at(2, 1), -matrix.at(2, 2));
+            // create YPR
             const yprA = new YawPitchRollAngles(yawA, pitchA, rollA);
             const yprB = new YawPitchRollAngles(yawB, pitchB, rollB);
+            // decide to pick yprA or yprB with smallest magnitude angles
             const absFactor = 0.95;
-            const radiansA = yprA.maxAbsRadians();
-            const radiansB = yprB.maxAbsRadians();
-            if (radiansA < absFactor * radiansB) {
+            const maxRadiansA = yprA.maxAbsRadians();
+            const maxRadiansB = yprB.maxAbsRadians();
+            if (maxRadiansA < absFactor * maxRadiansB) {
                 angles.setFrom(yprA);
             }
-            else if (radiansB < absFactor * radiansA) {
+            else if (maxRadiansB < absFactor * maxRadiansA) {
                 angles.setFrom(yprB);
             }
             else {
@@ -237564,6 +237715,7 @@ class YawPitchRollAngles {
                 }
             }
         }
+        // sanity check
         const matrix1 = angles.toMatrix3d();
         return matrix.maxDiff(matrix1) < _Geometry__WEBPACK_IMPORTED_MODULE_2__.Geometry.smallAngleRadians ? angles : undefined;
     }
@@ -250531,6 +250683,85 @@ class PolyfaceQuery {
         const inertiaProducts = PolyfaceQuery.sumFacetSecondVolumeMomentProducts(source, origin);
         return _geometry4d_MomentData__WEBPACK_IMPORTED_MODULE_7__.MomentData.inertiaProductsToPrincipalAxes(origin, inertiaProducts);
     }
+    /**
+     * Test for convex volume by dihedral angle tests on all edges.
+     * * This tests if all dihedral angles are positive.
+     * * In a closed solid, this is a strong test for overall convexity.
+     * * With `ignoreBoundaries` true, this may be a useful test when all the facets are in a single edge-connected component, such as a pyramid with no underside.
+     * * It is not a correct test if there are multiple, disjoint components.
+     *   * Take the above-mentioned pyramid with no underside.
+     *   * Within the same mesh, have a second pyramid placed to the side, still facing upward.
+     *   * The angles will pass the dihedral convexity test, but the composite thing surely is not convex.
+     * @param source mesh to examine
+     * @param ignoreBoundaries if true, ignore simple boundary edges, i.e. allow unclosed meshes.
+     * @returns true if the mesh is closed and has all dihedral angles (angle across edge) positive
+     */
+    static isConvexByDihedralAngleCount(source, ignoreBoundaries = false) {
+        return this.dihedralAngleSummary(source, ignoreBoundaries) > 0;
+    }
+    /**
+    * Compute a number summarizing the dihedral angles in the mesh.
+    * @see [[isConvexByDihedralAngleCount]] for comments about ignoreBoundaries===true when there are multiple connected components.
+    * @param source mesh to examine
+    * @param ignoreBoundaries if true, ignore simple boundary edges, i.e. allow unclosed meshes.
+    * @returns a number summarizing the dihedral angles in the mesh.
+    *   * Return 1 if all angles are positive or planar.  The mesh is probably convex with outward normals.
+    *   * Return -1 if all angles are negative or planar.  The mesh is probably convex with inward normals.
+    *   * Return 0 if
+    *     * angles area mixed
+    *     * any edge has other than 1 incident facet or more than 2 incident facets.
+    *     * (but null edges are permitted -- These occur naturally at edges of quads at north or south pole)
+    */
+    static dihedralAngleSummary(source, ignoreBoundaries = false) {
+        const edges = new _IndexedEdgeMatcher__WEBPACK_IMPORTED_MODULE_9__.IndexedEdgeMatcher();
+        const visitor = source.createVisitor(1);
+        visitor.reset();
+        const centroidNormal = [];
+        let normalCounter = 0;
+        while (visitor.moveToNextFacet()) {
+            const numEdges = visitor.pointCount - 1;
+            const normal = _geometry3d_PolygonOps__WEBPACK_IMPORTED_MODULE_4__.PolygonOps.centroidAreaNormal(visitor.point);
+            if (normal === undefined)
+                return 0;
+            centroidNormal.push(normal);
+            for (let i = 0; i < numEdges; i++) {
+                edges.addEdge(visitor.clientPointIndex(i), visitor.clientPointIndex(i + 1), normalCounter);
+            }
+            normalCounter++;
+        }
+        const badClusters = [];
+        const manifoldClusters = [];
+        edges.sortAndCollectClusters(manifoldClusters, ignoreBoundaries ? undefined : badClusters, undefined, badClusters);
+        if (badClusters.length > 0)
+            return 0;
+        let numPositive = 0;
+        let numPlanar = 0;
+        let numNegative = 0;
+        const edgeVector = _geometry3d_Point3dVector3d__WEBPACK_IMPORTED_MODULE_6__.Vector3d.create();
+        for (const cluster of manifoldClusters) {
+            const sideA = cluster.at(0);
+            const sideB = cluster.at(1);
+            if (sideA instanceof _IndexedEdgeMatcher__WEBPACK_IMPORTED_MODULE_9__.SortableEdge
+                && sideB instanceof _IndexedEdgeMatcher__WEBPACK_IMPORTED_MODULE_9__.SortableEdge
+                && source.data.point.vectorIndexIndex(sideA.vertexIndexA, sideA.vertexIndexB, edgeVector)) {
+                const dihedralAngle = centroidNormal[sideA.facetIndex].direction.signedAngleTo(centroidNormal[sideB.facetIndex].direction, edgeVector);
+                if (dihedralAngle.isAlmostZero)
+                    numPlanar++;
+                else if (dihedralAngle.radians > 0.0)
+                    numPositive++;
+                else
+                    numNegative++;
+            }
+        }
+        if (numPositive > 0 && numNegative === 0)
+            return 1;
+        if (numNegative > 0 && numPositive === 0)
+            return -1;
+        // problem case: if all edges have zero dihedral angle, record it as convex.
+        if (numPlanar > 0 && numPositive === 0 && numNegative === 0)
+            return 1;
+        return 0;
+    }
     /**
      * Test if the facets in `source` occur in perfectly mated pairs, as is required for a closed manifold volume.
      */
@@ -302349,7 +302580,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":"3.6.0-dev.14","description":"iTwin.js frontend components","main":"lib/cjs/core-frontend.js","module":"lib/esm/core-frontend.js","typings":"lib/cjs/core-frontend","license":"MIT","scripts":{"build":"npm run -s copy:public && npm run -s build:cjs","build:ci":"npm run -s build && npm run -s build:esm","build:cjs":"npm run -s copy:js:cjs && tsc 1>&2 --outDir lib/cjs","build:esm":"npm run -s copy:js:esm && tsc 1>&2 --module ES2020 --outDir lib/esm","clean":"rimraf lib .rush/temp/package-deps*.json","copy:public":"cpx \\"./src/public/**/*\\" ./lib/public","copy:js:cjs":"cpx \\"./src/**/*.js\\" ./lib/cjs","copy:js:esm":"cpx \\"./src/**/*.js\\" ./lib/esm","docs":"betools docs --includes=../../generated-docs/extract --json=../../generated-docs/core/core-frontend/file.json --tsIndexFile=./core-frontend.ts --onlyJson --excludes=webgl/**/*,**/primitives,**/map/*.d.ts,**/tile/*.d.ts,**/*-css.ts","extract-api":"betools extract-api --entry=core-frontend && npm run extract-extension-api","extract-extension-api":"eslint --no-eslintrc -c \\"../../tools/eslint-plugin/dist/configs/extension-exports-config.js\\" \\"./src/**/*.ts\\" 1>&2","lint":"eslint -f visualstudio \\"./src/**/*.ts\\" 1>&2","pseudolocalize":"betools pseudolocalize --englishDir ./src/public/locales/en --out ./public/locales/en-PSEUDO","test":"npm run -s webpackTests && certa -r chrome","cover":"npm -s test","test:debug":"certa -r chrome --debug","webpackTests":"webpack --config ./src/test/utils/webpack.config.js 1>&2"},"repository":{"type":"git","url":"https://github.com/iTwin/itwinjs-core/tree/master/core/frontend"},"keywords":["Bentley","BIM","iModel","digital-twin","iTwin"],"author":{"name":"Bentley Systems, Inc.","url":"http://www.bentley.com"},"peerDependencies":{"@itwin/appui-abstract":"workspace:^3.6.0-dev.14","@itwin/core-bentley":"workspace:^3.6.0-dev.14","@itwin/core-common":"workspace:^3.6.0-dev.14","@itwin/core-geometry":"workspace:^3.6.0-dev.14","@itwin/core-orbitgt":"workspace:^3.6.0-dev.14","@itwin/core-quantity":"workspace:^3.6.0-dev.14","@itwin/webgl-compatibility":"workspace:^3.6.0-dev.14"},"//devDependencies":["NOTE: All peerDependencies should also be listed as devDependencies since peerDependencies are not considered by npm install","NOTE: All tools used by scripts in this package must be listed as devDependencies"],"devDependencies":{"@itwin/appui-abstract":"workspace:*","@itwin/build-tools":"workspace:*","@itwin/core-bentley":"workspace:*","@itwin/core-common":"workspace:*","@itwin/core-geometry":"workspace:*","@itwin/core-orbitgt":"workspace:*","@itwin/core-quantity":"workspace:*","@itwin/certa":"workspace:*","@itwin/eslint-plugin":"workspace:*","@itwin/webgl-compatibility":"workspace:*","@types/chai":"4.3.1","@types/chai-as-promised":"^7","@types/deep-assign":"^0.1.0","@types/lodash":"^4.14.0","@types/mocha":"^8.2.2","@types/node":"18.11.5","@types/qs":"^6.5.0","@types/semver":"7.3.10","@types/superagent":"^4.1.14","@types/sinon":"^9.0.0","babel-loader":"~8.2.5","babel-plugin-istanbul":"~6.1.1","chai":"^4.1.2","chai-as-promised":"^7","cpx2":"^3.0.0","eslint":"^7.11.0","glob":"^7.1.2","mocha":"^10.0.0","nyc":"^15.1.0","rimraf":"^3.0.2","sinon":"^9.0.2","source-map-loader":"^4.0.0","typescript":"~4.4.0","webpack":"^5.64.4"},"//dependencies":["NOTE: these dependencies should be only for things that DO NOT APPEAR IN THE API","NOTE: core-frontend should remain UI technology agnostic, so no react/angular dependencies are allowed"],"dependencies":{"@itwin/object-storage-azure":"~1.4.0","@itwin/cloud-agnostic-core":"~1.4.0","@itwin/object-storage-core":"~1.4.0","@itwin/core-i18n":"workspace:*","@itwin/core-telemetry":"workspace:*","@loaders.gl/core":"^3.1.6","@loaders.gl/draco":"^3.1.6","deep-assign":"^2.0.0","fuse.js":"^3.3.0","lodash":"^4.17.10","qs":"^6.5.3","semver":"^7.3.5","superagent":"^7.1.5","wms-capabilities":"0.4.0","reflect-metadata":"0.1.13"},"nyc":{"extends":"./node_modules/@itwin/build-tools/.nycrc"},"eslintConfig":{"plugins":["@itwin"],"extends":"plugin:@itwin/itwinjs-recommended","rules":{"@itwin/no-internal-barrel-imports":["error",{"required-barrel-modules":["./src/tile/internal.ts"]}],"@itwin/public-extension-exports":["error",{"releaseTags":["public","preview"],"outputApiFile":false}]},"overrides":[{"files":["*.test.ts","*.test.tsx","**/test/**/*.ts"],"rules":{"@itwin/no-internal-barrel-imports":"off"}}]}}');
+module.exports = JSON.parse('{"name":"@itwin/core-frontend","version":"3.6.0-dev.22","description":"iTwin.js frontend components","main":"lib/cjs/core-frontend.js","module":"lib/esm/core-frontend.js","typings":"lib/cjs/core-frontend","license":"MIT","scripts":{"build":"npm run -s copy:public && npm run -s build:cjs","build:ci":"npm run -s build && npm run -s build:esm","build:cjs":"npm run -s copy:js:cjs && tsc 1>&2 --outDir lib/cjs","build:esm":"npm run -s copy:js:esm && tsc 1>&2 --module ES2020 --outDir lib/esm","clean":"rimraf lib .rush/temp/package-deps*.json","copy:public":"cpx \\"./src/public/**/*\\" ./lib/public","copy:js:cjs":"cpx \\"./src/**/*.js\\" ./lib/cjs","copy:js:esm":"cpx \\"./src/**/*.js\\" ./lib/esm","docs":"betools docs --includes=../../generated-docs/extract --json=../../generated-docs/core/core-frontend/file.json --tsIndexFile=./core-frontend.ts --onlyJson --excludes=webgl/**/*,**/primitives,**/map/*.d.ts,**/tile/*.d.ts,**/*-css.ts","extract-api":"betools extract-api --entry=core-frontend && npm run extract-extension-api","extract-extension-api":"eslint --no-eslintrc -c \\"../../tools/eslint-plugin/dist/configs/extension-exports-config.js\\" \\"./src/**/*.ts\\" 1>&2","lint":"eslint -f visualstudio \\"./src/**/*.ts\\" 1>&2","pseudolocalize":"betools pseudolocalize --englishDir ./src/public/locales/en --out ./public/locales/en-PSEUDO","test":"npm run -s webpackTests && certa -r chrome","cover":"npm -s test","test:debug":"certa -r chrome --debug","webpackTests":"webpack --config ./src/test/utils/webpack.config.js 1>&2"},"repository":{"type":"git","url":"https://github.com/iTwin/itwinjs-core/tree/master/core/frontend"},"keywords":["Bentley","BIM","iModel","digital-twin","iTwin"],"author":{"name":"Bentley Systems, Inc.","url":"http://www.bentley.com"},"peerDependencies":{"@itwin/appui-abstract":"workspace:^3.6.0-dev.22","@itwin/core-bentley":"workspace:^3.6.0-dev.22","@itwin/core-common":"workspace:^3.6.0-dev.22","@itwin/core-geometry":"workspace:^3.6.0-dev.22","@itwin/core-orbitgt":"workspace:^3.6.0-dev.22","@itwin/core-quantity":"workspace:^3.6.0-dev.22","@itwin/webgl-compatibility":"workspace:^3.6.0-dev.22"},"//devDependencies":["NOTE: All peerDependencies should also be listed as devDependencies since peerDependencies are not considered by npm install","NOTE: All tools used by scripts in this package must be listed as devDependencies"],"devDependencies":{"@itwin/appui-abstract":"workspace:*","@itwin/build-tools":"workspace:*","@itwin/core-bentley":"workspace:*","@itwin/core-common":"workspace:*","@itwin/core-geometry":"workspace:*","@itwin/core-orbitgt":"workspace:*","@itwin/core-quantity":"workspace:*","@itwin/certa":"workspace:*","@itwin/eslint-plugin":"workspace:*","@itwin/webgl-compatibility":"workspace:*","@types/chai":"4.3.1","@types/chai-as-promised":"^7","@types/deep-assign":"^0.1.0","@types/lodash":"^4.14.0","@types/mocha":"^8.2.2","@types/node":"18.11.5","@types/qs":"^6.5.0","@types/semver":"7.3.10","@types/superagent":"^4.1.14","@types/sinon":"^9.0.0","babel-loader":"~8.2.5","babel-plugin-istanbul":"~6.1.1","chai":"^4.1.2","chai-as-promised":"^7","cpx2":"^3.0.0","eslint":"^7.11.0","glob":"^7.1.2","mocha":"^10.0.0","nyc":"^15.1.0","rimraf":"^3.0.2","sinon":"^9.0.2","source-map-loader":"^4.0.0","typescript":"~4.4.0","webpack":"^5.64.4"},"//dependencies":["NOTE: these dependencies should be only for things that DO NOT APPEAR IN THE API","NOTE: core-frontend should remain UI technology agnostic, so no react/angular dependencies are allowed"],"dependencies":{"@itwin/object-storage-azure":"~1.4.0","@itwin/cloud-agnostic-core":"~1.4.0","@itwin/object-storage-core":"~1.4.0","@itwin/core-i18n":"workspace:*","@itwin/core-telemetry":"workspace:*","@loaders.gl/core":"^3.1.6","@loaders.gl/draco":"^3.1.6","deep-assign":"^2.0.0","fuse.js":"^3.3.0","lodash":"^4.17.10","qs":"^6.5.3","semver":"^7.3.5","superagent":"^7.1.5","wms-capabilities":"0.4.0","reflect-metadata":"0.1.13"},"nyc":{"extends":"./node_modules/@itwin/build-tools/.nycrc"},"eslintConfig":{"plugins":["@itwin"],"extends":"plugin:@itwin/itwinjs-recommended","rules":{"@itwin/no-internal-barrel-imports":["error",{"required-barrel-modules":["./src/tile/internal.ts"]}],"@itwin/public-extension-exports":["error",{"releaseTags":["public","preview"],"outputApiFile":false}]},"overrides":[{"files":["*.test.ts","*.test.tsx","**/test/**/*.ts"],"rules":{"@itwin/no-internal-barrel-imports":"off"}}]}}');
 
 /***/ })