@nascentdigital/funnel-core 4.4.4

package/dist/ui/geometry/AspectRatio.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AspectRatio = void 0;
+// class
+const errors_1 = require("../../errors");
+class AspectRatio {
+    constructor(value) {
+        // normalize value
+        const { width, height } = AspectRatio.Data.parse(value);
+        // initialize instance variables
+        this.width = width;
+        this.height = height;
+    }
+    get ratio() {
+        const { width, height } = this;
+        return width / height;
+    }
+    isSimilarTo(that) {
+        const threshold = 0.005;
+        return Math.abs(this.ratio - that.ratio) < threshold;
+    }
+    toString() {
+        const { width, height } = this;
+        return `${width.toFixed()}:${height.toFixed()}`;
+    }
+}
+exports.AspectRatio = AspectRatio;
+// extension
+(function (AspectRatio) {
+    let Data;
+    (function (Data) {
+        // helpers
+        function parse(value) {
+            // handle tuple form
+            if (Array.isArray(value)) {
+                return Tuple.parse(value);
+            }
+            // or handle data form
+            else if (typeof value === 'object') {
+                return value;
+            }
+            // otherwise try to parse string
+            else if (String.filter(value)) {
+                return String.parse(value);
+            }
+            // or throw
+            else {
+                throw new errors_1.ArgumentError(`Invalid AspectRatio "${value}"`);
+            }
+        }
+        Data.parse = parse;
+    })(Data = AspectRatio.Data || (AspectRatio.Data = {}));
+    let String;
+    (function (String) {
+        // helper
+        function filter(value) {
+            return /^[1-9]\d?:[1-9]\d?$/.test(value);
+        }
+        String.filter = filter;
+        function parse(value) {
+            const [widthValue, heightValue] = value.split(':');
+            return {
+                width: Number.parseInt(widthValue),
+                height: Number.parseInt(heightValue)
+            };
+        }
+        String.parse = parse;
+    })(String = AspectRatio.String || (AspectRatio.String = {}));
+    let Tuple;
+    (function (Tuple) {
+        // helper
+        function parse([width, height]) {
+            return { width, height };
+        }
+        Tuple.parse = parse;
+    })(Tuple = AspectRatio.Tuple || (AspectRatio.Tuple = {}));
+})(AspectRatio || (exports.AspectRatio = AspectRatio = {}));

package/dist/ui/geometry/Bounds.d.ts

@@ -0,0 +1,4 @@
+import { Rect } from './Rect';
+export declare class Bounds extends Rect {
+    constructor(width: number, height: number);
+}

package/dist/ui/geometry/Bounds.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bounds = void 0;
+const Rect_1 = require("./Rect");
+// class
+class Bounds extends Rect_1.Rect {
+    constructor(width, height) {
+        super(0, 0, width, height);
+    }
+}
+exports.Bounds = Bounds;

package/dist/ui/geometry/Frame.d.ts

@@ -0,0 +1,3 @@
+import { Insets } from './Insets';
+import { Size } from './Size';
+export type Frame = Insets & Size;

package/dist/ui/geometry/Frame.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ui/geometry/Insets.d.ts

