uicore-ts 1.1.376 → 1.1.378

package/compiledScripts/UIRectangle.d.ts

@@ -2,7 +2,42 @@ 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>;
+    childContexts: UIGroupingWrapperFrameContext[];
+};
+type UIGroupingWrapperFrameLayoutPass = {
+    owner: UIView;
+    groupingContextStack: UIGroupingWrapperFrameContext[];
+    requests: UIGroupingWrapperFrameContext[];
+};
+type UIGroupingWrapperFrameRecord = {
+    identifier?: string;
+    wrapperHTMLElement: HTMLDivElement;
+    coordinateSpaceHTMLElement: HTMLDivElement;
+    views: UIView[];
+    childRecords: UIGroupingWrapperFrameRecord[];
+    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 +167,24 @@ 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 _viewsInGroupingWrapperFrameRecord(record: UIGroupingWrapperFrameRecord): UIView[];
+    static _reorderGroupingWrapperFrameElements(containerHTMLElement: HTMLElement, desiredElements: HTMLElement[]): void;
+    static _newGroupingWrapperFrameRecord(): UIGroupingWrapperFrameRecord;
+    static _configureGroupingWrapperFrameRecord(record: UIGroupingWrapperFrameRecord, request: UIGroupingWrapperFrameContext, owner: UIView, containerHTMLElement: HTMLElement): void;
+    static _topLevelHTMLElementForView(view: UIView): HTMLElement & import("./UIView").LooseObject;
+    static _detachViewFromGroupingWrapperFrame(view: UIView): void;
+    static _removeEmptyGroupingWrapperFrameAncestors(wrapperHTMLElement: Element | null): void;
     toString(): string;
     get [Symbol.toStringTag](): string;
     IF(condition: boolean): UIRectangleConditionalChain<UIRectangle>;
@@ -146,6 +199,12 @@ export declare class UIRectangle extends UIObject {
     didChange(): void;
     _rectanglePointDidChange(): void;
 }
+declare global {
+    interface Array<T> {
+        /** Returns the smallest rectangle containing every point and rectangle in the array. */
+        boundingBox(this: Array<UIPoint | UIRectangle>): UIRectangle;
+    }
+}
 type RectangleChainMethods<TResult> = {
     [K in keyof UIRectangle as (K extends 'IF' | 'ELSE' | 'ELSE_IF' | 'ENDIF' ? never : K)]: UIRectangle[K] extends (...args: infer Args) => infer R ? R extends UIRectangle | UIRectangle[] ? (...args: Args) => UIRectangleConditionalChain<R, TResult> : never : never;
 };

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,295 @@ 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");
+    }
+    const groupingContext = {
+      configuration,
+      views: [],
+      framesByView: /* @__PURE__ */ new Map(),
+      childContexts: []
+    };
+    const parentContext = layoutPass.groupingContextStack.lastElement;
+    if (parentContext) {
+      parentContext.childContexts.push(groupingContext);
+    } else {
+      layoutPass.requests.push(groupingContext);
+    }
+    layoutPass.groupingContextStack.push(groupingContext);
+    return this;
+  }
+  endGroupingWrapperFrame() {
+    const layoutPass = _UIRectangle._groupingWrapperFrameLayoutPasses.lastElement;
+    if (!(layoutPass == null ? void 0 : layoutPass.groupingContextStack.length)) {
+      throw new Error("endGroupingWrapperFrame() requires a matching beginGroupingWrapperFrame()");
+    }
+    layoutPass.groupingContextStack.pop();
+    return this;
+  }
+  static _beginGroupingWrapperFrameLayoutPass(owner) {
+    _UIRectangle._groupingWrapperFrameLayoutPasses.push({
+      owner,
+      groupingContextStack: [],
+      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.groupingContextStack.length) {
+      console.error("beginGroupingWrapperFrame() was not balanced with endGroupingWrapperFrame()", owner);
+      layoutPass.groupingContextStack.length = 0;
+    }
+    if (!import_UIView.UIView.isVirtualLayouting) {
+      _UIRectangle._reconcileGroupingWrapperFrames(layoutPass);
+    }
+  }
+  static _assignFrameToView(frame, view) {
+    var _a;
+    view.frame = frame;
+    const groupingContexts = (_a = _UIRectangle._groupingWrapperFrameLayoutPasses.lastElement) == null ? void 0 : _a.groupingContextStack;
+    if (!(groupingContexts == null ? void 0 : groupingContexts.length)) {
+      return;
+    }
+    groupingContexts.forEach((groupingContext) => groupingContext.framesByView.set(view, frame.copy()));
+    const innermostContext = groupingContexts.lastElement;
+    if (!innermostContext.views.contains(view)) {
+      innermostContext.views.push(view);
+    }
+  }
+  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();
+    const configuredIdentifiers = /* @__PURE__ */ new Set();
+    const validateContext = (request) => {
+      if (request.configuration.identifier) {
+        if (configuredIdentifiers.has(request.configuration.identifier)) {
+          throw new Error("Grouping wrapper frame identifiers must be unique within one layout owner");
+        }
+        configuredIdentifiers.add(request.configuration.identifier);
+      }
+      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);
+      });
+      request.childContexts.forEach(validateContext);
+    };
+    layoutPass.requests.forEach(validateContext);
+    const recordForRequest = (request) => {
+      let record;
+      if (request.configuration.identifier) {
+        record = availablePreviousRecords.find(
+          (candidate) => candidate.identifier === request.configuration.identifier
+        );
+      } else {
+        record = availablePreviousRecords.find((candidate) => !candidate.identifier);
+      }
+      if (record) {
+        availablePreviousRecords.removeElement(record);
+      } else {
+        record = _UIRectangle._newGroupingWrapperFrameRecord();
+      }
+      return record;
+    };
+    const reconcileContext = (request, containerHTMLElement) => {
+      if (!request.framesByView.size) {
+        return;
+      }
+      const record = recordForRequest(request);
+      _UIRectangle._configureGroupingWrapperFrameRecord(
+        record,
+        request,
+        owner,
+        containerHTMLElement
+      );
+      nextRecords.push(record);
+      record.childRecords = request.childContexts.map(
+        (childContext) => reconcileContext(childContext, record.coordinateSpaceHTMLElement)
+      ).filter((childRecord) => !!childRecord);
+      const elementByView = /* @__PURE__ */ new Map();
+      record.views.forEach((view) => elementByView.set(view, view.viewHTMLElement));
+      record.childRecords.forEach((childRecord) => {
+        _UIRectangle._viewsInGroupingWrapperFrameRecord(childRecord).forEach(
+          (view) => elementByView.set(view, childRecord.wrapperHTMLElement)
+        );
+      });
+      _UIRectangle._reorderGroupingWrapperFrameElements(
+        record.coordinateSpaceHTMLElement,
+        owner.subviews.map((view) => elementByView.get(view)).filter(
+          (element) => !!element
+        )
+      );
+      return record;
+    };
+    const rootRecords = layoutPass.requests.map(
+      (request) => reconcileContext(request, owner.viewHTMLElement)
+    ).filter((record) => !!record);
+    availablePreviousRecords.forEach((record) => {
+      record.views.forEach((view) => {
+        if (view.viewHTMLElement.parentElement === record.coordinateSpaceHTMLElement) {
+          owner.viewHTMLElement.appendChild(view.viewHTMLElement);
+        }
+      });
+      record.wrapperHTMLElement.remove();
+    });
+    const rootRecordByView = /* @__PURE__ */ new Map();
+    rootRecords.forEach((record) => {
+      _UIRectangle._viewsInGroupingWrapperFrameRecord(record).forEach(
+        (view) => rootRecordByView.set(view, record)
+      );
+    });
+    const desiredTopLevelElements = [];
+    owner.subviews.forEach((view) => {
+      var _a2;
+      const record = rootRecordByView.get(view);
+      const element = (_a2 = record == null ? void 0 : record.wrapperHTMLElement) != null ? _a2 : view.viewHTMLElement;
+      if (!desiredTopLevelElements.contains(element)) {
+        desiredTopLevelElements.push(element);
+      }
+    });
+    _UIRectangle._reorderGroupingWrapperFrameElements(owner.viewHTMLElement, desiredTopLevelElements);
+    _UIRectangle._groupingWrapperFrameRecordsByOwner.set(owner, nextRecords);
+  }
+  static _viewsInGroupingWrapperFrameRecord(record) {
+    return record.views.concat(record.childRecords.flatMap(
+      (childRecord) => _UIRectangle._viewsInGroupingWrapperFrameRecord(childRecord)
+    ));
+  }
+  static _reorderGroupingWrapperFrameElements(containerHTMLElement, desiredElements) {
+    const uniqueDesiredElements = desiredElements.filter(
+      (element, index) => desiredElements.indexOf(element) === index
+    );
+    const currentElements = Array.from(containerHTMLElement.children).filter(
+      (element) => uniqueDesiredElements.contains(element)
+    );
+    if (!currentElements.isEqualToArray(uniqueDesiredElements) || uniqueDesiredElements.some((element) => element.parentElement !== containerHTMLElement)) {
+      uniqueDesiredElements.forEach((element) => containerHTMLElement.appendChild(element));
+    }
+  }
+  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: [],
+      childRecords: [],
+      configuredClassNames: [],
+      configuredAttributeNames: [],
+      configuredStyleNames: []
+    };
+  }
+  static _configureGroupingWrapperFrameRecord(record, request, owner, containerHTMLElement) {
+    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 = Array.from(request.framesByView.values());
+    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 !== containerHTMLElement) {
+      containerHTMLElement.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";
+  }
+  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;
+    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);
+    _UIRectangle._removeEmptyGroupingWrapperFrameAncestors(wrapperHTMLElement);
+  }
+  static _removeEmptyGroupingWrapperFrameAncestors(wrapperHTMLElement) {
+    var _a, _b;
+    while (wrapperHTMLElement) {
+      const parentWrapperHTMLElement = (_b = (_a = wrapperHTMLElement.parentElement) == null ? void 0 : _a.closest(
+        "[data-uicore-grouping-wrapper-frame]"
+      )) != null ? _b : null;
+      const coordinateSpaceHTMLElement = wrapperHTMLElement.querySelector(
+        ":scope > [data-uicore-grouping-wrapper-coordinate-space]"
+      );
+      if (coordinateSpaceHTMLElement == null ? void 0 : coordinateSpaceHTMLElement.children.length) {
+        return;
+      }
+      wrapperHTMLElement.remove();
+      wrapperHTMLElement = parentWrapperHTMLElement;
+    }
+  }
   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 +1036,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 +1047,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,6 +1076,19 @@ class UIRectangle extends import_UIObject.UIObject {
       this.didChange();
     }
   }
+};
+let UIRectangle = _UIRectangle;
+UIRectangle._groupingWrapperFrameLayoutPasses = [];
+UIRectangle._groupingWrapperFrameRecordsByOwner = /* @__PURE__ */ new WeakMap();
+if (!("boundingBox" in Array.prototype)) {
+  Object.defineProperty(Array.prototype, "boundingBox", {
+    configurable: import_UIObject.YES,
+    enumerable: import_UIObject.NO,
+    writable: import_UIObject.YES,
+    value: function() {
+      return UIRectangle.boundingBoxForRectanglesAndPoints(this);
+    }
+  });
 }
 class UIRectangleConditionalBlock {
   constructor(initialResult, condition) {