@flikk/ui 1.0.0-beta.30 → 1.0.0-beta.32

package/dist/components/forms/RichTextEditor/RichTextToolbar.js

@@ -0,0 +1,93 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { ArrowUUpRight, ArrowUUpLeft, Eraser, Code, Quotes, ListNumbers, ListBullets, LinkSimple, TextStrikethrough, TextUnderline, TextItalic, TextB } from '@phosphor-icons/react';
+import { Button } from '../../core/Button/Button.js';
+import { Select } from '../Select/Select.js';
+import '../Select/Select.theme.js';
+import { cn } from '../../../utils/cn.js';
+import 'react';
+import { richTextEditorTheme } from './RichTextEditor.theme.js';
+
+/** The compact default: block style, inline marks, links, lists, history. */
+const DEFAULT_TOOLBAR_TOOLS = [
+    "blockStyle",
+    "separator",
+    "bold",
+    "italic",
+    "underline",
+    "strikethrough",
+    "separator",
+    "link",
+    "bulletList",
+    "orderedList",
+    "separator",
+    "blockquote",
+    "code",
+    "clearFormat",
+    "separator",
+    "undo",
+    "redo",
+];
+const BLOCK_OPTIONS = [
+    { id: "paragraph", value: "paragraph", label: "Paragraph" },
+    { id: "h1", value: "h1", label: "Heading 1" },
+    { id: "h2", value: "h2", label: "Heading 2" },
+    { id: "h3", value: "h3", label: "Heading 3" },
+    { id: "h4", value: "h4", label: "Heading 4" },
+];
+/** Icon + accessible name for every button-shaped tool. */
+const TOOL_META = {
+    bold: { icon: jsx(TextB, {}), label: "Bold" },
+    italic: { icon: jsx(TextItalic, {}), label: "Italic" },
+    underline: { icon: jsx(TextUnderline, {}), label: "Underline" },
+    strikethrough: { icon: jsx(TextStrikethrough, {}), label: "Strikethrough" },
+    link: { icon: jsx(LinkSimple, {}), label: "Link" },
+    bulletList: { icon: jsx(ListBullets, {}), label: "Bulleted list" },
+    orderedList: { icon: jsx(ListNumbers, {}), label: "Numbered list" },
+    blockquote: { icon: jsx(Quotes, {}), label: "Blockquote" },
+    code: { icon: jsx(Code, {}), label: "Code" },
+    clearFormat: { icon: jsx(Eraser, {}), label: "Clear formatting" },
+    undo: { icon: jsx(ArrowUUpLeft, {}), label: "Undo" },
+    redo: { icon: jsx(ArrowUUpRight, {}), label: "Redo" },
+};
+/** Which tools report a pressed state, and where to read it from. */
+const PRESSED_KEY = {
+    bold: "bold",
+    italic: "italic",
+    underline: "underline",
+    strikethrough: "strikethrough",
+    bulletList: "bulletList",
+    orderedList: "orderedList",
+    blockquote: "blockquote",
+    code: "code",
+};
+const RichTextToolbar = ({ tools, formatting, disabled, size, className, onCommand, onBlockChange, }) => {
+    const controlSize = size === "lg" ? "md" : "sm";
+    return (jsx("div", { role: "toolbar", "aria-label": "Formatting", "aria-orientation": "horizontal", className: cn(richTextEditorTheme.toolbarStyle, className), children: tools.map((tool, index) => {
+            if (tool === "separator") {
+                return (jsx("span", { "aria-hidden": "true", className: richTextEditorTheme.separatorStyle }, `separator-${index}`));
+            }
+            if (tool === "blockStyle") {
+                return (jsx(Select, { "aria-label": "Block style", options: BLOCK_OPTIONS, value: formatting.block, onChange: onBlockChange, disabled: disabled, size: controlSize, 
+                    // 🔴 wrapperClassName, not className: per CLAUDE.md §9 `className`
+                    // targets Select's trigger button, while its wrapper carries the
+                    // shared `relative w-full`. Sizing the trigger alone left the
+                    // wrapper stretching the whole toolbar row, so `flex-wrap` pushed
+                    // every button onto a second line.
+                    wrapperClassName: "w-36 shrink-0" }, "blockStyle"));
+            }
+            const meta = TOOL_META[tool];
+            if (!meta)
+                return null;
+            const pressedKey = PRESSED_KEY[tool];
+            const isPressed = tool === "link" ? formatting.link !== null : pressedKey ? formatting[pressedKey] : undefined;
+            return (jsx(Button, { type: "button", iconOnly: true, variant: isPressed ? "soft" : "ghost", color: "mono", size: controlSize, state: disabled ? "disabled" : "default", "aria-label": meta.label, "aria-pressed": isPressed, iconStart: meta.icon, 
+                // 🔴 Load-bearing: without this the button takes focus on press and the
+                // editor's selection collapses, so the command would apply to nothing.
+                // preventDefault on mousedown keeps focus (and the Range) in the editor.
+                onMouseDown: (event) => event.preventDefault(), onClick: () => onCommand(tool) }, tool));
+        }) }));
+};
+RichTextToolbar.displayName = "RichTextToolbar";
+
+export { DEFAULT_TOOLBAR_TOOLS, RichTextToolbar };