@@ -0,0 +1,14 @@
+export type Insets = {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+export declare namespace Insets {
+    const none: Readonly<Insets>;
+    type AsText = `${AsText.Format}` | `${AsText.Format} ${AsText.Format}` | `${AsText.Format} ${AsText.Format} ${AsText.Format} ${AsText.Format}`;
+    namespace AsText {
+        type Format = `${number}${'px' | '%'}`;
+    }
+    function asText({ top, right, bottom, left }: Insets): AsText;
+}

package/dist/ui/geometry/Insets.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Insets = void 0;
+// extension
+var Insets;
+(function (Insets) {
+    // constants
+    Insets.none = { top: 0, right: 0, bottom: 0, left: 0 };
+    // helpers
+    function asText({ top, right, bottom, left }) {
+        return `${top}px ${right}px ${bottom}px ${left}px`;
+    }
+    Insets.asText = asText;
+})(Insets || (exports.Insets = Insets = {}));

package/dist/ui/geometry/PixelSize.d.ts

@@ -0,0 +1 @@
+export type PixelSize = `${number}px`;

package/dist/ui/geometry/PixelSize.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ui/geometry/Point.d.ts

@@ -0,0 +1,7 @@
+export declare class Point {
+    readonly x: number;
+    readonly y: number;
+    static readonly origin: Point;
+    constructor(x: number, y: number);
+    distanceTo(point: Point): number;
+}

package/dist/ui/geometry/Point.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Point = void 0;
+// class
+class Point {
+    constructor(x, y) {
+        this.x = x;
+        this.y = y;
+    }
+    distanceTo(point) {
+        return Math.hypot(this.x - point.x, this.y - point.y);
+    }
+}
+exports.Point = Point;
+Point.origin = new Point(0, 0);

package/dist/ui/geometry/Rect.d.ts

@@ -0,0 +1,19 @@
+import { Insets } from './Insets';
+import { Point } from './Point';
+export declare class Rect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    constructor(x: number, y: number, width: number, height: number);
+    get top(): number;
+    get bottom(): number;
+    get left(): number;
+    get right(): number;
+    get center(): Point;
+    contains(that: Rect): boolean;
+    overlaps(that: Rect): boolean;
+    touches(that: Rect): boolean;
+    static fromInsets(insets: Insets): Rect;
+    static fromRect({ x, y, width, height }: Pick<Rect, 'x' | 'y' | 'width' | 'height'>): Rect;
+}

package/dist/ui/geometry/Rect.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rect = void 0;
+const Point_1 = require("./Point");
+class Rect {
+    constructor(x, y, width, height) {
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+    }
+    get top() {
+        return this.y;
+    }
+    get bottom() {
+        return this.y + this.height;
+    }
+    get left() {
+        return this.x;
+    }
+    get right() {
+        return this.x + this.width;
+    }
+    get center() {
+        return new Point_1.Point(this.x + this.width / 2, this.y + this.height / 2);
+    }
+    contains(that) {
+        return !(that.x < this.x ||
+            that.y < this.y ||
+            (that.x + that.width) > (this.x + this.width) ||
+            (that.y + that.height) > (this.y + this.height));
+    }
+    overlaps(that) {
+        // no horizontal overlap
+        if (this.x >= (that.x + that.width) || that.x >= (this.x + this.width)) {
+            return false;
+        }
+        // no vertical overlap
+        else if (this.y >= (that.y + that.height) || that.y >= (this.y + this.height)) {
+            return false;
+        }
+        // otherwise they must overlap
+        else {
+            return true;
+        }
+    }
+    touches(that) {
+        // has horizontal gap
+        if (this.x > (that.x + that.width) || that.x > (this.x + this.width)) {
+            return false;
+        }
+        // has vertical gap
+        else if (this.y > (that.y + that.height) || that.y > (this.y + this.height)) {
+            return false;
+        }
+        // otherwise there's no gap
+        else {
+            return true;
+        }
+    }
+    static fromInsets(insets) {
+        return new Rect(insets.left, insets.top, insets.right - insets.left, insets.bottom - insets.top);
+    }
+    static fromRect({ x, y, width, height }) {
+        return new Rect(x, y, width, height);
+    }
+}
+exports.Rect = Rect;

package/dist/ui/geometry/ScreenSize.d.ts

@@ -0,0 +1 @@
+export type ScreenSize = 'mobile' | 'desktop';

package/dist/ui/geometry/ScreenSize.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ui/geometry/Size.d.ts

@@ -0,0 +1,7 @@
+export type Size = {
+    width: number;
+    height: number;
+};
+export declare namespace Size {
+    const none: Readonly<Size>;
+}

package/dist/ui/geometry/Size.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Size = void 0;
+// extension
+var Size;
+(function (Size) {
+    // constants
+    Size.none = { width: 0, height: 0 };
+})(Size || (exports.Size = Size = {}));

package/dist/ui/geometry/index.d.ts

@@ -0,0 +1,9 @@
+export * from './AspectRatio';
+export * from './Bounds';
+export * from './Frame';
+export * from './Insets';
+export * from './PixelSize';
+export * from './Point';
+export * from './Rect';
+export * from './ScreenSize';
+export * from './Size';

