@gilav21/shadcn-angular-rte 0.1.2 → 0.2.1

package/types/gilav21-shadcn-angular-rte.d.ts

@@ -795,7 +795,9 @@ declare abstract class RichTextEditorAddonHost {
     /**
      * Apply a built-in toolbar command to a specific block (its block-transform
      * engine): re-tag/list-wrap the block or run the formatting command, place
-     * the caret, and record one history entry.
+     * the caret, and record one history entry. `null` runs the command at the
+     * current selection; a block no longer inside the editor (detached by an
+     * undo since it was captured) is ignored and nothing changes.
      */
     abstract executeToolbarCommandOnBlock(command: string, anchorBlock: HTMLElement | null): void;
     /**
@@ -1506,6 +1508,11 @@ declare class RichTextEditorComponent extends RichTextEditorAddonHost implements
     tableContextMenuRef?: ElementRef<HTMLDivElement>;
     /** Output format: `'markdown'` converts to/from Markdown; `'html'` works with raw HTML. */
     readonly mode: _angular_core.InputSignal<EditorMode>;
+    /**
+     * Colour preset for this editor and its overlays — the names `change-theme`
+     * accepts. Unset, the editor follows the app's global tokens.
+     */
+    readonly theme: _angular_core.InputSignal<"zinc" | "slate" | "stone" | "gray" | "neutral" | "red" | "rose" | "orange" | "green" | "blue" | "yellow" | "violet" | "amber" | undefined>;
     /** Visual border/focus style. See {@link EditorVariant}. */
     readonly variant: _angular_core.InputSignal<"default" | "ghost" | null | undefined>;
     /** Text size preset for the editor content. See {@link EditorSize}. */
@@ -1809,6 +1816,13 @@ declare class RichTextEditorComponent extends RichTextEditorAddonHost implements
     }>;
     private tableContextMenuTarget;
     private tableContextMenuCloseHandler;
+    /**
+     * A running column resize: the first-row cells sizing the columns before
+     * and after the dragged border (`after` is null at the table's end edge,
+     * where the table itself grows), their widths when the drag began, and
+     * `direction` 1 in LTR or -1 in RTL, where the column before the border
+     * is the one on the right.
+     */
     private tableResizeState;
     private readonly tableResizeCursor;
     private readonly onTableResizeMoveBound;
@@ -2068,8 +2082,9 @@ declare class RichTextEditorComponent extends RichTextEditorAddonHost implements
      * Insert plain text at the restored caret as one history entry, then focus
      * the editor — the method a page button next to the editor calls.
      *
-     * No-op while readonly or disabled, and for the empty string (an empty
-     * insert would otherwise record a history entry that undoes nothing).
+     * No-op while readonly or disabled, when the text would take the document
+     * past {@link maxLength}, and for the empty string (an empty insert would
+     * otherwise record a history entry that undoes nothing).
      *
      * @publicApi
      */
@@ -2079,7 +2094,8 @@ declare class RichTextEditorComponent extends RichTextEditorAddonHost implements
      * editor. The markup goes through the editor's allow-list sanitizer, so a
      * `<script>` is dropped rather than inserted.
      *
-     * No-op while readonly or disabled, and when nothing survives sanitization.
+     * No-op while readonly or disabled, when nothing survives sanitization, and
+     * when its text would take the document past {@link maxLength}.
      * The single sanitize pass both answers that question and supplies the
      * markup that is inserted — deciding and inserting must not disagree.
      *
@@ -2391,7 +2407,6 @@ declare class RichTextEditorComponent extends RichTextEditorAddonHost implements
      * into a single text node, collapsing the block's lines into one.
      */
     private trailingBreakIn;
-    private insertNewlineInCodeBlock;
     private findAncestorByTag;
     private setSelectionRange;
     /**
@@ -2403,6 +2418,11 @@ declare class RichTextEditorComponent extends RichTextEditorAddonHost implements
      * down. Pasting is budgeted separately inside {@link onPaste}.
      */
     onBeforeInput(event: Event): void;
+    /**
+     * The text a drop or a paste would add, from the flavour that is inserted:
+     * the HTML when there is some, else the plain text.
+     */
+    private transferredText;
     /**
      * Template-bound `paste` handler. The native paste is ALWAYS cancelled first
      * — nothing reaches the DOM unfiltered — and any pending debounced history
@@ -2418,9 +2438,9 @@ declare class RichTextEditorComponent extends RichTextEditorAddonHost implements
     onPaste(event: ClipboardEvent): void;
     /**
      * Enforce `maxLength` on a paste, returning `true` when the paste was fully
-     * handled here. Measures against the plain-text (`text/plain`) clipboard
-     * value rather than parsing the untrusted HTML — the over-limit path inserts
-     * plain text anyway, so the HTML length would be the wrong budget.
+     * handled here. `text` is the visible text of what the paste inserts -- the
+     * normalized HTML flavour when there is one -- and the over-limit path
+     * inserts it, truncated, as plain text.
      */
     /**
      * The visible text an HTML fragment contributes, for budgeting against
@@ -2489,6 +2509,12 @@ declare class RichTextEditorComponent extends RichTextEditorAddonHost implements
      */
     private sweepSpentCaretAnchors;
     private perceivedText;
+    /**
+     * Whether adding `text` beside the document, replacing nothing, would take
+     * it past {@link maxLength}: an insert that lands after the caret's line
+     * frees none of the selection, which counted as freed let a block through.
+     */
+    private exceedsMaxLengthBeside;
     private exceedsMaxLength;
     private handlePasteMaxLength;
     /**
@@ -2635,6 +2661,13 @@ declare class RichTextEditorComponent extends RichTextEditorAddonHost implements
      * pinned to `'none'` for ~100ms while focus returns, which stops the mobile
      * software keyboard from flashing open. The caret is re-saved afterwards so
      * consecutive inserts append instead of stacking at the same spot.
+     *
+     * The guards every such insert shares come first: nothing is inserted while
+     * the editor is read-only or disabled, and `plainText` -- what the insert
+     * adds -- must fit {@link maxLength}. The limit is measured once the
+     * editor's caret is restored, against what the insert will replace:
+     * measured before, a selection elsewhere on the page was subtracted from
+     * the document as if the insert would replace it, and the limit gave way.
      */
     private insertAtRestoredCaret;
     /** Commit addon DOM edits to the model + flush pending history (addon host surface). */
@@ -2848,6 +2881,12 @@ declare class RichTextEditorComponent extends RichTextEditorAddonHost implements
         y: number;
     }) => void): () => void;
     private getSelectedTextLength;
+    /**
+     * The selected text when the selection lies in the editor, else nothing:
+     * only that is what an insert replaces. Text selected elsewhere on the page
+     * freed budget it does not occupy, so an insert got past maxLength.
+     */
+    private selectedTextInEditor;
     private closeTableContextMenu;
     private setupTableContextMenuCloseHandlers;
     private adjustTableContextMenuPosition;
@@ -2871,8 +2910,9 @@ declare class RichTextEditorComponent extends RichTextEditorAddonHost implements
     onEditorContextMenu(event: MouseEvent): void;
     /**
      * Template-bound `mousemove` handler; its only job is the column-resize
-     * affordance. Within 4px of a cell's right edge — or its left edge, for any
-     * column but the first — it switches the editable area's cursor to
+     * affordance. Within 4px of a column border that can be dragged (see
+     * `resolveResizeBorder`: a cell's end or start edge, mirrored in RTL, never
+     * the table's start edge) it switches the editable area's cursor to
      * `col-resize` and arms the flag {@link onEditorMouseDown} checks to start a
      * drag. Idle while a resize is already running, or when disabled/readonly.
      */