package/dist/components/forms/RichTextEditor/editorCommands.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The ONLY module permitted to call `document.execCommand`.
+ *
+ * `execCommand` is deprecated, and every non-deprecated alternative is an editor
+ * framework (ProseMirror/Lexical) — a dependency this library does not take. For
+ * a semantic editor the API maps almost 1:1 onto the tools we ship, and
+ * hand-rolling list nesting and block splitting from `Range` is where custom
+ * editors accumulate their worst selection bugs.
+ *
+ * Two things contain the risk:
+ *   1. Its practical weakness is inconsistent markup across browsers (`<b>` vs
+ *      `<strong>`, stray `<div>`, `<font>`), which `sanitizeHtml`'s normalizer
+ *      resolves on every read — so the value we store is identical everywhere.
+ *   2. It is confined to this file. Adopting a real engine later means
+ *      reimplementing this module and nothing else.
+ *
+ * State is deliberately NOT read here: `queryCommandState` is unreliable for
+ * block-level state. See `editorState.ts`.
+ */
+import type { BlockStyle } from "./RichTextEditor.types";
+export declare const toggleBold: () => void;
+export declare const toggleItalic: () => void;
+export declare const toggleUnderline: () => void;
+export declare const toggleStrikethrough: () => void;
+export declare const toggleBulletList: () => void;
+export declare const toggleOrderedList: () => void;
+export declare const undo: () => void;
+export declare const redo: () => void;
+/**
+ * Clear inline formatting. `removeFormat` leaves list/quote structure alone,
+ * which is what "clear formatting" should mean — it unbolds text, it does not
+ * silently destroy the list the user is standing in.
+ */
+export declare const clearFormatting: () => void;
+export declare const setBlockStyle: (block: BlockStyle) => void;
+/** Toggle blockquote by comparing against the block the selection is already in. */
+export declare const toggleBlockquote: (isActive: boolean) => void;
+/** Toggle `<pre>` for code blocks, same shape as blockquote. */
+export declare const toggleCodeBlock: (isActive: boolean) => void;
+export declare const createLink: (href: string) => void;
+export declare const removeLink: () => void;
+/**
+ * Insert already-sanitized HTML at the caret.
+ *
+ * 🔴 Callers MUST pass output of `sanitizeHtml`. This is the paste/drop path and
+ * the one command that writes caller-supplied markup into the document.
+ */
+export declare const insertSanitizedHtml: (html: string) => void;
+/** Insert plain text, letting the browser handle escaping. */
+export declare const insertText: (text: string) => void;

package/dist/components/forms/RichTextEditor/editorCommands.js

