uicore-ts 1.1.375 → 1.1.377

package/compiledScripts/UIAutocompleteTextField.d.ts

@@ -39,6 +39,7 @@ export declare class UIAutocompleteTextField<T = string> extends UITextField {
         readonly UpArrowDown: "UpArrowDown";
         readonly Focus: "Focus";
         readonly Blur: "Blur";
+        readonly ScrollWheel: "ScrollWheel";
     } & {
         TextChange: string;
         ValidationChange: string;

package/compiledScripts/UIBaseButton.d.ts

@@ -23,6 +23,7 @@ export declare class UIBaseButton extends UIView {
         readonly UpArrowDown: "UpArrowDown";
         readonly Focus: "Focus";
         readonly Blur: "Blur";
+        readonly ScrollWheel: "ScrollWheel";
     } & {
         readonly PrimaryActionTriggered: "PrimaryActionTriggered";
     };
@@ -49,6 +50,7 @@ export declare class UIBaseButton extends UIView {
         readonly UpArrowDown: "UpArrowDown";
         readonly Focus: "Focus";
         readonly Blur: "Blur";
+        readonly ScrollWheel: "ScrollWheel";
     } & {
         readonly PrimaryActionTriggered: "PrimaryActionTriggered";
     };

package/compiledScripts/UIDateTimeInput.d.ts

@@ -24,6 +24,7 @@ export declare class UIDateTimeInput extends UIView {
         readonly UpArrowDown: "UpArrowDown";
         readonly Focus: "Focus";
         readonly Blur: "Blur";
+        readonly ScrollWheel: "ScrollWheel";
     } & {
         ValueChange: string;
     };

package/compiledScripts/UILinkButton.d.ts

@@ -27,6 +27,7 @@ export declare class UILinkButton extends UILink {
         readonly UpArrowDown: "UpArrowDown";
         readonly Focus: "Focus";
         readonly Blur: "Blur";
+        readonly ScrollWheel: "ScrollWheel";
     } & {
         readonly PrimaryActionTriggered: "PrimaryActionTriggered";
     } & {
@@ -55,6 +56,7 @@ export declare class UILinkButton extends UILink {
         readonly UpArrowDown: "UpArrowDown";
         readonly Focus: "Focus";
         readonly Blur: "Blur";
+        readonly ScrollWheel: "ScrollWheel";
     } & {
         readonly PrimaryActionTriggered: "PrimaryActionTriggered";
     } & {

package/compiledScripts/UIRectangle.d.ts

@@ -2,7 +2,40 @@ import { UIObject } from "./UIObject";
 import { UIPoint } from "./UIPoint";
 import { UIView } from "./UIView";
 export type SizeNumberOrFunctionOrView = number | ((constrainingOrthogonalSize: number) => number) | UIView;
+export type UIGroupingWrapperFrameConfiguration = {
+    /** Stable identity used to reuse the same wrapper when surrounding conditional layout changes. */
+    identifier?: string;
+    /** CSS classes applied to the generated outer wrapper element. */
+    classNames?: string[];
+    /** HTML attributes applied to the generated outer wrapper element. */
+    attributes?: Record<string, string>;
+    /** Presentational CSS applied to the generated outer wrapper element. */
+    style?: Partial<CSSStyleDeclaration>;
+    /** Optionally transforms the bounding frame calculated from all assigned view frames. */
+    frame?: (defaultFrame: UIRectangle, assignedFrames: UIRectangle[]) => UIRectangle;
+};
+type UIGroupingWrapperFrameContext = {
+    configuration: UIGroupingWrapperFrameConfiguration;
+    views: UIView[];
+    framesByView: Map<UIView, UIRectangle>;
+};
+type UIGroupingWrapperFrameLayoutPass = {
+    owner: UIView;
+    groupingContext?: UIGroupingWrapperFrameContext;
+    requests: UIGroupingWrapperFrameContext[];
+};
+type UIGroupingWrapperFrameRecord = {
+    identifier?: string;
+    wrapperHTMLElement: HTMLDivElement;
+    coordinateSpaceHTMLElement: HTMLDivElement;
+    views: UIView[];
+    configuredClassNames: string[];
+    configuredAttributeNames: string[];
+    configuredStyleNames: string[];
+};
 export declare class UIRectangle extends UIObject {
+    static _groupingWrapperFrameLayoutPasses: UIGroupingWrapperFrameLayoutPass[];
+    static _groupingWrapperFrameRecordsByOwner: WeakMap<UIView, UIGroupingWrapperFrameRecord[]>;
     _isBeingUpdated: boolean;
     rectanglePointDidChange?: (b: any) => void;
     private _data;
@@ -132,6 +165,21 @@ export declare class UIRectangle extends UIObject {
     settingMaxWidth(maxWidth?: number): this;
     rectangleByEnforcingMinAndMaxSizes(centeredOnXPosition?: number, centeredOnYPosition?: number): UIRectangle;
     assignedAsFrameOfView(view: UIView, isWeakFrame?: boolean): this;
+    /**
+     * Begins collecting views assigned through the rectangle frame-assignment API into a DOM wrapper.
+     * The matching endGroupingWrapperFrame() returns the current rectangle unchanged, preserving the chain.
+     */
+    beginGroupingWrapperFrame(configuration?: UIGroupingWrapperFrameConfiguration): this;
+    /** Ends the current grouping wrapper frame and returns this rectangle unchanged. */
+    endGroupingWrapperFrame(): this;
+    static _beginGroupingWrapperFrameLayoutPass(owner: UIView): void;
+    static _endGroupingWrapperFrameLayoutPass(owner: UIView): void;
+    static _assignFrameToView(frame: UIRectangle, view: UIView): void;
+    static _reconcileGroupingWrapperFrames(layoutPass: UIGroupingWrapperFrameLayoutPass): void;
+    static _newGroupingWrapperFrameRecord(): UIGroupingWrapperFrameRecord;
+    static _configureGroupingWrapperFrameRecord(record: UIGroupingWrapperFrameRecord, request: UIGroupingWrapperFrameContext, owner: UIView): void;
+    static _topLevelHTMLElementForView(view: UIView): HTMLElement & import("./UIView").LooseObject;
+    static _detachViewFromGroupingWrapperFrame(view: UIView): void;
     toString(): string;
     get [Symbol.toStringTag](): string;
     IF(condition: boolean): UIRectangleConditionalChain<UIRectangle>;

package/compiledScripts/UIRectangle.js

@@ -24,7 +24,7 @@ module.exports = __toCommonJS(UIRectangle_exports);
 var import_UIObject = require("./UIObject");
 var import_UIPoint = require("./UIPoint");
 var import_UIView = require("./UIView");
-class UIRectangle extends import_UIObject.UIObject {
+const _UIRectangle = class extends import_UIObject.UIObject {
   constructor(x = 0, y = 0, height = 0, width = 0) {
     super();
     this._isLazyCopy = import_UIObject.NO;
@@ -72,7 +72,7 @@ class UIRectangle extends import_UIObject.UIObject {
     }
   }
   lazyCopy() {
-    const result = Object.create(UIRectangle.prototype);
+    const result = Object.create(_UIRectangle.prototype);
     result._data = this._data;
     result._data.refCount++;
     result._isLazyCopy = import_UIObject.YES;
@@ -125,7 +125,7 @@ class UIRectangle extends import_UIObject.UIObject {
     this._data.maxWidth = value;
   }
   copy() {
-    const result = new UIRectangle(this.x, this.y, this.height, this.width);
+    const result = new _UIRectangle(this.x, this.y, this.height, this.width);
     result.minHeight = this.minHeight;
     result.minWidth = this.minWidth;
     result.maxHeight = this.maxHeight;
@@ -136,7 +136,7 @@ class UIRectangle extends import_UIObject.UIObject {
     return (0, import_UIObject.IS)(rectangle) && this.min.isEqualTo(rectangle.min) && this.max.isEqualTo(rectangle.max);
   }
   static zero() {
-    return new UIRectangle(0, 0, 0, 0);
+    return new _UIRectangle(0, 0, 0, 0);
   }
   containsPoint(point) {
     return this.min.x <= point.x && this.min.y <= point.y && point.x <= this.max.x && point.y <= this.max.y;
@@ -528,7 +528,7 @@ class UIRectangle extends import_UIObject.UIObject {
       weights = [weights].arrayByRepeating(views.length);
     }
     const frames = this.rectanglesBySplittingWidth(weights, paddings, absoluteWidths);
-    frames.forEach((frame, index) => (0, import_UIObject.FIRST_OR_NIL)(views[index]).frame = frame);
+    frames.forEach((frame, index) => _UIRectangle._assignFrameToView(frame, (0, import_UIObject.FIRST_OR_NIL)(views[index])));
     return this;
   }
   distributeViewsAlongHeight(views, weights = 1, paddings, absoluteHeights) {
@@ -536,17 +536,17 @@ class UIRectangle extends import_UIObject.UIObject {
       weights = [weights].arrayByRepeating(views.length);
     }
     const frames = this.rectanglesBySplittingHeight(weights, paddings, absoluteHeights);
-    frames.forEach((frame, index) => (0, import_UIObject.FIRST_OR_NIL)(views[index]).frame = frame);
+    frames.forEach((frame, index) => _UIRectangle._assignFrameToView(frame, (0, import_UIObject.FIRST_OR_NIL)(views[index])));
     return this;
   }
   distributeViewsEquallyAlongWidth(views, padding) {
     const frames = this.rectanglesByEquallySplittingWidth(views.length, padding);
-    frames.forEach((frame, index) => views[index].frame = frame);
+    frames.forEach((frame, index) => _UIRectangle._assignFrameToView(frame, views[index]));
     return this;
   }
   distributeViewsEquallyAlongHeight(views, padding) {
     const frames = this.rectanglesByEquallySplittingHeight(views.length, padding);
-    frames.forEach((frame, index) => views[index].frame = frame);
+    frames.forEach((frame, index) => _UIRectangle._assignFrameToView(frame, views[index]));
     return this;
   }
   _heightNumberFromSizeNumberOrFunctionOrView(height) {
@@ -617,7 +617,7 @@ class UIRectangle extends import_UIObject.UIObject {
       if ((0, import_UIObject.IS_NOT_NIL)(absoluteHeights[i])) {
         frame.height = absoluteHeights[i];
       }
-      views[i].frame = frame;
+      _UIRectangle._assignFrameToView(frame, views[i]);
       frames.push(frame);
       const padding = paddings[i] || 0;
       currentRectangle = frame.rectangleForNextRow(padding);
@@ -653,7 +653,7 @@ class UIRectangle extends import_UIObject.UIObject {
         frame.x += offset;
       });
     }
-    frames.forEach((frame, index) => views[index].frame = frame);
+    frames.forEach((frame, index) => _UIRectangle._assignFrameToView(frame, views[index]));
     return frames;
   }
   framesByDistributingViewsAsGrid(views, paddings = 0, absoluteHeights = import_UIObject.nil) {
@@ -676,7 +676,7 @@ class UIRectangle extends import_UIObject.UIObject {
         const heightNumber = absoluteHeights[i];
         rowFrames.forEach((frame, j) => {
           frame.height = heightNumber;
-          rowViews[j].frame = frame;
+          _UIRectangle._assignFrameToView(frame, rowViews[j]);
         });
       }
       frames.push(rowFrames);
@@ -722,10 +722,228 @@ class UIRectangle extends import_UIObject.UIObject {
     );
   }
   assignedAsFrameOfView(view, isWeakFrame = view.hasWeakFrame) {
-    view.frame = this;
+    _UIRectangle._assignFrameToView(this, view);
     view.hasWeakFrame = isWeakFrame;
     return this;
   }
+  beginGroupingWrapperFrame(configuration = {}) {
+    const layoutPass = _UIRectangle._groupingWrapperFrameLayoutPasses.lastElement;
+    if (!layoutPass) {
+      throw new Error("beginGroupingWrapperFrame() must be called during a UIView layout pass");
+    }
+    if (layoutPass.groupingContext) {
+      throw new Error("Nested grouping wrapper frames are not supported");
+    }
+    layoutPass.groupingContext = {
+      configuration,
+      views: [],
+      framesByView: /* @__PURE__ */ new Map()
+    };
+    return this;
+  }
+  endGroupingWrapperFrame() {
+    const layoutPass = _UIRectangle._groupingWrapperFrameLayoutPasses.lastElement;
+    if (!(layoutPass == null ? void 0 : layoutPass.groupingContext)) {
+      throw new Error("endGroupingWrapperFrame() requires a matching beginGroupingWrapperFrame()");
+    }
+    layoutPass.requests.push(layoutPass.groupingContext);
+    layoutPass.groupingContext = void 0;
+    return this;
+  }
+  static _beginGroupingWrapperFrameLayoutPass(owner) {
+    _UIRectangle._groupingWrapperFrameLayoutPasses.push({
+      owner,
+      requests: []
+    });
+  }
+  static _endGroupingWrapperFrameLayoutPass(owner) {
+    const layoutPass = _UIRectangle._groupingWrapperFrameLayoutPasses.pop();
+    if (!layoutPass || layoutPass.owner !== owner) {
+      throw new Error("Unbalanced grouping wrapper frame layout pass");
+    }
+    if (layoutPass.groupingContext) {
+      console.error("beginGroupingWrapperFrame() was not balanced with endGroupingWrapperFrame()", owner);
+      layoutPass.requests.push(layoutPass.groupingContext);
+    }
+    if (!import_UIView.UIView.isVirtualLayouting) {
+      _UIRectangle._reconcileGroupingWrapperFrames(layoutPass);
+    }
+  }
+  static _assignFrameToView(frame, view) {
+    var _a;
+    view.frame = frame;
+    const groupingContext = (_a = _UIRectangle._groupingWrapperFrameLayoutPasses.lastElement) == null ? void 0 : _a.groupingContext;
+    if (!groupingContext) {
+      return;
+    }
+    if (!groupingContext.framesByView.has(view)) {
+      groupingContext.views.push(view);
+    }
+    groupingContext.framesByView.set(view, frame.copy());
+  }
+  static _reconcileGroupingWrapperFrames(layoutPass) {
+    var _a;
+    const owner = layoutPass.owner;
+    const previousRecords = (_a = _UIRectangle._groupingWrapperFrameRecordsByOwner.get(owner)) != null ? _a : [];
+    const availablePreviousRecords = previousRecords.copy();
+    const nextRecords = [];
+    const groupedViews = /* @__PURE__ */ new Set();
+    layoutPass.requests.forEach((request, requestIndex) => {
+      var _a2;
+      if (!request.views.length) {
+        return;
+      }
+      request.views.forEach((view) => {
+        if (view.superview !== owner) {
+          throw new Error("Views in a grouping wrapper frame must be direct subviews of the layout owner");
+        }
+        if (groupedViews.has(view)) {
+          throw new Error("A view cannot belong to multiple grouping wrapper frames in one layout pass");
+        }
+        groupedViews.add(view);
+      });
+      let record;
+      if (request.configuration.identifier) {
+        record = availablePreviousRecords.find(
+          (candidate) => candidate.identifier === request.configuration.identifier
+        );
+      }
+      record = (_a2 = record != null ? record : availablePreviousRecords[requestIndex]) != null ? _a2 : availablePreviousRecords.firstElement;
+      if (record) {
+        availablePreviousRecords.removeElement(record);
+      } else {
+        record = _UIRectangle._newGroupingWrapperFrameRecord();
+      }
+      _UIRectangle._configureGroupingWrapperFrameRecord(record, request, owner);
+      nextRecords.push(record);
+    });
+    availablePreviousRecords.forEach((record) => {
+      record.views.forEach((view) => {
+        var _a2;
+        if (view.viewHTMLElement.parentElement === record.coordinateSpaceHTMLElement) {
+          (_a2 = record.wrapperHTMLElement.parentElement) == null ? void 0 : _a2.insertBefore(
+            view.viewHTMLElement,
+            record.wrapperHTMLElement
+          );
+        }
+      });
+      record.wrapperHTMLElement.remove();
+    });
+    const recordByView = /* @__PURE__ */ new Map();
+    nextRecords.forEach((record) => record.views.forEach((view) => recordByView.set(view, record)));
+    const desiredTopLevelElements = [];
+    owner.subviews.forEach((view) => {
+      var _a2;
+      const record = recordByView.get(view);
+      const element = (_a2 = record == null ? void 0 : record.wrapperHTMLElement) != null ? _a2 : view.viewHTMLElement;
+      if (!desiredTopLevelElements.contains(element)) {
+        desiredTopLevelElements.push(element);
+      }
+    });
+    const currentTopLevelElements = Array.from(owner.viewHTMLElement.children).filter(
+      (element) => desiredTopLevelElements.contains(element)
+    );
+    if (!currentTopLevelElements.isEqualToArray(desiredTopLevelElements)) {
+      desiredTopLevelElements.forEach((element) => owner.viewHTMLElement.appendChild(element));
+    }
+    _UIRectangle._groupingWrapperFrameRecordsByOwner.set(owner, nextRecords);
+  }
+  static _newGroupingWrapperFrameRecord() {
+    const wrapperHTMLElement = document.createElement("div");
+    const coordinateSpaceHTMLElement = document.createElement("div");
+    wrapperHTMLElement.classList.add("UICore_UIGroupingWrapperFrame");
+    wrapperHTMLElement.setAttribute("data-uicore-grouping-wrapper-frame", "");
+    coordinateSpaceHTMLElement.classList.add("UICore_UIGroupingWrapperFrame_CoordinateSpace");
+    coordinateSpaceHTMLElement.setAttribute("data-uicore-grouping-wrapper-coordinate-space", "");
+    wrapperHTMLElement.appendChild(coordinateSpaceHTMLElement);
+    return {
+      wrapperHTMLElement,
+      coordinateSpaceHTMLElement,
+      views: [],
+      configuredClassNames: [],
+      configuredAttributeNames: [],
+      configuredStyleNames: []
+    };
+  }
+  static _configureGroupingWrapperFrameRecord(record, request, owner) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    const wrapperHTMLElement = record.wrapperHTMLElement;
+    record.configuredClassNames.forEach((className) => wrapperHTMLElement.classList.remove(className));
+    record.configuredAttributeNames.forEach((attributeName) => wrapperHTMLElement.removeAttribute(attributeName));
+    record.configuredStyleNames.forEach((styleName) => wrapperHTMLElement.style[styleName] = "");
+    wrapperHTMLElement.classList.add("UICore_UIGroupingWrapperFrame");
+    wrapperHTMLElement.setAttribute("data-uicore-grouping-wrapper-frame", "");
+    record.identifier = request.configuration.identifier;
+    record.views = request.views.copy();
+    record.configuredClassNames = (_b = (_a = request.configuration.classNames) == null ? void 0 : _a.copy()) != null ? _b : [];
+    record.configuredAttributeNames = Object.keys((_c = request.configuration.attributes) != null ? _c : {});
+    record.configuredStyleNames = Object.keys((_d = request.configuration.style) != null ? _d : {});
+    record.configuredClassNames.forEach((className) => wrapperHTMLElement.classList.add(className));
+    Object.keys((_e = request.configuration.attributes) != null ? _e : {}).forEach((attributeName) => {
+      wrapperHTMLElement.setAttribute(
+        attributeName,
+        request.configuration.attributes[attributeName]
+      );
+    });
+    Object.keys((_f = request.configuration.style) != null ? _f : {}).forEach((styleName) => {
+      wrapperHTMLElement.style[styleName] = request.configuration.style[styleName];
+    });
+    if (record.identifier) {
+      wrapperHTMLElement.setAttribute("data-uicore-grouping-wrapper-frame-identifier", record.identifier);
+    } else {
+      wrapperHTMLElement.removeAttribute("data-uicore-grouping-wrapper-frame-identifier");
+    }
+    const assignedFrames = request.views.map((view) => request.framesByView.get(view));
+    const framePoints = [];
+    assignedFrames.forEach((frame) => {
+      framePoints.push(frame.min);
+      framePoints.push(frame.max);
+    });
+    const defaultFrame = _UIRectangle.boundingBoxForPoints(framePoints);
+    const wrapperFrame = (_i = (_h = (_g = request.configuration).frame) == null ? void 0 : _h.call(_g, defaultFrame.copy(), assignedFrames.copy())) != null ? _i : defaultFrame;
+    wrapperHTMLElement.style.position = "absolute";
+    wrapperHTMLElement.style.left = wrapperFrame.x + "px";
+    wrapperHTMLElement.style.top = wrapperFrame.y + "px";
+    wrapperHTMLElement.style.width = wrapperFrame.width + "px";
+    wrapperHTMLElement.style.height = wrapperFrame.height + "px";
+    wrapperHTMLElement.style.boxSizing = "border-box";
+    if (wrapperHTMLElement.parentElement !== owner.viewHTMLElement) {
+      owner.viewHTMLElement.appendChild(wrapperHTMLElement);
+    }
+    const coordinateSpaceHTMLElement = record.coordinateSpaceHTMLElement;
+    coordinateSpaceHTMLElement.classList.add("UICore_UIGroupingWrapperFrame_CoordinateSpace");
+    coordinateSpaceHTMLElement.setAttribute("data-uicore-grouping-wrapper-coordinate-space", "");
+    coordinateSpaceHTMLElement.style.position = "absolute";
+    coordinateSpaceHTMLElement.style.left = -wrapperFrame.x - (wrapperHTMLElement.clientLeft || 0) + "px";
+    coordinateSpaceHTMLElement.style.top = -wrapperFrame.y - (wrapperHTMLElement.clientTop || 0) + "px";
+    coordinateSpaceHTMLElement.style.width = owner.bounds.width + "px";
+    coordinateSpaceHTMLElement.style.height = owner.bounds.height + "px";
+    const currentViewElements = Array.from(coordinateSpaceHTMLElement.children);
+    const desiredViewElements = request.views.map((view) => view.viewHTMLElement);
+    if (!currentViewElements.isEqualToArray(desiredViewElements)) {
+      desiredViewElements.forEach((element) => coordinateSpaceHTMLElement.appendChild(element));
+    }
+  }
+  static _topLevelHTMLElementForView(view) {
+    var _a;
+    let element = view.viewHTMLElement;
+    while (element.parentElement && element.parentElement !== ((_a = view.superview) == null ? void 0 : _a.viewHTMLElement)) {
+      element = element.parentElement;
+    }
+    return element;
+  }
+  static _detachViewFromGroupingWrapperFrame(view) {
+    var _a, _b;
+    const superviewHTMLElement = (_a = view.superview) == null ? void 0 : _a.viewHTMLElement;
+    if (!superviewHTMLElement || view.viewHTMLElement.parentElement === superviewHTMLElement) {
+      return;
+    }
+    const wrapperHTMLElement = view.viewHTMLElement.closest("[data-uicore-grouping-wrapper-frame]");
+    superviewHTMLElement.appendChild(view.viewHTMLElement);
+    if (wrapperHTMLElement && !((_b = wrapperHTMLElement.querySelector("[data-uicore-grouping-wrapper-coordinate-space]")) == null ? void 0 : _b.children.length)) {
+      wrapperHTMLElement.remove();
+    }
+  }
   toString() {
     const result = "[" + this.class.name + "] { x: " + this.x + ", y: " + this.y + ", height: " + this.height.toFixed(2) + ", width: " + this.height.toFixed(2) + " }";
     return result;
@@ -751,10 +969,10 @@ class UIRectangle extends import_UIObject.UIObject {
   }
   static boundingBoxForPoints(points) {
     if (points.length === 0) {
-      return new UIRectangle();
+      return new _UIRectangle();
     }
     const first = points[0];
-    const result = new UIRectangle(first.x, first.y, 0, 0);
+    const result = new _UIRectangle(first.x, first.y, 0, 0);
     for (let i = 1; i < points.length; i++) {
       result.updateByAddingPoint(points[i]);
     }
@@ -762,13 +980,13 @@ class UIRectangle extends import_UIObject.UIObject {
   }
   static boundingBoxForRectanglesAndPoints(rectanglesAndPoints) {
     if (rectanglesAndPoints.length === 0) {
-      return new UIRectangle();
+      return new _UIRectangle();
     }
     const first = rectanglesAndPoints[0];
-    const result = first instanceof UIRectangle ? new UIRectangle(first.x, first.y, first.height, first.width) : new UIRectangle(first.x, first.y, 0, 0);
+    const result = first instanceof _UIRectangle ? new _UIRectangle(first.x, first.y, first.height, first.width) : new _UIRectangle(first.x, first.y, 0, 0);
     for (let i = 1; i < rectanglesAndPoints.length; i++) {
       const rectangleOrPoint = rectanglesAndPoints[i];
-      if (rectangleOrPoint instanceof UIRectangle) {
+      if (rectangleOrPoint instanceof _UIRectangle) {
         result.updateByAddingPoint(rectangleOrPoint.min);
         result.updateByAddingPoint(rectangleOrPoint.max);
       } else {
@@ -791,7 +1009,10 @@ class UIRectangle extends import_UIObject.UIObject {
       this.didChange();
     }
   }
-}
+};
+let UIRectangle = _UIRectangle;
+UIRectangle._groupingWrapperFrameLayoutPasses = [];
+UIRectangle._groupingWrapperFrameRecordsByOwner = /* @__PURE__ */ new WeakMap();
 class UIRectangleConditionalBlock {
   constructor(initialResult, condition) {
     this._stack = [{