@@ -2914,7 +2954,7 @@ declare class RichTextEditorComponent extends RichTextEditorAddonHost implements
     private startTableResize;
     /**
      * Whether a pointer at `clientX` is within the column-resize hotspot of a
-     * cell's left or right edge.
+     * border {@link resolveResizeBorder} can move.
      *
      * Shared by the mouse and touch paths. The mouse path also uses it to set
      * the `col-resize` cursor on hover; touch has no hover, so the touch path
@@ -2922,7 +2962,24 @@ declare class RichTextEditorComponent extends RichTextEditorAddonHost implements
      * being shared, a column simply could not be resized on a touch device.
      */
     private isNearResizeBorder;
-    private getResizeColumnIndex;
+    /**
+     * The column border a pointer at `clientX` grabs on `cell`, as the
+     * first-row cells that size the rendered columns either side of it.
+     *
+     * Within 4px of the cell's end edge (right, or left in RTL) it is the
+     * border after the cell's last column; within 4px of its start edge, the
+     * border before its first column — none before the table's first column.
+     * Columns come from the cell grid, not the cell's index in its row, which a
+     * rowspan from above shifts. A fixed-layout table takes its column widths
+     * from the first row alone, so the border is only resizable when each
+     * column beside it has a first-row cell of its own (no colspan over it);
+     * `after` is null for the table's end edge, which resizes the table.
+     */
+    private resolveResizeBorder;
+    /** Which of the cell's inline edges `clientX` is on, if either. */
+    private resizeEdgeAt;
+    /** The cell covering `column` of a grid row, when it covers that column alone. */
+    private singleColumnCell;
     private onTableResizeMove;
     /**
      * Touch equivalent of {@link onTableResizeMove}. Registered non-passive so
@@ -2946,12 +3003,17 @@ declare class RichTextEditorComponent extends RichTextEditorAddonHost implements
     private onTableCellTouchMove;
     private onTableCellTouchEnd;
     private clearCellSelection;
+    /**
+     * The table as the browser lays it out: one slot per rendered row and
+     * column, each holding the cell that covers it (`null` for a hole in a
+     * ragged table). A cell starts at the first column its row has free after
+     * the rowspans reaching down from above, so the grid is as wide as the
+     * widest row *including* those carried-over columns — a row's own colspan
+     * sum undercounts it and leaves the pushed-right cells out of the grid.
+     */
     private buildCellGrid;
-    private getTotalRowColSpan;
     private fillCellGridRow;
-    private findNextAvailableColumn;
     private placeCellInGrid;
-    private isGridPositionInBounds;
     private getCellGridBounds;
     private findCellInRow;
     private updateCellSelection;
@@ -3125,7 +3187,19 @@ declare class RichTextEditorComponent extends RichTextEditorAddonHost implements
      *  own outer border must be left alone. */
     private clearTableBorders;
     private setBorderStyleNone;
+    /**
+     * The cells of `table` itself — not those of a table nested in one of
+     * them, which `querySelectorAll('td, th')` would also return.
+     */
+    private ownTableCells;
+    /**
+     * Frame the table: a cell gets a border on each side that lies on the
+     * table's edge as rendered — from its grid position, so a cell pushed
+     * right by a rowspan is not taken for the first column, and with the
+     * first column on the right in RTL.
+     */
     private applyOuterTableBorders;
+    /** Rules over the top and between rows; a cell reaching the last row gets none below. */
     private applyHorizontalTableBorders;
     /**
      * Set `text-align` on the single cell the table context menu targets — not
@@ -3685,7 +3759,10 @@ declare class RichTextEditorComponent extends RichTextEditorAddonHost implements
     private setSelectionAtNodeEnd;
     /**
      * Apply a built-in toolbar command to a specific block (addon host surface):
-     * the block-transform engine used by the slash-commands addon.
+     * the block-transform engine used by the slash-commands addon. With `null`
+     * the command runs at the current selection. A block that is no longer
+     * inside the editor — one an addon captured before an undo or `writeValue`
+     * rewrote the content — is ignored and nothing changes.
      */
     executeToolbarCommandOnBlock(command: string, anchorBlock: HTMLElement | null): void;
     private insertInlineCodeFromSlash;
@@ -4109,6 +4186,13 @@ declare class RichTextEditorComponent extends RichTextEditorAddonHost implements
     private lastReconstructedHtml;
     private reconstructHtmlCached;
     private pushHistory;
+    /**
+     * Drop the oldest entries past the history limit. Every entry must still
+     * reconstruct the HTML it was pushed with, so the head is always a
+     * keyframe: a delta about to become the head is rebuilt into a full
+     * snapshot while the base it depends on is still in the stack.
+     */
+    private trimHistoryToLimit;
     /**
      * Undo one step — mirrors `Ctrl`/`Cmd`+`Z`. Flushes a pending typing burst
      * first, so one call takes back the whole burst rather than half of it.
@@ -4197,7 +4281,7 @@ declare class RichTextEditorComponent extends RichTextEditorAddonHost implements
     private highlightCaretCodeBlock;
     ngOnDestroy(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RichTextEditorComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RichTextEditorComponent, "ui-rich-text-editor", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "toolbar": { "alias": "toolbar"; "required": false; "isSignal": true; }; "toolbarItems": { "alias": "toolbarItems"; "required": false; "isSignal": true; }; "customToolbarItems": { "alias": "customToolbarItems"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "minHeight": { "alias": "minHeight"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "markdownShortcuts": { "alias": "markdownShortcuts"; "required": false; "isSignal": true; }; "counter": { "alias": "counter"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "history": { "alias": "history"; "required": false; "isSignal": true; }; "findDebounceMs": { "alias": "findDebounceMs"; "required": false; "isSignal": true; }; "codeHighlightDebounceMs": { "alias": "codeHighlightDebounceMs"; "required": false; "isSignal": true; }; "allowedImageHosts": { "alias": "allowedImageHosts"; "required": false; "isSignal": true; }; "allowedLinkSchemes": { "alias": "allowedLinkSchemes"; "required": false; "isSignal": true; }; "blockedImageMessage": { "alias": "blockedImageMessage"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; }, { "customToolbarAction": "customToolbarAction"; "htmlChange": "htmlChange"; "markdownChange": "markdownChange"; "wordCountChange": "wordCountChange"; "historyChange": "historyChange"; "imageBlocked": "imageBlocked"; "focused": "focused"; "blurred": "blurred"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RichTextEditorComponent, "ui-rich-text-editor", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "toolbar": { "alias": "toolbar"; "required": false; "isSignal": true; }; "toolbarItems": { "alias": "toolbarItems"; "required": false; "isSignal": true; }; "customToolbarItems": { "alias": "customToolbarItems"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "minHeight": { "alias": "minHeight"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "markdownShortcuts": { "alias": "markdownShortcuts"; "required": false; "isSignal": true; }; "counter": { "alias": "counter"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "history": { "alias": "history"; "required": false; "isSignal": true; }; "findDebounceMs": { "alias": "findDebounceMs"; "required": false; "isSignal": true; }; "codeHighlightDebounceMs": { "alias": "codeHighlightDebounceMs"; "required": false; "isSignal": true; }; "allowedImageHosts": { "alias": "allowedImageHosts"; "required": false; "isSignal": true; }; "allowedLinkSchemes": { "alias": "allowedLinkSchemes"; "required": false; "isSignal": true; }; "blockedImageMessage": { "alias": "blockedImageMessage"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; }, { "customToolbarAction": "customToolbarAction"; "htmlChange": "htmlChange"; "markdownChange": "markdownChange"; "wordCountChange": "wordCountChange"; "historyChange": "historyChange"; "imageBlocked": "imageBlocked"; "focused": "focused"; "blurred": "blurred"; }, never, never, true, never>;
 }
 
 /**
@@ -4237,12 +4321,6 @@ declare const DEFAULT_LINK_SCHEMES: readonly string[];
 declare class RichTextSanitizerService {
     private readonly document;
     /** Allowlisted elements - only these can appear in sanitized output */