@@ -0,0 +1,58 @@
+"use client";
+function run(command, value) {
+    try {
+        document.execCommand(command, false, value);
+    }
+    catch (error) {
+        if (process.env.NODE_ENV !== "production") {
+            // eslint-disable-next-line no-console
+            console.warn(`[RichTextEditor]: execCommand("${command}") failed`, error);
+        }
+    }
+}
+const toggleBold = () => run("bold");
+const toggleItalic = () => run("italic");
+const toggleUnderline = () => run("underline");
+const toggleStrikethrough = () => run("strikeThrough");
+const toggleBulletList = () => run("insertUnorderedList");
+const toggleOrderedList = () => run("insertOrderedList");
+const undo = () => run("undo");
+const redo = () => run("redo");
+/**
+ * Clear inline formatting. `removeFormat` leaves list/quote structure alone,
+ * which is what "clear formatting" should mean — it unbolds text, it does not
+ * silently destroy the list the user is standing in.
+ */
+const clearFormatting = () => run("removeFormat");
+const BLOCK_TAG = {
+    paragraph: "P",
+    h1: "H1",
+    h2: "H2",
+    h3: "H3",
+    h4: "H4",
+};
+const setBlockStyle = (block) => {
+    // Angle brackets are required by Firefox and harmless in Chromium/WebKit.
+    run("formatBlock", `<${BLOCK_TAG[block]}>`);
+};
+/** Toggle blockquote by comparing against the block the selection is already in. */
+const toggleBlockquote = (isActive) => {
+    run("formatBlock", isActive ? "<P>" : "<BLOCKQUOTE>");
+};
+/** Toggle `<pre>` for code blocks, same shape as blockquote. */
+const toggleCodeBlock = (isActive) => {
+    run("formatBlock", isActive ? "<P>" : "<PRE>");
+};
+const createLink = (href) => run("createLink", href);
+const removeLink = () => run("unlink");
+/**
+ * Insert already-sanitized HTML at the caret.
+ *
+ * 🔴 Callers MUST pass output of `sanitizeHtml`. This is the paste/drop path and
+ * the one command that writes caller-supplied markup into the document.
+ */
+const insertSanitizedHtml = (html) => run("insertHTML", html);
+/** Insert plain text, letting the browser handle escaping. */
+const insertText = (text) => run("insertText", text);
+
+export { clearFormatting, createLink, insertSanitizedHtml, insertText, redo, removeLink, setBlockStyle, toggleBlockquote, toggleBold, toggleBulletList, toggleCodeBlock, toggleItalic, toggleOrderedList, toggleStrikethrough, toggleUnderline, undo };

package/dist/components/forms/RichTextEditor/editorState.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Reads the formatting active at the current selection by walking the DOM
+ * ancestors of the selection anchor, up to (but not including) the editor root.
+ *
+ * This replaces `document.queryCommandState`, which is unreliable — notably for
+ * block-level state, where browsers disagree about what "active" means inside
+ * nested lists and quotes. An ancestor walk is deterministic, needs no
+ * deprecated API, and answers block and inline questions with the same code.
+ */
+import type { FormattingState } from "./RichTextEditor.types";
+export declare const EMPTY_FORMATTING_STATE: FormattingState;
+/**
+ * Compute the formatting state for `selection` within `root`.
+ *
+ * Returns `EMPTY_FORMATTING_STATE` when there is no selection, or when the
+ * selection lies outside `root` — a toolbar must not report state for text the
+ * user selected somewhere else on the page.
+ */
+export declare function readFormattingState(root: HTMLElement | null, selection: Selection | null): FormattingState;

package/dist/components/forms/RichTextEditor/editorState.js

