@jackuait/blok 0.4.1-beta.4 → 0.4.1-beta.6

package/dist/tools.mjs

@@ -0,0 +1,3073 @@
+var nt = Object.defineProperty, rt = Object.defineProperties;
+var st = Object.getOwnPropertyDescriptors;
+var K = Object.getOwnPropertySymbols;
+var ot = Object.prototype.hasOwnProperty, it = Object.prototype.propertyIsEnumerable;
+var U = (f, t, e) => t in f ? nt(f, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : f[t] = e, w = (f, t) => {
+  for (var e in t || (t = {}))
+    ot.call(t, e) && U(f, e, t[e]);
+  if (K)
+    for (var e of K(t))
+      it.call(t, e) && U(f, e, t[e]);
+  return f;
+}, P = (f, t) => rt(f, st(t));
+import { t as L, D as g, a9 as et, aa as at, ab as lt, ac as ct, ad as dt, ae as ut, af as ht, ag as ft, ah as pt, ai as G, aj as j, ak as $, f as A, al as gt, am as mt, S as H, P as Et, an as Tt, l as Ct, J as At } from "./chunks/inline-tool-convert-RBcopmCh.mjs";
+import { a0 as Ot } from "./chunks/inline-tool-convert-RBcopmCh.mjs";
+const W = [
+  "empty:before:pointer-events-none",
+  "empty:before:text-gray-text",
+  "empty:before:cursor-text",
+  "empty:before:content-[attr(data-placeholder)]",
+  "[&[data-blok-empty=true]]:before:pointer-events-none",
+  "[&[data-blok-empty=true]]:before:text-gray-text",
+  "[&[data-blok-empty=true]]:before:cursor-text",
+  "[&[data-blok-empty=true]]:before:content-[attr(data-placeholder)]"
+], yt = [
+  "empty:focus:before:pointer-events-none",
+  "empty:focus:before:text-gray-text",
+  "empty:focus:before:cursor-text",
+  "empty:focus:before:content-[attr(data-blok-placeholder-active)]",
+  "[&[data-empty=true]:focus]:before:pointer-events-none",
+  "[&[data-empty=true]:focus]:before:text-gray-text",
+  "[&[data-empty=true]:focus]:before:cursor-text",
+  "[&[data-empty=true]:focus]:before:content-[attr(data-blok-placeholder-active)]"
+], bt = (f) => {
+  const t = f.innerHTML.trim();
+  return t === "" || t === "<br>";
+}, St = (f) => {
+  f.innerHTML === "<br>" && (f.innerHTML = "");
+  const t = window.getSelection();
+  if (!t) return;
+  const e = document.createRange();
+  e.selectNodeContents(f), e.collapse(!0), t.removeAllRanges(), t.addRange(e);
+}, Nt = (f) => {
+  bt(f) && St(f);
+}, z = (f, t, e = "data-placeholder") => {
+  f.setAttribute(e, t != null ? t : "");
+  const n = () => Nt(f);
+  f.addEventListener("focus", n), f.addEventListener("input", n);
+}, Bt = (f) => {
+  const t = document.createElement("div");
+  t.innerHTML = f.trim();
+  const e = document.createDocumentFragment();
+  return e.append(...Array.from(t.childNodes)), e;
+}, M = class M {
+  /**
+   * Default placeholder for Paragraph Tool
+   *
+   * @returns empty string
+   */
+  static get DEFAULT_PLACEHOLDER() {
+    return "";
+  }
+  /**
+   * Render plugin's main Element and fill it with saved data
+   *
+   * @param options - constructor options
+   * @param options.data - previously saved data
+   * @param options.config - user config for Tool
+   * @param options.api - editor.js api
+   * @param options.readOnly - read only mode flag
+   */
+  constructor({ data: t, config: e, api: n, readOnly: r }) {
+    var s, o, a;
+    this.api = n, this.readOnly = r, this.readOnly || (this.onKeyUp = this.onKeyUp.bind(this)), this._placeholder = (s = e == null ? void 0 : e.placeholder) != null ? s : M.DEFAULT_PLACEHOLDER, this._data = t != null ? t : { text: "" }, this._element = null, this._preserveBlank = (o = e == null ? void 0 : e.preserveBlank) != null ? o : !1, this._styles = (a = e == null ? void 0 : e.styles) != null ? a : {};
+  }
+  /**
+   * Check if text content is empty and set empty string to inner html.
+   * We need this because some browsers (e.g. Safari) insert <br> into empty contenteditable elements
+   *
+   * @param e - key up event
+   */
+  onKeyUp(t) {
+    if (t.code !== "Backspace" && t.code !== "Delete" || !this._element)
+      return;
+    const { textContent: e } = this._element;
+    e === "" && (this._element.innerHTML = "");
+  }
+  /**
+   * Build inline styles from style configuration
+   *
+   * @returns Partial CSSStyleDeclaration with custom styles
+   */
+  buildInlineStyles() {
+    const t = {};
+    return this._styles.size && (t.fontSize = this._styles.size), this._styles.lineHeight && (t.lineHeight = this._styles.lineHeight), this._styles.marginTop && (t.marginTop = this._styles.marginTop), this._styles.marginBottom && (t.marginBottom = this._styles.marginBottom), t;
+  }
+  drawView() {
+    const t = document.createElement("DIV");
+    t.className = L(
+      this.api.styles.block,
+      M.WRAPPER_CLASSES,
+      yt
+    ), t.setAttribute(g.tool, "paragraph"), t.contentEditable = "false";
+    const e = this.buildInlineStyles();
+    return Object.keys(e).length > 0 && Object.assign(t.style, e), this._data.text && (t.innerHTML = this._data.text), this.readOnly ? t.setAttribute("data-blok-placeholder-active", this.api.i18n.t(this._placeholder)) : (t.contentEditable = "true", t.addEventListener("keyup", this.onKeyUp), z(t, this.api.i18n.t(this._placeholder), "data-blok-placeholder-active")), t;
+  }
+  /**
+   * Return Tool's view
+   *
+   * @returns HTMLDivElement
+   */
+  render() {
+    return this._element = this.drawView(), this._element;
+  }
+  /**
+   * Method that specified how to merge two Text blocks.
+   * Called by Editor by backspace at the beginning of the Block
+   *
+   * @param data - saved data to merge with current block
+   */
+  merge(t) {
+    if (!this._element)
+      return;
+    this._data.text += t.text;
+    const e = Bt(t.text);
+    this._element.appendChild(e), this._element.normalize();
+  }
+  /**
+   * Validate Paragraph block data:
+   * - check for emptiness
+   *
+   * @param savedData - data received after saving
+   * @returns false if saved data is not correct, otherwise true
+   */
+  validate(t) {
+    return !(t.text.trim() === "" && !this._preserveBlank);
+  }
+  /**
+   * Extract Tool's data from the view
+   *
+   * @param toolsContent - Paragraph tools rendered view
+   * @returns saved data
+   */
+  save(t) {
+    return {
+      text: et(t.innerHTML)
+    };
+  }
+  /**
+   * On paste callback fired from Editor.
+   *
+   * @param event - event with pasted data
+   */
+  onPaste(t) {
+    const e = t.detail;
+    if (!("data" in e))
+      return;
+    const r = {
+      text: e.data.innerHTML
+    };
+    this._data = r, window.requestAnimationFrame(() => {
+      this._element && (this._element.innerHTML = this._data.text || "");
+    });
+  }
+  /**
+   * Enable Conversion Toolbar. Paragraph can be converted to/from other tools
+   *
+   * @returns ConversionConfig
+   */
+  static get conversionConfig() {
+    return {
+      export: "text",
+      // to convert Paragraph to other block, use 'text' property of saved data
+      import: "text"
+      // to convert other block's exported string to Paragraph, fill 'text' property of tool data
+    };
+  }
+  /**
+   * Sanitizer rules
+   *
+   * @returns SanitizerConfig
+   */
+  static get sanitize() {
+    return {
+      text: {
+        br: !0
+      }
+    };
+  }
+  /**
+   * Returns true to notify the core that read-only mode is supported
+   *
+   * @returns true
+   */
+  static get isReadOnlySupported() {
+    return !0;
+  }
+  /**
+   * Used by Editor paste handling API.
+   * Provides configuration to handle P tags.
+   *
+   * @returns PasteConfig
+   */
+  static get pasteConfig() {
+    return {
+      tags: ["P"]
+    };
+  }
+  /**
+   * Icon and title for displaying at the Toolbox
+   *
+   * @returns ToolboxConfig
+   */
+  static get toolbox() {
+    return {
+      icon: at,
+      title: "Text",
+      titleKey: "text"
+    };
+  }
+};
+M.WRAPPER_CLASSES = [
+  "leading-[1.6em]",
+  "outline-none",
+  "mt-[2px]",
+  "mb-px",
+  "[&>p:first-of-type]:mt-0",
+  "[&>p:last-of-type]:mb-0"
+];
+let X = M;
+const I = class I {
+  /**
+   * Render plugin's main Element and fill it with saved data
+   *
+   * @param options - constructor options
+   * @param options.data - previously saved data
+   * @param options.config - user config for Tool
+   * @param options.api - Editor API
+   * @param options.readOnly - read only mode flag
+   */
+  constructor({ data: t, config: e, api: n, readOnly: r }) {
+    this.api = n, this.readOnly = r, this._settings = e || {}, this._data = this.normalizeData(t), this._element = this.getTag();
+  }
+  /**
+   * Styles
+   * @deprecated Use data-blok-tool attribute instead (DATA_ATTR.tool)
+   */
+  get _CSS() {
+    return {
+      block: this.api.styles.block,
+      wrapper: ""
+    };
+  }
+  /**
+   * Check if data is valid HeaderData
+   *
+   * @param data - data to check
+   * @returns true if data is HeaderData
+   */
+  isHeaderData(t) {
+    return typeof t == "object" && t !== null && "text" in t;
+  }
+  /**
+   * Normalize input data
+   *
+   * @param data - saved data to process
+   * @returns normalized HeaderData
+   */
+  normalizeData(t) {
+    if (!this.isHeaderData(t))
+      return { text: "", level: this.defaultLevel.number };
+    const e = parseInt(String(t.level)), n = t.level !== void 0 && !isNaN(e);
+    return {
+      text: t.text || "",
+      level: n ? e : this.defaultLevel.number
+    };
+  }
+  /**
+   * Return Tool's view
+   *
+   * @returns HTMLHeadingElement
+   */
+  render() {
+    return this._element;
+  }
+  /**
+   * Returns header block tunes config
+   *
+   * @returns MenuConfig array
+   */
+  renderSettings() {
+    return this.levels.map((t) => {
+      const e = this.api.i18n.t(t.nameKey), n = e !== t.nameKey ? e : t.name;
+      return {
+        icon: t.icon,
+        title: n,
+        onActivate: () => this.setLevel(t.number),
+        closeOnActivate: !0,
+        isActive: this.currentLevel.number === t.number,
+        dataset: {
+          "blok-header-level": String(t.number)
+        }
+      };
+    });
+  }
+  /**
+   * Callback for Block's settings buttons
+   *
+   * @param level - level to set
+   */
+  setLevel(t) {
+    this.data = {
+      level: t,
+      text: this.data.text
+    };
+  }
+  /**
+   * Method that specified how to merge two Text blocks.
+   * Called by Editor by backspace at the beginning of the Block
+   *
+   * @param data - saved data to merge with current block
+   */
+  merge(t) {
+    this._element.insertAdjacentHTML("beforeend", t.text);
+  }
+  /**
+   * Validate Text block data:
+   * - check for emptiness
+   *
+   * @param blockData - data received after saving
+   * @returns false if saved data is not correct, otherwise true
+   */
+  validate(t) {
+    return t.text.trim() !== "";
+  }
+  /**
+   * Extract Tool's data from the view
+   *
+   * @param toolsContent - Text tools rendered view
+   * @returns saved data
+   */
+  save(t) {
+    return {
+      text: t.innerHTML,
+      level: this.currentLevel.number
+    };
+  }
+  /**
+   * Allow Header to be converted to/from other blocks
+   */
+  static get conversionConfig() {
+    return {
+      export: "text",
+      // use 'text' property for other blocks
+      import: "text"
+      // fill 'text' property from other block's export string
+    };
+  }
+  /**
+   * Sanitizer Rules
+   */
+  static get sanitize() {
+    return {
+      level: !1,
+      text: {}
+    };
+  }
+  /**
+   * Returns true to notify core that read-only is supported
+   *
+   * @returns true
+   */
+  static get isReadOnlySupported() {
+    return !0;
+  }
+  /**
+   * Get current Tool's data
+   *
+   * @returns Current data
+   */
+  get data() {
+    return this._data.text = this._element.innerHTML, this._data.level = this.currentLevel.number, this._data;
+  }
+  /**
+   * Store data in plugin:
+   * - at the this._data property
+   * - at the HTML
+   *
+   * @param data - data to set
+   */
+  set data(t) {
+    if (this._data = this.normalizeData(t), t.level !== void 0 && this._element.parentNode) {
+      const e = this.getTag();
+      e.innerHTML = this._element.innerHTML, this._element.parentNode.replaceChild(e, this._element), this._element = e;
+    }
+    t.text !== void 0 && (this._element.innerHTML = this._data.text || "");
+  }
+  /**
+   * Get tag for target level
+   * By default returns second-leveled header
+   *
+   * @returns HTMLHeadingElement
+   */
+  getTag() {
+    const t = document.createElement(this.currentLevel.tag);
+    t.innerHTML = this._data.text || "", t.className = L(I.BASE_STYLES, this.currentLevel.styles, W);
+    const { inlineStyles: e } = this.currentLevel;
+    return e && Object.assign(t.style, e), t.setAttribute(g.tool, "header"), t.contentEditable = this.readOnly ? "false" : "true", this.readOnly ? t.setAttribute("data-placeholder", this.api.i18n.t(this._settings.placeholder || "")) : z(t, this.api.i18n.t(this._settings.placeholder || "")), t;
+  }
+  /**
+   * Get current level
+   *
+   * @returns Level object
+   */
+  get currentLevel() {
+    const t = this.levels.find((e) => e.number === this._data.level);
+    return t != null ? t : this.defaultLevel;
+  }
+  /**
+   * Return default level
+   *
+   * @returns Level object
+   */
+  get defaultLevel() {
+    if (!this._settings.defaultLevel)
+      return this.levels[1];
+    const t = this.levels.find((e) => e.number === this._settings.defaultLevel);
+    return t || (console.warn("(ง'̀-'́)ง Heading Tool: the default level specified was not found in available levels"), this.levels[1]);
+  }
+  /**
+   * Available header levels
+   *
+   * @returns Level array
+   */
+  get levels() {
+    const t = this._settings.levelOverrides || {}, e = I.DEFAULT_LEVELS.map((n) => {
+      var o;
+      const r = t[n.number] || {}, s = {};
+      return r.size && (s.fontSize = r.size), r.marginTop && (s.marginTop = r.marginTop), r.marginBottom && (s.marginBottom = r.marginBottom), {
+        number: n.number,
+        tag: ((o = r.tag) == null ? void 0 : o.toUpperCase()) || n.tag,
+        nameKey: n.nameKey,
+        name: r.name || n.name,
+        icon: n.icon,
+        styles: n.styles,
+        inlineStyles: s
+      };
+    });
+    return this._settings.levels ? e.filter((n) => this._settings.levels.includes(n.number)) : e;
+  }
+  /**
+   * Handle H1-H6 tags on paste to substitute it with header Tool
+   *
+   * @param event - event with pasted content
+   */
+  onPaste(t) {
+    var a;
+    const e = t.detail;
+    if (!("data" in e))
+      return;
+    const n = e.data, s = (a = {
+      H1: 1,
+      H2: 2,
+      H3: 3,
+      H4: 4,
+      H5: 5,
+      H6: 6
+    }[n.tagName]) != null ? a : this.defaultLevel.number, o = this._settings.levels ? this._settings.levels.reduce((l, d) => Math.abs(d - s) < Math.abs(l - s) ? d : l) : s;
+    this.data = {
+      level: o,
+      text: n.innerHTML
+    };
+  }
+  /**
+   * Used by Editor paste handling API.
+   * Provides configuration to handle H1-H6 tags.
+   *
+   * @returns PasteConfig
+   */
+  static get pasteConfig() {
+    return {
+      tags: ["H1", "H2", "H3", "H4", "H5", "H6"]
+    };
+  }
+  /**
+   * Get Tool toolbox settings
+   * icon - Tool icon's SVG
+   * title - title to show in toolbox
+   *
+   * @returns ToolboxConfig
+   */
+  static get toolbox() {
+    return {
+      icon: pt,
+      title: "Heading",
+      titleKey: "heading"
+    };
+  }
+};
+I.BASE_STYLES = "py-[3px] px-[2px] m-0 !leading-[1.3] outline-none [&_p]:!p-0 [&_p]:!m-0 [&_div]:!p-0 [&_div]:!m-0", I.DEFAULT_LEVELS = [
+  { number: 1, tag: "H1", nameKey: "tools.header.heading1", name: "Heading 1", icon: lt, styles: "text-4xl font-bold mt-8 mb-1" },
+  { number: 2, tag: "H2", nameKey: "tools.header.heading2", name: "Heading 2", icon: ct, styles: "text-3xl font-semibold mt-6 mb-px" },
+  { number: 3, tag: "H3", nameKey: "tools.header.heading3", name: "Heading 3", icon: dt, styles: "text-2xl font-semibold mt-4 mb-px" },
+  { number: 4, tag: "H4", nameKey: "tools.header.heading4", name: "Heading 4", icon: ut, styles: "text-xl font-semibold mt-3 mb-px" },
+  { number: 5, tag: "H5", nameKey: "tools.header.heading5", name: "Heading 5", icon: ht, styles: "text-base font-semibold mt-3 mb-px" },
+  { number: 6, tag: "H6", nameKey: "tools.header.heading6", name: "Heading 6", icon: ft, styles: "text-sm font-semibold mt-3 mb-px" }
+];
+let Y = I;
+const u = class u {
+  constructor({ data: t, config: e, api: n, readOnly: r, block: s }) {
+    this._element = null, this.handleBlockChanged = (o) => {
+      var l;
+      const a = o;
+      ((l = a == null ? void 0 : a.event) == null ? void 0 : l.type) === "block-removed" && (u.pendingMarkerUpdate || (u.pendingMarkerUpdate = !0, requestAnimationFrame(() => {
+        u.pendingMarkerUpdate = !1, this.updateAllOrderedListMarkers();
+      })));
+    }, this.api = n, this.readOnly = r, this._settings = e || {}, this._data = this.normalizeData(t), s && (this.blockId = s.id), this._data.style === "ordered" && this.api.events.on("block changed", this.handleBlockChanged);
+  }
+  normalizeData(t) {
+    var n;
+    const e = this._settings.defaultStyle || "unordered";
+    return !t || typeof t != "object" ? {
+      text: "",
+      style: e,
+      checked: !1,
+      depth: 0
+    } : w({
+      text: t.text || "",
+      style: t.style || e,
+      checked: !!t.checked,
+      depth: (n = t.depth) != null ? n : 0
+    }, t.start !== void 0 && t.start !== 1 ? { start: t.start } : {});
+  }
+  get currentStyleConfig() {
+    return u.STYLE_CONFIGS.find((t) => t.style === this._data.style) || u.STYLE_CONFIGS[0];
+  }
+  get availableStyles() {
+    const t = this._settings.styles;
+    return !t || t.length === 0 ? u.STYLE_CONFIGS : u.STYLE_CONFIGS.filter((e) => t.includes(e.style));
+  }
+  get itemColor() {
+    return this._settings.itemColor;
+  }
+  get itemSize() {
+    return this._settings.itemSize;
+  }
+  get placeholder() {
+    return this.api.i18n.t(u.DEFAULT_PLACEHOLDER);
+  }
+  applyItemStyles(t) {
+    const e = t.style;
+    this.itemColor && (e.color = this.itemColor), this.itemSize && (e.fontSize = this.itemSize);
+  }
+  setupItemPlaceholder(t) {
+    this.readOnly || z(t, this.placeholder);
+  }
+  render() {
+    return this._element = this.createItemElement(), this._element;
+  }
+  /**
+   * Called after block content is added to the page.
+   * Updates the marker with the correct index now that we know our position,
+   * and also updates all sibling list items since their indices may have changed.
+   */
+  rendered() {
+    this.updateMarkersAfterPositionChange();
+  }
+  /**
+   * Called after block was moved.
+   * Validates and adjusts depth to follow list formation rules,
+   * then updates the marker to reflect the new position.
+   */
+  moved(t) {
+    this.validateAndAdjustDepthAfterMove(t.detail.toIndex), this.updateMarkersAfterPositionChange();
+  }
+  /**
+   * Updates this block's marker and all sibling ordered list markers.
+   * Called after this block's position may have changed (rendered, moved).
+   */
+  updateMarkersAfterPositionChange() {
+    this._data.style !== "ordered" || !this._element || (this.updateMarker(), this.updateSiblingListMarkers());
+  }
+  /**
+   * Validates and adjusts the depth of this list item after a drag-and-drop move.
+   * Ensures the depth follows list formation rules:
+   * 1. First item (index 0) must be at depth 0
+   * 2. Item depth cannot exceed previousItem.depth + 1
+   * 3. When dropped between nested items, adopt the sibling's depth
+   *
+   * @param newIndex - The new index where the block was moved to
+   */
+  validateAndAdjustDepthAfterMove(t) {
+    const e = this.getDepth(), n = this.calculateMaxAllowedDepth(t), r = this.calculateTargetDepthForPosition(t, n);
+    e !== r && this.adjustDepthTo(r);
+  }
+  /**
+   * Calculates the target depth for a list item dropped at the given index.
+   * When dropping into a nested context, the item should match the sibling's depth.
+   *
+   * @param blockIndex - The index where the block was dropped
+   * @param maxAllowedDepth - The maximum allowed depth at this position
+   * @returns The target depth for the dropped item
+   */
+  calculateTargetDepthForPosition(t, e) {
+    const n = this.getDepth();
+    if (n > e)
+      return e;
+    const r = this.api.blocks.getBlockByIndex(t + 1), s = r && r.name === u.TOOL_NAME, o = s ? this.getBlockDepth(r) : 0;
+    if (s && o > n && o <= e)
+      return o;
+    const l = t > 0 ? this.api.blocks.getBlockByIndex(t - 1) : null, d = l && l.name === u.TOOL_NAME, c = d ? this.getBlockDepth(l) : 0;
+    return d && !s && c > n && c <= e ? c : n;
+  }
+  /**
+   * Calculates the maximum allowed depth for a list item at the given index.
+   *
+   * Rules:
+   * 1. First item (index 0) must be at depth 0
+   * 2. For other items: maxDepth = previousListItem.depth + 1
+   * 3. If previous block is not a list item, maxDepth = 0
+   *
+   * @param blockIndex - The index of the block
+   * @returns The maximum allowed depth (0 or more)
+   */
+  calculateMaxAllowedDepth(t) {
+    if (t === 0)
+      return 0;
+    const e = this.api.blocks.getBlockByIndex(t - 1);
+    return !e || e.name !== u.TOOL_NAME ? 0 : this.getBlockDepth(e) + 1;
+  }
+  /**
+   * Adjusts the depth of this list item to the specified value.
+   * Updates internal data and the DOM element's indentation.
+   *
+   * @param newDepth - The new depth value
+   */
+  adjustDepthTo(t) {
+    var n;
+    this._data.depth = t, this._element && this._element.setAttribute("data-list-depth", String(t));
+    const e = (n = this._element) == null ? void 0 : n.querySelector('[role="listitem"]');
+    e instanceof HTMLElement && (e.style.marginLeft = t > 0 ? `${t * u.INDENT_PER_LEVEL}px` : "");
+  }
+  /**
+   * Called when this block is about to be removed.
+   * Updates sibling ordered list markers to renumber correctly after removal.
+   */
+  removed() {
+    this._data.style === "ordered" && (this.api.events.off("block changed", this.handleBlockChanged), requestAnimationFrame(() => {
+      this.updateAllOrderedListMarkers();
+    }));
+  }
+  /**
+   * Update markers on all ordered list items in the editor.
+   * Called when a list item is removed to ensure correct renumbering.
+   */
+  updateAllOrderedListMarkers() {
+    const t = this.api.blocks.getBlocksCount();
+    Array.from({ length: t }, (e, n) => n).forEach((e) => {
+      const n = this.api.blocks.getBlockByIndex(e);
+      if (!n || n.name !== u.TOOL_NAME)
+        return;
+      const r = n.holder;
+      r != null && r.querySelector('[data-list-style="ordered"]') && this.updateBlockMarker(n);
+    });
+  }
+  /**
+   * Update marker if this is an ordered list item.
+   */
+  updateMarkerIfOrdered() {
+    this._data.style !== "ordered" || !this._element || this.updateMarker();
+  }
+  /**
+   * Update the marker element with the correct index.
+   * Called after the block is rendered and positioned.
+   */
+  updateMarker() {
+    var s;
+    const t = (s = this._element) == null ? void 0 : s.querySelector("[data-list-marker]");
+    if (!t)
+      return;
+    const e = this.getDepth(), n = this.getSiblingIndex(), r = this.getOrderedMarkerText(n, e);
+    t.textContent = r;
+  }
+  /**
+   * Update markers on all sibling ordered list items.
+   * Called when this block is moved to ensure all list numbers are correct.
+   * Respects style boundaries - only updates items with the same style.
+   */
+  updateSiblingListMarkers() {
+    var o;
+    const t = this.blockId ? (o = this.api.blocks.getBlockIndex(this.blockId)) != null ? o : this.api.blocks.getCurrentBlockIndex() : this.api.blocks.getCurrentBlockIndex(), e = this.getDepth(), n = this._data.style, r = this.api.blocks.getBlocksCount(), s = this.findListGroupStartIndex(t, e, n);
+    this.updateMarkersInRange(s, r, t, e, n);
+  }
+  /**
+   * Find the starting index of a list group by walking backwards.
+   * Stops at style boundaries at the same depth (when encountering a different list style).
+   * Items at deeper depths are skipped regardless of their style.
+   */
+  findListGroupStartIndex(t, e, n) {
+    const r = (s, o) => {
+      if (s < 0)
+        return o;
+      const a = this.api.blocks.getBlockByIndex(s);
+      if (!a || a.name !== u.TOOL_NAME)
+        return o;
+      const l = this.getBlockDepth(a);
+      if (l < e)
+        return o;
+      if (l > e)
+        return r(s - 1, o);
+      const d = this.getBlockStyle(a);
+      return n !== void 0 && d !== n ? o : r(s - 1, s);
+    };
+    return r(t - 1, t);
+  }
+  /**
+   * Update markers for all list items in a range at the given depth.
+   * Stops at style boundaries at the same depth (when encountering a different list style).
+   * Items at deeper depths are skipped regardless of their style.
+   */
+  updateMarkersInRange(t, e, n, r, s) {
+    const o = (a) => {
+      if (a >= e)
+        return;
+      if (a === n) {
+        o(a + 1);
+        return;
+      }
+      const l = this.api.blocks.getBlockByIndex(a);
+      if (!l || l.name !== u.TOOL_NAME)
+        return;
+      const d = this.getBlockDepth(l);
+      if (d < r)
+        return;
+      if (d > r) {
+        o(a + 1);
+        return;
+      }
+      const c = this.getBlockStyle(l);
+      s !== void 0 && c !== s || (this.updateBlockMarker(l), o(a + 1));
+    };
+    o(t);
+  }
+  /**
+   * Get the depth of a block by reading from its DOM
+   */
+  getBlockDepth(t) {
+    if (!t)
+      return 0;
+    const e = t.holder, n = e == null ? void 0 : e.querySelector('[role="listitem"]'), r = n == null ? void 0 : n.getAttribute("style"), s = r == null ? void 0 : r.match(/margin-left:\s*(\d+)px/);
+    return s ? Math.round(parseInt(s[1], 10) / u.INDENT_PER_LEVEL) : 0;
+  }
+  /**
+   * Get the style of a block by reading from its DOM
+   */
+  getBlockStyle(t) {
+    if (!t)
+      return null;
+    const e = t.holder, n = e == null ? void 0 : e.querySelector("[data-list-style]");
+    return (n == null ? void 0 : n.getAttribute("data-list-style")) || null;
+  }
+  /**
+   * Update the marker of a specific block by finding its marker element and recalculating
+   */
+  updateBlockMarker(t) {
+    if (!t)
+      return;
+    const e = t.holder, n = e == null ? void 0 : e.querySelector('[data-list-style="ordered"]');
+    if (!n)
+      return;
+    const r = n.querySelector("[data-list-marker]");
+    if (!r)
+      return;
+    const s = this.api.blocks.getBlockIndex(t.id);
+    if (s == null)
+      return;
+    const o = this.getBlockDepth(t), a = this.getBlockStyle(t) || "ordered", l = this.countPrecedingSiblingsAtDepth(s, o, a), c = this.getListStartValueForBlock(s, o, l, a) + l, h = this.formatOrderedMarker(c, o);
+    r.textContent = h;
+  }
+  /**
+   * Format an ordered list marker based on the number and depth
+   */
+  formatOrderedMarker(t, e) {
+    const n = e % 3;
+    return n === 1 ? `${this.numberToLowerAlpha(t)}.` : n === 2 ? `${this.numberToLowerRoman(t)}.` : `${t}.`;
+  }
+  /**
+   * Count preceding list items at the same depth and style for a given block index
+   */
+  countPrecedingSiblingsAtDepth(t, e, n) {
+    return t <= 0 ? 0 : this.countPrecedingListItemsAtDepthFromIndex(t - 1, e, n);
+  }
+  /**
+   * Recursively count preceding list items at the given depth and style starting from index.
+   * Stops at style boundaries at the same depth (when encountering a different list style).
+   * Items at deeper depths are skipped regardless of their style.
+   */
+  countPrecedingListItemsAtDepthFromIndex(t, e, n) {
+    if (t < 0)
+      return 0;
+    const r = this.api.blocks.getBlockByIndex(t);
+    if (!r || r.name !== u.TOOL_NAME)
+      return 0;
+    const s = this.getBlockDepth(r);
+    if (s < e)
+      return 0;
+    if (s > e)
+      return this.countPrecedingListItemsAtDepthFromIndex(t - 1, e, n);
+    const o = this.getBlockStyle(r);
+    return n !== void 0 && o !== n ? 0 : 1 + this.countPrecedingListItemsAtDepthFromIndex(t - 1, e, n);
+  }
+  /**
+   * Get the list start value for a block at a given index and depth
+   */
+  getListStartValueForBlock(t, e, n, r) {
+    if (n === 0)
+      return this.getBlockStartValue(t);
+    const s = this.findFirstListItemIndexFromBlock(t - 1, e, n, r);
+    return s === null ? 1 : this.getBlockStartValue(s);
+  }
+  /**
+   * Get the start value from a block's data-list-start attribute
+   */
+  getBlockStartValue(t) {
+    const e = this.api.blocks.getBlockByIndex(t);
+    if (!e)
+      return 1;
+    const n = e.holder, r = n == null ? void 0 : n.querySelector("[data-list-style]"), s = r == null ? void 0 : r.getAttribute("data-list-start");
+    return s ? parseInt(s, 10) : 1;
+  }
+  /**
+   * Find the first list item in a consecutive group.
+   * Stops at style boundaries at the same depth (when encountering a different list style).
+   * Items at deeper depths are skipped regardless of their style.
+   */
+  findFirstListItemIndexFromBlock(t, e, n, r) {
+    if (t < 0 || n <= 0)
+      return t + 1;
+    const s = this.api.blocks.getBlockByIndex(t);
+    if (!s || s.name !== u.TOOL_NAME)
+      return t + 1;
+    const o = this.getBlockDepth(s);
+    if (o < e)
+      return t + 1;
+    if (o > e)
+      return this.findFirstListItemIndexFromBlock(t - 1, e, n, r);
+    const a = this.getBlockStyle(s);
+    return r !== void 0 && a !== r ? t + 1 : this.findFirstListItemIndexFromBlock(t - 1, e, n - 1, r);
+  }
+  createItemElement() {
+    const { style: t } = this._data, e = document.createElement("div");
+    e.className = u.BASE_STYLES, e.setAttribute(g.tool, u.TOOL_NAME), e.setAttribute("data-list-style", t), e.setAttribute("data-list-depth", String(this.getDepth())), this._data.start !== void 0 && this._data.start !== 1 && e.setAttribute("data-list-start", String(this._data.start));
+    const n = t === "checklist" ? this.createChecklistContent() : this.createStandardContent();
+    return e.appendChild(n), this.readOnly || e.addEventListener("keydown", this.handleKeyDown.bind(this)), e;
+  }
+  createStandardContent() {
+    const t = document.createElement("div");
+    t.setAttribute("role", "listitem"), t.className = L(u.ITEM_STYLES, "flex", ...W), this.applyItemStyles(t);
+    const e = this.getDepth();
+    e > 0 && (t.style.marginLeft = `${e * u.INDENT_PER_LEVEL}px`);
+    const n = this.createListMarker();
+    n.setAttribute("data-list-marker", "true"), t.appendChild(n);
+    const r = document.createElement("div");
+    return r.className = L("flex-1 min-w-0 outline-none", ...W), r.contentEditable = this.readOnly ? "false" : "true", r.innerHTML = this._data.text, this.setupItemPlaceholder(r), t.appendChild(r), t;
+  }
+  createChecklistContent() {
+    const t = document.createElement("div");
+    t.setAttribute("role", "listitem"), t.className = u.CHECKLIST_ITEM_STYLES, this.applyItemStyles(t);
+    const e = this.getDepth();
+    e > 0 && (t.style.marginLeft = `${e * u.INDENT_PER_LEVEL}px`);
+    const n = document.createElement("input");
+    n.type = "checkbox", n.className = u.CHECKBOX_STYLES, n.checked = !!this._data.checked, n.disabled = this.readOnly;
+    const r = document.createElement("div");
+    return r.className = L(
+      "flex-1 outline-none leading-[1.6em]",
+      this._data.checked ? "line-through opacity-60" : "",
+      ...W
+    ), r.contentEditable = this.readOnly ? "false" : "true", r.innerHTML = this._data.text, this.setupItemPlaceholder(r), this.readOnly || n.addEventListener("change", () => {
+      this._data.checked = n.checked, r.classList.toggle("line-through", n.checked), r.classList.toggle("opacity-60", n.checked);
+    }), t.appendChild(n), t.appendChild(r), t;
+  }
+  /**
+   * Create the marker element (bullet or number) for a list item
+   */
+  createListMarker() {
+    const t = document.createElement("span");
+    t.className = "flex-shrink-0 select-none", t.setAttribute("aria-hidden", "true"), t.contentEditable = "false";
+    const e = this.getDepth();
+    if (this._data.style === "ordered") {
+      const n = this.getSiblingIndex(), r = this.getOrderedMarkerText(n, e);
+      t.textContent = r, t.className = L(t.className, "text-right"), t.style.paddingRight = "11px", t.style.minWidth = "fit-content";
+    } else {
+      const n = this.getBulletCharacter(e);
+      t.textContent = n, t.className = L(t.className, "w-6 text-center flex justify-center"), t.style.paddingLeft = "1px", t.style.paddingRight = "13px", t.style.fontSize = "24px", t.style.fontFamily = "Arial";
+    }
+    return t;
+  }
+  /**
+   * Calculate the index of this ListItem among consecutive siblings with the same style.
+   * This is used to determine the correct number for ordered lists.
+   */
+  getSiblingIndex() {
+    var n;
+    const t = this.blockId ? (n = this.api.blocks.getBlockIndex(this.blockId)) != null ? n : this.api.blocks.getCurrentBlockIndex() : this.api.blocks.getCurrentBlockIndex();
+    if (t <= 0)
+      return 0;
+    const e = this.getDepth();
+    return this.countPrecedingListItemsAtDepth(t - 1, e);
+  }
+  /**
+   * Recursively count consecutive preceding list blocks at the same depth and style.
+   * Stops when encountering a block that's not a list, a list at a shallower depth (parent),
+   * or a list with a different style at the same depth (treating style changes as list boundaries).
+   * Items at deeper depths are skipped regardless of their style.
+   */
+  countPrecedingListItemsAtDepth(t, e) {
+    var c;
+    if (t < 0)
+      return 0;
+    const n = this.api.blocks.getBlockByIndex(t);
+    if (!n || n.name !== u.TOOL_NAME)
+      return 0;
+    const r = n.holder, s = r == null ? void 0 : r.querySelector("[data-list-style]"), o = (c = s == null ? void 0 : s.querySelector('[role="listitem"]')) == null ? void 0 : c.getAttribute("style"), a = o == null ? void 0 : o.match(/margin-left:\s*(\d+)px/), l = a ? Math.round(parseInt(a[1], 10) / u.INDENT_PER_LEVEL) : 0;
+    return l < e ? 0 : l > e ? this.countPrecedingListItemsAtDepth(t - 1, e) : (s == null ? void 0 : s.getAttribute("data-list-style")) !== this._data.style ? 0 : 1 + this.countPrecedingListItemsAtDepth(t - 1, e);
+  }
+  /**
+   * Get the depth of this item in the hierarchy (0 = root level)
+   */
+  getDepth() {
+    var t;
+    return (t = this._data.depth) != null ? t : 0;
+  }
+  /**
+   * Get the appropriate bullet character based on nesting depth
+   */
+  getBulletCharacter(t) {
+    const e = ["•", "◦", "▪"];
+    return e[t % e.length];
+  }
+  /**
+   * Get the ordered list marker text based on depth and index
+   */
+  getOrderedMarkerText(t, e) {
+    const r = this.getListStartValue(t, e) + t;
+    switch (e % 3) {
+      case 0:
+        return `${r}.`;
+      case 1:
+        return `${this.numberToLowerAlpha(r)}.`;
+      case 2:
+        return `${this.numberToLowerRoman(r)}.`;
+      default:
+        return `${r}.`;
+    }
+  }
+  /**
+   * Get the starting number for this list group.
+   * Looks up the first item in the consecutive list group to find its start value.
+   */
+  getListStartValue(t, e) {
+    var d, c;
+    if (t === 0)
+      return (d = this._data.start) != null ? d : 1;
+    const n = this.blockId ? (c = this.api.blocks.getBlockIndex(this.blockId)) != null ? c : this.api.blocks.getCurrentBlockIndex() : this.api.blocks.getCurrentBlockIndex(), r = this.findFirstListItemIndex(n - 1, e, t);
+    if (r === null)
+      return 1;
+    const s = this.api.blocks.getBlockByIndex(r);
+    if (!s)
+      return 1;
+    const o = s.holder, a = o == null ? void 0 : o.querySelector("[data-list-style]"), l = a == null ? void 0 : a.getAttribute("data-list-start");
+    return l ? parseInt(l, 10) : 1;
+  }
+  /**
+   * Find the index of the first list item in this consecutive group.
+   * Walks backwards through the blocks counting items at the same depth and style.
+   * Stops at style boundaries at the same depth (when encountering a different list style).
+   * Items at deeper depths are skipped regardless of their style.
+   */
+  findFirstListItemIndex(t, e, n) {
+    var h;
+    if (t < 0 || n <= 0)
+      return t + 1;
+    const r = this.api.blocks.getBlockByIndex(t);
+    if (!r || r.name !== u.TOOL_NAME)
+      return t + 1;
+    const s = r.holder, o = s == null ? void 0 : s.querySelector("[data-list-style]"), a = (h = o == null ? void 0 : o.querySelector('[role="listitem"]')) == null ? void 0 : h.getAttribute("style"), l = a == null ? void 0 : a.match(/margin-left:\s*(\d+)px/), d = l ? Math.round(parseInt(l[1], 10) / u.INDENT_PER_LEVEL) : 0;
+    return d < e ? t + 1 : d > e ? this.findFirstListItemIndex(t - 1, e, n) : (o == null ? void 0 : o.getAttribute("data-list-style")) !== this._data.style ? t + 1 : this.findFirstListItemIndex(t - 1, e, n - 1);
+  }
+  numberToLowerAlpha(t) {
+    const e = (n) => {
+      if (n <= 0) return "";
+      const r = n - 1;
+      return e(Math.floor(r / 26)) + String.fromCharCode(97 + r % 26);
+    };
+    return e(t);
+  }
+  numberToLowerRoman(t) {
+    const e = [
+      [1e3, "m"],
+      [900, "cm"],
+      [500, "d"],
+      [400, "cd"],
+      [100, "c"],
+      [90, "xc"],
+      [50, "l"],
+      [40, "xl"],
+      [10, "x"],
+      [9, "ix"],
+      [5, "v"],
+      [4, "iv"],
+      [1, "i"]
+    ], n = (r, s) => {
+      if (r <= 0 || s >= e.length) return "";
+      const [o, a] = e[s];
+      return r >= o ? a + n(r - o, s) : n(r, s + 1);
+    };
+    return n(t, 0);
+  }
+  handleKeyDown(t) {
+    if (t.key === "Enter" && !t.shiftKey) {
+      t.preventDefault(), this.handleEnter();
+      return;
+    }
+    if (t.key === "Backspace") {
+      this.handleBackspace(t);
+      return;
+    }
+    if (t.key === "Tab" && t.shiftKey) {
+      t.preventDefault(), this.handleOutdent();
+      return;
+    }
+    t.key === "Tab" && (t.preventDefault(), this.handleIndent());
+  }
+  async handleEnter() {
+    const t = window.getSelection();
+    if (!t || !this._element) return;
+    const e = this.getContentElement();
+    if (!e) return;
+    const n = e.innerHTML.trim();
+    if (n === "" || n === "<br>") {
+      await this.exitListOrOutdent();
+      return;
+    }
+    const r = t.getRangeAt(0), { beforeContent: s, afterContent: o } = this.splitContentAtCursor(e, r);
+    e.innerHTML = s, this._data.text = s;
+    const a = this.api.blocks.getCurrentBlockIndex(), l = this.api.blocks.insert(u.TOOL_NAME, {
+      text: o,
+      style: this._data.style,
+      checked: !1,
+      depth: this._data.depth
+    }, void 0, a + 1, !0);
+    this.setCaretToBlockContent(l, "start");
+  }
+  async exitListOrOutdent() {
+    const t = this.api.blocks.getCurrentBlockIndex();
+    if (this.getDepth() > 0) {
+      await this.handleOutdent();
+      return;
+    }
+    await this.api.blocks.delete(t);
+    const n = this.api.blocks.insert("paragraph", { text: "" }, void 0, t, !0);
+    this.setCaretToBlockContent(n, "start");
+  }
+  async handleBackspace(t) {
+    const e = window.getSelection();
+    if (!e || !this._element) return;
+    const n = e.getRangeAt(0), r = this.getContentElement();
+    if (!r) return;
+    this.syncContentFromDOM();
+    const s = this.api.blocks.getCurrentBlockIndex(), o = this._data.text, a = this.getDepth();
+    if (this.isEntireContentSelected(r, n) && !e.isCollapsed) {
+      t.preventDefault(), r.innerHTML = "", this._data.text = "";
+      const c = document.createRange();
+      c.setStart(r, 0), c.collapse(!0), e.removeAllRanges(), e.addRange(c);
+      return;
+    }
+    if (!this.isAtStart(r, n)) return;
+    t.preventDefault(), await this.api.blocks.delete(s);
+    const d = this.api.blocks.insert(
+      "paragraph",
+      { text: o },
+      void 0,
+      s,
+      !0
+    );
+    a > 0 && requestAnimationFrame(() => {
+      const c = d.holder;
+      c && (c.style.marginLeft = `${a * u.INDENT_PER_LEVEL}px`, c.setAttribute("data-blok-depth", String(a)));
+    }), this.setCaretToBlockContent(d, "start");
+  }
+  /**
+   * Collect all text nodes from an element
+   * @param node - Node to collect text nodes from
+   * @returns Array of text nodes
+   */
+  collectTextNodes(t) {
+    var e;
+    return t.nodeType === Node.TEXT_NODE ? [t] : (e = t.hasChildNodes) != null && e.call(t) ? Array.from(t.childNodes).flatMap((n) => this.collectTextNodes(n)) : [];
+  }
+  /**
+   * Find the text node and offset for a given character position
+   * @param textNodes - Array of text nodes to search through
+   * @param targetPosition - Character position to find
+   * @returns Object with node and offset, or null if not found
+   */
+  findCaretPosition(t, e) {
+    const n = t.reduce(
+      (r, s) => {
+        var a, l;
+        if (r.found) return r;
+        const o = (l = (a = s.textContent) == null ? void 0 : a.length) != null ? l : 0;
+        return r.charCount + o >= e ? {
+          found: !0,
+          charCount: r.charCount,
+          node: s,
+          offset: e - r.charCount
+        } : P(w({}, r), {
+          charCount: r.charCount + o
+        });
+      },
+      { found: !1, charCount: 0, node: null, offset: 0 }
+    );
+    return n.node ? { node: n.node, offset: n.offset } : null;
+  }
+  /**
+   * Sync the current DOM content to the data model
+   */
+  syncContentFromDOM() {
+    var n;
+    const t = this.getContentElement();
+    if (t && (this._data.text = t.innerHTML), this._data.style !== "checklist")
+      return;
+    const e = (n = this._element) == null ? void 0 : n.querySelector('input[type="checkbox"]');
+    e && (this._data.checked = e.checked);
+  }
+  /**
+   * Get the depth of the parent list item by walking backwards through preceding items.
+   * A parent is the first preceding list item with a depth less than the current item.
+   * @param blockIndex - The index of the current block
+   * @returns The parent's depth, or -1 if no parent exists (at root level)
+   */
+  getParentDepth(t) {
+    const e = this.getDepth(), n = (r) => {
+      if (r < 0)
+        return -1;
+      const s = this.api.blocks.getBlockByIndex(r);
+      if (!s || s.name !== u.TOOL_NAME)
+        return -1;
+      const o = this.getBlockDepth(s);
+      return o < e ? o : n(r - 1);
+    };
+    return n(t - 1);
+  }
+  async handleIndent() {
+    const t = this.api.blocks.getCurrentBlockIndex();
+    if (t === 0) return;
+    const e = this.api.blocks.getBlockByIndex(t - 1);
+    if (!e || e.name !== u.TOOL_NAME) return;
+    const n = this.getDepth(), r = this.getBlockDepth(e);
+    if (n > r) return;
+    this.syncContentFromDOM();
+    const s = n + 1;
+    this._data.depth = s;
+    const o = await this.api.blocks.update(this.blockId || "", P(w({}, this._data), {
+      depth: s
+    }));
+    this.setCaretToBlockContent(o);
+  }
+  async handleOutdent() {
+    const t = this.getDepth();
+    if (t === 0) return;
+    this.syncContentFromDOM();
+    const e = t - 1;
+    this._data.depth = e;
+    const n = await this.api.blocks.update(this.blockId || "", P(w({}, this._data), {
+      depth: e
+    }));
+    this.setCaretToBlockContent(n);
+  }
+  getContentElement() {
+    return this._element ? this._data.style === "checklist" ? this._element.querySelector("[contenteditable]") : this._element.querySelector("div.flex-1") : null;
+  }
+  /**
+   * Sets caret to the content element of a block after ensuring DOM is ready.
+   * Uses requestAnimationFrame to wait for the browser to process DOM updates.
+   * @param block - BlockAPI to set caret to
+   * @param position - 'start' or 'end' position (defaults to 'end')
+   */
+  setCaretToBlockContent(t, e = "end") {
+    requestAnimationFrame(() => {
+      const n = t.holder;
+      if (!n) return;
+      const r = n.querySelector('[contenteditable="true"]');
+      if (!r) {
+        this.api.caret.setToBlock(t, e);
+        return;
+      }
+      r.focus();
+      const s = window.getSelection();
+      if (!s) return;
+      const o = document.createRange();
+      e === "start" ? (o.setStart(r, 0), o.collapse(!0)) : (o.selectNodeContents(r), o.collapse(!1)), s.removeAllRanges(), s.addRange(o);
+    });
+  }
+  isAtStart(t, e) {
+    const n = document.createRange();
+    return n.selectNodeContents(t), n.setEnd(e.startContainer, e.startOffset), n.toString().length === 0;
+  }
+  /**
+   * Check if the entire content of an element is selected
+   * @param element - The content element to check
+   * @param range - The current selection range
+   * @returns true if the entire content is selected
+   */
+  isEntireContentSelected(t, e) {
+    const n = document.createRange();
+    n.selectNodeContents(t), n.setEnd(e.startContainer, e.startOffset);
+    const r = n.toString().length === 0, s = document.createRange();
+    s.selectNodeContents(t), s.setStart(e.endContainer, e.endOffset);
+    const o = s.toString().length === 0;
+    return r && o;
+  }
+  splitContentAtCursor(t, e) {
+    const n = document.createRange();
+    n.setStart(t, 0), n.setEnd(e.startContainer, e.startOffset);
+    const r = document.createRange();
+    return r.setStart(e.endContainer, e.endOffset), r.setEndAfter(t.lastChild || t), {
+      beforeContent: this.getFragmentHTML(n.cloneContents()),
+      afterContent: this.getFragmentHTML(r.cloneContents())
+    };
+  }
+  getFragmentHTML(t) {
+    const e = document.createElement("div");
+    return e.appendChild(t), e.innerHTML;
+  }
+  renderSettings() {
+    return this.availableStyles.map((t) => ({
+      icon: t.icon,
+      label: this.api.i18n.t(`toolNames.${t.name}`),
+      onActivate: () => this.setStyle(t.style),
+      closeOnActivate: !0,
+      isActive: this._data.style === t.style
+    }));
+  }
+  setStyle(t) {
+    const e = this._data.style;
+    this._data.style = t, this.rerender(), e !== t && requestAnimationFrame(() => {
+      this.updateAllOrderedListMarkers();
+    });
+  }
+  rerender() {
+    if (!this._element) return;
+    const t = this._element.parentNode;
+    if (!t) return;
+    const e = this.createItemElement();
+    t.replaceChild(e, this._element), this._element = e;
+  }
+  validate(t) {
+    return typeof t.text == "string";
+  }
+  save() {
+    if (!this._element) return this._data;
+    const t = this.getContentElement(), n = {
+      text: t ? et(t.innerHTML) : this._data.text,
+      style: this._data.style,
+      checked: this._data.checked
+    };
+    return this._data.start !== void 0 && this._data.start !== 1 && (n.start = this._data.start), this._data.depth !== void 0 && this._data.depth > 0 && (n.depth = this._data.depth), n;
+  }
+  merge(t) {
+    if (!this._element)
+      return;
+    this._data.text += t.text;
+    const e = this.getContentElement();
+    if (e && t.text) {
+      const n = this.parseHtml(t.text);
+      e.appendChild(n), e.normalize();
+    }
+  }
+  /**
+   * Parse HTML string into a DocumentFragment
+   * @param html - HTML string to parse
+   * @returns DocumentFragment with parsed nodes
+   */
+  parseHtml(t) {
+    const e = document.createElement("div");
+    e.innerHTML = t.trim();
+    const n = document.createDocumentFragment();
+    return n.append(...Array.from(e.childNodes)), n;
+  }
+  static get conversionConfig() {
+    return {
+      export: (t) => t.text,
+      import: (t) => ({
+        text: t,
+        style: "unordered",
+        checked: !1
+      })
+    };
+  }
+  static get sanitize() {
+    return {
+      text: {
+        br: !0,
+        a: !0,
+        b: !0,
+        i: !0,
+        mark: !0
+      }
+    };
+  }
+  static get pasteConfig() {
+    return { tags: ["LI"] };
+  }
+  onPaste(t) {
+    const e = t.detail;
+    if (!("data" in e)) return;
+    const n = e.data, r = n.innerHTML || n.textContent || "", s = n.querySelector('input[type="checkbox"]'), o = (s == null ? void 0 : s.checked) || !1;
+    this._data = {
+      text: r,
+      style: this.detectStyleFromPastedContent(n),
+      checked: o
+    }, this.rerender();
+  }
+  /**
+   * Detect list style from pasted content based on parent element
+   */
+  detectStyleFromPastedContent(t) {
+    const e = t.parentElement;
+    return e ? e.tagName === "OL" ? "ordered" : e.tagName !== "UL" ? this._data.style : t.querySelector('input[type="checkbox"]') ? "checklist" : "unordered" : this._data.style;
+  }
+  static get isReadOnlySupported() {
+    return !0;
+  }
+  /**
+   * Returns the horizontal offset of the content at the hovered element.
+   * Used by the toolbar to position itself closer to nested list items.
+   *
+   * @param hoveredElement - The element that is currently being hovered
+   * @returns Object with left offset in pixels based on the list item's depth
+   */
+  getContentOffset(t) {
+    var r;
+    const e = (r = t.closest('[role="listitem"]')) != null ? r : t.querySelector('[role="listitem"]'), n = this.getMarginLeftFromElement(e);
+    return n !== void 0 ? n : this.getOffsetFromDepthAttribute(t);
+  }
+  /**
+   * Extracts the margin-left value from an element's inline style
+   * @param element - The element to extract margin-left from
+   * @returns Object with left offset if valid margin-left found, undefined otherwise
+   */
+  getMarginLeftFromElement(t) {
+    if (!t)
+      return;
+    const n = (t.getAttribute("style") || "").match(/margin-left:\s*(\d+)px/);
+    if (!n)
+      return;
+    const r = parseInt(n[1], 10);
+    return r > 0 ? { left: r } : void 0;
+  }
+  /**
+   * Gets the offset from the data-list-depth attribute
+   * @param hoveredElement - The element to start searching from
+   * @returns Object with left offset based on depth, undefined if depth is 0 or not found
+   */
+  getOffsetFromDepthAttribute(t) {
+    const e = t.closest("[data-list-depth]");
+    if (!e)
+      return;
+    const n = e.getAttribute("data-list-depth");
+    if (n === null)
+      return;
+    const r = parseInt(n, 10);
+    return r > 0 ? { left: r * u.INDENT_PER_LEVEL } : void 0;
+  }
+  static get toolbox() {
+    return [
+      {
+        icon: G,
+        title: "Bulleted list",
+        titleKey: "bulletedList",
+        data: { style: "unordered" },
+        name: "bulleted-list"
+      },
+      {
+        icon: j,
+        title: "Numbered list",
+        titleKey: "numberedList",
+        data: { style: "ordered" },
+        name: "numbered-list"
+      },
+      {
+        icon: $,
+        title: "To-do list",
+        titleKey: "todoList",
+        data: { style: "checklist" },
+        name: "check-list"
+      }
+    ];
+  }
+};
+u.BASE_STYLES = "outline-none", u.ITEM_STYLES = "outline-none py-0.5 pl-0.5 leading-[1.6em]", u.CHECKLIST_ITEM_STYLES = "flex items-start py-0.5 pl-0.5", u.CHECKBOX_STYLES = "mt-1 w-4 mr-2 h-4 cursor-pointer accent-current", u.STYLE_CONFIGS = [
+  { style: "unordered", name: "bulletedList", icon: G },
+  { style: "ordered", name: "numberedList", icon: j },
+  { style: "checklist", name: "todoList", icon: $ }
+], u.pendingMarkerUpdate = !1, u.DEFAULT_PLACEHOLDER = "List", u.INDENT_PER_LEVEL = 24, u.TOOL_NAME = "list";
+let J = u;
+const i = class i {
+  /**
+   * Sanitizer Rule
+   * Leave <strong> tags
+   * @returns {object}
+   */
+  static get sanitize() {
+    return {
+      strong: {},
+      b: {}
+    };
+  }
+  /**
+   * Normalize any remaining legacy <b> tags within the blok wrapper
+   */
+  static normalizeAllBoldTags() {
+    if (typeof document == "undefined")
+      return;
+    const t = `${A(g.interface)} b, ${A(g.editor)} b`;
+    document.querySelectorAll(t).forEach((e) => {
+      i.ensureStrongElement(e);
+    });
+  }
+  /**
+   * Normalize bold tags within a mutated node if it belongs to the blok
+   * @param node - The node affected by mutation
+   */
+  static normalizeBoldInNode(t) {
+    var r;
+    const e = t.nodeType === Node.ELEMENT_NODE ? t : t.parentElement;
+    !e || typeof e.closest != "function" || !e.closest(`${A(g.interface)}, ${A(g.editor)}`) || (e.tagName === "B" && i.ensureStrongElement(e), (r = e.querySelectorAll) == null || r.call(e, "b").forEach((s) => {
+      i.ensureStrongElement(s);
+    }));
+  }
+  /**
+   *
+   */
+  constructor() {
+    typeof document != "undefined" && (i.instances.add(this), i.initializeGlobalListeners());
+  }
+  /**
+   * Ensure global event listeners are registered once per document
+   */
+  static initializeGlobalListeners() {
+    return typeof document == "undefined" ? !1 : (i.shortcutListenerRegistered || (document.addEventListener("keydown", i.handleShortcut, !0), i.shortcutListenerRegistered = !0), i.selectionListenerRegistered || (document.addEventListener("selectionchange", i.handleGlobalSelectionChange, !0), i.selectionListenerRegistered = !0), i.inputListenerRegistered || (document.addEventListener("input", i.handleGlobalInput, !0), i.inputListenerRegistered = !0), i.beforeInputListenerRegistered || (document.addEventListener("beforeinput", i.handleBeforeInput, !0), i.beforeInputListenerRegistered = !0), i.ensureMutationObserver(), !0);
+  }
+  /**
+   * Ensure that text typed after exiting a collapsed bold selection stays outside of the bold element
+   */
+  static maintainCollapsedExitState() {
+    var t, e, n, r, s;
+    if (typeof document != "undefined")
+      for (const o of Array.from(i.collapsedExitRecords)) {
+        const a = i.resolveBoundary(o);
+        if (!a) {
+          i.collapsedExitRecords.delete(o);
+          continue;
+        }
+        o.boundary = a.boundary, o.boldElement = a.boldElement;
+        const l = a.boundary, d = a.boldElement, c = o.allowedLength, h = (t = d.textContent) != null ? t : "";
+        if (h.length > c) {
+          const b = h.slice(0, c), S = h.slice(c);
+          d.textContent = b, l.textContent = ((e = l.textContent) != null ? e : "") + S;
+        }
+        const p = (n = l.textContent) != null ? n : "";
+        p.length > 1 && p.startsWith("​") && (l.textContent = p.slice(1));
+        const T = window.getSelection();
+        i.ensureCaretAtBoundary(T, l), i.scheduleBoundaryCaretAdjustment(l);
+        const y = (r = l.textContent) != null ? r : "", m = y.replace(/\u200B/g, ""), C = m.match(/^\s+/), E = /\S/.test(m), N = y.startsWith("​");
+        C && (o.hasLeadingSpace = !0, o.leadingWhitespace = C[0]), E && (o.hasTypedContent = !0);
+        const B = /^\s/.test(m), x = o.hasTypedContent && !N && ((s = d.textContent) != null ? s : "").length <= c, v = o.hasLeadingSpace && o.hasTypedContent && !B;
+        if (x && v) {
+          const b = y.replace(/^[\u200B\s]+/, ""), S = o.leadingWhitespace || " ";
+          l.textContent = `${S}${b}`, i.ensureCaretAtBoundary(T, l);
+        }
+        x && i.collapsedExitRecords.delete(o);
+      }
+  }
+  /**
+   * Ensure the caret remains at the end of the boundary text node when exiting bold
+   * @param selection - Current document selection
+   * @param boundary - Text node following the bold element
+   */
+  static ensureCaretAtBoundary(t, e) {
+    !t || !t.isCollapsed || i.setCaretToBoundaryEnd(t, e);
+  }
+  /**
+   * Ensure the caret remains at the end of the boundary text node after the current microtask queue is flushed
+   * @param boundary - Boundary text node that should keep the caret at its end
+   */
+  static scheduleBoundaryCaretAdjustment(t) {
+    i.pendingBoundaryCaretAdjustments.has(t) || (i.pendingBoundaryCaretAdjustments.add(t), setTimeout(() => {
+      var s, o, a;
+      i.pendingBoundaryCaretAdjustments.delete(t);
+      const e = (s = t.ownerDocument) != null ? s : typeof document != "undefined" ? document : null;
+      if (!e)
+        return;
+      const n = e.getSelection();
+      if (!n || !n.isCollapsed || n.anchorNode !== t)
+        return;
+      const r = (a = (o = t.textContent) == null ? void 0 : o.length) != null ? a : 0;
+      n.anchorOffset !== r && i.setCaret(n, t, r);
+    }, 0));
+  }
+  /**
+   * Ensure there is a text node immediately following the provided bold element.
+   * Creates one when necessary.
+   * @param boldElement - Bold element that precedes the boundary
+   * @returns The text node following the bold element or null if it cannot be created
+   */
+  static ensureTextNodeAfter(t) {
+    var o;
+    const e = t.nextSibling;
+    if ((e == null ? void 0 : e.nodeType) === Node.TEXT_NODE)
+      return e;
+    const n = t.parentNode;
+    if (!n)
+      return null;
+    const r = (o = t.ownerDocument) != null ? o : typeof document != "undefined" ? document : null;
+    if (!r)
+      return null;
+    const s = r.createTextNode("");
+    return n.insertBefore(s, e), s;
+  }
+  /**
+   * Resolve the boundary text node tracked for a collapsed exit record.
+   * @param record - Collapsed exit tracking record
+   * @returns The aligned boundary text node or null when it cannot be determined
+   */
+  static resolveBoundary(t) {
+    if (!t.boldElement.isConnected)
+      return null;
+    const e = i.ensureStrongElement(t.boldElement), n = t.boundary, s = n.isConnected && n.previousSibling === e ? n : i.ensureTextNodeAfter(e);
+    return s ? {
+      boundary: s,
+      boldElement: e
+    } : null;
+  }
+  /**
+   * Move caret to the end of the provided boundary text node
+   * @param selection - Current selection to update
+   * @param boundary - Boundary text node that hosts the caret
+   */
+  static setCaretToBoundaryEnd(t, e) {
+    var s, o;
+    const n = document.createRange(), r = (o = (s = e.textContent) == null ? void 0 : s.length) != null ? o : 0;
+    n.setStart(e, r), n.collapse(!0), t.removeAllRanges(), t.addRange(n);
+  }
+  /**
+   * Recursively check if a node or any of its parents is a bold tag (<strong>)
+   * @param node - The node to check
+   */
+  static hasBoldParent(t) {
+    return t ? t.nodeType === Node.ELEMENT_NODE && i.isBoldTag(t) ? !0 : i.hasBoldParent(t.parentNode) : !1;
+  }
+  /**
+   * Recursively find a bold element (<strong>) in the parent chain
+   * @param node - The node to start searching from
+   */
+  static findBoldElement(t) {
+    return t ? t.nodeType === Node.ELEMENT_NODE && i.isBoldTag(t) ? i.ensureStrongElement(t) : i.findBoldElement(t.parentNode) : null;
+  }
+  /**
+   * Check if an element is a bold tag (<strong> for conversion)
+   * @param node - The element to check
+   */
+  static isBoldTag(t) {
+    const e = t.tagName;
+    return e === "B" || e === "STRONG";
+  }
+  /**
+   * Ensure an element is a <strong> tag, converting from <b> if needed
+   * @param element - The element to ensure is a strong tag
+   */
+  static ensureStrongElement(t) {
+    if (t.tagName === "STRONG")
+      return t;
+    const e = document.createElement("strong");
+    for (t.hasAttributes() && Array.from(t.attributes).forEach((n) => {
+      e.setAttribute(n.name, n.value);
+    }); t.firstChild; )
+      e.appendChild(t.firstChild);
+    return t.replaceWith(e), e;
+  }
+  /**
+   * Merge two strong elements by moving children from right to left
+   * @param left - The left strong element to merge into
+   * @param right - The right strong element to merge from
+   */
+  static mergeStrongNodes(t, e) {
+    const n = i.ensureStrongElement(t), r = i.ensureStrongElement(e);
+    for (; r.firstChild; )
+      n.appendChild(r.firstChild);
+    return r.remove(), n;
+  }
+  /**
+   * Create button for Inline Toolbar
+   */
+  render() {
+    return {
+      icon: gt,
+      name: "bold",
+      onActivate: () => {
+        this.toggleBold();
+      },
+      isActive: () => {
+        const t = window.getSelection();
+        return t ? this.isSelectionVisuallyBold(t) : !1;
+      }
+    };
+  }
+  /**
+   * Apply or remove bold formatting using modern Selection API
+   */
+  toggleBold() {
+    const t = window.getSelection();
+    if (!t || t.rangeCount === 0)
+      return;
+    const e = t.getRangeAt(0);
+    if (e.collapsed) {
+      this.toggleCollapsedSelection();
+      return;
+    }
+    this.isRangeBold(e, { ignoreWhitespace: !0 }) ? this.unwrapBoldTags(e) : this.wrapWithBold(e);
+  }
+  /**
+   * Check if current selection is within a bold tag (<strong>)
+   * @param selection - The Selection object to check
+   */
+  isSelectionVisuallyBold(t) {
+    if (!t || t.rangeCount === 0)
+      return !1;
+    const e = t.getRangeAt(0);
+    return this.isRangeBold(e, { ignoreWhitespace: !0 });
+  }
+  /**
+   * Wrap selection with <strong> tag
+   * @param range - The Range object containing the selection to wrap
+   */
+  wrapWithBold(t) {
+    const e = this.getRangeHtmlWithoutBold(t), n = this.replaceRangeWithHtml(t, `<strong>${e}</strong>`), r = window.getSelection();
+    r && n && (r.removeAllRanges(), r.addRange(n)), i.normalizeAllBoldTags();
+    const s = this.findBoldElementFromRangeOrSelection(n, r);
+    if (!s) {
+      this.notifySelectionChange();
+      return;
+    }
+    const o = this.mergeAdjacentBold(s);
+    this.normalizeWhitespaceAround(o), this.selectElementContents(o), i.normalizeBoldTagsWithinBlok(window.getSelection()), i.replaceNbspInBlock(window.getSelection()), this.notifySelectionChange();
+  }
+  /**
+   * Remove bold tags (<strong>) while preserving content
+   * @param range - The Range object containing the selection to unwrap
+   */
+  unwrapBoldTags(t) {
+    const e = this.collectBoldAncestors(t), n = window.getSelection();
+    if (!n)
+      return;
+    const r = document.createElement("span"), s = t.extractContents();
+    r.setAttribute("data-blok-bold-marker", `unwrap-${i.markerSequence++}`), r.appendChild(s), this.removeNestedBold(r), t.insertNode(r);
+    const o = document.createRange();
+    for (o.selectNodeContents(r), n.removeAllRanges(), n.addRange(o); ; ) {
+      const c = i.findBoldElement(r);
+      if (!c)
+        break;
+      this.moveMarkerOutOfBold(r, c);
+    }
+    const a = r.firstChild, l = r.lastChild;
+    this.unwrapElement(r);
+    const d = a && l ? (() => {
+      const c = document.createRange();
+      return c.setStartBefore(a), c.setEndAfter(l), n.removeAllRanges(), n.addRange(c), c;
+    })() : void 0;
+    d || n.removeAllRanges(), this.replaceNbspWithinRange(d), i.normalizeBoldTagsWithinBlok(n), i.replaceNbspInBlock(n), i.removeEmptyBoldElements(n), e.forEach((c) => {
+      i.isElementEmpty(c) && c.remove();
+    }), this.notifySelectionChange();
+  }
+  /**
+   * Replace the current range contents with provided HTML snippet
+   * @param range - Range to replace
+   * @param html - HTML string to insert
+   * @returns range spanning inserted content
+   */
+  replaceRangeWithHtml(t, e) {
+    var a, l;
+    const n = i.createFragmentFromHtml(e), r = (a = n.firstChild) != null ? a : null, s = (l = n.lastChild) != null ? l : null;
+    if (t.deleteContents(), !r || !s)
+      return;
+    t.insertNode(n);
+    const o = document.createRange();
+    return o.setStartBefore(r), o.setEndAfter(s), o;
+  }
+  /**
+   * Move a temporary marker element outside of a bold ancestor while preserving content order
+   * @param marker - Marker element wrapping the selection contents
+   * @param boldElement - Bold ancestor containing the marker
+   */
+  moveMarkerOutOfBold(t, e) {
+    const n = e.parentNode;
+    if (!n)
+      return;
+    if (Array.from(e.childNodes).forEach((l) => {
+      var d;
+      l.nodeType === Node.TEXT_NODE && ((d = l.textContent) != null ? d : "").length === 0 && l.remove();
+    }), e.childNodes.length === 1 && e.firstChild === t) {
+      e.replaceWith(t);
+      return;
+    }
+    if (e.firstChild === t) {
+      n.insertBefore(t, e);
+      return;
+    }
+    if (e.lastChild === t) {
+      n.insertBefore(t, e.nextSibling);
+      return;
+    }
+    const a = e.cloneNode(!1);
+    for (; t.nextSibling; )
+      a.appendChild(t.nextSibling);
+    n.insertBefore(a, e.nextSibling), n.insertBefore(t, a);
+  }
+  /**
+   * Select all contents of an element
+   * @param element - The element whose contents should be selected
+   */
+  selectElementContents(t) {
+    const e = window.getSelection();
+    if (!e)
+      return;
+    const n = document.createRange();
+    n.selectNodeContents(t), e.removeAllRanges(), e.addRange(n);
+  }
+  /**
+   * Check if a range contains bold text
+   * @param range - The range to check
+   * @param options - Options for checking bold status
+   * @param options.ignoreWhitespace - Whether to ignore whitespace-only text nodes
+   */
+  isRangeBold(t, e) {
+    var s;
+    if (t.collapsed)
+      return !!i.findBoldElement(t.startContainer);
+    const n = document.createTreeWalker(
+      t.commonAncestorContainer,
+      NodeFilter.SHOW_TEXT,
+      {
+        acceptNode: (o) => {
+          try {
+            return t.intersectsNode(o) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
+          } catch (a) {
+            const l = document.createRange();
+            l.selectNodeContents(o);
+            const d = t.compareBoundaryPoints(Range.END_TO_START, l) > 0, c = t.compareBoundaryPoints(Range.START_TO_END, l) < 0;
+            return d && c ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
+          }
+        }
+      }
+    ), r = [];
+    for (; n.nextNode(); ) {
+      const o = n.currentNode, a = (s = o.textContent) != null ? s : "";
+      e.ignoreWhitespace && a.trim().length === 0 || a.length !== 0 && r.push(o);
+    }
+    return r.length === 0 ? !!i.findBoldElement(t.startContainer) : r.every((o) => i.hasBoldParent(o));
+  }
+  /**
+   * Remove nested bold tags from a root node
+   * @param root - The root node to process
+   */
+  removeNestedBold(t) {
+    var n;
+    const e = (n = t.querySelectorAll) == null ? void 0 : n.call(t, "b,strong");
+    e && e.forEach((r) => {
+      this.unwrapElement(r);
+    });
+  }
+  /**
+   * Unwrap an element by moving its children to the parent
+   * @param element - The element to unwrap
+   */
+  unwrapElement(t) {
+    const e = t.parentNode;
+    if (!e) {
+      t.remove();
+      return;
+    }
+    for (; t.firstChild; )
+      e.insertBefore(t.firstChild, t);
+    e.removeChild(t);
+  }
+  /**
+   * Find bold element from an inserted range or fall back to selection
+   * @param insertedRange - Range spanning inserted content
+   * @param selection - Current selection as fallback
+   */
+  findBoldElementFromRangeOrSelection(t, e) {
+    if (!t)
+      return e ? i.findBoldElement(e.focusNode) : null;
+    const n = i.findBoldElement(t.startContainer);
+    if (n)
+      return n;
+    const r = i.findBoldElement(t.commonAncestorContainer);
+    return r || (t.startContainer.nodeType === Node.ELEMENT_NODE && i.isBoldTag(t.startContainer) ? t.startContainer : null);
+  }
+  /**
+   * Merge adjacent bold elements into a single element
+   * @param element - The bold element to merge with adjacent elements
+   */
+  mergeAdjacentBold(t) {
+    const e = i.ensureStrongElement(t), n = e.previousSibling, r = n && n.nodeType === Node.ELEMENT_NODE && i.isBoldTag(n) ? i.mergeStrongNodes(n, e) : e, s = r.nextSibling;
+    return s && s.nodeType === Node.ELEMENT_NODE && i.isBoldTag(s) ? i.mergeStrongNodes(r, s) : r;
+  }
+  /**
+   * Toggle bold formatting for a collapsed selection (caret position)
+   * Exits bold if caret is inside a bold element, otherwise starts a new bold element
+   */
+  toggleCollapsedSelection() {
+    const t = window.getSelection();
+    if (!t || t.rangeCount === 0)
+      return;
+    const e = t.getRangeAt(0), n = i.findBoldElement(e.startContainer), r = (() => {
+      if (n && n.getAttribute(i.DATA_ATTR_COLLAPSED_ACTIVE) !== "true")
+        return i.exitCollapsedBold(t, n);
+      const s = n != null ? n : i.getBoundaryBold(e);
+      return s ? i.exitCollapsedBold(t, s) : this.startCollapsedBold(e);
+    })();
+    document.dispatchEvent(new Event("selectionchange")), r && (t.removeAllRanges(), t.addRange(r)), i.normalizeBoldTagsWithinBlok(t), i.replaceNbspInBlock(t), i.removeEmptyBoldElements(t), this.notifySelectionChange();
+  }
+  /**
+   * Insert a bold wrapper at the caret so newly typed text becomes bold
+   * @param range - Current collapsed range
+   */
+  startCollapsedBold(t) {
+    if (!t.collapsed)
+      return;
+    const e = document.createElement("strong"), n = document.createTextNode("");
+    e.appendChild(n), e.setAttribute(i.DATA_ATTR_COLLAPSED_ACTIVE, "true");
+    const r = t.startContainer, s = t.startOffset;
+    if (!(r.nodeType === Node.TEXT_NODE ? this.insertCollapsedBoldIntoText(r, e, s) : r.nodeType === Node.ELEMENT_NODE ? (this.insertCollapsedBoldIntoElement(r, e, s), !0) : !1))
+      return;
+    const a = window.getSelection(), l = document.createRange();
+    l.setStart(n, 0), l.collapse(!0);
+    const d = this.mergeAdjacentBold(e);
+    return i.normalizeBoldTagsWithinBlok(a), i.replaceNbspInBlock(a), i.removeEmptyBoldElements(a), a && (a.removeAllRanges(), a.addRange(l)), this.notifySelectionChange(), d.firstChild instanceof Text ? (() => {
+      var h, p;
+      const c = document.createRange();
+      return c.setStart(d.firstChild, (p = (h = d.firstChild.textContent) == null ? void 0 : h.length) != null ? p : 0), c.collapse(!0), c;
+    })() : l;
+  }
+  /**
+   * Insert a collapsed bold wrapper when the caret resides inside a text node
+   * @param text - Text node containing the caret
+   * @param strong - Strong element to insert
+   * @param offset - Caret offset within the text node
+   * @returns true when insertion succeeded
+   */
+  insertCollapsedBoldIntoText(t, e, n) {
+    var c;
+    const r = t, s = r.parentNode;
+    if (!s)
+      return !1;
+    const o = (c = r.textContent) != null ? c : "", a = o.slice(0, n), l = o.slice(n);
+    r.textContent = a;
+    const d = l.length ? document.createTextNode(l) : null;
+    return d && s.insertBefore(d, r.nextSibling), s.insertBefore(e, d != null ? d : r.nextSibling), e.setAttribute(i.DATA_ATTR_PREV_LENGTH, a.length.toString()), !0;
+  }
+  /**
+   * Insert a collapsed bold wrapper directly into an element container
+   * @param element - Container element
+   * @param strong - Strong element to insert
+   * @param offset - Index at which to insert the strong element
+   */
+  insertCollapsedBoldIntoElement(t, e, n) {
+    var s;
+    const r = (s = t.childNodes[n]) != null ? s : null;
+    t.insertBefore(e, r), e.setAttribute(i.DATA_ATTR_PREV_LENGTH, "0");
+  }
+  /**
+   * Check if an element is empty (has no text content)
+   * @param element - The element to check
+   */
+  static isElementEmpty(t) {
+    var e;
+    return ((e = t.textContent) != null ? e : "").length === 0;
+  }
+  /**
+   *
+   */
+  notifySelectionChange() {
+    i.enforceCollapsedBoldLengths(window.getSelection()), document.dispatchEvent(new Event("selectionchange")), this.updateToolbarButtonState();
+  }
+  /**
+   * Ensure inline toolbar button reflects the actual bold state after programmatic toggles
+   */
+  updateToolbarButtonState() {
+    const t = window.getSelection();
+    if (!t)
+      return;
+    const e = t.anchorNode, n = (e == null ? void 0 : e.nodeType) === Node.ELEMENT_NODE ? e : e == null ? void 0 : e.parentElement, r = n == null ? void 0 : n.closest(A(g.editor));
+    if (!r)
+      return;
+    const s = r.querySelector("[data-blok-testid=inline-toolbar]");
+    if (!(s instanceof HTMLElement))
+      return;
+    const o = s.querySelector('[data-blok-item-name="bold"]');
+    if (!(o instanceof HTMLElement))
+      return;
+    this.isSelectionVisuallyBold(t) ? o.setAttribute("data-blok-popover-item-active", "true") : o.removeAttribute("data-blok-popover-item-active");
+  }
+  /**
+   * Normalize whitespace around a bold element
+   * @param element - The bold element to normalize whitespace around
+   */
+  normalizeWhitespaceAround(t) {
+    i.replaceNbspWithSpace(t.previousSibling), i.replaceNbspWithSpace(t.nextSibling);
+  }
+  /**
+   * Replace non-breaking spaces with regular spaces in a text node
+   * @param node - The text node to process
+   */
+  static replaceNbspWithSpace(t) {
+    var r;
+    if (!t || t.nodeType !== Node.TEXT_NODE)
+      return;
+    const e = t, n = (r = e.textContent) != null ? r : "";
+    n.includes(" ") && (e.textContent = n.replace(/\u00A0/g, " "));
+  }
+  /**
+   * Restore a selection range from marker elements
+   * @param markerId - The ID of the markers used to mark the selection
+   */
+  restoreSelectionFromMarkers(t) {
+    const e = document.querySelector(`[data-blok-bold-marker="${t}-start"]`), n = document.querySelector(`[data-blok-bold-marker="${t}-end"]`);
+    if (!e || !n) {
+      e == null || e.remove(), n == null || n.remove();
+      return;
+    }
+    const r = window.getSelection();
+    if (!r) {
+      e.remove(), n.remove();
+      return;
+    }
+    const s = document.createRange();
+    return s.setStartAfter(e), s.setEndBefore(n), r.removeAllRanges(), r.addRange(s), e.remove(), n.remove(), s;
+  }
+  /**
+   * Replace non-breaking spaces with regular spaces within a range
+   * @param range - The range to process
+   */
+  replaceNbspWithinRange(t) {
+    if (!t)
+      return;
+    const e = document.createTreeWalker(
+      t.commonAncestorContainer,
+      NodeFilter.SHOW_TEXT,
+      {
+        acceptNode: (n) => {
+          try {
+            return t.intersectsNode(n) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
+          } catch (r) {
+            const s = document.createRange();
+            s.selectNodeContents(n);
+            const o = t.compareBoundaryPoints(Range.END_TO_START, s) > 0, a = t.compareBoundaryPoints(Range.START_TO_END, s) < 0;
+            return o && a ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
+          }
+        }
+      }
+    );
+    for (; e.nextNode(); )
+      i.replaceNbspWithSpace(e.currentNode);
+  }
+  /**
+   * Normalize all bold tags within the blok to <strong> tags
+   * Converts any legacy <b> tags to <strong> tags
+   * @param selection - The current selection to determine the blok context
+   */
+  static normalizeBoldTagsWithinBlok(t) {
+    var s;
+    const e = (s = t == null ? void 0 : t.anchorNode) != null ? s : t == null ? void 0 : t.focusNode;
+    if (!e)
+      return;
+    const n = e.nodeType === Node.ELEMENT_NODE ? e : e.parentElement, r = n == null ? void 0 : n.closest(A(g.editor));
+    r && r.querySelectorAll("b").forEach((o) => {
+      i.ensureStrongElement(o);
+    });
+  }
+  /**
+   * Replace non-breaking spaces with regular spaces in the block containing the selection
+   * @param selection - The current selection to determine the block context
+   */
+  static replaceNbspInBlock(t) {
+    var o;
+    const e = (o = t == null ? void 0 : t.anchorNode) != null ? o : t == null ? void 0 : t.focusNode;
+    if (!e)
+      return;
+    const n = e.nodeType === Node.ELEMENT_NODE ? e : e.parentElement, r = n == null ? void 0 : n.closest('[data-blok-component="paragraph"]');
+    if (!r)
+      return;
+    const s = document.createTreeWalker(r, NodeFilter.SHOW_TEXT);
+    for (; s.nextNode(); )
+      i.replaceNbspWithSpace(s.currentNode);
+    r.querySelectorAll("b").forEach((a) => {
+      i.ensureStrongElement(a);
+    });
+  }
+  /**
+   * Remove empty bold elements within the current block
+   * @param selection - The current selection to determine the block context
+   */
+  static removeEmptyBoldElements(t) {
+    var o, a;
+    const e = (o = t == null ? void 0 : t.anchorNode) != null ? o : t == null ? void 0 : t.focusNode;
+    if (!e)
+      return;
+    const n = e.nodeType === Node.ELEMENT_NODE ? e : e.parentElement, r = n == null ? void 0 : n.closest('[data-blok-component="paragraph"]');
+    if (!r)
+      return;
+    const s = (a = t == null ? void 0 : t.focusNode) != null ? a : null;
+    r.querySelectorAll("strong").forEach((l) => {
+      var h;
+      const d = l.getAttribute(i.DATA_ATTR_COLLAPSED_ACTIVE) === "true", c = l.hasAttribute(i.DATA_ATTR_COLLAPSED_LENGTH);
+      d || c || ((h = l.textContent) != null ? h : "").length === 0 && !i.isNodeWithin(s, l) && l.remove();
+    });
+  }
+  /**
+   * Ensure collapsed bold placeholders absorb newly typed text
+   * @param selection - The current selection to determine the blok context
+   */
+  static synchronizeCollapsedBold(t) {
+    var o, a;
+    const e = (o = t == null ? void 0 : t.anchorNode) != null ? o : t == null ? void 0 : t.focusNode, n = e && e.nodeType === Node.ELEMENT_NODE ? e : e == null ? void 0 : e.parentElement, r = (a = n == null ? void 0 : n.closest(A(g.editor))) != null ? a : n == null ? void 0 : n.ownerDocument;
+    if (!r)
+      return;
+    const s = `strong[${i.DATA_ATTR_COLLAPSED_ACTIVE}="true"]`;
+    r.querySelectorAll(s).forEach((l) => {
+      var k, R, F, V, q;
+      const d = l.getAttribute(i.DATA_ATTR_PREV_LENGTH), c = l.previousSibling;
+      if (!d || !c || c.nodeType !== Node.TEXT_NODE)
+        return;
+      const h = Number(d);
+      if (!Number.isFinite(h))
+        return;
+      const p = c, T = (k = p.textContent) != null ? k : "";
+      if (T.length <= h)
+        return;
+      const y = T.slice(0, h), m = T.slice(h);
+      p.textContent = y;
+      const C = m.match(/^[\u00A0\s]+/);
+      if (C && !l.hasAttribute(i.DATA_ATTR_LEADING_WHITESPACE) && l.setAttribute(i.DATA_ATTR_LEADING_WHITESPACE, C[0]), m.length === 0)
+        return;
+      const E = (R = l.textContent) != null ? R : "", N = E + m, B = (F = l.getAttribute(i.DATA_ATTR_LEADING_WHITESPACE)) != null ? F : "", v = B.length > 0 && E.length === 0 && !N.startsWith(B) ? B + N : N, b = document.createTextNode(v);
+      for (; l.firstChild; )
+        l.removeChild(l.firstChild);
+      if (l.appendChild(b), !(t != null && t.isCollapsed) || !i.isNodeWithin(t.focusNode, p))
+        return;
+      const S = document.createRange(), _ = (q = (V = b.textContent) == null ? void 0 : V.length) != null ? q : 0;
+      S.setStart(b, _), S.collapse(!0), t.removeAllRanges(), t.addRange(S);
+    });
+  }
+  /**
+   * Ensure caret is positioned after boundary bold elements when toggling collapsed selections
+   * @param selection - Current selection
+   */
+  static moveCaretAfterBoundaryBold(t) {
+    if (!t.rangeCount)
+      return;
+    const e = t.getRangeAt(0);
+    if (!e.collapsed)
+      return;
+    const n = i.findBoldElement(e.startContainer);
+    (n == null ? void 0 : n.getAttribute(i.DATA_ATTR_COLLAPSED_ACTIVE)) !== "true" && (i.moveCaretFromElementContainer(t, e) || i.moveCaretFromTextContainer(t, e));
+  }
+  /**
+   * Locate a bold element adjacent to a collapsed range
+   * @param range - Range to inspect
+   */
+  static getAdjacentBold(t) {
+    const e = t.startContainer;
+    return e.nodeType === Node.TEXT_NODE ? i.getBoldAdjacentToText(t, e) : e.nodeType === Node.ELEMENT_NODE ? i.getBoldAdjacentToElement(t, e) : null;
+  }
+  /**
+   * Get bold element adjacent to a text node container
+   * @param range - Current collapsed range
+   * @param textNode - Text node hosting the caret
+   */
+  static getBoldAdjacentToText(t, e) {
+    var o, a;
+    const n = (a = (o = e.textContent) == null ? void 0 : o.length) != null ? a : 0, r = e.previousSibling;
+    if (t.startOffset === 0 && i.isBoldElement(r))
+      return r;
+    if (t.startOffset !== n)
+      return null;
+    const s = e.nextSibling;
+    return i.isBoldElement(s) ? s : null;
+  }
+  /**
+   * Get bold element adjacent to an element container
+   * @param range - Current collapsed range
+   * @param element - Element containing the caret
+   */
+  static getBoldAdjacentToElement(t, e) {
+    var s, o;
+    const n = t.startOffset > 0 && (s = e.childNodes[t.startOffset - 1]) != null ? s : null;
+    if (i.isBoldElement(n))
+      return n;
+    const r = (o = e.childNodes[t.startOffset]) != null ? o : null;
+    return i.isBoldElement(r) ? r : null;
+  }
+  /**
+   * Exit collapsed bold state when caret no longer resides within bold content
+   * @param selection - Current selection
+   * @param range - Collapsed range after toggling bold
+   */
+  static exitCollapsedIfNeeded(t, e) {
+    var o;
+    if (!!i.findBoldElement(e.startContainer))
+      return;
+    const r = (o = i.getBoundaryBold(e)) != null ? o : i.getAdjacentBold(e);
+    if (!r)
+      return;
+    const s = i.exitCollapsedBold(t, r);
+    s && (t.removeAllRanges(), t.addRange(s));
+  }
+  /**
+   * Adjust caret when selection container is an element adjacent to bold content
+   * @param selection - Current selection
+   * @param range - Collapsed range to inspect
+   * @returns true when caret position was updated
+   */
+  static moveCaretFromElementContainer(t, e) {
+    if (e.startContainer.nodeType !== Node.ELEMENT_NODE)
+      return !1;
+    const n = e.startContainer;
+    return i.moveCaretAfterPreviousBold(t, n, e.startOffset) ? !0 : i.moveCaretBeforeNextBold(t, n, e.startOffset);
+  }
+  /**
+   * Move caret after the bold node that precedes the caret when possible
+   * @param selection - Current selection
+   * @param element - Container element
+   * @param offset - Caret offset within the container
+   */
+  static moveCaretAfterPreviousBold(t, e, n) {
+    var a, l, d;
+    const r = n > 0 && (a = e.childNodes[n - 1]) != null ? a : null;
+    if (!i.isBoldElement(r))
+      return !1;
+    const s = i.ensureFollowingTextNode(r, r.nextSibling);
+    if (!s)
+      return !1;
+    const o = (d = (l = s.textContent) == null ? void 0 : l.length) != null ? d : 0;
+    return i.setCaret(t, s, o), !0;
+  }
+  /**
+   * Move caret before the bold node that follows the caret, ensuring there's a text node to receive input
+   * @param selection - Current selection
+   * @param element - Container element
+   * @param offset - Caret offset within the container
+   */
+  static moveCaretBeforeNextBold(t, e, n) {
+    var o;
+    const r = (o = e.childNodes[n]) != null ? o : null;
+    if (!i.isBoldElement(r))
+      return !1;
+    const s = i.ensureFollowingTextNode(r, r.nextSibling);
+    return s ? (i.setCaret(t, s, 0), !0) : (i.setCaretAfterNode(t, r), !0);
+  }
+  /**
+   * Adjust caret when selection container is a text node adjacent to bold content
+   * @param selection - Current selection
+   * @param range - Collapsed range to inspect
+   */
+  static moveCaretFromTextContainer(t, e) {
+    var d, c, h;
+    if (e.startContainer.nodeType !== Node.TEXT_NODE)
+      return;
+    const n = e.startContainer, r = n.previousSibling, s = (d = n.textContent) != null ? d : "", o = /^\s/.test(s);
+    if (e.startOffset === 0 && i.isBoldElement(r) && (s.length === 0 || o)) {
+      i.setCaret(t, n, s.length);
+      return;
+    }
+    const a = i.findBoldElement(n);
+    if (!a || e.startOffset !== ((h = (c = n.textContent) == null ? void 0 : c.length) != null ? h : 0))
+      return;
+    const l = i.ensureFollowingTextNode(a, a.nextSibling);
+    if (l) {
+      i.setCaret(t, l, 0);
+      return;
+    }
+    i.setCaretAfterNode(t, a);
+  }
+  /**
+   * Ensure caret is positioned at the end of a collapsed boundary text node before the browser processes a printable keydown
+   * @param event - Keydown event fired before browser input handling
+   */
+  static guardCollapsedBoundaryKeydown(t) {
+    var l;
+    if (t.defaultPrevented || t.metaKey || t.ctrlKey || t.altKey || t.key.length !== 1)
+      return;
+    const n = window.getSelection();
+    if (!n || !n.isCollapsed || n.rangeCount === 0)
+      return;
+    const r = n.getRangeAt(0);
+    if (r.startContainer.nodeType !== Node.TEXT_NODE)
+      return;
+    const s = r.startContainer, o = (l = s.textContent) != null ? l : "";
+    if (o.length === 0 || r.startOffset !== 0)
+      return;
+    const a = s.previousSibling;
+    i.isBoldElement(a) && /^\s/.test(o) && i.setCaret(n, s, o.length);
+  }
+  /**
+   * Determine whether a node is a bold element (<strong>/<b>)
+   * @param node - Node to inspect
+   */
+  static isBoldElement(t) {
+    return !!(t && t.nodeType === Node.ELEMENT_NODE && i.isBoldTag(t));
+  }
+  /**
+   * Place caret at the provided offset within a text node
+   * @param selection - Current selection
+   * @param node - Target text node
+   * @param offset - Offset within the text node
+   */
+  static setCaret(t, e, n) {
+    const r = document.createRange();
+    r.setStart(e, n), r.collapse(!0), t.removeAllRanges(), t.addRange(r);
+  }
+  /**
+   * Position caret immediately after the provided node
+   * @param selection - Current selection
+   * @param node - Reference node
+   */
+  static setCaretAfterNode(t, e) {
+    if (!e)
+      return;
+    const n = document.createRange();
+    n.setStartAfter(e), n.collapse(!0), t.removeAllRanges(), t.addRange(n);
+  }
+  /**
+   * Ensure there is a text node immediately following a bold element to accept new input
+   * @param boldElement - Bold element after which text should be inserted
+   * @param referenceNode - Node that currently follows the bold element
+   */
+  static ensureFollowingTextNode(t, e) {
+    const n = t.parentNode;
+    if (!n)
+      return null;
+    if (e && e.nodeType === Node.TEXT_NODE)
+      return e;
+    const r = document.createTextNode("");
+    return n.insertBefore(r, e), r;
+  }
+  /**
+   * Enforce length limits on collapsed bold elements
+   * @param selection - The current selection to determine the blok context
+   */
+  static enforceCollapsedBoldLengths(t) {
+    var o;
+    const e = (o = t == null ? void 0 : t.anchorNode) != null ? o : t == null ? void 0 : t.focusNode;
+    if (!e)
+      return;
+    const n = e.nodeType === Node.ELEMENT_NODE ? e : e.parentElement, r = n == null ? void 0 : n.closest(A(g.editor));
+    if (!r)
+      return;
+    r.querySelectorAll(`strong[${i.DATA_ATTR_COLLAPSED_LENGTH}]`).forEach((a) => {
+      var x, v, b, S, _;
+      const l = a, d = l.getAttribute(i.DATA_ATTR_COLLAPSED_LENGTH);
+      if (!d)
+        return;
+      const c = Number(d), h = (x = l.textContent) != null ? x : "";
+      if (!Number.isFinite(c))
+        return;
+      const p = h.length > c, T = p ? i.splitCollapsedBoldText(l, c, h) : null, y = l.getAttribute(i.DATA_ATTR_PREV_LENGTH), m = y ? Number(y) : NaN, C = l.previousSibling, E = (C == null ? void 0 : C.nodeType) === Node.TEXT_NODE ? C : null, N = (v = E == null ? void 0 : E.textContent) != null ? v : "", B = !!(y && Number.isFinite(m) && E && N.length > m);
+      if (B && E) {
+        const k = N.slice(0, m), R = N.slice(m);
+        E.textContent = k;
+        const F = document.createTextNode(R);
+        (b = l.parentNode) == null || b.insertBefore(F, l.nextSibling);
+      }
+      if (B && l.removeAttribute(i.DATA_ATTR_PREV_LENGTH), t != null && t.isCollapsed && T && i.isNodeWithin(t.focusNode, l)) {
+        const k = document.createRange(), R = (_ = (S = T.textContent) == null ? void 0 : S.length) != null ? _ : 0;
+        k.setStart(T, R), k.collapse(!0), t.removeAllRanges(), t.addRange(k);
+      }
+      p && l.removeAttribute(i.DATA_ATTR_COLLAPSED_LENGTH);
+    });
+  }
+  /**
+   * Split text content exceeding the allowed collapsed bold length and move the excess outside
+   * @param boldEl - Bold element hosting the collapsed selection
+   * @param allowedLength - Maximum allowed length for the collapsed bold
+   * @param currentText - Current text content inside the bold element
+   */
+  static splitCollapsedBoldText(t, e, n) {
+    const r = t, s = r.parentNode;
+    if (!s)
+      return null;
+    const o = n.slice(0, e), a = n.slice(e);
+    r.textContent = o;
+    const l = document.createTextNode(a);
+    return s.insertBefore(l, r.nextSibling), l;
+  }
+  /**
+   * Check if a node is within the provided container
+   * @param target - Node to test
+   * @param container - Potential ancestor container
+   */
+  static isNodeWithin(t, e) {
+    return t ? t === e || e.contains(t) : !1;
+  }
+  /**
+   *
+   */
+  static handleGlobalSelectionChange() {
+    i.refreshSelectionState("selectionchange");
+  }
+  /**
+   *
+   */
+  static handleGlobalInput() {
+    i.refreshSelectionState("input");
+  }
+  /**
+   * Normalize selection state after blok input or selection updates
+   * @param source - The event source triggering the refresh
+   */
+  static refreshSelectionState(t) {
+    const e = window.getSelection();
+    i.enforceCollapsedBoldLengths(e), i.maintainCollapsedExitState(), i.synchronizeCollapsedBold(e), i.normalizeBoldTagsWithinBlok(e), i.removeEmptyBoldElements(e), t === "input" && e && i.moveCaretAfterBoundaryBold(e), i.normalizeAllBoldTags();
+  }
+  /**
+   * Ensure mutation observer is registered to convert legacy <b> tags
+   */
+  static ensureMutationObserver() {
+    if (typeof MutationObserver == "undefined" || i.mutationObserver)
+      return;
+    const t = new MutationObserver((e) => {
+      if (!i.isProcessingMutation) {
+        i.isProcessingMutation = !0;
+        try {
+          e.forEach((n) => {
+            n.addedNodes.forEach((r) => {
+              i.normalizeBoldInNode(r);
+            }), n.type === "characterData" && n.target && i.normalizeBoldInNode(n.target);
+          });
+        } finally {
+          i.isProcessingMutation = !1;
+        }
+      }
+    });
+    t.observe(document.body, {
+      subtree: !0,
+      childList: !0,
+      characterData: !0
+    }), i.mutationObserver = t;
+  }
+  /**
+   * Prevent the browser's native bold command to avoid <b> wrappers
+   * @param event - BeforeInput event fired by the browser
+   */
+  static handleBeforeInput(t) {
+    if (t.inputType !== "formatBold")
+      return;
+    const e = window.getSelection(), n = !!(e && i.isSelectionInsideBlok(e)), r = i.isEventTargetInsideBlok(t.target);
+    !n && !r || (t.preventDefault(), t.stopPropagation(), t.stopImmediatePropagation(), i.normalizeAllBoldTags());
+  }
+  /**
+   * Attempt to toggle bold via the browser's native command
+   * @param selection - Current selection
+   */
+  /**
+   * Exit a collapsed bold selection by moving the caret outside the bold element
+   * @param selection - The current selection
+   * @param boldElement - The bold element to exit from
+   */
+  static exitCollapsedBold(t, e) {
+    const n = i.ensureStrongElement(e), r = n.parentNode;
+    if (r)
+      return i.isElementEmpty(n) ? i.removeEmptyBoldElement(t, n, r) : i.exitCollapsedBoldWithContent(t, n, r);
+  }
+  /**
+   * Remove an empty bold element and place the caret before its position
+   * @param selection - Current selection
+   * @param boldElement - Bold element to remove
+   * @param parent - Parent node that hosts the bold element
+   */
+  static removeEmptyBoldElement(t, e, n) {
+    const r = document.createRange();
+    return r.setStartBefore(e), r.collapse(!0), n.removeChild(e), t.removeAllRanges(), t.addRange(r), r;
+  }
+  /**
+   * Exit a collapsed bold state when the bold element still contains text
+   * @param selection - Current selection
+   * @param boldElement - Bold element currently wrapping the caret
+   * @param parent - Parent node that hosts the bold element
+   */
+  static exitCollapsedBoldWithContent(t, e, n) {
+    var p, T, y, m, C, E;
+    e.setAttribute(i.DATA_ATTR_COLLAPSED_LENGTH, ((T = (p = e.textContent) == null ? void 0 : p.length) != null ? T : 0).toString()), e.removeAttribute(i.DATA_ATTR_PREV_LENGTH), e.removeAttribute(i.DATA_ATTR_COLLAPSED_ACTIVE), e.removeAttribute(i.DATA_ATTR_LEADING_WHITESPACE);
+    const r = e.nextSibling, s = !r || r.nodeType !== Node.TEXT_NODE, o = s ? document.createTextNode("​") : null;
+    o && n.insertBefore(o, r);
+    const a = o != null ? o : r;
+    !s && ((y = a.textContent) != null ? y : "").length === 0 && (a.textContent = "​");
+    const l = document.createRange(), c = ((m = a.textContent) != null ? m : "").startsWith("​") ? 1 : 0;
+    l.setStart(a, c), l.collapse(!0), t.removeAllRanges(), t.addRange(l);
+    const h = i.ensureStrongElement(e);
+    return i.collapsedExitRecords.add({
+      boundary: a,
+      boldElement: h,
+      allowedLength: (E = (C = h.textContent) == null ? void 0 : C.length) != null ? E : 0,
+      hasLeadingSpace: !1,
+      hasTypedContent: !1,
+      leadingWhitespace: ""
+    }), l;
+  }
+  /**
+   * Get a bold element at the boundary of a collapsed range
+   * @param range - The collapsed range to check
+   */
+  static getBoundaryBold(t) {
+    const e = t.startContainer;
+    return e.nodeType === Node.TEXT_NODE ? i.getBoundaryBoldForText(t, e) : e.nodeType === Node.ELEMENT_NODE ? i.getBoundaryBoldForElement(t, e) : null;
+  }
+  /**
+   * Get boundary bold when caret resides inside a text node
+   * @param range - Collapsed range
+   * @param textNode - Text container
+   */
+  static getBoundaryBoldForText(t, e) {
+    var s, o;
+    const n = (o = (s = e.textContent) == null ? void 0 : s.length) != null ? o : 0;
+    if (t.startOffset === n)
+      return i.findBoldElement(e);
+    if (t.startOffset !== 0)
+      return null;
+    const r = e.previousSibling;
+    return i.isBoldElement(r) ? r : null;
+  }
+  /**
+   * Get boundary bold when caret container is an element
+   * @param range - Collapsed range
+   * @param element - Element container
+   */
+  static getBoundaryBoldForElement(t, e) {
+    if (t.startOffset <= 0)
+      return null;
+    const n = e.childNodes[t.startOffset - 1];
+    return i.isBoldElement(n) ? n : null;
+  }
+  /**
+   * Handle keyboard shortcut for bold when selection is collapsed
+   * @param event - The keyboard event
+   */
+  static handleShortcut(t) {
+    var r;
+    if (i.guardCollapsedBoundaryKeydown(t), !i.isBoldShortcut(t))
+      return;
+    const e = window.getSelection();
+    if (!e || !e.rangeCount || !i.isSelectionInsideBlok(e))
+      return;
+    const n = (r = i.instances.values().next().value) != null ? r : new i();
+    n && (t.preventDefault(), t.stopPropagation(), t.stopImmediatePropagation(), n.toggleBold());
+  }
+  /**
+   * Check if a keyboard event is the bold shortcut (Cmd/Ctrl+B)
+   * @param event - The keyboard event to check
+   */
+  static isBoldShortcut(t) {
+    return !((typeof navigator != "undefined" ? navigator.userAgent.toLowerCase() : "").includes("mac") ? t.metaKey : t.ctrlKey) || t.altKey ? !1 : t.key.toLowerCase() === "b";
+  }
+  /**
+   * Check if a selection is inside the blok
+   * @param selection - The selection to check
+   */
+  static isSelectionInsideBlok(t) {
+    const e = t.anchorNode;
+    if (!e)
+      return !1;
+    const n = e.nodeType === Node.ELEMENT_NODE ? e : e.parentElement;
+    return !!(n != null && n.closest(A(g.editor)));
+  }
+  /**
+   * Check if an event target resides inside the blok wrapper
+   * @param target - Event target to inspect
+   */
+  static isEventTargetInsideBlok(t) {
+    var n;
+    if (!t || typeof Node == "undefined")
+      return !1;
+    if (t instanceof Element)
+      return !!t.closest(A(g.editor));
+    if (t instanceof Text)
+      return !!((n = t.parentElement) != null && n.closest(A(g.editor)));
+    if (typeof ShadowRoot != "undefined" && t instanceof ShadowRoot)
+      return i.isEventTargetInsideBlok(t.host);
+    if (!(t instanceof Node))
+      return !1;
+    const e = t.parentNode;
+    return e ? e instanceof Element ? !!e.closest(A(g.editor)) : i.isEventTargetInsideBlok(e) : !1;
+  }
+  /**
+   * Get HTML content of a range with bold tags removed
+   * @param range - The range to extract HTML from
+   */
+  getRangeHtmlWithoutBold(t) {
+    const e = t.cloneContents();
+    this.removeNestedBold(e);
+    const n = document.createElement("div");
+    return n.appendChild(e), n.innerHTML;
+  }
+  /**
+   * Convert an HTML snippet to a document fragment
+   * @param html - HTML string to convert
+   */
+  static createFragmentFromHtml(t) {
+    const e = document.createElement("template");
+    return e.innerHTML = t, e.content;
+  }
+  /**
+   * Collect all bold ancestor elements within a range
+   * @param range - The range to search for bold ancestors
+   */
+  collectBoldAncestors(t) {
+    const e = /* @__PURE__ */ new Set(), n = document.createTreeWalker(
+      t.commonAncestorContainer,
+      NodeFilter.SHOW_TEXT,
+      {
+        acceptNode: (r) => {
+          try {
+            return t.intersectsNode(r) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
+          } catch (s) {
+            const o = document.createRange();
+            o.selectNodeContents(r);
+            const a = t.compareBoundaryPoints(Range.END_TO_START, o) > 0, l = t.compareBoundaryPoints(Range.START_TO_END, o) < 0;
+            return a && l ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
+          }
+        }
+      }
+    );
+    for (; n.nextNode(); ) {
+      const r = i.findBoldElement(n.currentNode);
+      r && e.add(r);
+    }
+    return Array.from(e);
+  }
+};
+i.isInline = !0, i.title = "Bold", i.titleKey = "bold", i.shortcutListenerRegistered = !1, i.selectionListenerRegistered = !1, i.inputListenerRegistered = !1, i.beforeInputListenerRegistered = !1, i.globalListenersInitialized = i.initializeGlobalListeners(), i.collapsedExitRecords = /* @__PURE__ */ new Set(), i.markerSequence = 0, i.isProcessingMutation = !1, i.DATA_ATTR_COLLAPSED_LENGTH = "data-blok-bold-collapsed-length", i.DATA_ATTR_COLLAPSED_ACTIVE = "data-blok-bold-collapsed-active", i.DATA_ATTR_PREV_LENGTH = "data-blok-bold-prev-length", i.DATA_ATTR_LEADING_WHITESPACE = "data-blok-bold-leading-ws", i.instances = /* @__PURE__ */ new Set(), i.pendingBoundaryCaretAdjustments = /* @__PURE__ */ new WeakSet(), i.shortcut = "CMD+B";
+let Z = i;
+const O = class O {
+  /**
+   * Sanitizer Rule
+   * Leave <i> and <em> tags
+   * @returns {object}
+   */
+  static get sanitize() {
+    return {
+      i: {},
+      em: {}
+    };
+  }
+  /**
+   * Create button for Inline Toolbar
+   */
+  render() {
+    return {
+      icon: mt,
+      name: "italic",
+      onActivate: () => {
+        this.toggleItalic();
+      },
+      isActive: () => {
+        const t = window.getSelection();
+        return t ? this.isSelectionVisuallyItalic(t) : !1;
+      }
+    };
+  }
+  /**
+   * Apply or remove italic formatting using modern Selection API
+   */
+  toggleItalic() {
+    const t = window.getSelection();
+    if (!t || t.rangeCount === 0)
+      return;
+    const e = t.getRangeAt(0);
+    if (e.collapsed) {
+      this.toggleCollapsedItalic(e, t);
+      return;
+    }
+    this.isRangeItalic(e, { ignoreWhitespace: !0 }) ? this.unwrapItalicTags(e) : this.wrapWithItalic(e);
+  }
+  /**
+   * Handle toggle for collapsed selection (caret)
+   * @param range - Current range
+   * @param selection - Current selection
+   */
+  toggleCollapsedItalic(t, e) {
+    if (this.isRangeItalic(t, { ignoreWhitespace: !0 })) {
+      const r = document.createTextNode("​");
+      t.insertNode(r), t.selectNode(r), this.unwrapItalicTags(t);
+      const s = document.createRange();
+      s.setStart(r, 1), s.setEnd(r, 1), e.removeAllRanges(), e.addRange(s);
+    } else {
+      const r = document.createElement("i"), s = document.createTextNode("​");
+      r.appendChild(s), t.insertNode(r);
+      const o = document.createRange();
+      o.setStart(s, 1), o.setEnd(s, 1), e.removeAllRanges(), e.addRange(o);
+    }
+  }
+  /**
+   * Check if current selection is within an italic tag
+   * @param selection - The Selection object to check
+   */
+  isSelectionVisuallyItalic(t) {
+    if (!t || t.rangeCount === 0)
+      return !1;
+    const e = t.getRangeAt(0);
+    return this.isRangeItalic(e, { ignoreWhitespace: !0 });
+  }
+  /**
+   * Check if a range contains italic text
+   * @param range - The range to check
+   * @param options - Options for checking italic status
+   */
+  isRangeItalic(t, e) {
+    var s;
+    if (t.collapsed)
+      return !!this.findItalicElement(t.startContainer);
+    const n = document.createTreeWalker(
+      t.commonAncestorContainer,
+      NodeFilter.SHOW_TEXT,
+      {
+        acceptNode: (o) => {
+          try {
+            return t.intersectsNode(o) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
+          } catch (a) {
+            const l = document.createRange();
+            l.selectNodeContents(o);
+            const d = t.compareBoundaryPoints(Range.END_TO_START, l) > 0, c = t.compareBoundaryPoints(Range.START_TO_END, l) < 0;
+            return d && c ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
+          }
+        }
+      }
+    ), r = [];
+    for (; n.nextNode(); ) {
+      const o = n.currentNode, a = (s = o.textContent) != null ? s : "";
+      e.ignoreWhitespace && a.trim().length === 0 || a.length !== 0 && r.push(o);
+    }
+    return r.length === 0 ? !!this.findItalicElement(t.startContainer) : r.every((o) => this.hasItalicParent(o));
+  }
+  /**
+   * Wrap selection with <i> tag
+   * @param range - The Range object containing the selection to wrap
+   */
+  wrapWithItalic(t) {
+    const e = this.getRangeHtmlWithoutItalic(t), n = this.replaceRangeWithHtml(t, `<i>${e}</i>`), r = window.getSelection();
+    r && n && (r.removeAllRanges(), r.addRange(n));
+  }
+  /**
+   * Remove italic tags (<i>/<em>) while preserving content
+   * @param range - The Range object containing the selection to unwrap
+   */
+  unwrapItalicTags(t) {
+    const e = this.collectItalicAncestors(t), n = window.getSelection();
+    if (!n)
+      return;
+    const r = document.createElement("span"), s = t.extractContents();
+    r.appendChild(s), this.removeNestedItalic(r), t.insertNode(r);
+    const o = document.createRange();
+    for (o.selectNodeContents(r), n.removeAllRanges(), n.addRange(o); ; ) {
+      const c = this.findItalicElement(r);
+      if (!c)
+        break;
+      this.moveMarkerOutOfItalic(r, c);
+    }
+    const a = r.firstChild, l = r.lastChild;
+    this.unwrapElement(r), (a && l ? (() => {
+      const c = document.createRange();
+      return c.setStartBefore(a), c.setEndAfter(l), n.removeAllRanges(), n.addRange(c), c;
+    })() : void 0) || n.removeAllRanges(), e.forEach((c) => {
+      var h;
+      ((h = c.textContent) != null ? h : "").length === 0 && c.remove();
+    });
+  }
+  /**
+   * Check if a node or any of its parents is an italic tag
+   * @param node - The node to check
+   */
+  hasItalicParent(t) {
+    return t ? t.nodeType === Node.ELEMENT_NODE && this.isItalicTag(t) ? !0 : this.hasItalicParent(t.parentNode) : !1;
+  }
+  /**
+   * Find an italic element in the parent chain
+   * @param node - The node to start searching from
+   */
+  findItalicElement(t) {
+    return t ? t.nodeType === Node.ELEMENT_NODE && this.isItalicTag(t) ? t : this.findItalicElement(t.parentNode) : null;
+  }
+  /**
+   * Check if an element is an italic tag (<i> or <em>)
+   * @param node - The element to check
+   */
+  isItalicTag(t) {
+    const e = t.tagName;
+    return e === "I" || e === "EM";
+  }
+  /**
+   * Collect all italic ancestor elements within a range
+   * @param range - The range to search for italic ancestors
+   */
+  collectItalicAncestors(t) {
+    const e = /* @__PURE__ */ new Set(), n = document.createTreeWalker(
+      t.commonAncestorContainer,
+      NodeFilter.SHOW_TEXT,
+      {
+        acceptNode: (r) => {
+          try {
+            return t.intersectsNode(r) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
+          } catch (s) {
+            const o = document.createRange();
+            o.selectNodeContents(r);
+            const a = t.compareBoundaryPoints(Range.END_TO_START, o) > 0, l = t.compareBoundaryPoints(Range.START_TO_END, o) < 0;
+            return a && l ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
+          }
+        }
+      }
+    );
+    for (; n.nextNode(); ) {
+      const r = this.findItalicElement(n.currentNode);
+      r && e.add(r);
+    }
+    return Array.from(e);
+  }
+  /**
+   * Get HTML content of a range with italic tags removed
+   * @param range - The range to extract HTML from
+   */
+  getRangeHtmlWithoutItalic(t) {
+    const e = t.cloneContents();
+    this.removeNestedItalic(e);
+    const n = document.createElement("div");
+    return n.appendChild(e), n.innerHTML;
+  }
+  /**
+   * Remove nested italic tags from a root node
+   * @param root - The root node to process
+   */
+  removeNestedItalic(t) {
+    var n;
+    const e = (n = t.querySelectorAll) == null ? void 0 : n.call(t, "i,em");
+    e && e.forEach((r) => {
+      this.unwrapElement(r);
+    });
+  }
+  /**
+   * Unwrap an element by moving its children to the parent
+   * @param element - The element to unwrap
+   */
+  unwrapElement(t) {
+    const e = t.parentNode;
+    if (!e) {
+      t.remove();
+      return;
+    }
+    for (; t.firstChild; )
+      e.insertBefore(t.firstChild, t);
+    e.removeChild(t);
+  }
+  /**
+   * Replace the current range contents with provided HTML snippet
+   * @param range - Range to replace
+   * @param html - HTML string to insert
+   */
+  replaceRangeWithHtml(t, e) {
+    var a, l;
+    const n = this.createFragmentFromHtml(e), r = (a = n.firstChild) != null ? a : null, s = (l = n.lastChild) != null ? l : null;
+    if (t.deleteContents(), !r || !s)
+      return;
+    t.insertNode(n);
+    const o = document.createRange();
+    return o.setStartBefore(r), o.setEndAfter(s), o;
+  }
+  /**
+   * Convert an HTML snippet to a document fragment
+   * @param html - HTML string to convert
+   */
+  createFragmentFromHtml(t) {
+    const e = document.createElement("template");
+    return e.innerHTML = t, e.content;
+  }
+  /**
+   * Move a temporary marker element outside of an italic ancestor while preserving content order
+   * @param marker - Marker element wrapping the selection contents
+   * @param italicElement - Italic ancestor containing the marker
+   */
+  moveMarkerOutOfItalic(t, e) {
+    const n = e.parentNode;
+    if (!n)
+      return;
+    if (Array.from(e.childNodes).forEach((l) => {
+      var d;
+      l.nodeType === Node.TEXT_NODE && ((d = l.textContent) != null ? d : "").length === 0 && l.remove();
+    }), e.childNodes.length === 1 && e.firstChild === t) {
+      e.replaceWith(t);
+      return;
+    }
+    if (e.firstChild === t) {
+      n.insertBefore(t, e);
+      return;
+    }
+    if (e.lastChild === t) {
+      n.insertBefore(t, e.nextSibling);
+      return;
+    }
+    const a = e.cloneNode(!1);
+    for (; t.nextSibling; )
+      a.appendChild(t.nextSibling);
+    n.insertBefore(a, e.nextSibling), n.insertBefore(t, a);
+  }
+};
+O.isInline = !0, O.title = "Italic", O.titleKey = "italic", O.shortcut = "CMD+I";
+let Q = O;
+const D = class D {
+  /**
+   * @param api - Blok API
+   */
+  constructor({ api: t }) {
+    this.INPUT_BASE_CLASSES = "hidden w-full m-0 px-2 py-1 text-sm leading-[22px] font-medium bg-item-hover-bg border border-[rgba(226,226,229,0.2)] rounded-md outline-none box-border appearance-none font-[inherit] placeholder:text-gray-text mobile:text-[15px] mobile:font-medium", this.DATA_ATTRIBUTES = {
+      buttonActive: "data-blok-link-tool-active",
+      buttonUnlink: "data-blok-link-tool-unlink",
+      inputOpened: "data-blok-link-tool-input-opened"
+    }, this.nodes = {
+      input: null,
+      button: null
+    }, this.inputOpened = !1, this.unlinkAvailable = !1, this.handleButtonClick = (e) => {
+      !this.inputOpened || !this.unlinkAvailable || (e.preventDefault(), e.stopPropagation(), e.stopImmediatePropagation(), this.restoreSelection(), this.unlink(), this.inlineToolbar.close());
+    }, this.toolbar = t.toolbar, this.inlineToolbar = t.inlineToolbar, this.notifier = t.notifier, this.i18n = t.i18n, this.selection = new H(), this.nodes.input = this.createInput();
+  }
+  /**
+   * Sanitizer Rule
+   * Leave <a> tags
+   * @returns {object}
+   */
+  static get sanitize() {
+    return {
+      a: {
+        href: !0,
+        target: "_blank",
+        rel: "nofollow"
+      }
+    };
+  }
+  /**
+   * Create button for Inline Toolbar
+   */
+  render() {
+    return {
+      icon: Tt,
+      name: "link",
+      isActive: () => !!this.selection.findParentTag("A"),
+      children: {
+        hideChevron: !0,
+        items: [
+          {
+            type: Et.Html,
+            element: this.nodes.input
+          }
+        ],
+        onOpen: () => {
+          this.openActions(!0);
+        },
+        onClose: () => {
+          this.closeActions();
+        }
+      }
+    };
+  }
+  /**
+   * Input for the link
+   */
+  createInput() {
+    const t = document.createElement("input");
+    return t.placeholder = this.i18n.t("tools.link.addLink"), t.enterKeyHint = "done", t.className = this.INPUT_BASE_CLASSES, t.setAttribute("data-blok-testid", "inline-tool-input"), this.setBooleanStateAttribute(t, this.DATA_ATTRIBUTES.inputOpened, !1), t.addEventListener("keydown", (e) => {
+      e.key === "Enter" && this.enterPressed(e);
+    }), t;
+  }
+  /**
+   * @param {boolean} needFocus - on link creation we need to focus input. On editing - nope.
+   */
+  openActions(t = !1) {
+    if (!this.nodes.input)
+      return;
+    const e = this.selection.findParentTag("A"), n = !!e;
+    if (this.updateButtonStateAttributes(n), this.unlinkAvailable = n, e) {
+      const r = e.getAttribute("href");
+      this.nodes.input.value = r !== null ? r : "";
+    } else
+      this.nodes.input.value = "";
+    this.nodes.input.className = L(this.INPUT_BASE_CLASSES, "block"), this.setBooleanStateAttribute(this.nodes.input, this.DATA_ATTRIBUTES.inputOpened, !0), this.selection.setFakeBackground(), this.selection.save(), t && this.focusInputWithRetry(), this.inputOpened = !0;
+  }
+  /**
+   * Ensures the link input receives focus even if other listeners steal it
+   */
+  focusInputWithRetry() {
+    this.nodes.input && (this.nodes.input.focus(), !(typeof window == "undefined" || typeof document == "undefined") && window.setTimeout(() => {
+      var t;
+      document.activeElement !== this.nodes.input && ((t = this.nodes.input) == null || t.focus());
+    }, 0));
+  }
+  /**
+   * Resolve the current inline toolbar button element
+   */
+  getButtonElement() {
+    const t = document.querySelector(
+      `${A(g.interface, At)} [data-blok-item-name="link"]`
+    );
+    return t && t !== this.nodes.button && (t.addEventListener("click", this.handleButtonClick, !0), this.nodes.button = t), t;
+  }
+  /**
+   * Update button state attributes for e2e hooks
+   * @param hasAnchor - Optional override for anchor presence
+   */
+  updateButtonStateAttributes(t) {
+    const e = this.getButtonElement();
+    if (!e)
+      return;
+    const n = typeof t == "boolean" ? t : !!this.selection.findParentTag("A");
+    this.setBooleanStateAttribute(e, this.DATA_ATTRIBUTES.buttonActive, n), this.setBooleanStateAttribute(e, this.DATA_ATTRIBUTES.buttonUnlink, n);
+  }
+  /**
+   * Close input
+   * @param {boolean} clearSavedSelection — we don't need to clear saved selection
+   *                                        on toggle-clicks on the icon of opened Toolbar
+   */
+  closeActions(t = !0) {
+    (this.selection.isFakeBackgroundEnabled || t && this.selection.savedSelectionRange) && this.restoreSelection(), this.nodes.input && (this.nodes.input.className = this.INPUT_BASE_CLASSES, this.setBooleanStateAttribute(this.nodes.input, this.DATA_ATTRIBUTES.inputOpened, !1), this.nodes.input.value = "", this.updateButtonStateAttributes(!1), this.unlinkAvailable = !1, t && this.selection.clearSaved(), this.inputOpened = !1);
+  }
+  /**
+   * Restore selection after closing actions
+   */
+  restoreSelection() {
+    const t = new H(), e = H.isAtBlok;
+    if (e && t.save(), this.selection.removeFakeBackground(), this.selection.restore(), !e && this.selection.savedSelectionRange) {
+      const s = this.selection.savedSelectionRange.commonAncestorContainer, o = s.nodeType === Node.ELEMENT_NODE ? s : s.parentElement;
+      o == null || o.focus();
+    }
+    if (!e)
+      return;
+    t.restore();
+    const n = t.savedSelectionRange;
+    if (n) {
+      const r = n.commonAncestorContainer, s = r.nodeType === Node.ELEMENT_NODE ? r : r.parentElement;
+      s == null || s.focus();
+    }
+  }
+  /**
+   * Enter pressed on input
+   * @param {KeyboardEvent} event - enter keydown event
+   */
+  enterPressed(t) {
+    if (!this.nodes.input)
+      return;
+    const e = this.nodes.input.value || "";
+    if (!e.trim()) {
+      this.selection.restore(), this.unlink(), t.preventDefault(), this.closeActions(), this.inlineToolbar.close();
+      return;
+    }
+    if (!this.validateURL(e)) {
+      this.notifier.show({
+        message: this.i18n.t("tools.link.invalidLink"),
+        style: "error"
+      }), Ct("Incorrect Link pasted", "warn", e);
+      return;
+    }
+    const n = this.prepareLink(e);
+    this.selection.removeFakeBackground(), this.selection.restore(), this.insertLink(n), t.preventDefault(), t.stopPropagation(), t.stopImmediatePropagation(), this.selection.collapseToEnd(), this.inlineToolbar.close();
+  }
+  /**
+   * Detects if passed string is URL
+   * @param {string} str - string to validate
+   * @returns {boolean}
+   */
+  validateURL(t) {
+    return !/\s/.test(t);
+  }
+  /**
+   * Process link before injection
+   * - sanitize
+   * - add protocol for links like 'google.com'
+   * @param {string} link - raw user input
+   */
+  prepareLink(t) {
+    return this.addProtocol(t.trim());
+  }
+  /**
+   * Add 'http' protocol to the links like 'vc.ru', 'google.com'
+   * @param {string} link - string to process
+   */
+  addProtocol(t) {
+    if (/^(\w+):(\/\/)?/.test(t))
+      return t;
+    const e = /^\/[^/\s]/.test(t), n = t.substring(0, 1) === "#", r = /^\/\/[^/\s]/.test(t);
+    return !e && !n && !r ? "http://" + t : t;
+  }
+  /**
+   * Inserts <a> tag with "href"
+   * @param {string} link - "href" value
+   */
+  insertLink(t) {
+    const e = this.selection.findParentTag("A");
+    if (e) {
+      this.selection.expandToTag(e), e.href = t, e.target = "_blank", e.rel = "nofollow";
+      return;
+    }
+    const n = H.range;
+    if (!n)
+      return;
+    const r = document.createElement("a");
+    r.href = t, r.target = "_blank", r.rel = "nofollow", r.appendChild(n.extractContents()), n.insertNode(r), this.selection.expandToTag(r);
+  }
+  /**
+   * Removes <a> tag
+   */
+  unlink() {
+    const t = this.selection.findParentTag("A");
+    t && (this.unwrap(t), this.updateButtonStateAttributes(!1), this.unlinkAvailable = !1);
+  }
+  /**
+   * Unwrap passed node
+   * @param term - node to unwrap
+   */
+  unwrap(t) {
+    var n;
+    const e = document.createDocumentFragment();
+    for (; t.firstChild; )
+      e.appendChild(t.firstChild);
+    (n = t.parentNode) == null || n.replaceChild(e, t);
+  }
+  /**
+   * Persist state as data attributes for testing hooks
+   * @param element - The HTML element to set the attribute on, or null
+   * @param attributeName - The name of the attribute to set
+   * @param state - The boolean state value to persist
+   */
+  setBooleanStateAttribute(t, e, n) {
+    t && t.setAttribute(e, n ? "true" : "false");
+  }
+};
+D.isInline = !0, D.title = "Link", D.titleKey = "link", D.shortcut = "CMD+K";
+let tt = D;
+const xt = {
+  paragraph: { inlineToolbar: !0, config: { preserveBlank: !0 } },
+  header: { inlineToolbar: !0 },
+  list: { inlineToolbar: !0 }
+}, vt = {
+  bold: {},
+  italic: {},
+  link: {}
+};
+export {
+  Z as Bold,
+  Ot as Convert,
+  Y as Header,
+  Q as Italic,
+  tt as Link,
+  J as List,
+  X as Paragraph,
+  xt as defaultBlockTools,
+  vt as defaultInlineTools
+};