-    /**
-     * Whether `tagName` survives {@link sanitize}. The markdown service asks so
-     * it can decide whether a `<` in the source opens a real tag or is just a
-     * less-than sign the author typed.
-     */
-    isAllowedTag(tagName: string): boolean;
     private readonly ALLOWED_TAGS;
     /** Allowlisted attributes per element */
     private readonly ALLOWED_ATTRS;
@@ -4250,8 +4328,6 @@ declare class RichTextSanitizerService {
     private readonly ALLOWED_STYLE_PROPERTIES;
     /** Allowed class patterns (for syntax highlighting) */
     private readonly ALLOWED_CLASS_PATTERNS;
-    /** Dangerous URL protocols to block */
-    private readonly DANGEROUS_PROTOCOLS;
     /** Event handler attributes pattern */
     private readonly EVENT_HANDLER_PATTERN;
     /** Attributes an addon rule may never target — the security boundary stays here. */
@@ -4296,6 +4372,20 @@ declare class RichTextSanitizerService {
      * the next read took apart, so the document gained an empty paragraph on
      * every pass. The wrapper moves inside instead, around each inline run, so
      * its formatting survives: `<b><p>x</p></b>` becomes `<p><b>x</b></p>`.
+     *
+     * Innermost wrapper first, so each one finds the ones inside it already
+     * pushed down and descends only to the runs, never through them again:
+     * outermost first re-walked every wrapper nested below, and unclosed inline
+     * tags nest thousands deep. It also keeps the wrappers in their written
+     * order around each run. The moves keep every holder in the tree, and
+     * holding its block, so the holders are found once, up front.
+     *
+     * Each run takes each wrapper around it once, so the output is the runs
+     * times the wrappers -- quadratic when a wrapper is left open around every
+     * block. It is bounded, block by block: a block is not walked again for a
+     * copy of a wrapper already walked through it, which adds nothing, nor past
+     * MAX_NESTING_DEPTH wrappers, as every nested construct is capped. A copy of
+     * the very wrapper already around a run is skipped for the same reason.
      */
     private pushInlineWrappersIntoBlocks;
     /** Wrap each inline piece of `node` in a copy of `wrapper`, descending through blocks. */
@@ -4371,14 +4461,15 @@ declare class RichTextSanitizerService {
      */
     private normalizeStrayLines;
     /**
-     * Runs of inline content between the block children of `el`.
+     * `children` with each run of inline content between the blocks in a
+     * paragraph of its own, everything else in place.
      *
      * A block ENDS a run and is never part of one. Letting a nested list stay
      * in the run — because the sub-list exception says it does not make its
      * item a container — moved the list into the new paragraph, producing a
      * `<ul>` inside a `<p>` and one more empty paragraph on every save.
      */
-    private strayRunsOf;
+    private withStrayRunsWrapped;
     /**
      * Whether a block child means its host's own text needs a line of its own.
      *
@@ -4571,9 +4662,45 @@ declare class RichTextSanitizerService {
     stripTags(html: string): string;
     /** Tags that should be removed entirely (including content) */
     private readonly TAGS_TO_REMOVE;
+    /**
+     * Elements that change how the markup INSIDE them is parsed: MathML and SVG
+     * are foreign content, and the rest are scope boundaries a `<table>` does
+     * not close a paragraph across. Unwrapped, their content kept a shape the
+     * parser never builds -- `<p>a <math><mtext><table>` left a table inside a
+     * paragraph -- so the output read back as a different document, the
+     * instability mutation XSS is built on. Removed whole, the author's text
+     * went with them: "Click <button>Save</button> to continue" lost a word.
+     * They become their text alone, which keeps the words and none of the
+     * structure.
+     */
+    private readonly TAGS_TO_FLATTEN;
+    /**
+     * Copy one element, or what of it is safe, into `target`. Returns whether
+     * anything in it was removed rather than copied, so a paragraph can tell an
+     * emptiness sanitising caused from one the author wrote.
+     */
     private processElementNode;
+    /**
+     * Copy `element` into `target` as one text node of the text it shows --
+     * without the script or style text a removed tag holds. Walked with a
+     * stack: foreign content nests as deep as the parser allows.
+     *
+     * The element was a box of its own, so its text is set apart from text
+     * right before it: two buttons side by side read "Accept Decline", not
+     * one fused word.
+     */
+    private flattenToText;
+    /** Whether an image that named a source was left with neither a `src` nor a blocked-source marker. */
+    private lostItsSource;
+    /**
+     * Whether a block renders nothing: no element that draws, and no text but
+     * collapsible whitespace. A non-breaking space is the author's blank line
+     * and counts as content.
+     */
+    private showsNothingAtAll;
     /**
      * Process nodes recursively, copying safe content to clean container.
+     * Returns whether any of them was removed rather than copied.
      */
     private processNodes;
     /**
@@ -4680,6 +4807,11 @@ declare class RichTextPasteNormalizerService {
     private parseWordListItem;
     private convertWordLists;
     private stripListBulletSpan;
+    /**
+     * Nest a run of Word list paragraphs by their mso-list level: consecutive
+     * items at one level share one list under the same parent item, and an item
+     * at a shallower level closes every deeper list.
+     */
     private buildNestedList;
     private ensureNestedListParent;
     private readonly systemColorMap;
@@ -4740,7 +4872,27 @@ declare class RichTextPasteNormalizerService {
     private removeMetaTags;
     private stripClassAndIdAttributes;
     private isEffectivelyEmpty;
+    /**
+     * Drop wrappers that carry nothing: an attribute-less span with no visible
+     * content and a whitespace-only paragraph that has siblings.
+     *
+     * A span holding only whitespace is unwrapped, never deleted -- that
+     * whitespace is often the only thing separating two words
+     * (`<b>a</b><span> </span><i>b</i>`, or a Word spacerun), and deleting it
+     * glued them together.
+     */
     private removeEmptyElements;
+    /**
+     * The text nodes inside Word's `mso-spacerun:yes` runs: spaces the author
+     * typed, written as nbsp so they keep their width. Collected as nodes rather
+     * than elements because removeEmptyElements unwraps the whitespace-only run
+     * span, while the text node itself survives.
+     */
+    private collectSpacerunText;
+    /**
+     * Collapse each run of two or more nbsp into one space, leaving code and
+     * spacerun text (see {@link collectSpacerunText}) as written.
+     */
     private normalizeWhitespace;
     private readonly SEMANTIC_TAGS;
     private applySemanticStyleToElement;
@@ -4765,6 +4917,15 @@ interface MarkdownSpanSerializer {
 declare class RichTextMarkdownService {
     private readonly sanitizer;
     private readonly spanSerializers;
+    /** A code tag form the inline passes read back: their syntax escaped, an image as markdown. */
+    private readonly inlineCodeTag;
+    /**
+     * A code tag form that opens a raw HTML block, read back verbatim: nothing
+     * in it is markdown, so its text is only HTML-escaped and an image is its tag.
+     * Written as markdown there, the image came back as the characters of its
+     * syntax, and every escaped asterisk as a visible backslash.
+     */
+    private readonly rawCodeTag;
     /**
      * Register a span serializer consulted before the built-in mention/tag
      * handling in {@link toMarkdown}. Returns a teardown that unregisters it.
@@ -4773,27 +4934,17 @@ declare class RichTextMarkdownService {
     /**
      * Convert Markdown to sanitized HTML. Block constructs are parsed before
      * inline ones — the order of the passes below is load-bearing.
-     */
-    toHtml(markdown: string): string;
-    /**
-     * Replace every raw `<span …>` / `</span>` tag and `data-action-*` image
-     * tag with a placeholder token the markdown pipeline treats as opaque
-     * text, so escaping and block parsing leave the tag intact while its inner
-     * content is still processed. The restored tags are re-sanitized, so
-     * protecting non-action spans (rare in markdown) is harmless. Any private-
-     * use delimiter chars already in the input are stripped first so user
-     * content can never spoof a token.
-     */
-    /**
-     * Whether a tag written in the source is markup or prose about markup.
      *
-     * An author writing "the <table> element has <tr> children" means those as
-     * words; treating them as markup turned the sentence into a real table with
-     * the prose swallowed into a cell. Real markup comes in matched pairs, so an
-     * unpaired non-void tag is text.
+     * Raw HTML follows CommonMark 0.31.2. A raw HTML block (§4.6), at the top
+     * level or inside a quote, a list item or a details body, passes through
+     * verbatim to its end condition -- a blank line after a block tag or a lone
+     * tag, the closing tag of `<pre>`/`<script>`/`<style>`/`<textarea>`, the end
+     * of a comment -- so `<details>`, a blank line, markdown, a blank line and
+     * `</details>` renders the markdown inside the element. Inside a paragraph
+     * every well-formed tag, comment or declaration is raw HTML (§6.6), paired
+     * or not. The sanitizer still judges the whole output.
      */
-    private isMarkupTag;
-    private protectRawTags;
+    toHtml(markdown: string): string;
     /**
      * Lift fenced code bodies out of the source before anything else touches
      * them, already converted to their final `<pre><code>` form. Restored after
@@ -4801,17 +4952,39 @@ declare class RichTextMarkdownService {
      * with no markup smuggled through it into the live document.
      */
     private protectCodeFences;
+    /**
+     * Park every top-level raw HTML block (CommonMark 0.31.2 §4.6) whole: like a
+     * fence it is one opaque block that no markdown pass may rewrite, restored
+     * verbatim for the sanitizer to judge.
+     *
+     * Every pass's delimiters are stripped from the block, not only this pass's
+     * own: it runs before the others strip theirs, and a restored block is
+     * scanned again by the restores after it, so a delimiter typed inside it
+     * would forge another pass's token.
+     */
+    private protectHtmlBlocks;
     /**
      * Park a backslash-escaped punctuation character so no later pass reads it
-     * as syntax.
+     * as syntax, and every inline raw HTML construct of CommonMark 0.31.2 §6.6
+     * -- an open or closing tag, a comment, a processing instruction, a
+     * declaration, a CDATA section -- in `tagStore`.
      *
      * CommonMark: a backslash before any ASCII punctuation makes that character
      * literal. Neither half of that worked -- "2 \\* 3 \\* 4" came out as
      * "2 \\ 3 \\ 4" in italics, so the escape was ignored AND the backslash
      * rendered. Others (\\#, \\-, \\[) left a visible backslash.
      *
-     * Runs after protectInlineCode, so a backslash inside `code` stays literal
-     * as the spec requires, and before every syntax pass.
+     * One left-to-right scan, because escapes, code spans and raw HTML take
+     * precedence by position: a backslash inside `code` or inside a tag stays
+     * literal (example 631), and a backtick inside a tag opens no code span.
+     *
+     * Raw HTML is any well-formed construct, paired or not, known or not; the
+     * sanitizer, not this reader, decides what survives. Text that only mentions
+     * a tag is written with its "<" escaped, as toMarkdown does for every
+     * tag-shaped "<" in prose. Closing tags are parked like opening ones:
+     * escaping "</u>" but not "<u>" appended another visible "</u>" on every
+     * save. Every pass's delimiters are stripped first, so user content can
+     * never spoof a token.
      */
     private protectEscapes;
     /** Put escaped characters back as literal text, HTML-escaped. */
@@ -4828,8 +5001,9 @@ declare class RichTextMarkdownService {
     private restoreCodeFences;
     private restoreRawTags;
     /**
-     * Escape HTML entities but preserve Markdown syntax. Only `<`/`>` that look
-     * like HTML tags are escaped, so characters carrying Markdown meaning survive.
+     * Escape the angle brackets left in the text. Every raw HTML construct is
+     * parked by now (see protectEscapes), so a "<" left is text; a ">" is kept
+     * where it can be a quote marker.
      */
     private escapeHtmlInContent;
     /**
@@ -4897,7 +5071,11 @@ declare class RichTextMarkdownService {
     private isTableRow;
     /** The `| --- | :--: |` row that makes the line above it a header. */
     private isTableSeparator;
-    /** Cells of one row, honouring `\\|` escapes inside cell text. */
+    /**
+     * Cells of one row. Every pipe here is a cell boundary: an escaped `\|` in
+     * cell text never reaches this pass, because protectEscapes parks it before
+     * any block is parsed.
+     */
     private splitTableRow;
     /**
      * Parse horizontal rules (---, ***, ___).
@@ -4948,12 +5126,6 @@ declare class RichTextMarkdownService {
      * attribute of its own.
      */
     private attr;
-    /**
-     * An attribute value made of document text, which escapeHtmlInContent has
-     * already escaped: only a quote is escaped here. Escaped again, a "<" in alt
-     * text came back as the characters "&lt;", one more layer on every save.
-     */
-    private textAttr;
     /** Restore the characters {@link shieldUrl} hid, once those passes are done. */
     private unshieldUrls;
     /**
@@ -4976,6 +5148,9 @@ declare class RichTextMarkdownService {
      * parenthesis the target grammar cannot carry (see markdownTarget): the real
      * character reaches the sanitizer and the attribute, rather than the parked
      * token, which sanitizeImageSrc percent-encoded into the address.
+     *
+     * A title after the destination is split off and returned apart, typed the
+     * same way.
      */
     private targetSource;
     /**
@@ -5017,6 +5192,20 @@ declare class RichTextMarkdownService {
      * Parse links [text](url).
      */
     private parseLinks;
+    /**
+     * Remove a paragraph whose only content the media passes rejected.
+     *
+     * parseParagraphs must wrap lines before parseImages runs (the order is
+     * load-bearing), so a line holding only an unsafe image was wrapped first
+     * and then emptied, leaving a `<p></p>` the author never wrote -- visible
+     * spacing under prose margins. A paragraph is the parser's wrapper for
+     * content, so with its content gone it goes too; a heading or list item the
+     * author marked keeps its structure. Only parser-written `<p>` is literal at
+     * this point: an author's raw `<p></p>` is still parked and survives. One
+     * separating newline goes with the paragraph, so its neighbours keep the
+     * single newline between them.
+     */
+    private dropEmptiedParagraphs;
     /**
      * Parse bold and italic, in this order so the longer delimiters win:
      *
@@ -5076,10 +5265,10 @@ declare class RichTextMarkdownService {
      */
     private handleCodeTag;
     /**
-     * A code element's content for its tag form: its text escaped, each break as
-     * the tag, each image as markdown, and newlines as character references -- a
-     * raw one ended a heading or a task row the tag sat in, a blank line split the
-     * tag pair, and the break rewrite changed the code's own spaces.
+     * A code element's content for its tag form: its text and images as `writer`
+     * writes them, each break as the tag, and newlines as character references --
+     * a raw one ended a heading or a task row the tag sat in, a blank line split
+     * the tag pair, and the break rewrite changed the code's own spaces.
      */
     private codeTagContent;
     private handleAnchorTag;
@@ -5117,11 +5306,13 @@ declare class RichTextMarkdownService {
     /**
      * A code block as its tag pair, on one markdown line.
      *
-     * One line, with every newline written as a character reference, because a
-     * raw newline inside the pair would let the block passes split it: the
-     * `<pre>` and `</pre>` are parked separately and the lines between them are
-     * read as markdown. The reference decodes to the newline when the sanitizer
-     * parses the restored tag, so the code keeps its own line breaks.
+     * One line, with every newline written as a character reference. At the
+     * margin the pair opens a raw HTML block and is read back verbatim; inside a
+     * list item or a quote it is read inline, where a raw newline would let the
+     * block passes split it: the `<pre>` and `</pre>` are parked separately and
+     * the lines between them are read as markdown. The reference decodes to the
+     * newline when the sanitizer parses the restored tag, so the code keeps its
+     * own line breaks.
      */
     private preTagForm;
     private handleUlTag;
@@ -5312,11 +5503,14 @@ declare function richTextRequired(): ValidatorFn;
 /**
  * Cap the number of *visible* characters, so `<strong>` tags and `**` markers
  * do not eat a 280-character budget. Line breaks and block boundaries are not
- * characters. Emoji count in UTF-16 units, matching Angular's `maxLength` and
- * the editor's own character counter.
+ * characters. A character is what a reader sees as one (a grapheme cluster),
+ * counted by the same helper as the editor's own counter, so an emoji is one
+ * character here and there — unlike Angular's `maxLength`, which counts UTF-16
+ * units.
  *
  * @returns Angular's `{ maxlength: { requiredLength, actualLength } }`, so
  * `ui-field-auto-errors` renders its existing message with no configuration.
+ * `actualLength` is in the same characters.
  */
 declare function richTextMaxLength(max: number): ValidatorFn;
 /**
@@ -5507,8 +5701,28 @@ declare function isNestedList(node: Node): boolean;
  * empty paragraph on every pass.
  */
 declare function isPhrasing(node: Node): boolean;
-/** An inline element that wraps a block: a shape the parser keeps and nothing downstream can hold. */
-declare function isInlineHoldingBlock(node: Node): boolean;
+/**
+ * `node`'s children, walked by sibling rather than read from `childNodes`.
+ *
+ * Reading `childNodes` makes some DOM implementations keep that live list up to
+ * date on every later change to the node, a walk of every child per insert or
+ * removal: a pass that read a host holding thousands of lines, and then wrapped
+ * them, took time quadratic in the host.
+ */
+declare function childList(node: Node): ChildNode[];
+/**
+ * Every inline element under `root` that wraps a block -- a shape the parser
+ * keeps and nothing downstream can hold -- innermost first, with
+ * {@link isPhrasing} answered for the whole tree from the same single pass.
+ *
+ * Found from the leaves up in one pass. Asking isPhrasing of each element walks
+ * its whole subtree again, which is quadratic in the nesting depth, and unclosed
+ * inline tags nest thousands deep: three thousand `<b>` took eight seconds.
+ */
+declare function inlineElementsHoldingBlocks(root: Element): {
+    holders: Element[];
+    phrasing: (node: Node) => boolean;
+};
 /** A task row's content and the nested lists under it; see rowRunsOf. */
 interface RowRun {
     readonly content: Node[];
@@ -5799,7 +6013,7 @@ interface RichTextActionDefinition {
     id: string;
     label: string;
     description?: string;
-    /** Lucide icon name shown in the picker. */
+    /** Icon name shown in the picker. */
     icon?: string;
     triggers: RichTextActionTrigger[];
     /** Which targets the action may attach to. Default: both. */
@@ -5923,8 +6137,10 @@ declare class RichTextActionsDirective {
     /**
      * An action was written to the document (attach or edit). A combined
      * action emits twice — once for `'click'`, once for `'hover'` — with the
-     * params each trigger received. Not emitted when the flow aborts because
-     * the target selection was lost.
+     * params each trigger received. Not emitted when the target was lost —
+     * the text selection could not be restored, or the captured image or
+     * action element left the editor while the dialog was open (setContent,
+     * undo): nothing is written and a dialog awaiting confirm stays open.
      */
     readonly actionAttached: _angular_core.OutputEmitterRef<{
         actionId: string;
@@ -5989,6 +6205,15 @@ declare class RichTextActionsDirective {
      */
     private injectVisualizationStyles;
     private releaseVisualizationStyles;
+    /**
+     * Whether the element the flow captured can no longer take the action,
+     * logging when so. An image flow always captures its image, and any
+     * captured element must still be inside the editor: setContent, undo or
+     * writeValue can replace the content while the dialog is open, and an
+     * action written onto the detached node would be reported as attached
+     * although the document never changed.
+     */
+    private targetLost;
     private applyAction;
     private applyCombined;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RichTextActionsDirective, never>;
@@ -6871,6 +7096,7 @@ declare const RICH_TEXT_FILE_IMPORT_LOCALES: Record<string, RichTextFileImportLo
 
 declare class RichTextFileImportDirective {
     private readonly host;
+    private readonly sanitizer;
     private readonly injector;
     private readonly vcr;
     /** Locale for the addon UI: a registry key (`'en'`/`'he'`/…) or a full dictionary. */
@@ -6891,7 +7117,7 @@ declare class RichTextFileImportDirective {
     readonly uiRteFileImportAccept: _angular_core.InputSignal<string | undefined>;
     /** Emits the `File` when an import begins. */
     readonly fileImportStart: _angular_core.OutputEmitterRef<File>;
-    /** Emits the inserted HTML when an import completes. */
+    /** Emits the sanitized HTML that was inserted when an import completes — the same markup the editor now holds. */
     readonly fileImportComplete: _angular_core.OutputEmitterRef<string>;
     /** Emits an error message when an import fails. */
     readonly fileImportError: _angular_core.OutputEmitterRef<string>;
@@ -7403,6 +7629,7 @@ declare class RichTextImagesDirective {
     private readonly injector;
     private readonly vcr;
     private readonly document;
+    private readonly destroyRef;
     /** Locale for the addon UI: a registry key (`'en'`/`'he'`/…) or a full dictionary. */
     readonly uiRteImagesLocale: _angular_core.InputSignal<LocaleInput<RichTextImagesLocale> | undefined>;
     /**
@@ -7441,18 +7668,26 @@ declare class RichTextImagesDirective {
     private readonly uploading;
     private readonly autoUploadErrors;
     private readonly autoUploadMap;
+    /**
+     * The src this directive last wrote to each image (placeholder or upload
+     * result). An image whose src is still that value is never auto-uploaded.
+     * The observer sees the directive's own edits too -- its records arrive as a
+     * microtask, after any flag set around the edit is cleared -- so eligibility,
+     * not timing, keeps a placeholder or a data-URL result from being sent.
+     */
+    private readonly writtenSources;
     private autoUploadCounter;
-    private autoUploadMutating;
     private autoUploadObserver;
     private overlayRef?;
     /**
      * Whether this directive has been torn down.
      *
      * An upload is a network round-trip the user can easily outlive — routing
-     * away, closing a dialog, toggling a tab. The auto-upload path already
-     * unsubscribes on destroy, but the manual insert/drop/paste path awaited its
-     * promise with nothing watching, then committed into a dead editor and
-     * emitted outputs whose owning directive no longer exists (NG0953).
+     * away, closing a dialog, toggling a tab. Teardown cancels every in-flight
+     * upload, which settles the manual insert/drop/paste promise; this flag
+     * stops that settled promise, and a file read still in progress, from
+     * committing into a dead editor or emitting outputs whose owning directive
+     * no longer exists (NG0953).
      */
     private destroyed;
     private readonly resizerLabels;
@@ -7498,6 +7733,21 @@ declare class RichTextImagesDirective {
     private injectAutoUploadStyles;
     private releaseAutoUploadStyles;
     private scanForBase64Images;
+    /**
+     * A base64 image that is not already uploading and whose src this directive
+     * did not write. The placeholder pixel is also refused by value, because
+     * undo or setContent restore a rejected image as a new element that
+     * {@link writtenSources} has never seen.
+     */
+    private isAutoUploadCandidate;
+    /**
+     * Cancel every upload whose image has left the editor -- deleted, inside a
+     * removed subtree, or replaced by undo/setContent. Checked against the
+     * document when the records arrive, so an image moved within the editor
+     * (removed and re-added in one batch) keeps its upload.
+     */
+    private cancelDetachedUploads;
+    private writeSrc;
     private processAutoUploadImage;
     private markImageAsUploading;
     private revertInvalidUploadImage;
@@ -7624,6 +7874,12 @@ declare class RichTextImageResizerComponent implements OnDestroy {
     readonly deleteIconHtml: SafeHtml;
     private rafId;
     private resizeObserver;
+    /**
+     * The element the scroll listener was added to. Kept because
+     * {@link container} may have changed by the time tracking stops, and the
+     * listener must come off the element it went on.
+     */
+    private scrollListenerTarget;
     private readonly onContainerScrollBound;
     private readonly onWindowResizeBound;
     private resizeState;
@@ -7682,6 +7938,15 @@ declare class RichTextImageResizerComponent implements OnDestroy {
      */
     startResize(event: MouseEvent | TouchEvent, handle: ResizeHandle): void;
     private onPointerMove;
+    /**
+     * Accessible name for one resize handle.
+     *
+     * The handles were bare divs -- no tabindex, no role, no name -- so image
+     * resizing was strictly pointer-only. They are buttons now, and each says
+     * which corner or edge it drags. The compass point is spelled out rather
+     * than left as "nw" so it is pronounceable.
+     */
+    handleLabel(handle: ResizeHandle): string;
     /**
      * Resize the image from the keyboard.
      *
@@ -7692,15 +7957,6 @@ declare class RichTextImageResizerComponent implements OnDestroy {
      * the image with the arrow keys, holding the aspect ratio when
      * {@link lockAspectRatio} asks for it. Shift moves in larger steps.
      */
-    /**
-     * Accessible name for one resize handle.
-     *
-     * The handles were bare divs -- no tabindex, no role, no name -- so image
-     * resizing was strictly pointer-only. They are buttons now, and each says
-     * which corner or edge it drags. The compass point is spelled out rather
-     * than left as "nw" so it is pronounceable.
-     */
-    handleLabel(handle: ResizeHandle): string;
     onResizeKeydown(event: KeyboardEvent, handle: ResizeHandle): void;
     /**
      * Emit one {@link resizeEnd} for a run of keypresses.
@@ -7721,31 +7977,18 @@ declare class RichTextImageResizerComponent implements OnDestroy {
      * the default.
      */
     private clampWidth;
+    /** The width bound: {@link maxWidth} when set, never above the absolute cap. */
+    private widthCeiling;
     /**
-     * Size with the aspect ratio held. BOTH axes are bounded here.
-     *
-     * Clamping width and then deriving height by division skipped the height
-     * bound entirely: a 20x10000 image dragged out reached 5,000,000px. And
-     * because `lockAspectRatio` defaults to true, that is the path most users
-     * are on -- the earlier bounds fix, and both of its tests, only exercised
-     * `freeSize`, the ratio-unlocked function.
+     * Fit a ratio-locked size inside the bounds by scaling both axes by one
+     * factor, so the image keeps its shape and the drag stays responsive.
      *
-     * The ratio is preserved while clamping, so the image stays the shape it
-     * was. Only the ceiling is enforced here; the floor belongs to
-     * onPointerMove, which rejects an undersized drag rather than snapping it.
-     */
-    /**
-     * Fit a ratio-locked size inside the bounds, scaling rather than overriding.
-     *
-     * The earlier version enforced the floor on the DERIVED axis and then
-     * back-projected it onto the axis the user was dragging, which pinned the
-     * width: a 2000x40 banner returned 1000px for a 500px request and for a
-     * 100px request alike, so the drag was unresponsive below 1000px -- the
-     * frozen drag relocated, not removed. It could also return a dimension under
-     * the very floor it exists to enforce.
-     *
-     * Scaling both axes by one factor keeps the ratio, keeps the drag
-     * responsive, and cannot produce a dimension outside the bounds.
+     * The floor is applied first and the ceiling last, so the ceiling always
+     * holds: {@link minWidth} on both axes, {@link maxWidth} (or the absolute
+     * cap) on width and the absolute cap on height. When the ratio is so extreme
+     * that no size satisfies floor and ceiling together (past cap:floor, 500:1 by
+     * default), the ceiling wins and the short side may end under the floor --
+     * the ratio is never bent to rescue it.
      */
     private ratioBoundedSize;
     private lockedSize;
@@ -8299,6 +8542,7 @@ declare class RichTextMentionsDirective {
     constructor();
     private get doc();
     private setupSearch;
+    private runSearch;
     private onInput;
     private onKeydown;
     private onSelect;
@@ -8391,7 +8635,7 @@ declare class RichTextMentionPopoverComponent implements AfterViewInit, OnDestro
     readonly itemSelect: _angular_core.OutputEmitterRef<MentionItem | TagItem>;
     /**
      * The user dismissed the list: `Escape`/`Tab`, or a click anywhere outside
-     * the `ui-rich-text-mention-popover` element. The host owns the teardown;
+     * this popover (whatever its host tag). The host owns the teardown;
      * this component stays rendered until it is destroyed.
      */
     readonly closed: _angular_core.OutputEmitterRef<void>;
@@ -8404,6 +8648,13 @@ declare class RichTextMentionPopoverComponent implements AfterViewInit, OnDestro
     readonly listboxId: string;
     optionId(index: number): string;
     readonly selectedIndex: _angular_core.WritableSignal<number>;
+    private readonly host;
+    /**
+     * Dismisses on a click outside THIS popover. Containment is the host's DOM
+     * subtree, never a selector string: a `--prefix` install or a selector
+     * rename changes the tag, and a tag query also treated a click inside a
+     * second, sibling popover as "inside" this one.
+     */
     private readonly clickListener;
     readonly containerClasses: _angular_core.Signal<string>;
     /**
@@ -9053,6 +9304,6 @@ declare const RICH_TEXT_TYPOGRAPHY_BUTTON_CONTEXT: InjectionToken<RichTextTypogr
 
 declare const RTE_FULL: readonly [typeof RichTextActionsDirective, typeof RichTextAiDirective, typeof RichTextColorsDirective, typeof RichTextEmojiDirective, typeof RichTextFileImportDirective, typeof RichTextHistoryDirective, typeof RichTextImagesDirective, typeof RichTextLinksDirective, typeof RichTextMentionsDirective, typeof RichTextOutlineDirective, typeof RichTextSlashCommandsDirective, typeof RichTextTablesDirective, typeof RichTextTypographyDirective];
 
-export { ACTION_ATTRS, ACTION_PARAMS, AddonSlotRegistry, DEFAULT_COLOR_PALETTE, DEFAULT_FONT_FAMILIES, DEFAULT_HIGHLIGHT_PALETTE, DEFAULT_LINK_SCHEMES, DEFAULT_TOOLBAR_ITEMS, DOCUMENT_IMPORT_ACCEPT, DOCX_MIME, EMPTINESS_FIXTURES, FIND_MAX_PAINTED_RECTS, FIND_MAX_QUERY_LENGTH, HEADER_BYTES, IMAGE_IMPORT_ACCEPT, INLINE_RULE_LOOKBEHIND, MAX_NESTING_DEPTH, PDF_MIME, PresetDialogComponent, PresetHoverCardComponent, RICH_TEXT_ACTIONS_SANITIZER_RULES, RICH_TEXT_AI_CONTEXT, RICH_TEXT_AI_LOCALES, RICH_TEXT_COLORS_LOCALES, RICH_TEXT_COLOR_BUTTON_CONTEXT, RICH_TEXT_EMOJI_CONTEXT, RICH_TEXT_EMOJI_LOCALES, RICH_TEXT_FILE_IMPORT_BUTTON_CONTEXT, RICH_TEXT_FILE_IMPORT_LOCALES, RICH_TEXT_HISTORY_LOCALES, RICH_TEXT_IMAGES_BUTTON_CONTEXT, RICH_TEXT_IMAGES_LOCALES, RICH_TEXT_LINKS_BUTTON_CONTEXT, RICH_TEXT_LINKS_LOCALES, RICH_TEXT_LOCALES, RICH_TEXT_MENTIONS_LOCALES, RICH_TEXT_OUTLINE_CONTEXT, RICH_TEXT_OUTLINE_LOCALES, RICH_TEXT_PROSE_CLASSES, RICH_TEXT_SHORTCUT_DEFINITIONS, RICH_TEXT_SLASH_COMMANDS_LOCALES, RICH_TEXT_TABLES_BUTTON_CONTEXT, RICH_TEXT_TABLES_LOCALES, RICH_TEXT_TYPOGRAPHY_BUTTON_CONTEXT, RICH_TEXT_TYPOGRAPHY_LOCALES, RTE_FULL, RichTextActionsBindDirective, RichTextActionsDirective, RichTextAiChipComponent, RichTextAiDirective, RichTextAiPanelComponent, RichTextAllowDirective, RichTextAllowHost, RichTextColorsButtonComponent, RichTextColorsDirective, RichTextCommandRegistry, RichTextEditorAddonHost, RichTextEditorComponent, RichTextEmojiButtonComponent, RichTextEmojiDirective, RichTextFileImportButtonComponent, RichTextFileImportDirective, RichTextFileImportOverlayComponent, RichTextHistoryDirective, RichTextHistoryPanelComponent, RichTextImageResizerComponent, RichTextImagesButtonComponent, RichTextImagesDirective, RichTextImagesOverlayComponent, RichTextLinksButtonComponent, RichTextLinksDirective, RichTextLinksFormComponent, RichTextMarkdownService, RichTextMentionPopoverComponent, RichTextMentionsDirective, RichTextOutlineDirective, RichTextOutlinePanelComponent, RichTextPasteNormalizerService, RichTextSanitizerService, RichTextSlashCommandsDirective, RichTextSlashCommandsMenuComponent, RichTextTablesButtonComponent, RichTextTablesDirective, RichTextToolbarComponent, RichTextToolbarViewContext, RichTextTypographyButtonComponent, RichTextTypographyDirective, TEXT_STYLE_OPTIONS, TOOLBAR_BUTTONS, TRANSPARENT_PIXEL, addonSetting, anchorOverlay, applyImageAlignment, applyStarterStyle, assertFlatParams, bindRichTextActions, blockquoteDepthOf, buildDefaultSlashCommands, buildEntityInsertNode, buildEntityRenderContext, buildFindIndex, buildLineIndex, caretPosition, classifyImport, compileFindRegex, computeSeedStyleString, containsCssUrl, createImageElement, cssFunctionCalls, dataUrlToFile, decodeCssEscapes, detectTrigger, directionOf, dragHasSupportedDocument, extractCssUrls, flattenIntoRowText, hasUnsafeCssFunction, holdsNothing, hostOf, hoverCardAction, hoverCardHandlers, isCombinedOnElement, isHostAllowed, isHostBearingUrl, isInlineHoldingBlock, isLineOwner, isNestedList, isPdfHeader, isPhrasing, isRichTextEmpty, isSupportedDocumentFile, isZipHeader, labelBlockedImages, lastOwnInlineNode, lineAbove, lineBelow, lineIsEmpty, lineIsTextOnly, lineKeepsItsElement, lineOf, lineOwnNodes, lineTagIsFixed, lineText, linesBetween, linesMayJoin, linkedPreviewDialogAction, linkedPreviewDialogHandlers, matchBlockInputRule, matchInlineInputRule, mountTopLayer, nodeShowsNothing, normalizeHostEntry, offsetToPosition, openDialogAction, openDialogHandlers, parseImageSize, placeCaretIn, placeImageAtSelection, positionAfterLine, rangeShowsNothing, readActions, readFileAsDataUrl, remoteHostOf, removeAction, reportResourceDecisions, resolveFromPage, richTextHasMedia, richTextMaxLength, richTextMinWords, richTextRequired, richTextVisibleText, rowRunsOf, selectTriggerRange, separateListKinds, simpleHash, stripCssComments, stripStyleIfMatches, structureAround, validateActionId, validateActionParams, writeAction, writeCombined };
+export { ACTION_ATTRS, ACTION_PARAMS, AddonSlotRegistry, DEFAULT_COLOR_PALETTE, DEFAULT_FONT_FAMILIES, DEFAULT_HIGHLIGHT_PALETTE, DEFAULT_LINK_SCHEMES, DEFAULT_TOOLBAR_ITEMS, DOCUMENT_IMPORT_ACCEPT, DOCX_MIME, EMPTINESS_FIXTURES, FIND_MAX_PAINTED_RECTS, FIND_MAX_QUERY_LENGTH, HEADER_BYTES, IMAGE_IMPORT_ACCEPT, INLINE_RULE_LOOKBEHIND, MAX_NESTING_DEPTH, PDF_MIME, PresetDialogComponent, PresetHoverCardComponent, RICH_TEXT_ACTIONS_SANITIZER_RULES, RICH_TEXT_AI_CONTEXT, RICH_TEXT_AI_LOCALES, RICH_TEXT_COLORS_LOCALES, RICH_TEXT_COLOR_BUTTON_CONTEXT, RICH_TEXT_EMOJI_CONTEXT, RICH_TEXT_EMOJI_LOCALES, RICH_TEXT_FILE_IMPORT_BUTTON_CONTEXT, RICH_TEXT_FILE_IMPORT_LOCALES, RICH_TEXT_HISTORY_LOCALES, RICH_TEXT_IMAGES_BUTTON_CONTEXT, RICH_TEXT_IMAGES_LOCALES, RICH_TEXT_LINKS_BUTTON_CONTEXT, RICH_TEXT_LINKS_LOCALES, RICH_TEXT_LOCALES, RICH_TEXT_MENTIONS_LOCALES, RICH_TEXT_OUTLINE_CONTEXT, RICH_TEXT_OUTLINE_LOCALES, RICH_TEXT_PROSE_CLASSES, RICH_TEXT_SHORTCUT_DEFINITIONS, RICH_TEXT_SLASH_COMMANDS_LOCALES, RICH_TEXT_TABLES_BUTTON_CONTEXT, RICH_TEXT_TABLES_LOCALES, RICH_TEXT_TYPOGRAPHY_BUTTON_CONTEXT, RICH_TEXT_TYPOGRAPHY_LOCALES, RTE_FULL, RichTextActionsBindDirective, RichTextActionsDirective, RichTextAiChipComponent, RichTextAiDirective, RichTextAiPanelComponent, RichTextAllowDirective, RichTextAllowHost, RichTextColorsButtonComponent, RichTextColorsDirective, RichTextCommandRegistry, RichTextEditorAddonHost, RichTextEditorComponent, RichTextEmojiButtonComponent, RichTextEmojiDirective, RichTextFileImportButtonComponent, RichTextFileImportDirective, RichTextFileImportOverlayComponent, RichTextHistoryDirective, RichTextHistoryPanelComponent, RichTextImageResizerComponent, RichTextImagesButtonComponent, RichTextImagesDirective, RichTextImagesOverlayComponent, RichTextLinksButtonComponent, RichTextLinksDirective, RichTextLinksFormComponent, RichTextMarkdownService, RichTextMentionPopoverComponent, RichTextMentionsDirective, RichTextOutlineDirective, RichTextOutlinePanelComponent, RichTextPasteNormalizerService, RichTextSanitizerService, RichTextSlashCommandsDirective, RichTextSlashCommandsMenuComponent, RichTextTablesButtonComponent, RichTextTablesDirective, RichTextToolbarComponent, RichTextToolbarViewContext, RichTextTypographyButtonComponent, RichTextTypographyDirective, TEXT_STYLE_OPTIONS, TOOLBAR_BUTTONS, TRANSPARENT_PIXEL, addonSetting, anchorOverlay, applyImageAlignment, applyStarterStyle, assertFlatParams, bindRichTextActions, blockquoteDepthOf, buildDefaultSlashCommands, buildEntityInsertNode, buildEntityRenderContext, buildFindIndex, buildLineIndex, caretPosition, childList, classifyImport, compileFindRegex, computeSeedStyleString, containsCssUrl, createImageElement, cssFunctionCalls, dataUrlToFile, decodeCssEscapes, detectTrigger, directionOf, dragHasSupportedDocument, extractCssUrls, flattenIntoRowText, hasUnsafeCssFunction, holdsNothing, hostOf, hoverCardAction, hoverCardHandlers, inlineElementsHoldingBlocks, isCombinedOnElement, isHostAllowed, isHostBearingUrl, isLineOwner, isNestedList, isPdfHeader, isPhrasing, isRichTextEmpty, isSupportedDocumentFile, isZipHeader, labelBlockedImages, lastOwnInlineNode, lineAbove, lineBelow, lineIsEmpty, lineIsTextOnly, lineKeepsItsElement, lineOf, lineOwnNodes, lineTagIsFixed, lineText, linesBetween, linesMayJoin, linkedPreviewDialogAction, linkedPreviewDialogHandlers, matchBlockInputRule, matchInlineInputRule, mountTopLayer, nodeShowsNothing, normalizeHostEntry, offsetToPosition, openDialogAction, openDialogHandlers, parseImageSize, placeCaretIn, placeImageAtSelection, positionAfterLine, rangeShowsNothing, readActions, readFileAsDataUrl, remoteHostOf, removeAction, reportResourceDecisions, resolveFromPage, richTextHasMedia, richTextMaxLength, richTextMinWords, richTextRequired, richTextVisibleText, rowRunsOf, selectTriggerRange, separateListKinds, simpleHash, stripCssComments, stripStyleIfMatches, structureAround, validateActionId, validateActionParams, writeAction, writeCombined };
 export type { ActionParams, ActionParamsMode, ActionTargetKind, BindRichTextActionsOptions, BlockInputRuleKind, BlockInputRuleMatch, CounterMode, DocumentImportKind, EditorMode, EditorSize, EditorVariant, FindIndex, FindOptions, FindPosition, FindSegment, FontFamilyStrategy, HoverCardPresetOptions, ImageAlignment, ImageInsertDefaults, ImageUploadErrorEntry, ImportKind, InlineInputRuleKind, InlineInputRuleMatch, Line, LineIndex, LineKind, LinePosition, LinkedPreviewDialogOptions, MarkdownSpanSerializer, MentionItem, MountedOverlay, OpenDialogPresetOptions, OutlineHeading, PasteSource, ResourcePolicyDecision, RichTextActionDefinition, RichTextActionEvent, RichTextActionField, RichTextActionHandler, RichTextActionParamsContext, RichTextActionParamsForm, RichTextActionTrigger, RichTextAddonOptions, RichTextAddonSetting, RichTextAddonState, RichTextAiContext, RichTextAiLocale, RichTextAiPhase, RichTextAiPoint, RichTextAiTaskOption, RichTextAllow, RichTextColorButtonContext, RichTextColorChange, RichTextColorKind, RichTextColorsLocale, RichTextCustomToolbarItem, RichTextEditorApi, RichTextEditorRef, RichTextEmojiContext, RichTextEmojiLocale, RichTextEntityInsertEvent, RichTextEntityRenderContext, RichTextEntityRenderMode, RichTextEntityRenderOptions, RichTextEntitySearchFn, RichTextEntitySearchResult, RichTextEntityType, RichTextExclusivePopover, RichTextFileImportButtonContext, RichTextFileImportLocale, RichTextFormatCommand, RichTextHistoryEntrySnapshot, RichTextHistoryLocale, RichTextHistoryOptions, RichTextHistoryState, RichTextImageResizerLabels, RichTextImageSources, RichTextImagesButtonContext, RichTextImagesLayoutOptions, RichTextImagesLocale, RichTextImagesUploadOptions, RichTextInlineStyle, RichTextLinkSubmit, RichTextLinksButtonContext, RichTextLinksLocale, RichTextLocale, RichTextMentionsLocale, RichTextOutlineContext, RichTextOutlineLocale, RichTextSelectionInlineStyle, RichTextSelectionSnapshot, RichTextSetContentOptions, RichTextSlashCommand, RichTextSlashCommandAvailabilityContext, RichTextSlashCommandContext, RichTextSlashCommandsLocale, RichTextTablesButtonContext, RichTextTablesLocale, RichTextToolbarSlot, RichTextTypographyButtonContext, RichTextTypographyKind, RichTextTypographyLocale, RowRun, SanitizerAttributeRule, TagItem, TextDirection, TextStyleOption, ToolbarButton, ToolbarButtonItem, ToolbarItem, ToolbarPosition, TriggerMatch };
 //# sourceMappingURL=gilav21-shadcn-angular-rte.d.ts.map