@@ -0,0 +1,103 @@
+/**
+ * Reads the formatting active at the current selection by walking the DOM
+ * ancestors of the selection anchor, up to (but not including) the editor root.
+ *
+ * This replaces `document.queryCommandState`, which is unreliable — notably for
+ * block-level state, where browsers disagree about what "active" means inside
+ * nested lists and quotes. An ancestor walk is deterministic, needs no
+ * deprecated API, and answers block and inline questions with the same code.
+ */
+const EMPTY_FORMATTING_STATE = {
+    bold: false,
+    italic: false,
+    underline: false,
+    strikethrough: false,
+    bulletList: false,
+    orderedList: false,
+    blockquote: false,
+    code: false,
+    link: null,
+    block: "paragraph",
+};
+const BLOCK_FOR_TAG = {
+    H1: "h1",
+    H2: "h2",
+    H3: "h3",
+    H4: "h4",
+    P: "paragraph",
+};
+/** The element the selection sits in (text nodes resolve to their parent). */
+function selectionElement(selection) {
+    const node = selection.anchorNode;
+    if (!node)
+        return null;
+    return node.nodeType === Node.ELEMENT_NODE
+        ? node
+        : node.parentElement;
+}
+/**
+ * Compute the formatting state for `selection` within `root`.
+ *
+ * Returns `EMPTY_FORMATTING_STATE` when there is no selection, or when the
+ * selection lies outside `root` — a toolbar must not report state for text the
+ * user selected somewhere else on the page.
+ */
+function readFormattingState(root, selection) {
+    if (!root || !selection || selection.rangeCount === 0)
+        return EMPTY_FORMATTING_STATE;
+    const start = selectionElement(selection);
+    if (!start || !root.contains(start))
+        return EMPTY_FORMATTING_STATE;
+    const state = { ...EMPTY_FORMATTING_STATE };
+    let blockFound = false;
+    let node = start;
+    while (node && node !== root) {
+        switch (node.tagName) {
+            case "STRONG":
+            case "B":
+                state.bold = true;
+                break;
+            case "EM":
+            case "I":
+                state.italic = true;
+                break;
+            case "U":
+                state.underline = true;
+                break;
+            case "S":
+            case "STRIKE":
+            case "DEL":
+                state.strikethrough = true;
+                break;
+            case "CODE":
+            case "PRE":
+                state.code = true;
+                break;
+            case "BLOCKQUOTE":
+                state.blockquote = true;
+                break;
+            case "UL":
+                // Only the nearest list wins — a <ul> inside an <ol> is a bullet list.
+                if (!state.orderedList)
+                    state.bulletList = true;
+                break;
+            case "OL":
+                if (!state.bulletList)
+                    state.orderedList = true;
+                break;
+            case "A":
+                if (state.link === null)
+                    state.link = node.getAttribute("href");
+                break;
+        }
+        // The nearest block ancestor determines the block style; outer ones do not.
+        if (!blockFound && node.tagName in BLOCK_FOR_TAG) {
+            state.block = BLOCK_FOR_TAG[node.tagName];
+            blockFound = true;
+        }
+        node = node.parentElement;
+    }
+    return state;
+}
+
+export { EMPTY_FORMATTING_STATE, readFormattingState };

package/dist/components/forms/RichTextEditor/index.d.ts

@@ -1,3 +1,5 @@
-export { RichTextEditor, DEFAULT_FONT_FAMILY_OPTIONS, loadGoogleFont, } from './RichTextEditor';
-export type { RichTextEditorProps, RichTextEditorSize, RichTextEditorState, ToolbarConfig, ToolbarTool, FormattingState, FontFamilyOption, ColorOption, RichTextEditorTheme, RichTextEditorThemeOverrides, } from './RichTextEditor.types';
-export { richTextEditorTheme, colorOptions } from './RichTextEditor.theme';
+export { RichTextEditor } from './RichTextEditor';
+export { RichTextToolbar, DEFAULT_TOOLBAR_TOOLS } from './RichTextToolbar';
+export { sanitizeHtml } from './sanitizeHtml';
+export type { RichTextEditorProps, RichTextEditorSize, RichTextEditorState, ToolbarConfig, ToolbarTool, BlockStyle, FormattingState, RichTextEditorTheme, RichTextEditorThemeOverrides, } from './RichTextEditor.types';
+export { richTextEditorTheme } from './RichTextEditor.theme';