package/dist/ui/geometry/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AspectRatio"), exports);
+__exportStar(require("./Bounds"), exports);
+__exportStar(require("./Frame"), exports);
+__exportStar(require("./Insets"), exports);
+__exportStar(require("./PixelSize"), exports);
+__exportStar(require("./Point"), exports);
+__exportStar(require("./Rect"), exports);
+__exportStar(require("./ScreenSize"), exports);
+__exportStar(require("./Size"), exports);

package/dist/ui/index.d.ts

@@ -0,0 +1,18 @@
+export * from './block-layout';
+export * from './browser/index';
+export * from './fields';
+export * from './geometry';
+export * from './responsive';
+export * from './richtext';
+export * from './Accessible';
+export * from './BlockThemes';
+export * from './ColorMode';
+export * from './ImageSource';
+export * from './File';
+export * from './FileType';
+export * from './MimeType';
+export * from './Placement';
+export * from './Position';
+export * from './Selector';
+export * from './SemanticColor';
+export * from './Visual';

package/dist/ui/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./block-layout"), exports);
+__exportStar(require("./browser/index"), exports);
+__exportStar(require("./fields"), exports);
+__exportStar(require("./geometry"), exports);
+__exportStar(require("./responsive"), exports);
+__exportStar(require("./richtext"), exports);
+__exportStar(require("./Accessible"), exports);
+__exportStar(require("./BlockThemes"), exports);
+__exportStar(require("./ColorMode"), exports);
+__exportStar(require("./ImageSource"), exports);
+__exportStar(require("./File"), exports);
+__exportStar(require("./FileType"), exports);
+__exportStar(require("./MimeType"), exports);
+__exportStar(require("./Placement"), exports);
+__exportStar(require("./Position"), exports);
+__exportStar(require("./Selector"), exports);
+__exportStar(require("./SemanticColor"), exports);
+__exportStar(require("./Visual"), exports);

package/dist/ui/responsive/Breakpoint.d.ts

@@ -0,0 +1,8 @@
+export type Breakpoint = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type BreakpointStates = Record<Breakpoint, boolean>;
+export declare namespace Breakpoint {
+    const values: ReadonlyArray<Breakpoint>;
+    const last: Breakpoint;
+    function test(value: string): value is Breakpoint;
+    function compare(lhs: Breakpoint, rhs: Breakpoint): number;
+}

package/dist/ui/responsive/Breakpoint.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Breakpoint = void 0;
+// extensions
+var Breakpoint;
+(function (Breakpoint) {
+    // constants
+    Breakpoint.values = ['xs', 'sm', 'md', 'lg', 'xl'];
+    Breakpoint.last = Breakpoint.values[Breakpoint.values.length - 1];
+    // helpers
+    function test(value) {
+        return Breakpoint.values.includes(value);
+    }
+    Breakpoint.test = test;
+    function compare(lhs, rhs) {
+        // skip if same
+        if (lhs === rhs) {
+            return 0;
+        }
+        // otherwise return based on index
+        return Breakpoint.values.indexOf(lhs) < Breakpoint.values.indexOf(rhs) ? -1 : 1;
+    }
+    Breakpoint.compare = compare;
+})(Breakpoint || (exports.Breakpoint = Breakpoint = {}));

package/dist/ui/responsive/BreakpointObserver.d.ts

@@ -0,0 +1,16 @@
+import { Observable } from 'rxjs';
+import { Breakpoint } from './Breakpoint';
+import { Breakpoints } from './Breakpoints';
+export declare class BreakpointObserver {
+    private _configurations;
+    private _current;
+    private _current$;
+    private _disposed;
+    constructor(breakpoints: Breakpoints);
+    get current(): Breakpoint | undefined;
+    get current$(): Observable<Breakpoint>;
+    get disposed(): boolean;
+    dispose(): void;
+    private setCurrent;
+    private bindBreakpoint;
+}