package/dist/components/forms/RichTextEditor/sanitizeHtml.d.ts

@@ -0,0 +1,38 @@
+/**
+ * HTML sanitizer for RichTextEditor.
+ *
+ * 🔴 SECURITY BOUNDARY. Every path that writes markup into the editor's DOM, and
+ * every value handed back to the consumer, passes through `sanitizeHtml`:
+ * the `value` prop, paste, drop, and the string emitted to `onChange`. Never add
+ * a write path that skips it.
+ *
+ * Deny-by-default: an element is dropped unless it is in ALLOWED_TAGS, and an
+ * attribute is dropped unless it is in that tag's allowlist. The allowlist is
+ * small because we also control what the editor PRODUCES — this sanitizes the
+ * output of a semantic editor, not the arbitrary web.
+ *
+ * ── On not using DOMPurify ────────────────────────────────────────────────────
+ * DOMPurify exists because sanitizing arbitrary HTML is hard; its hardest class
+ * of bug is mutation XSS, where sanitized output re-parses differently once
+ * assigned to `innerHTML`. Two properties keep a hand-rolled allowlist
+ * defensible here:
+ *
+ *   1. The known mXSS vectors route through namespace confusion (`svg`, `math`)
+ *      and through `template`/`noscript`/`style`/`xmp`. All of those are in
+ *      DROP_WITH_CHILDREN, so they are never present in our output.
+ *   2. `sanitizeHtml` runs to a FIXED POINT (below). Markup that is unstable
+ *      under re-parsing is reduced to plain text rather than trusted.
+ *
+ * Consumers rendering hostile third-party HTML should still pass a hardened
+ * sanitizer via the `sanitize` prop.
+ */
+/**
+ * Sanitize `html` to the allowlist.
+ *
+ * Runs to a fixed point: if a second pass over the first pass's output differs,
+ * the markup re-parses differently than it serializes — the shape of a mutation
+ * XSS — and we fall back to plain text. The cost is one extra parse of
+ * editor-sized content; the benefit is that the failure mode is lost formatting
+ * rather than script execution.
+ */
+export declare function sanitizeHtml(html: string): string;

package/dist/components/forms/RichTextEditor/sanitizeHtml.js

@@ -0,0 +1,179 @@
+/**
+ * HTML sanitizer for RichTextEditor.
+ *
+ * 🔴 SECURITY BOUNDARY. Every path that writes markup into the editor's DOM, and
+ * every value handed back to the consumer, passes through `sanitizeHtml`:
+ * the `value` prop, paste, drop, and the string emitted to `onChange`. Never add
+ * a write path that skips it.
+ *
+ * Deny-by-default: an element is dropped unless it is in ALLOWED_TAGS, and an
+ * attribute is dropped unless it is in that tag's allowlist. The allowlist is
+ * small because we also control what the editor PRODUCES — this sanitizes the
+ * output of a semantic editor, not the arbitrary web.
+ *
+ * ── On not using DOMPurify ────────────────────────────────────────────────────
+ * DOMPurify exists because sanitizing arbitrary HTML is hard; its hardest class
+ * of bug is mutation XSS, where sanitized output re-parses differently once
+ * assigned to `innerHTML`. Two properties keep a hand-rolled allowlist
+ * defensible here:
+ *
+ *   1. The known mXSS vectors route through namespace confusion (`svg`, `math`)
+ *      and through `template`/`noscript`/`style`/`xmp`. All of those are in
+ *      DROP_WITH_CHILDREN, so they are never present in our output.
+ *   2. `sanitizeHtml` runs to a FIXED POINT (below). Markup that is unstable
+ *      under re-parsing is reduced to plain text rather than trusted.
+ *
+ * Consumers rendering hostile third-party HTML should still pass a hardened
+ * sanitizer via the `sanitize` prop.
+ */
+/** Elements the editor may emit, and that may survive a paste. */
+const ALLOWED_TAGS = new Set([
+    "P", "BR",
+    "STRONG", "EM", "U", "S", "CODE",
+    "H1", "H2", "H3", "H4",
+    "UL", "OL", "LI",
+    "BLOCKQUOTE", "PRE",
+    "A",
+]);
+/** Per-tag attribute allowlist. Everything not listed here is stripped. */
+const ALLOWED_ATTRS = {
+    A: new Set(["href"]),
+};
+/**
+ * Dropped along with their subtree. Everything here either executes, loads, or
+ * (for the parser-confusing set) is an mXSS vector — in no case is the text
+ * inside worth preserving.
+ */
+const DROP_WITH_CHILDREN = new Set([
+    "SCRIPT", "STYLE", "IFRAME", "OBJECT", "EMBED", "APPLET",
+    "LINK", "META", "BASE", "TITLE",
+    "SVG", "MATH", "NOSCRIPT", "TEMPLATE", "XMP",
+    "FORM", "INPUT", "BUTTON", "SELECT", "TEXTAREA", "OPTION",
+]);
+/**
+ * Presentational tags browsers still emit (notably via `execCommand`) mapped to
+ * their semantic equivalent. This is what makes `execCommand`'s cross-browser
+ * markup inconsistency a non-issue: whatever the browser produces, the value we
+ * store and emit is normalized.
+ */
+const TAG_ALIASES = {
+    B: "STRONG",
+    I: "EM",
+    STRIKE: "S",
+    DEL: "S",
+    INS: "U",
+    DIV: "P",
+};
+/** Schemes permitted in `href`. Relative URLs are allowed and need no scheme. */
+const ALLOWED_SCHEMES = new Set(["http:", "https:", "mailto:", "tel:"]);
+function isSafeHref(value) {
+    const trimmed = value.trim();
+    // Reject embedded control characters outright. NUL/newline/tab inside a scheme
+    // ("java\nscript:") is the classic way past a naive prefix check, since browsers
+    // strip them before resolving the URL. U+FFFD is included because the HTML parser
+    // has already rewritten any NUL to the replacement character by the time we read
+    // the attribute — that form is inert, but it is still junk we refuse to store.
+    // eslint-disable-next-line no-control-regex
+    if (/[\u0000-\u001F\u007F\uFFFD]/.test(trimmed))
+        return false;
+    // Relative URLs (no scheme) are safe and common.
+    if (/^[^a-zA-Z]/.test(trimmed) || !/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(trimmed)) {
+        return true;
+    }
+    try {
+        return ALLOWED_SCHEMES.has(new URL(trimmed, "https://example.invalid").protocol);
+    }
+    catch (_a) {
+        return false;
+    }
+}
+/** Recursively copy `source`'s allowed children into `target`. */
+function cleanChildren(source, target, doc) {
+    source.childNodes.forEach((child) => {
+        var _a, _b;
+        if (child.nodeType === Node.TEXT_NODE) {
+            target.appendChild(doc.createTextNode((_a = child.nodeValue) !== null && _a !== void 0 ? _a : ""));
+            return;
+        }
+        if (child.nodeType !== Node.ELEMENT_NODE)
+            return; // comments, PIs, doctypes
+        const element = child;
+        const rawTag = element.tagName.toUpperCase();
+        if (DROP_WITH_CHILDREN.has(rawTag))
+            return;
+        const tag = (_b = TAG_ALIASES[rawTag]) !== null && _b !== void 0 ? _b : rawTag;
+        // Unknown but harmless (e.g. <span>, <font>): drop the element, keep its
+        // content, so pasted text survives while its styling does not.
+        if (!ALLOWED_TAGS.has(tag)) {
+            cleanChildren(element, target, doc);
+            return;
+        }
+        const clean = doc.createElement(tag);
+        const allowed = ALLOWED_ATTRS[tag];
+        if (allowed) {
+            for (const attr of Array.from(element.attributes)) {
+                const name = attr.name.toLowerCase();
+                if (!allowed.has(name))
+                    continue;
+                if (name === "href" && !isSafeHref(attr.value))
+                    continue;
+                clean.setAttribute(name, attr.value);
+            }
+        }
+        // An anchor that lost its href is no longer a link; keep only its text.
+        if (tag === "A" && !clean.hasAttribute("href")) {
+            cleanChildren(element, target, doc);
+            return;
+        }
+        if (tag === "A") {
+            // Defence in depth for consumers rendering the stored HTML with target=_blank.
+            clean.setAttribute("rel", "noopener noreferrer");
+        }
+        cleanChildren(element, clean, doc);
+        target.appendChild(clean);
+    });
+}
+/** One sanitization pass. Parsing happens in an inert document — nothing executes. */
+function sanitizeOnce(html) {
+    const doc = new DOMParser().parseFromString(html, "text/html");
+    const output = doc.createElement("div");
+    cleanChildren(doc.body, output, doc);
+    return output.innerHTML;
+}
+/** Strip every tag, keeping text. The fallback when markup will not stabilize. */
+function toPlainText(html) {
+    var _a;
+    const doc = new DOMParser().parseFromString(html, "text/html");
+    const text = (_a = doc.body.textContent) !== null && _a !== void 0 ? _a : "";
+    const escaped = doc.createElement("div");
+    escaped.textContent = text;
+    return escaped.innerHTML;
+}
+/**
+ * Sanitize `html` to the allowlist.
+ *
+ * Runs to a fixed point: if a second pass over the first pass's output differs,
+ * the markup re-parses differently than it serializes — the shape of a mutation
+ * XSS — and we fall back to plain text. The cost is one extra parse of
+ * editor-sized content; the benefit is that the failure mode is lost formatting
+ * rather than script execution.
+ */
+function sanitizeHtml(html) {
+    if (!html)
+        return "";
+    // SSR / non-DOM environments have no parser; never return unsanitized markup.
+    if (typeof DOMParser === "undefined")
+        return "";
+    const first = sanitizeOnce(html);
+    const second = sanitizeOnce(first);
+    if (first !== second) {
+        if (process.env.NODE_ENV !== "production") {
+            // eslint-disable-next-line no-console
+            console.warn("[RichTextEditor]: markup did not stabilize under sanitization and was reduced to plain text.");
+        }
+        return toPlainText(html);
+    }
+    return first;
+}
+
+export { sanitizeHtml };