package/dist/ui/responsive/BreakpointObserver.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BreakpointObserver = void 0;
+const rxjs_1 = require("rxjs");
+const utils_1 = require("../../utils");
+const Browser_1 = require("../browser/Browser");
+const Breakpoint_1 = require("./Breakpoint");
+// class
+class BreakpointObserver {
+    constructor(breakpoints) {
+        // create configurations
+        const breakpointEntries = Object.entries(breakpoints)
+            .sort(([lhs], [rhs]) => Breakpoint_1.Breakpoint.compare(lhs, rhs));
+        const lastBreakpointIndex = breakpointEntries.length - 1;
+        this._configurations = breakpointEntries
+            .map(([breakpoint, start], index) => ({
+            breakpoint,
+            start,
+            end: index < lastBreakpointIndex
+                ? breakpointEntries[index + 1][1] - 1
+                : undefined
+        }));
+        // initialize instance variables
+        this._current = undefined;
+        this._current$ = new rxjs_1.BehaviorSubject(undefined);
+        this._disposed = false;
+        // bind breakpoints
+        this._configurations.forEach(configuration => {
+            // initialize media query callback
+            const breakpoint = configuration.breakpoint;
+            configuration.mediaQueryCallback = (e) => {
+                // update if matches and not current
+                if (e.matches) {
+                    this.setCurrent(breakpoint);
+                }
+            };
+            // bind breakpoint (indirectly updates to matching breakpoint)
+            this.bindBreakpoint(configuration);
+        });
+    }
+    get current() {
+        return this._current;
+    }
+    get current$() {
+        return this._current$
+            .pipe((0, rxjs_1.filter)(utils_1.isDefinedStrict));
+    }
+    get disposed() {
+        return this._disposed;
+    }
+    dispose() {
+        // mark disposed
+        this._disposed = true;
+        // clear all configurations
+        this._configurations.forEach(configuration => {
+            // remove listener (if any)
+            if (configuration.mediaQuery !== undefined) {
+                configuration.mediaQuery.removeEventListener('change', configuration.mediaQueryCallback);
+            }
+            // reset
+            delete configuration.mediaQuery;
+            delete configuration.mediaQueryCallback;
+        });
+        // clear configurations
+        this._configurations = [];
+    }
+    setCurrent(breakpoint) {
+        if (this._current !== breakpoint) {
+            this._current = breakpoint;
+            this._current$.next(breakpoint);
+        }
+    }
+    bindBreakpoint(configuration) {
+        // skip if in the backend
+        if (!Browser_1.Browser.available) {
+            return;
+        }
+        // unbind previous media query (if any)
+        if (configuration.mediaQuery !== undefined) {
+            configuration.mediaQuery.removeEventListener('change', configuration.mediaQueryCallback);
+        }
+        // create last breakpoint query
+        let mediaQuery;
+        if (configuration.end === undefined) {
+            mediaQuery = `(min-width: ${configuration.start}px)`;
+        }
+        // or create first breakpoint query
+        else if (configuration.start === 0) {
+            mediaQuery = `(max-width: ${configuration.end}px)`;
+        }
+        // or create bounded breakpoint query
+        else {
+            mediaQuery = `(min-width: ${configuration.start}px) and (max-width: ${configuration.end}px)`;
+        }
+        // bind new media query
+        configuration.mediaQuery = window.matchMedia(mediaQuery);
+        configuration.mediaQuery.addEventListener('change', configuration.mediaQueryCallback);
+        // update breakpoint if matching
+        if (configuration.mediaQuery.matches) {
+            this.setCurrent(configuration.breakpoint);
+        }
+    }
+}
+exports.BreakpointObserver = BreakpointObserver;

package/dist/ui/responsive/Breakpoints.d.ts

@@ -0,0 +1,5 @@
+import { ResponsiveValue } from './ResponsiveValue';
+export type Breakpoints = ResponsiveValue<number>;
+export declare namespace Breakpoints {
+    const defaults: Readonly<Breakpoints>;
+}

package/dist/ui/responsive/Breakpoints.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Breakpoints = void 0;
+// extension
+var Breakpoints;
+(function (Breakpoints) {
+    // constants
+    Breakpoints.defaults = {
+        xs: 0,
+        sm: 600,
+        md: 900,
+        lg: 1280,
+        xl: 1520
+    };
+})(Breakpoints || (exports.Breakpoints = Breakpoints = {}));

package/dist/ui/responsive/ResponsiveValue.d.ts

@@ -0,0 +1,7 @@
+import { Breakpoint } from './Breakpoint';
+export type ResponsiveValue<T> = Partial<Record<Breakpoint, T>>;
+export type MixedResponsiveValue<T> = T | ResponsiveValue<T>;
+export declare namespace ResponsiveValue {
+    function isResponsive<T>(value: any): value is Partial<Record<Breakpoint, T>>;
+    function resolve<T>(responsiveValue: Partial<ResponsiveValue<T>>, breakpoint: Breakpoint): T | undefined;
+}