package/dist/components/forms/RichTextEditor/sanitizeHtml.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/forms/Select/Select.d.ts

@@ -14,6 +14,8 @@ export interface SelectContextValue<T = any> extends UseSelectStateReturn<T> {
     theme: SelectThemeOverrides;
     /** Whether search is enabled */
     searchable: boolean;
+    /** Placeholder text for the search input */
+    searchPlaceholder: string;
     /** Whether typeahead is enabled */
     enableTypeahead: boolean;
     /** Button ref (alias for triggerRef for backward compatibility) */
@@ -44,6 +46,8 @@ export interface SelectProviderProps<T = any> {
     theme?: SelectThemeOverrides;
     /** Whether search is enabled */
     searchable?: boolean;
+    /** Placeholder text for the search input */
+    searchPlaceholder?: string;
     /** Whether typeahead is enabled */
     enableTypeahead?: boolean;
 }
@@ -68,7 +72,7 @@ export interface SelectProviderProps<T = any> {
  * </SelectProvider>
  * ```
  */
-export declare function SelectProvider<T = any>({ children, selectState, size, componentState, theme: themeOverrides, searchable, enableTypeahead, }: SelectProviderProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare function SelectProvider<T = any>({ children, selectState, size, componentState, theme: themeOverrides, searchable, searchPlaceholder, enableTypeahead, }: SelectProviderProps<T>): import("react/jsx-runtime").JSX.Element;
 /**
  * Select Button Component
  */