package/dist/ui/responsive/ResponsiveValue.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponsiveValue = void 0;
+const Breakpoint_1 = require("./Breakpoint");
+// extensions
+var ResponsiveValue;
+(function (ResponsiveValue) {
+    // guard
+    function isResponsive(value) {
+        return !!value
+            && typeof value === 'object'
+            && Object.keys(value).some(key => Breakpoint_1.Breakpoint.values.includes(key));
+    }
+    ResponsiveValue.isResponsive = isResponsive;
+    // helpers
+    function resolve(responsiveValue, breakpoint) {
+        // lookup the closest value
+        if (isResponsive(responsiveValue)) {
+            const closestBreakpoint = Breakpoint_1.Breakpoint.values.slice()
+                .reverse()
+                .find(b => Breakpoint_1.Breakpoint.compare(b, breakpoint) <= 0 && responsiveValue[b] !== undefined);
+            return closestBreakpoint && responsiveValue[closestBreakpoint];
+        }
+    }
+    ResponsiveValue.resolve = resolve;
+})(ResponsiveValue || (exports.ResponsiveValue = ResponsiveValue = {}));

package/dist/ui/responsive/index.d.ts

@@ -0,0 +1,4 @@
+export * from './Breakpoint';
+export * from './BreakpointObserver';
+export * from './Breakpoints';
+export * from './ResponsiveValue';

package/dist/ui/responsive/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Breakpoint"), exports);
+__exportStar(require("./BreakpointObserver"), exports);
+__exportStar(require("./Breakpoints"), exports);
+__exportStar(require("./ResponsiveValue"), exports);

package/dist/ui/richtext/LexicalUtils.d.ts

@@ -0,0 +1,31 @@
+import { SerializedLinkNode } from '@lexical/link';
+import { SerializedListItemNode, SerializedListNode } from '@lexical/list';
+import { SerializedHeadingNode } from '@lexical/rich-text';
+import { BaseSelection, ElementNode, type Klass, LexicalEditor, LexicalNode, SerializedElementNode, SerializedLexicalNode, SerializedParagraphNode, SerializedRootNode, SerializedTextNode, TextNode } from 'lexical';
+import { Transform } from '../../types';
+import { Rect } from '../geometry';
+export declare namespace LexicalUtils {
+    function isSerializedTextNode(node: SerializedLexicalNode): node is SerializedTextNode;
+    function isSerializedParagraphNode(node: SerializedLexicalNode): node is SerializedParagraphNode;
+    function isSerializedHeadingNode(node: SerializedLexicalNode): node is SerializedHeadingNode;
+    function isSerializedQuoteNode(node: SerializedLexicalNode): boolean;
+    function isSerializedListNode(node: SerializedLexicalNode): node is SerializedListNode;
+    function isSerializedHrNode(node: SerializedLexicalNode): boolean;
+    function isSerializedListItemNode(node: SerializedLexicalNode): node is SerializedListItemNode;
+    function isSerializedLinkNode(node: SerializedLexicalNode): node is SerializedLinkNode;
+    function isSerializedElementNode(node: SerializedLexicalNode): node is SerializedElementNode;
+    function rootToString(root?: SerializedRootNode): string;
+    type ReplaceTextNodesArgs = {
+        selection?: BaseSelection | null;
+        onReplaceNode: Transform<TextNode, LexicalNode>;
+    };
+    function replaceTextNodes({ selection: selectionRaw, onReplaceNode }: ReplaceTextNodesArgs): boolean;
+    function findContainer<T extends ReadonlyArray<Klass<ElementNode>>>(node: LexicalNode | null | undefined, types: T): InstanceType<T[number]> | undefined;
+    type GetSelectionRectArgs = {
+        editor: LexicalEditor;
+        selection?: BaseSelection | null | undefined;
+        coerce?: boolean | ReadonlyArray<Klass<ElementNode>>;
+        allowEmpty?: boolean;
+    };
+    function getSelectionRect({ editor, selection: selectionRaw, coerce, allowEmpty }: GetSelectionRectArgs): Rect | undefined;
+}