@jackuait/blok 0.4.1 → 0.4.2

package/dist/chunks/inline-tool-convert-Bx5BVd8I.mjs

@@ -0,0 +1,1988 @@
+var Y = Object.defineProperty, Q = Object.defineProperties;
+var tt = Object.getOwnPropertyDescriptors;
+var W = Object.getOwnPropertySymbols;
+var et = Object.prototype.hasOwnProperty, nt = Object.prototype.propertyIsEnumerable;
+var D = (o, t, e) => t in o ? Y(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e, I = (o, t) => {
+  for (var e in t || (t = {}))
+    et.call(t, e) && D(o, e, t[e]);
+  if (W)
+    for (var e of W(t))
+      nt.call(t, e) && D(o, e, t[e]);
+  return o;
+}, O = (o, t) => Q(o, tt(t));
+const ot = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+let rt = (o = 21) => {
+  let t = "", e = crypto.getRandomValues(new Uint8Array(o |= 0));
+  for (; o--; )
+    t += ot[e[o] & 63];
+  return t;
+};
+var st = /* @__PURE__ */ ((o) => (o.VERBOSE = "VERBOSE", o.INFO = "INFO", o.WARN = "WARN", o.ERROR = "ERROR", o))(st || {});
+const it = () => "0.4.2", Et = {
+  BACKSPACE: 8,
+  TAB: 9,
+  ENTER: 13,
+  LEFT: 37,
+  UP: 38,
+  DOWN: 40,
+  RIGHT: 39,
+  DELETE: 46
+}, Tt = {
+  LEFT: 0
+}, at = 1e8, lt = 16, m = (() => {
+  try {
+    return Function("return this")();
+  } catch (o) {
+    return;
+  }
+})();
+m && typeof m.window == "undefined" && (m.window = m);
+const B = () => {
+  if (m != null && m.window)
+    return m.window;
+}, X = () => {
+  if (m != null && m.navigator)
+    return m.navigator;
+  const o = B();
+  return o == null ? void 0 : o.navigator;
+}, N = (o, t, e = "log", n, r = "color: inherit") => {
+  const s = typeof console == "undefined" ? void 0 : console;
+  if (!s || typeof s[e] != "function")
+    return;
+  const i = ["info", "log", "warn", "error"].includes(e), l = [];
+  switch (N.logLevel) {
+    case "ERROR":
+      if (e !== "error")
+        return;
+      break;
+    case "WARN":
+      if (!["error", "warn"].includes(e))
+        return;
+      break;
+    case "INFO":
+      if (!i || o)
+        return;
+      break;
+  }
+  n && l.push(n);
+  const c = `Blok ${it()}`, a = `line-height: 1em;
+            color: #006FEA;
+            display: inline-block;
+            font-size: 11px;
+            line-height: 1em;
+            background-color: #fff;
+            padding: 4px 9px;
+            border-radius: 30px;
+            border: 1px solid rgba(56, 138, 229, 0.16);
+            margin: 4px 5px 4px 0;`, d = o ? i ? (l.unshift(a, r), `%c${c}%c ${t}`) : `( ${c} )${t}` : t, u = i ? n !== void 0 ? [`${d} %o`, ...l] : [d, ...l] : [d];
+  try {
+    s[e](...u);
+  } catch (g) {
+  }
+};
+N.logLevel = "VERBOSE";
+const xt = (o) => {
+  N.logLevel = o;
+}, M = (o, t = "log", e, n) => {
+  N(!1, o, t, e, n);
+}, At = (o, t = "log", e, n) => {
+  N(!0, o, t, e, n);
+}, F = (o) => typeof o == "function", L = (o) => {
+  if (o === null || typeof o != "object")
+    return !1;
+  const t = Object.getPrototypeOf(o);
+  return t === null || t === Object.prototype;
+}, x = (o) => typeof o == "string", Nt = (o) => typeof o == "boolean", _ = (o) => typeof o == "number", St = function(o) {
+  return o === void 0;
+}, q = (o) => o == null ? !0 : typeof o == "string" || Array.isArray(o) ? o.length === 0 : o instanceof Map || o instanceof Set ? o.size === 0 : typeof o == "object" ? Object.keys(o).length === 0 : !1, ct = (o) => Array.from(o), It = (o, t) => function(...e) {
+  setTimeout(() => o.apply(this, e), t);
+}, Rt = (o) => {
+  var t;
+  return (t = o.name.split(".").pop()) != null ? t : "";
+}, Mt = (o) => /^[-\w]+\/([-+\w]+|\*)$/.test(o), Lt = (o, t, e) => {
+  const n = {
+    timeoutId: null
+  };
+  return function(...r) {
+    const s = () => {
+      n.timeoutId = null, o.apply(this, r);
+    };
+    n.timeoutId !== null && clearTimeout(n.timeoutId), n.timeoutId = setTimeout(s, t);
+  };
+}, Bt = (o, t, e) => {
+  const n = {
+    lastCallTime: void 0,
+    lastInvokeTime: 0,
+    timerId: void 0,
+    lastArgs: void 0,
+    lastThis: void 0
+  }, r = (a) => {
+    n.lastInvokeTime = a;
+    const d = n.lastArgs, u = n.lastThis;
+    return n.lastArgs = void 0, n.lastThis = void 0, o.apply(u, d != null ? d : []);
+  }, s = (a) => {
+    var h;
+    const d = a - ((h = n.lastCallTime) != null ? h : 0), u = a - n.lastInvokeTime, g = t - d;
+    return Math.min(g, t - u);
+  }, i = (a) => {
+    var g;
+    const d = a - ((g = n.lastCallTime) != null ? g : 0), u = a - n.lastInvokeTime;
+    return n.lastCallTime === void 0 || d >= t || d < 0 || u >= t;
+  }, l = () => {
+    const a = Date.now();
+    if (!i(a)) {
+      n.timerId = setTimeout(l, s(a));
+      return;
+    }
+    n.timerId = void 0, n.lastArgs !== void 0 && r(a), n.lastArgs = void 0, n.lastThis = void 0;
+  };
+  return function(...a) {
+    const d = Date.now(), u = i(d);
+    if (n.lastArgs = a, n.lastThis = this, n.lastCallTime = d, !!(u && n.timerId === void 0))
+      return n.lastInvokeTime = d, n.timerId = setTimeout(l, t), r(d);
+  };
+}, dt = () => {
+  var r, s;
+  const o = {
+    win: !1,
+    mac: !1,
+    x11: !1,
+    linux: !1
+  }, t = X(), e = (s = (r = t == null ? void 0 : t.userAgent) == null ? void 0 : r.toLowerCase()) != null ? s : "", n = e ? Object.keys(o).find((i) => e.indexOf(i) !== -1) : void 0;
+  return n !== void 0 && (o[n] = !0), o;
+}, ut = (o) => o && o.slice(0, 1).toUpperCase() + o.slice(1), K = (o, t) => {
+  const e = I({}, o);
+  return Object.keys(t).forEach((n) => {
+    const r = e[n], s = t[n];
+    if (s === void 0)
+      return;
+    if (L(s) && L(r) && !Array.isArray(s)) {
+      e[n] = K(
+        r,
+        s
+      );
+      return;
+    }
+    e[n] = s;
+  }), e;
+}, Ot = (o, ...t) => {
+  if (!L(o) || t.length === 0)
+    return o;
+  const e = t.reduce((n, r) => L(r) ? K(n, r) : n, o);
+  return Object.assign(o, e), o;
+}, $t = (o) => {
+  const t = dt(), e = o.replace(/shift/gi, "⇧").replace(/backspace/gi, "⌫").replace(/enter/gi, "⏎").replace(/up/gi, "↑").replace(/left/gi, "→").replace(/down/gi, "↓").replace(/right/gi, "←").replace(/escape/gi, "⎋").replace(/insert/gi, "Ins").replace(/delete/gi, "␡").replace(/\+/gi, " + ");
+  return t.mac ? e.replace(/ctrl|cmd/gi, "⌘").replace(/alt/gi, "⌥") : e.replace(/cmd/gi, "Ctrl").replace(/windows/gi, "WIN");
+}, Ft = (o) => {
+  try {
+    return new URL(o).href;
+  } catch (e) {
+  }
+  const t = B();
+  return o.substring(0, 2) === "//" ? t ? `${t.location.protocol}${o}` : o : t ? `${t.location.origin}${o}` : o;
+}, Ht = () => rt(10), Gt = (o) => {
+  const t = B();
+  t && t.open(o, "_blank");
+}, jt = (o = "") => `${o}${Math.floor(Math.random() * at).toString(lt)}`, pt = 650, gt = () => {
+  const o = B();
+  return !o || typeof o.matchMedia != "function" ? !1 : o.matchMedia(`(max-width: ${pt}px)`).matches;
+}, Pt = (() => {
+  var c;
+  const o = X();
+  if (!o)
+    return !1;
+  const t = o.userAgent || "", e = o.userAgentData, n = e == null ? void 0 : e.platform;
+  if (/iP(ad|hone|od)/.test(t) || n !== void 0 && n !== "" && /iP(ad|hone|od)/.test(n))
+    return !0;
+  const r = ((c = o.maxTouchPoints) != null ? c : 0) > 1, s = () => (
+    // eslint-disable-next-line @typescript-eslint/no-deprecated -- Fallback for older browsers that don't support User-Agent Client Hints
+    o.platform
+  ), i = n !== void 0 && n !== "" ? n : void 0;
+  return (r ? i != null ? i : s() : void 0) === "MacIntel";
+})(), ht = (o, t) => o.length !== t.length ? !1 : o.every((e, n) => H(e, t[n])), H = (o, t) => {
+  if (o === t)
+    return !0;
+  if (o === null || t === null || typeof o != "object" || typeof t != "object" || Array.isArray(o) !== Array.isArray(t))
+    return !1;
+  if (Array.isArray(o) && Array.isArray(t))
+    return ht(o, t);
+  const e = Object.keys(o), n = Object.keys(t);
+  return e.length !== n.length ? !1 : e.every(
+    (r) => Object.prototype.hasOwnProperty.call(t, r) && H(o[r], t[r])
+  );
+}, Vt = (o) => {
+  if (!o || !o.includes("data-blok-fake-background"))
+    return o;
+  const t = document.createElement("div");
+  return t.innerHTML = o, t.querySelectorAll('[data-blok-fake-background="true"]').forEach((n) => {
+    const r = n.parentNode;
+    if (r) {
+      for (; n.firstChild; )
+        r.insertBefore(n.firstChild, n);
+      r.removeChild(n);
+    }
+  }), t.innerHTML;
+};
+class p {
+  /**
+   * Check if passed tag has no closed tag
+   * @param {HTMLElement} tag - element to check
+   * @returns {boolean}
+   */
+  static isSingleTag(t) {
+    return !!t.tagName && [
+      "AREA",
+      "BASE",
+      "BR",
+      "COL",
+      "COMMAND",
+      "EMBED",
+      "HR",
+      "IMG",
+      "INPUT",
+      "KEYGEN",
+      "LINK",
+      "META",
+      "PARAM",
+      "SOURCE",
+      "TRACK",
+      "WBR"
+    ].includes(t.tagName);
+  }
+  /**
+   * Check if element is BR or WBR
+   * @param {HTMLElement} element - element to check
+   * @returns {boolean}
+   */
+  static isLineBreakTag(t) {
+    return !!t && ["BR", "WBR"].includes(t.tagName);
+  }
+  /**
+   * Checks if a class name is valid for use with classList.add()
+   * classList.add() throws if class contains whitespace, is empty, or contains invalid characters
+   * @param className - class name to validate
+   * @returns {boolean} - true if valid for classList.add()
+   */
+  static isValidClassName(t) {
+    if (t === "" || /\s/.test(t))
+      return !1;
+    try {
+      return document.createElement("div").classList.add(t), !0;
+    } catch (e) {
+      return !1;
+    }
+  }
+  /**
+   * Safely adds class names to an element, filtering out invalid ones
+   * @param element - element to add classes to
+   * @param classNames - array of class names to add
+   */
+  static safelyAddClasses(t, e) {
+    const n = [], r = [];
+    for (const s of e)
+      p.isValidClassName(s) ? n.push(s) : r.push(s);
+    if (n.length > 0 && t.classList.add(...n), r.length > 0) {
+      const s = t.className, i = s ? `${s} ${r.join(" ")}` : r.join(" ");
+      t.setAttribute("class", i);
+    }
+  }
+  /**
+   * Helper for making Elements with class name and attributes
+   * @param  {string} tagName - new Element tag name
+   * @param  {string[]|string} [classNames] - list or name of CSS class name(s)
+   * @param  {object} [attributes] - any attributes
+   * @returns {HTMLElement}
+   */
+  static make(t, e = null, n = {}) {
+    const r = document.createElement(t);
+    if (Array.isArray(e)) {
+      const s = e.filter((i) => i !== void 0 && i !== "").flatMap((i) => i.split(" ")).filter((i) => i !== "");
+      p.safelyAddClasses(r, s);
+    }
+    if (typeof e == "string" && e !== "") {
+      const s = e.split(" ").filter((i) => i !== "");
+      p.safelyAddClasses(r, s);
+    }
+    for (const s in n) {
+      if (!Object.prototype.hasOwnProperty.call(n, s))
+        continue;
+      const i = n[s];
+      if (i != null) {
+        if (s in r) {
+          r[s] = i;
+          continue;
+        }
+        r.setAttribute(s, String(i));
+      }
+    }
+    return r;
+  }
+  /**
+   * Creates Text Node with the passed content
+   * @param {string} content - text content
+   * @returns {Text}
+   */
+  static text(t) {
+    return document.createTextNode(t);
+  }
+  /**
+   * Append one or several elements to the parent
+   * @param  {Element|DocumentFragment} parent - where to append
+   * @param  {Element|Element[]|DocumentFragment|Text|Text[]} elements - element or elements list
+   */
+  static append(t, e) {
+    Array.isArray(e) ? e.forEach((n) => t.appendChild(n)) : t.appendChild(e);
+  }
+  /**
+   * Append element or a couple to the beginning of the parent elements
+   * @param {Element} parent - where to append
+   * @param {Element|Element[]} elements - element or elements list
+   */
+  static prepend(t, e) {
+    Array.isArray(e) ? [...e].reverse().forEach((r) => t.prepend(r)) : t.prepend(e);
+  }
+  /**
+   * Selector Decorator
+   *
+   * Returns first match
+   * @param {Element} el - element we searching inside. Default - DOM Document
+   * @param {string} selector - searching string
+   * @returns {Element}
+   */
+  static find(t = document, e) {
+    return t.querySelector(e);
+  }
+  /**
+   * Get Element by Id
+   * @param {string} id - id to find
+   * @returns {HTMLElement | null}
+   */
+  static get(t) {
+    return document.getElementById(t);
+  }
+  /**
+   * Selector Decorator.
+   *
+   * Returns all matches
+   * @param {Element|Document} el - element we searching inside. Default - DOM Document
+   * @param {string} selector - searching string
+   * @returns {NodeList}
+   */
+  static findAll(t = document, e) {
+    return t.querySelectorAll(e);
+  }
+  /**
+   * Returns CSS selector for all text inputs
+   */
+  static get allInputsSelector() {
+    return "[contenteditable=true], textarea, input:not([type]), " + ["text", "password", "email", "number", "search", "tel", "url"].map((e) => `input[type="${e}"]`).join(", ");
+  }
+  /**
+   * Find all contenteditable, textarea and editable input elements passed holder contains
+   * @param holder - element where to find inputs
+   */
+  static findAllInputs(t) {
+    return ct(t.querySelectorAll(p.allInputsSelector)).reduce((e, n) => p.isNativeInput(n) || p.containsOnlyInlineElements(n) ? [...e, n] : [...e, ...p.getDeepestBlockElements(n)], []);
+  }
+  /**
+   * Search for deepest node which is Leaf.
+   * Leaf is the vertex that doesn't have any child nodes
+   * @description Method recursively goes throw the all Node until it finds the Leaf
+   * @param {Node} node - root Node. From this vertex we start Deep-first search
+   *                      {@link https://en.wikipedia.org/wiki/Depth-first_search}
+   * @param {boolean} [atLast] - find last text node
+   * @returns - it can be text Node or Element Node, so that caret will able to work with it
+   *            Can return null if node is Document or DocumentFragment, or node is not attached to the DOM
+   */
+  static getDeepestNode(t, e = !1) {
+    var d;
+    const n = e ? "lastChild" : "firstChild", r = e ? "previousSibling" : "nextSibling";
+    if (t === null || t.nodeType !== Node.ELEMENT_NODE)
+      return t;
+    const s = t[n];
+    if (s === null)
+      return t;
+    const i = s;
+    if (!(p.isSingleTag(i) && !p.isNativeInput(i) && !p.isLineBreakTag(i)))
+      return this.getDeepestNode(i, e);
+    const c = i[r];
+    if (c)
+      return this.getDeepestNode(c, e);
+    const a = (d = i.parentNode) == null ? void 0 : d[r];
+    return a ? this.getDeepestNode(a, e) : i.parentNode;
+  }
+  /**
+   * Check if object is DOM node
+   * @param {*} node - object to check
+   * @returns {boolean}
+   */
+  static isElement(t) {
+    return _(t) ? !1 : t != null && t.nodeType != null && t.nodeType === Node.ELEMENT_NODE;
+  }
+  /**
+   * Check if object is DocumentFragment node
+   * @param {object} node - object to check
+   * @returns {boolean}
+   */
+  static isFragment(t) {
+    return _(t) ? !1 : t != null && t.nodeType != null && t.nodeType === Node.DOCUMENT_FRAGMENT_NODE;
+  }
+  /**
+   * Check if passed element is contenteditable
+   * @param {HTMLElement} element - html element to check
+   * @returns {boolean}
+   */
+  static isContentEditable(t) {
+    return t.contentEditable === "true";
+  }
+  /**
+   * Checks target if it is native input
+   * @param {*} target - HTML element or string
+   * @returns {boolean}
+   */
+  static isNativeInput(t) {
+    const e = [
+      "INPUT",
+      "TEXTAREA"
+    ];
+    return t != null && typeof t.tagName == "string" ? e.includes(t.tagName) : !1;
+  }
+  /**
+   * Checks if we can set caret
+   * @param {HTMLElement} target - target to check
+   * @returns {boolean}
+   */
+  static canSetCaret(t) {
+    return p.isNativeInput(t) ? !(/* @__PURE__ */ new Set([
+      "file",
+      "checkbox",
+      "radio",
+      "hidden",
+      "submit",
+      "button",
+      "image",
+      "reset"
+    ])).has(t.type) : p.isContentEditable(t);
+  }
+  /**
+   * Checks node if it is empty
+   * @description Method checks simple Node without any childs for emptiness
+   * If you have Node with 2 or more children id depth, you better use {@link Dom#isEmpty} method
+   * @param {Node} node - node to check
+   * @param {string} [ignoreChars] - char or substring to treat as empty
+   * @returns {boolean} true if it is empty
+   */
+  static isNodeEmpty(t, e) {
+    var s, i;
+    if (this.isSingleTag(t) && !this.isLineBreakTag(t))
+      return !1;
+    const n = this.isElement(t) && this.isNativeInput(t) ? t.value : (s = t.textContent) == null ? void 0 : s.replace("​", ""), r = e ? n == null ? void 0 : n.replace(new RegExp(e, "g"), "") : n;
+    return ((i = r == null ? void 0 : r.length) != null ? i : 0) === 0;
+  }
+  /**
+   * checks node if it is doesn't have any child nodes
+   * @param {Node} node - node to check
+   * @returns {boolean}
+   */
+  static isLeaf(t) {
+    return t ? t.childNodes.length === 0 : !1;
+  }
+  /**
+   * breadth-first search (BFS)
+   * {@link https://en.wikipedia.org/wiki/Breadth-first_search}
+   * @description Pushes to stack all DOM leafs and checks for emptiness
+   * @param {Node} node - node to check
+   * @param {string} [ignoreChars] - char or substring to treat as empty
+   * @returns {boolean}
+   */
+  static isEmpty(t, e) {
+    const n = [t];
+    for (; n.length > 0; ) {
+      const r = n.shift();
+      if (r) {
+        if (this.isLeaf(r) && !this.isNodeEmpty(r, e))
+          return !1;
+        r.childNodes && n.push(...Array.from(r.childNodes));
+      }
+    }
+    return !0;
+  }
+  /**
+   * Check if string contains html elements
+   * @param {string} str - string to check
+   * @returns {boolean}
+   */
+  static isHTMLString(t) {
+    const e = p.make("div");
+    return e.innerHTML = t, e.childElementCount > 0;
+  }
+  /**
+   * Return length of node`s text content
+   * @param {Node} node - node with content
+   * @returns {number}
+   */
+  static getContentLength(t) {
+    var e, n;
+    return p.isNativeInput(t) ? t.value.length : t.nodeType === Node.TEXT_NODE ? t.length : (n = (e = t.textContent) == null ? void 0 : e.length) != null ? n : 0;
+  }
+  /**
+   * Return array of names of block html elements
+   * @returns {string[]}
+   */
+  static get blockElements() {
+    return [
+      "address",
+      "article",
+      "aside",
+      "blockquote",
+      "canvas",
+      "div",
+      "dl",
+      "dt",
+      "fieldset",
+      "figcaption",
+      "figure",
+      "footer",
+      "form",
+      "h1",
+      "h2",
+      "h3",
+      "h4",
+      "h5",
+      "h6",
+      "header",
+      "hgroup",
+      "hr",
+      "li",
+      "main",
+      "nav",
+      "noscript",
+      "ol",
+      "output",
+      "p",
+      "pre",
+      "ruby",
+      "section",
+      "table",
+      "tbody",
+      "thead",
+      "tr",
+      "tfoot",
+      "ul",
+      "video"
+    ];
+  }
+  /**
+   * Check if passed content includes only inline elements
+   * @param {string|HTMLElement} data - element or html string
+   * @returns {boolean}
+   */
+  static containsOnlyInlineElements(t) {
+    const e = x(t) ? (() => {
+      const r = document.createElement("div");
+      return r.innerHTML = t, r;
+    })() : t, n = (r) => !p.blockElements.includes(r.tagName.toLowerCase()) && Array.from(r.children).every(n);
+    return Array.from(e.children).every(n);
+  }
+  /**
+   * Find and return all block elements in the passed parent (including subtree)
+   * @param {HTMLElement} parent - root element
+   * @returns {HTMLElement[]}
+   */
+  static getDeepestBlockElements(t) {
+    return p.containsOnlyInlineElements(t) ? [t] : Array.from(t.children).reduce((e, n) => [...e, ...p.getDeepestBlockElements(n)], []);
+  }
+  /**
+   * Helper for get holder from {string} or return HTMLElement
+   * @param {string | HTMLElement} element - holder's id or holder's HTML Element
+   * @returns {HTMLElement}
+   */
+  static getHolder(t) {
+    if (!x(t))
+      return t;
+    const e = document.getElementById(t);
+    if (e !== null)
+      return e;
+    throw new Error(`Element with id "${t}" not found`);
+  }
+  /**
+   * Returns true if element is anchor (is A tag)
+   * @param {Element} element - element to check
+   * @returns {boolean}
+   */
+  static isAnchor(t) {
+    return t.tagName.toLowerCase() === "a";
+  }
+  /**
+   * Return element's offset related to the document
+   * @todo handle case when blok initialized in scrollable popup
+   * @param el - element to compute offset
+   */
+  static offset(t) {
+    const e = t.getBoundingClientRect(), n = window.scrollX || document.documentElement.scrollLeft, r = window.scrollY || document.documentElement.scrollTop, s = e.top + r, i = e.left + n;
+    return {
+      top: s,
+      left: i,
+      bottom: s + e.height,
+      right: i + e.width
+    };
+  }
+  /**
+   * Find text node and offset by total content offset
+   * @param {Node} root - root node to start search from
+   * @param {number} totalOffset - offset relative to the root node content
+   * @returns {{node: Node | null, offset: number}} - node and offset inside node
+   */
+  static getNodeByOffset(t, e) {
+    const n = document.createTreeWalker(
+      t,
+      NodeFilter.SHOW_TEXT,
+      null
+    ), r = (a, d, u, g) => {
+      var w;
+      if (!a && u) {
+        const k = d - g, C = Math.max(e - k, 0), y = Math.min(C, g);
+        return {
+          node: u,
+          offset: y
+        };
+      }
+      if (!a)
+        return {
+          node: null,
+          offset: 0
+        };
+      const f = ((w = a.textContent) != null ? w : "").length;
+      return d + f >= e ? {
+        node: a,
+        offset: Math.min(e - d, f)
+      } : r(
+        n.nextNode(),
+        d + f,
+        a,
+        f
+      );
+    }, s = n.nextNode(), { node: i, offset: l } = r(s, 0, null, 0);
+    if (!i)
+      return {
+        node: null,
+        offset: 0
+      };
+    const c = i.textContent;
+    return !c || c.length === 0 ? {
+      node: null,
+      offset: 0
+    } : {
+      node: i,
+      offset: l
+    };
+  }
+}
+const Wt = (o) => !/[^\t\n\r \u200B]/.test(o), Dt = (o) => {
+  o.setAttribute("data-blok-empty", p.isEmpty(o) ? "true" : "false");
+}, ft = [
+  // Max-width: max-w-* classes conflict with each other
+  { pattern: /^max-w-(.+)$/, getGroup: () => "max-w" },
+  // Width: w-* classes conflict with each other
+  { pattern: /^w-(.+)$/, getGroup: () => "w" },
+  // Min-width: min-w-* classes conflict with each other
+  { pattern: /^min-w-(.+)$/, getGroup: () => "min-w" },
+  // Height: h-* classes conflict with each other
+  { pattern: /^h-(.+)$/, getGroup: () => "h" },
+  // Display: block, inline-block, flex, hidden, etc.
+  { pattern: /^(block|inline-block|inline|flex|inline-flex|grid|inline-grid|hidden|contents|flow-root|list-item)$/, getGroup: () => "display" },
+  // Flex direction: flex-row, flex-col
+  { pattern: /^flex-(row|col|row-reverse|col-reverse)$/, getGroup: () => "flex-dir" },
+  // Justify content: justify-*
+  { pattern: /^justify-(.+)$/, getGroup: () => "justify" },
+  // Align items: items-*
+  { pattern: /^items-(.+)$/, getGroup: () => "items" },
+  // Text alignment: text-left, text-center, text-right
+  { pattern: /^text-(left|center|right|justify|start|end)$/, getGroup: () => "text-align" },
+  // Text color: text-{color} (but not text-align classes)
+  { pattern: /^text-((?!left|center|right|justify|start|end).+)$/, getGroup: () => "text-color" },
+  // Background: bg-*
+  { pattern: /^bg-(.+)$/, getGroup: () => "bg" },
+  // Opacity: opacity-*
+  { pattern: /^opacity-(.+)$/, getGroup: () => "opacity" },
+  // Z-index: z-*
+  { pattern: /^z-(.+)$/, getGroup: () => "z" },
+  // Position: static, fixed, absolute, relative, sticky
+  { pattern: /^(static|fixed|absolute|relative|sticky)$/, getGroup: () => "position" },
+  // Inset (all sides): inset-*
+  { pattern: /^inset-(.+)$/, getGroup: () => "inset" },
+  // Top/Right/Bottom/Left positioning
+  { pattern: /^(top|right|bottom|left)-(.+)$/, getGroup: (o) => o[1] },
+  // Margin: m-*, mx-*, my-*, mt-*, mr-*, mb-*, ml-*
+  { pattern: /^!?m-(.+)$/, getGroup: () => "m" },
+  { pattern: /^!?mx-(.+)$/, getGroup: () => "mx" },
+  { pattern: /^!?my-(.+)$/, getGroup: () => "my" },
+  { pattern: /^!?mt-(.+)$/, getGroup: () => "mt" },
+  { pattern: /^!?mr-(.+)$/, getGroup: () => "mr" },
+  { pattern: /^!?mb-(.+)$/, getGroup: () => "mb" },
+  { pattern: /^!?ml-(.+)$/, getGroup: () => "ml" },
+  // Padding: p-*, px-*, py-*, pt-*, pr-*, pb-*, pl-*
+  { pattern: /^p-(.+)$/, getGroup: () => "p" },
+  { pattern: /^px-(.+)$/, getGroup: () => "px" },
+  { pattern: /^py-(.+)$/, getGroup: () => "py" },
+  { pattern: /^pt-(.+)$/, getGroup: () => "pt" },
+  { pattern: /^pr-(.+)$/, getGroup: () => "pr" },
+  { pattern: /^pb-(.+)$/, getGroup: () => "pb" },
+  { pattern: /^pl-(.+)$/, getGroup: () => "pl" },
+  // Gap: gap-*, gap-x-*, gap-y-*
+  { pattern: /^gap-(.+)$/, getGroup: () => "gap" },
+  // Border radius: rounded-*
+  { pattern: /^rounded(-.*)?$/, getGroup: () => "rounded" },
+  // Visibility: visible, invisible
+  { pattern: /^(visible|invisible)$/, getGroup: () => "visibility" },
+  // Overflow: overflow-*
+  { pattern: /^overflow-(.+)$/, getGroup: () => "overflow" },
+  // Cursor: cursor-*
+  { pattern: /^cursor-(.+)$/, getGroup: () => "cursor" },
+  // Pointer events: pointer-events-*
+  { pattern: /^pointer-events-(.+)$/, getGroup: () => "pointer-events" },
+  // Transition: transition-*
+  { pattern: /^transition(-.*)?$/, getGroup: () => "transition" },
+  // Duration: duration-*
+  { pattern: /^duration-(.+)$/, getGroup: () => "duration" },
+  // Ease: ease-*
+  { pattern: /^ease-(.+)$/, getGroup: () => "ease" },
+  // Animation: animate-*
+  { pattern: /^animate-(.+)$/, getGroup: () => "animate" },
+  // Font weight: font-*
+  { pattern: /^font-(thin|extralight|light|normal|medium|semibold|bold|extrabold|black)$/, getGroup: () => "font-weight" },
+  // Font size: text-{size}
+  { pattern: /^text-(xs|sm|base|lg|xl|2xl|3xl|4xl|5xl|6xl|7xl|8xl|9xl)$/, getGroup: () => "font-size" },
+  // Line height: leading-*
+  { pattern: /^leading-(.+)$/, getGroup: () => "leading" },
+  // Outline: outline-*
+  { pattern: /^outline(-.*)?$/, getGroup: () => "outline" },
+  // Border: border-*
+  { pattern: /^border(-.*)?$/, getGroup: () => "border" },
+  // Shadow: shadow-*
+  { pattern: /^shadow(-.*)?$/, getGroup: () => "shadow" }
+], $ = /* @__PURE__ */ new Map(), mt = (o) => {
+  const t = $.get(o);
+  if (t !== void 0)
+    return t;
+  for (const { pattern: e, getGroup: n } of ft) {
+    const r = o.match(e);
+    if (r) {
+      const s = n(r);
+      return $.set(o, s), s;
+    }
+  }
+  return $.set(o, null), null;
+}, kt = (o, t, e) => {
+  const n = mt(o);
+  if (n) {
+    t.set(n, o);
+    return;
+  }
+  e.includes(o) || e.push(o);
+}, bt = (o) => {
+  const t = [];
+  for (const e of o)
+    if (e) {
+      if (Array.isArray(e)) {
+        t.push(...e.filter(Boolean));
+        continue;
+      }
+      t.push(e);
+    }
+  return t;
+}, _t = (...o) => {
+  const t = /* @__PURE__ */ new Map(), e = [], n = bt(o);
+  for (const r of n)
+    r.split(/\s+/).filter(Boolean).forEach((i) => kt(i, t, e));
+  return [...e, ...t.values()].join(" ");
+}, Ut = (...o) => o.filter(Boolean).join(" "), E = {
+  // ============================================
+  // Core Element Identifiers
+  // ============================================
+  /** Interface type identifier (blok, inline-toolbar, tooltip) */
+  interface: "data-blok-interface",
+  /** Block element wrapper */
+  element: "data-blok-element",
+  /** Block element content wrapper */
+  elementContent: "data-blok-element-content",
+  /** Editor wrapper container */
+  editor: "data-blok-editor",
+  /** Redactor zone */
+  redactor: "data-blok-redactor",
+  // ============================================
+  // Block Identifiers
+  // ============================================
+  /** Block unique identifier */
+  id: "data-blok-id",
+  /** Block component/tool type */
+  component: "data-blok-component",
+  /** Tool type attribute */
+  tool: "data-blok-tool",
+  /** Block nesting depth */
+  depth: "data-blok-depth",
+  // ============================================
+  // Global States
+  // ============================================
+  /** Element is hidden from view */
+  hidden: "data-blok-hidden",
+  /** Element is disabled and non-interactive */
+  disabled: "data-blok-disabled",
+  /** Element is focused via keyboard navigation */
+  focused: "data-blok-focused",
+  /** Block is selected */
+  selected: "data-blok-selected",
+  /** Block is stretched */
+  stretched: "data-blok-stretched",
+  /** Editor or element is empty */
+  empty: "data-blok-empty",
+  // ============================================
+  // Editor Modes
+  // ============================================
+  /** Narrow mode state */
+  narrow: "data-blok-narrow",
+  /** Right-to-left mode */
+  rtl: "data-blok-rtl",
+  // ============================================
+  // Drag and Drop
+  // ============================================
+  /** Block is being dragged */
+  dragging: "data-blok-dragging",
+  /** Multiple blocks being dragged */
+  draggingMulti: "data-blok-dragging-multi",
+  /** Block is being duplicated (Alt+drag) */
+  duplicating: "data-blok-duplicating",
+  /** Drag handle element */
+  dragHandle: "data-blok-drag-handle",
+  // ============================================
+  // Toolbar
+  // ============================================
+  /** Toolbar element */
+  toolbar: "data-blok-toolbar",
+  /** Settings toggler button */
+  settingsToggler: "data-blok-settings-toggler",
+  /** Toolbox is open */
+  toolboxOpened: "data-blok-toolbox-opened",
+  /** Element is opened (generic) */
+  opened: "data-blok-opened",
+  // ============================================
+  // Popover Container
+  // ============================================
+  /** Root popover element */
+  popover: "data-blok-popover",
+  /** Popover container wrapper */
+  popoverContainer: "data-blok-popover-container",
+  /** Popover items list */
+  popoverItems: "data-blok-popover-items",
+  /** Popover overlay element */
+  popoverOverlay: "data-blok-popover-overlay",
+  /** Popover custom content area */
+  popoverCustomContent: "data-blok-popover-custom-content",
+  /** Popover custom class */
+  popoverCustomClass: "data-blok-popover-custom-class",
+  /** Inline popover variant */
+  popoverInline: "data-blok-popover-inline",
+  /** Popover is open */
+  popoverOpened: "data-blok-popover-opened",
+  /** Popover opens upward */
+  popoverOpenTop: "data-blok-popover-open-top",
+  /** Popover opens leftward */
+  popoverOpenLeft: "data-blok-popover-open-left",
+  // ============================================
+  // Popover Nesting
+  // ============================================
+  /** Nested popover indicator */
+  nested: "data-blok-nested",
+  /** Nesting level value */
+  nestedLevel: "data-blok-nested-level",
+  // ============================================
+  // Popover Header
+  // ============================================
+  /** Header container */
+  popoverHeader: "data-blok-popover-header",
+  /** Header text element */
+  popoverHeaderText: "data-blok-popover-header-text",
+  /** Back button in nested popover */
+  popoverHeaderBackButton: "data-blok-popover-header-back-button",
+  // ============================================
+  // Popover Items
+  // ============================================
+  /** Item container */
+  popoverItem: "data-blok-popover-item",
+  /** Item icon wrapper */
+  popoverItemIcon: "data-blok-popover-item-icon",
+  /** Chevron icon for nested items */
+  popoverItemIconChevronRight: "data-blok-popover-item-icon-chevron-right",
+  /** Item title text */
+  popoverItemTitle: "data-blok-popover-item-title",
+  /** Item secondary title */
+  popoverItemSecondaryTitle: "data-blok-popover-item-secondary-title",
+  /** Item is active/selected */
+  popoverItemActive: "data-blok-popover-item-active",
+  /** Confirmation state */
+  popoverItemConfirmation: "data-blok-popover-item-confirmation",
+  /** Disable hover styling */
+  popoverItemNoHover: "data-blok-popover-item-no-hover",
+  /** Disable focus handling */
+  popoverItemNoFocus: "data-blok-popover-item-no-focus",
+  /** Wobble animation */
+  popoverItemWobble: "data-blok-popover-item-wobble",
+  /** Separator item */
+  popoverItemSeparator: "data-blok-popover-item-separator",
+  /** Separator line element */
+  popoverItemSeparatorLine: "data-blok-popover-item-separator-line",
+  /** HTML-based item */
+  popoverItemHtml: "data-blok-popover-item-html",
+  /** Item has child menu */
+  hasChildren: "data-blok-has-children",
+  /** Item name identifier */
+  itemName: "data-blok-item-name",
+  /** No search results shown */
+  nothingFoundDisplayed: "data-blok-nothing-found-displayed",
+  // ============================================
+  // Overlay / Selection
+  // ============================================
+  /** Selection overlay */
+  overlay: "data-blok-overlay",
+  /** Overlay container */
+  overlayContainer: "data-blok-overlay-container",
+  /** Selection rectangle */
+  overlayRectangle: "data-blok-overlay-rectangle",
+  /** Overlay is hidden */
+  overlayHidden: "data-blok-overlay-hidden",
+  /** Fake cursor indicator */
+  fakeCursor: "data-blok-fake-cursor",
+  /** Fake background for selection */
+  fakeBackground: "data-blok-fake-background",
+  // ============================================
+  // Scroll
+  // ============================================
+  /** Auto-scroll zone (top/bottom) */
+  scrollZone: "data-blok-scroll-zone",
+  /** Scroll is locked */
+  scrollLocked: "data-blok-scroll-locked",
+  /** Hard scroll lock */
+  scrollLockedHard: "data-blok-scroll-locked-hard",
+  // ============================================
+  // Caret
+  // ============================================
+  /** Shadow caret element */
+  shadowCaret: "data-blok-shadow-caret",
+  // ============================================
+  // Placeholders
+  // ============================================
+  /** Placeholder text */
+  placeholder: "data-blok-placeholder",
+  /** Active placeholder text */
+  placeholderActive: "data-blok-placeholder-active",
+  // ============================================
+  // Mutation Tracking
+  // ============================================
+  /** Element excluded from mutation tracking */
+  mutationFree: "data-blok-mutation-free",
+  // ============================================
+  // Navigation
+  // ============================================
+  /** Block has navigation focus */
+  navigationFocused: "data-blok-navigation-focused",
+  /** Flipper navigation target */
+  flipperNavigationTarget: "data-blok-flipper-navigation-target",
+  // ============================================
+  // Inline Toolbar
+  // ============================================
+  /** Inline toolbar enabled on external element */
+  inlineToolbar: "data-blok-inline-toolbar",
+  // ============================================
+  // Link Tool
+  // ============================================
+  /** Link tool is active */
+  linkToolActive: "data-blok-link-tool-active",
+  /** Link tool unlink mode */
+  linkToolUnlink: "data-blok-link-tool-unlink",
+  /** Link tool input is opened */
+  linkToolInputOpened: "data-blok-link-tool-input-opened",
+  // ============================================
+  // Bold Tool
+  // ============================================
+  /** Bold collapsed length tracking */
+  boldCollapsedLength: "data-blok-bold-collapsed-length",
+  /** Bold collapsed active state */
+  boldCollapsedActive: "data-blok-bold-collapsed-active",
+  /** Bold previous length tracking */
+  boldPrevLength: "data-blok-bold-prev-length",
+  /** Bold leading whitespace */
+  boldLeadingWs: "data-blok-bold-leading-ws",
+  /** Bold marker */
+  boldMarker: "data-blok-bold-marker",
+  // ============================================
+  // Tooltip
+  // ============================================
+  /** Tooltip is shown */
+  shown: "data-blok-shown",
+  /** Tooltip placement */
+  placement: "data-blok-placement",
+  // ============================================
+  // Notifier
+  // ============================================
+  /** Bounce in animation */
+  bounceIn: "data-blok-bounce-in",
+  // ============================================
+  // Announcer (Accessibility)
+  // ============================================
+  /** Live region announcer */
+  announcer: "data-blok-announcer",
+  // ============================================
+  // Stub Block
+  // ============================================
+  /** Stub block element */
+  stub: "data-blok-stub",
+  /** Stub info section */
+  stubInfo: "data-blok-stub-info",
+  /** Stub title */
+  stubTitle: "data-blok-stub-title",
+  /** Stub subtitle */
+  stubSubtitle: "data-blok-stub-subtitle",
+  // ============================================
+  // Testing
+  // ============================================
+  /** Test identifier (for E2E tests) */
+  testid: "data-blok-testid",
+  /** Force hover state (for tests/storybook) */
+  forceHover: "data-blok-force-hover"
+}, R = (o, t) => t === void 0 ? `[${o}]` : `[${o}="${t}"]`, Zt = 180, zt = 400, Xt = "blok", qt = "inline-toolbar", Kt = "tooltip", Jt = "[data-blok-interface=inline-toolbar]";
+typeof process != "undefined" && process.platform ? process.platform === "darwin" ? "Meta" : "Control" : typeof navigator != "undefined" && navigator.userAgent.toLowerCase().includes("mac") ? "Meta" : "Control";
+class v {
+  constructor() {
+    this.instance = null, this.selection = null, this.savedSelectionRange = null, this.isFakeBackgroundEnabled = !1, this.selectionContainer = null;
+  }
+  /**
+   * Returns selected anchor
+   * {@link https://developer.mozilla.org/ru/docs/Web/API/Selection/anchorNode}
+   * @returns {Node|null}
+   */
+  static get anchorNode() {
+    const t = window.getSelection();
+    return t ? t.anchorNode : null;
+  }
+  /**
+   * Returns selected anchor element
+   * @returns {Element|null}
+   */
+  static get anchorElement() {
+    const t = window.getSelection();
+    if (!t)
+      return null;
+    const e = t.anchorNode;
+    return e ? p.isElement(e) ? e : e.parentElement : null;
+  }
+  /**
+   * Returns selection offset according to the anchor node
+   * {@link https://developer.mozilla.org/ru/docs/Web/API/Selection/anchorOffset}
+   * @returns {number|null}
+   */
+  static get anchorOffset() {
+    const t = window.getSelection();
+    return t ? t.anchorOffset : null;
+  }
+  /**
+   * Is current selection range collapsed
+   * @returns {boolean|null}
+   */
+  static get isCollapsed() {
+    const t = window.getSelection();
+    return t ? t.isCollapsed : null;
+  }
+  /**
+   * Check current selection if it is at Blok's zone
+   * @returns {boolean}
+   */
+  static get isAtBlok() {
+    return this.isSelectionAtBlok(v.get());
+  }
+  /**
+   * Check if passed selection is at Blok's zone
+   * @param selection - Selection object to check
+   */
+  static isSelectionAtBlok(t) {
+    if (!t)
+      return !1;
+    const e = t.anchorNode || t.focusNode, n = e && e.nodeType === Node.TEXT_NODE ? e.parentNode : e, r = n && n instanceof Element ? n.closest(R(E.redactor)) : null;
+    return r ? r.nodeType === Node.ELEMENT_NODE : !1;
+  }
+  /**
+   * Check if passed range at Blok zone
+   * @param range - range to check
+   */
+  static isRangeAtBlok(t) {
+    if (!t)
+      return;
+    const e = t.startContainer && t.startContainer.nodeType === Node.TEXT_NODE ? t.startContainer.parentNode : t.startContainer, n = e && e instanceof Element ? e.closest(R(E.redactor)) : null;
+    return n ? n.nodeType === Node.ELEMENT_NODE : !1;
+  }
+  /**
+   * Methods return boolean that true if selection exists on the page
+   */
+  static get isSelectionExists() {
+    const t = v.get();
+    return !!(t != null && t.anchorNode);
+  }
+  /**
+   * Return first range
+   * @returns {Range|null}
+   */
+  static get range() {
+    return this.getRangeFromSelection(this.get());
+  }
+  /**
+   * Returns range from passed Selection object
+   * @param selection - Selection object to get Range from
+   */
+  static getRangeFromSelection(t) {
+    return t && t.rangeCount ? t.getRangeAt(0) : null;
+  }
+  /**
+   * Calculates position and size of selected text
+   * @returns {DOMRect}
+   */
+  static get rect() {
+    const t = document.selection, e = {
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0
+    };
+    if (t && t.type !== "Control") {
+      const l = t.createRange();
+      return e.x = l.boundingLeft, e.y = l.boundingTop, e.width = l.boundingWidth, e.height = l.boundingHeight, e;
+    }
+    const n = window.getSelection();
+    if (!n)
+      return M("Method window.getSelection returned null", "warn"), e;
+    if (n.rangeCount === null || isNaN(n.rangeCount))
+      return M("Method SelectionUtils.rangeCount is not supported", "warn"), e;
+    if (n.rangeCount === 0)
+      return e;
+    const r = n.getRangeAt(0).cloneRange(), s = r.getBoundingClientRect();
+    if (s.x === 0 && s.y === 0) {
+      const i = document.createElement("span");
+      i.appendChild(document.createTextNode("​")), r.insertNode(i);
+      const l = i.getBoundingClientRect(), c = i.parentNode;
+      return c == null || c.removeChild(i), c == null || c.normalize(), l;
+    }
+    return s;
+  }
+  /**
+   * Returns selected text as String
+   * @returns {string}
+   */
+  static get text() {
+    var e;
+    const t = window.getSelection();
+    return (e = t == null ? void 0 : t.toString()) != null ? e : "";
+  }
+  /**
+   * Returns window SelectionUtils
+   * {@link https://developer.mozilla.org/ru/docs/Web/API/Window/getSelection}
+   * @returns {Selection}
+   */
+  static get() {
+    return window.getSelection();
+  }
+  /**
+   * Set focus to contenteditable or native input element
+   * @param element - element where to set focus
+   * @param offset - offset of cursor
+   */
+  static setCursor(t, e = 0) {
+    const n = document.createRange(), r = window.getSelection(), s = p.isNativeInput(t);
+    if (s && !p.canSetCaret(t))
+      return t.getBoundingClientRect();
+    if (s) {
+      const i = t;
+      return i.focus(), i.selectionStart = e, i.selectionEnd = e, i.getBoundingClientRect();
+    }
+    return n.setStart(t, e), n.setEnd(t, e), r ? (r.removeAllRanges(), r.addRange(n), n.getBoundingClientRect()) : t.getBoundingClientRect();
+  }
+  /**
+   * Check if current range exists and belongs to container
+   * @param container - where range should be
+   */
+  static isRangeInsideContainer(t) {
+    const e = v.range;
+    return e === null ? !1 : t.contains(e.startContainer);
+  }
+  /**
+   * Adds fake cursor to the current range
+   */
+  static addFakeCursor() {
+    const t = v.range;
+    if (t === null)
+      return;
+    const e = p.make("span");
+    e.setAttribute(E.fakeCursor, ""), e.setAttribute("data-blok-mutation-free", "true"), t.collapse(), t.insertNode(e);
+  }
+  /**
+   * Check if passed element contains a fake cursor
+   * @param el - where to check
+   */
+  static isFakeCursorInsideContainer(t) {
+    return p.find(t, R(E.fakeCursor)) !== null;
+  }
+  /**
+   * Removes fake cursor from a container
+   * @param container - container to look for
+   */
+  static removeFakeCursor(t = document.body) {
+    const e = p.find(t, R(E.fakeCursor));
+    e && e.remove();
+  }
+  /**
+   * Removes fake background
+   * Unwraps the highlight spans and restores the selection
+   */
+  removeFakeBackground() {
+    this.removeOrphanedFakeBackgroundElements(), this.isFakeBackgroundEnabled && (this.removeHighlightSpans(), this.isFakeBackgroundEnabled = !1, this.selectionContainer = null);
+  }
+  /**
+   * Removes highlight spans and reconstructs the saved selection range
+   */
+  removeHighlightSpans() {
+    var i;
+    const t = document.querySelectorAll('[data-blok-fake-background="true"]');
+    if (t.length === 0)
+      return;
+    const e = t[0], n = t[t.length - 1], r = e.firstChild, s = n.lastChild;
+    if (t.forEach((l) => {
+      this.unwrapFakeBackground(l);
+    }), r && s) {
+      const l = document.createRange();
+      l.setStart(r, 0), l.setEnd(s, ((i = s.textContent) == null ? void 0 : i.length) || 0), this.savedSelectionRange = l;
+    }
+  }
+  /**
+   * Removes any fake background elements from the DOM that are not tracked
+   * This handles cleanup after undo/redo operations that may restore fake background elements
+   * Also provides backwards compatibility with old fake background approach
+   */
+  removeOrphanedFakeBackgroundElements() {
+    document.querySelectorAll('[data-blok-fake-background="true"]').forEach((e) => {
+      this.unwrapFakeBackground(e);
+    });
+  }
+  /**
+   * Clears all fake background state - both DOM elements and internal flags
+   * This is useful for cleanup after undo/redo operations or when the selection context has been lost
+   */
+  clearFakeBackground() {
+    this.removeOrphanedFakeBackgroundElements(), this.isFakeBackgroundEnabled = !1, this.selectionContainer = null;
+  }
+  /**
+   * Sets fake background by wrapping selected text in highlight spans
+   * Uses a gray background color to simulate the "unfocused selection" appearance
+   * similar to how Notion shows selections when focus moves to another element
+   */
+  setFakeBackground() {
+    this.removeFakeBackground();
+    const t = window.getSelection();
+    if (!t || t.rangeCount === 0)
+      return;
+    const e = t.getRangeAt(0);
+    if (e.collapsed)
+      return;
+    const n = e.commonAncestorContainer, r = n.nodeType === Node.ELEMENT_NODE ? n : n.parentElement;
+    this.selectionContainer = r == null ? void 0 : r.closest('[contenteditable="true"]');
+    const s = this.collectTextNodes(e);
+    if (s.length === 0)
+      return;
+    const i = e.startContainer, l = e.startOffset, c = e.endContainer, a = e.endOffset, d = [];
+    if (s.forEach((f) => {
+      var P, V;
+      const b = document.createRange(), w = f === i, k = f === c, C = w ? l : 0, y = (V = (P = f.textContent) == null ? void 0 : P.length) != null ? V : 0, S = k ? a : y;
+      if (C === S)
+        return;
+      b.setStart(f, C), b.setEnd(f, S);
+      const j = this.wrapRangeWithHighlight(b);
+      j && d.push(j);
+    }), d.length === 0)
+      return;
+    const u = this.postProcessHighlightWrappers(d);
+    this.applyLineHeightExtensions(u);
+    const g = document.createRange();
+    g.setStartBefore(u[0]), g.setEndAfter(u[u.length - 1]), this.savedSelectionRange = g.cloneRange();
+    const h = window.getSelection();
+    h && (h.removeAllRanges(), h.addRange(g)), this.isFakeBackgroundEnabled = !0;
+  }
+  /**
+   * Collects text nodes that intersect with the passed range
+   * @param range - selection range
+   */
+  collectTextNodes(t) {
+    const e = [], { commonAncestorContainer: n } = t;
+    if (n.nodeType === Node.TEXT_NODE)
+      return e.push(n), e;
+    const r = document.createTreeWalker(
+      n,
+      NodeFilter.SHOW_TEXT,
+      {
+        acceptNode: (s) => t.intersectsNode(s) && s.textContent && s.textContent.length > 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT
+      }
+    );
+    for (; r.nextNode(); )
+      e.push(r.currentNode);
+    return e;
+  }
+  /**
+   * Wraps passed range with a highlight span styled like an unfocused selection (gray)
+   * @param range - range to wrap
+   */
+  wrapRangeWithHighlight(t) {
+    if (t.collapsed)
+      return null;
+    const e = p.make("span");
+    e.setAttribute("data-blok-testid", "fake-background"), e.setAttribute("data-blok-fake-background", "true"), e.setAttribute("data-blok-mutation-free", "true"), e.style.color = "inherit", e.style.boxDecorationBreak = "clone", e.style["-webkit-box-decoration-break"] = "clone", e.style.whiteSpace = "pre-wrap";
+    const n = t.extractContents();
+    return n.childNodes.length === 0 ? null : (e.appendChild(n), t.insertNode(e), e);
+  }
+  /**
+   * Post-processes highlight wrappers to split multi-line spans and apply proper styling
+   * @param wrappers - array of wrapper elements
+   * @returns array of all wrapper elements (may be more than input if splits occurred)
+   */
+  postProcessHighlightWrappers(t) {
+    const e = [];
+    return t.forEach((n) => {
+      const r = this.splitMultiLineWrapper(n);
+      e.push(...r);
+    }), e;
+  }
+  /**
+   * Splits a multi-line wrapper into separate spans per line and applies box-shadow to each
+   * This ensures gaps between lines are properly filled
+   * @param wrapper - the highlight wrapper element
+   * @returns array of wrapper elements (original if single line, or new per-line wrappers)
+   */
+  splitMultiLineWrapper(t) {
+    const e = t.getClientRects();
+    if (e.length <= 1)
+      return this.applyBoxShadowToWrapper(t), [t];
+    const n = t.textContent || "", r = t.parentNode;
+    if (!r || !n)
+      return this.applyBoxShadowToWrapper(t), [t];
+    const s = [], i = t.firstChild;
+    if (!i || i.nodeType !== Node.TEXT_NODE)
+      return this.applyBoxShadowToWrapper(t), [t];
+    const l = this.findLineBreakPositions(i, e.length);
+    if (l.length === 0)
+      return this.applyBoxShadowToWrapper(t), [t];
+    const c = this.splitTextAtPositions(n, l), a = document.createDocumentFragment();
+    return c.forEach((d) => {
+      if (d.length === 0)
+        return;
+      const u = p.make("span");
+      u.setAttribute("data-blok-testid", "fake-background"), u.setAttribute("data-blok-fake-background", "true"), u.setAttribute("data-blok-mutation-free", "true"), u.style.color = "inherit", u.style.boxDecorationBreak = "clone", u.style["-webkit-box-decoration-break"] = "clone", u.style.whiteSpace = "pre-wrap", u.textContent = d, a.appendChild(u), s.push(u);
+    }), r.replaceChild(a, t), s;
+  }
+  /**
+   * Splits text content at given positions
+   */
+  splitTextAtPositions(t, e) {
+    const n = [0, ...e, t.length];
+    return n.slice(0, -1).map((r, s) => t.substring(r, n[s + 1])).filter((r) => r.length > 0);
+  }
+  /**
+   * Finds positions in text where line breaks occur
+   * @param textNode - the text node to analyze
+   * @param expectedLines - expected number of lines
+   */
+  findLineBreakPositions(t, e) {
+    const n = t.textContent || "", r = document.createRange();
+    return Array.from({ length: n.length }, (l, c) => c).reduce(
+      (l, c) => {
+        if (l.positions.length >= e - 1)
+          return l;
+        r.setStart(t, c), r.setEnd(t, c + 1);
+        const a = r.getBoundingClientRect();
+        return l.lastTop !== -1 && Math.abs(a.top - l.lastTop) > 5 && l.positions.push(c), { positions: l.positions, lastTop: a.top };
+      },
+      { positions: [], lastTop: -1 }
+    ).positions;
+  }
+  /**
+   * Applies box-shadow to a wrapper to extend the background to fill line-height
+   * @param wrapper - the wrapper element
+   */
+  applyBoxShadowToWrapper(t) {
+    const e = t.parentElement;
+    if (!e)
+      return;
+    const n = window.getComputedStyle(e), r = window.getComputedStyle(t), s = parseFloat(n.lineHeight), i = parseFloat(r.fontSize), l = isNaN(s) ? i * 1.2 : s, c = t.getBoundingClientRect(), a = Math.max(0, (l - c.height) / 2);
+    if (a > 0) {
+      const d = "rgba(0, 0, 0, 0.08)";
+      t.style.boxShadow = `0 ${a}px 0 ${d}, 0 -${a}px 0 ${d}`;
+    }
+  }
+  /**
+   * Applies additional box-shadow extensions to fill gaps between separate spans
+   * This is only needed when there are multiple spans that may have gaps between them
+   * @param spans - array of highlight span elements
+   */
+  applyLineHeightExtensions(t) {
+    const e = "rgba(0, 0, 0, 0.08)", n = this.collectAllLineRects(t);
+    if (n.length === 0)
+      return;
+    n.sort((s, i) => s.top - i.top);
+    const r = this.groupRectsByLine(n);
+    t.forEach((s) => {
+      this.applyMultiLineBoxShadow(s, r, e);
+    });
+  }
+  /**
+   * Collects all line rectangles from all spans using getClientRects()
+   */
+  collectAllLineRects(t) {
+    const e = [];
+    return t.forEach((n) => {
+      const r = n.getClientRects();
+      Array.from(r).forEach((s) => {
+        e.push({
+          top: s.top,
+          bottom: s.bottom,
+          span: n
+        });
+      });
+    }), e;
+  }
+  /**
+   * Groups rectangles by their visual line
+   */
+  groupRectsByLine(t) {
+    const e = [];
+    return t.forEach((n) => {
+      const r = e.find((s) => Math.abs(s.top - n.top) < 2);
+      r ? (r.top = Math.min(r.top, n.top), r.bottom = Math.max(r.bottom, n.bottom)) : e.push({ top: n.top, bottom: n.bottom });
+    }), e.sort((n, r) => n.top - r.top), e;
+  }
+  /**
+   * Applies box-shadow to a span that may span multiple lines
+   * Calculates extensions based on the span's position within the overall selection
+   */
+  applyMultiLineBoxShadow(t, e, n) {
+    const r = t.getClientRects();
+    if (r.length === 0)
+      return;
+    const s = t.parentElement;
+    if (!s)
+      return;
+    const i = window.getComputedStyle(s), l = parseFloat(i.lineHeight), c = parseFloat(window.getComputedStyle(t).fontSize), a = isNaN(l) ? c * 1.2 : l, d = r[0], u = r[r.length - 1], g = this.findLineIndex(d.top, e), h = this.findLineIndex(u.top, e), f = r.length > 1 && g !== h, b = g === 0, w = h === e.length - 1, k = Math.max(0, (a - d.height) / 2), C = f ? this.calculateLineTopExtension(k, b, e, g) : k, y = f ? this.calculateLineBottomExtension(k, w, e, h) : k, S = this.buildBoxShadow(C, y, n);
+    t.style.boxShadow = S;
+  }
+  /**
+   * Finds the line index for a given top position
+   */
+  findLineIndex(t, e) {
+    const n = e.findIndex((r) => Math.abs(r.top - t) < 5);
+    return n >= 0 ? n : 0;
+  }
+  /**
+   * Calculates top extension for a line
+   * Only uses base extension - gaps are filled by the previous line's bottom extension
+   */
+  calculateLineTopExtension(t, e, n, r) {
+    return t;
+  }
+  /**
+   * Calculates bottom extension for a line, accounting for gap to next line
+   * The bottom extension fills the gap up to where the next line's top extension begins
+   * This prevents overlap: line N's bottom shadow meets line N+1's top shadow exactly
+   */
+  calculateLineBottomExtension(t, e, n, r) {
+    if (e)
+      return t;
+    const s = n[r], l = n[r + 1].top - s.bottom, a = Math.max(0, l - t);
+    return t + a;
+  }
+  /**
+   * Builds box-shadow CSS value from top and bottom extensions
+   * Uses inset shadow for the element's own background (to avoid using background-color)
+   * and regular shadows for vertical extensions
+   */
+  buildBoxShadow(t, e, n) {
+    const r = [];
+    return r.push(`inset 0 0 0 9999px ${n}`), e > 0 && r.push(`0 ${e}px 0 ${n}`), t > 0 && r.push(`0 -${t}px 0 ${n}`), r.join(", ");
+  }
+  /**
+   * Removes fake background wrapper (legacy support)
+   * @param element - wrapper element
+   */
+  unwrapFakeBackground(t) {
+    const e = t.parentNode;
+    if (e) {
+      for (; t.firstChild; )
+        e.insertBefore(t.firstChild, t);
+      e.removeChild(t);
+    }
+  }
+  /**
+   * Save SelectionUtils's range
+   */
+  save() {
+    this.savedSelectionRange = v.range;
+  }
+  /**
+   * Restore saved SelectionUtils's range
+   */
+  restore() {
+    if (!this.savedSelectionRange)
+      return;
+    const t = window.getSelection();
+    t && (t.removeAllRanges(), t.addRange(this.savedSelectionRange));
+  }
+  /**
+   * Clears saved selection
+   */
+  clearSaved() {
+    this.savedSelectionRange = null;
+  }
+  /**
+   * Collapse current selection
+   */
+  collapseToEnd() {
+    const t = window.getSelection();
+    if (!t || !t.focusNode)
+      return;
+    const e = document.createRange();
+    e.selectNodeContents(t.focusNode), e.collapse(!1), t.removeAllRanges(), t.addRange(e);
+  }
+  /**
+   * Looks ahead to find passed tag from current selection
+   * @param  {string} tagName       - tag to found
+   * @param  {string} [className]   - tag's class name
+   * @param  {number} [searchDepth] - count of tags that can be included. For better performance.
+   * @returns {HTMLElement|null}
+   */
+  findParentTag(t, e, n = 10) {
+    const r = window.getSelection();
+    if (!r || !r.anchorNode || !r.focusNode)
+      return null;
+    const s = [
+      /** the Node in which the selection begins */
+      r.anchorNode,
+      /** the Node in which the selection ends */
+      r.focusNode
+    ], i = (l) => {
+      const c = (a, d) => {
+        if (d <= 0 || !a)
+          return null;
+        const u = a.nodeType === Node.ELEMENT_NODE && a.tagName === t, g = !e || a.classList && a.classList.contains(e);
+        if (u && g)
+          return a;
+        if (!a.parentNode)
+          return null;
+        const h = a.parentNode, f = !e || h.classList && h.classList.contains(e);
+        return h.tagName === t && f ? h : c(h, d - 1);
+      };
+      return c(l, n);
+    };
+    for (const l of s) {
+      const c = i(l);
+      if (c)
+        return c;
+    }
+    return null;
+  }
+  /**
+   * Expands selection range to the passed parent node
+   * @param {HTMLElement} element - element which contents should be selected
+   */
+  expandToTag(t) {
+    const e = window.getSelection();
+    if (!e)
+      return;
+    e.removeAllRanges();
+    const n = document.createRange();
+    n.selectNodeContents(t), e.addRange(n);
+  }
+}
+const A = (o, t) => {
+  if (!o.conversionConfig)
+    return !1;
+  const e = o.conversionConfig[t];
+  return F(e) || x(e);
+}, T = (o, t) => {
+  const e = `toolNames.${t}`;
+  return o.has(e) ? o.t(e) : void 0;
+}, U = (o, t, e = "") => {
+  const n = t.titleKey ? T(o, t.titleKey) : void 0;
+  if (n !== void 0)
+    return n;
+  const r = t.title ? T(o, t.title) : void 0;
+  if (r !== void 0)
+    return r;
+  if (t.title)
+    return t.title;
+  const s = e ? T(o, e) : void 0;
+  return s != null ? s : e;
+}, vt = (o, t, e) => {
+  const n = t ? T(o, t) : void 0;
+  if (n !== void 0)
+    return n;
+  const r = T(o, e);
+  return r != null ? r : e;
+}, Z = (o, t) => A(o.tool, t), wt = (o, t) => Object.entries(o).some((([e, n]) => t[e] && H(t[e], n))), J = async (o, t) => {
+  const n = (await o.save()).data, r = t.find((s) => s.name === o.name);
+  return r !== void 0 && !A(r, "export") ? [] : t.reduce((s, i) => {
+    if (!A(i, "import") || i.toolbox === void 0)
+      return s;
+    const l = i.toolbox.filter((c) => {
+      if (q(c) || c.icon === void 0)
+        return !1;
+      const a = c.data !== void 0;
+      return !(a && wt(c.data, n) || !a && i.name === o.name);
+    });
+    return s.push(O(I({}, i), {
+      toolbox: l
+    })), s;
+  }, []);
+}, Yt = (o, t) => o.mergeable ? o.name === t.name ? !0 : Z(t, "export") && Z(o, "import") : !1, Qt = async (o, t) => {
+  if (o.length === 0)
+    return [];
+  if (o.length === 1)
+    return J(o[0], t);
+  for (const n of o) {
+    const r = t.find((s) => s.name === n.name);
+    if (r !== void 0 && !A(r, "export"))
+      return [];
+  }
+  const e = new Set(o.map((n) => n.name));
+  return t.reduce((n, r) => {
+    if (!A(r, "import") || r.toolbox === void 0)
+      return n;
+    const s = r.toolbox.filter((i) => !(q(i) || i.icon === void 0 || !(i.data !== void 0) && e.size === 1 && e.has(r.name)));
+    return s.length > 0 && n.push(O(I({}, r), {
+      toolbox: s
+    })), n;
+  }, []);
+}, te = (o, t) => {
+  const e = t == null ? void 0 : t.export;
+  return F(e) ? e(o) : x(e) ? o[e] : (e !== void 0 && M("Conversion «export» property must be a string or function. String means key of saved data object to export. Function should export processed string to export."), "");
+}, ee = (o, t, e) => {
+  const n = t == null ? void 0 : t.import;
+  return F(n) ? n(o, e) : x(n) ? {
+    [n]: o
+  } : (n !== void 0 && M("Conversion «import» property must be a string or function. String means key of tool data to import. Function accepts a imported string and return composed tool data."), {});
+};
+var Ct = /* @__PURE__ */ ((o) => (o.Default = "default", o.Separator = "separator", o.Html = "html", o))(Ct || {});
+const ne = `
+<svg width="20" height="20" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path d="m4.5 15 11-11m0 11L4.5 4" stroke="currentColor" stroke-linecap="round"/>
+</svg>
+`, oe = `
+<svg width="20" height="20" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path
+    d="M5.5 11h4.9231c.6528 0 1.2789-.3161 1.7405-.8787.4617-.56259.721-1.32565.721-2.1213 0-.79565-.2593-1.55871-.721-2.12132C11.702 5.31607 11.0759 5 10.4231 5H5.5v6Zm0 0h5.5385c.6528 0 1.2789.3161 1.7405.8787.4617.5626.721 1.3257.721 2.1213 0 .7956-.2593 1.5587-.721 2.1213-.4616.5626-1.0877.8787-1.7405.8787H5.5v-6Z"
+    stroke="currentColor"
+    stroke-width="1.25"
+    stroke-linecap="round"
+    stroke-linejoin="round"
+  />
+</svg>
+`, re = `
+<svg width="20" height="20" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path
+    d="M8.5 5h6m-10 12h6m1-12-4 12"
+    stroke="currentColor"
+    stroke-linecap="round"
+    stroke-linejoin="round"
+  />
+</svg>
+`, se = `
+<svg width="20" height="20" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path
+    d="m9.98288 15.0959-.91628.9157c-.29867.3092-.65593.5559-1.05095.7255-.39502.1697-.81987.259-1.24978.2628-.4299.0037-.85625-.0782-1.25415-.241-.39791-.1628-.75941-.4032-1.06341-.7072-.304-.304-.54441-.6655-.70721-1.0634-.16279-.3979-.24471-.8243-.24098-1.2542.00374-.4299.09306-.8547.26274-1.2497.16969-.3951.41635-.7523.72558-1.051l.91499-.9163m8.24197.9156.9163-.9156c.6028-.60809.9402-1.43021.9383-2.28645-.0019-.85625-.3429-1.67688-.9483-2.28234-.6055-.60546-1.4261-.94643-2.2823-.9483-.8563-.00188-1.6784.3355-2.28652.9383l-.91628.91563M7.258 13.2413l4.5328-4.53278"
+    stroke="currentColor"
+    stroke-width=".784151"
+    stroke-linecap="round"
+    stroke-linejoin="round"
+  />
+</svg>
+`, ie = `
+<svg width="20" height="20" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path
+    d="M15.5 14.003h-3v-3.0004m-9-6.00078h3v3.0004m1.55478-3.80901A5.2170862 5.2170862 0 0 1 9.5 4.00014c1.1682.00058 2.3059.37321 3.2481 1.06388.9422.69067 1.64 1.66348 1.9923 2.77744.3523 1.11396.3407 2.31114-.033 3.41814-.3738 1.1069-1.0903 2.0661-2.0457 2.7384m-1.7165.8088c-.4703.1317-.9568.1967-1.4452.1931-1.16819-.0006-2.30585-.3733-3.24807-1.0639-.94222-.6907-1.64004-1.6635-1.99232-2.7775-.35229-1.1139-.34072-2.31114.03302-3.41808.37375-1.10694 1.09024-2.06608 2.04563-2.73841"
+    stroke="currentColor"
+    stroke-miterlimit="10"
+    stroke-linecap="round"
+  />
+</svg>
+`, ae = `
+<svg width="24" height="24" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path
+    d="M8 6c0-.55228.44772-1 1-1s1 .44772 1 1-.44772 1-1 1-1-.44772-1-1Zm0 6c0-.5523.44772-1 1-1s1 .4477 1 1-.44772 1-1 1-1-.4477-1-1Zm0 6c0-.5523.44772-1 1-1s1 .4477 1 1-.44772 1-1 1-1-.4477-1-1Zm6-12c0-.55228.4477-1 1-1s1 .44772 1 1-.4477 1-1 1-1-.44772-1-1Zm0 6c0-.5523.4477-1 1-1s1 .4477 1 1-.4477 1-1 1-1-.4477-1-1Zm0 6c0-.5523.4477-1 1-1s1 .4477 1 1-.4477 1-1 1-1-.4477-1-1Z"
+    fill="currentColor"
+  />
+</svg>
+`, le = `
+<svg width="24" height="24" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path d="M4.5 11.0711h14.1421m-7.071 7.071V4" stroke="currentColor" stroke-linecap="round"/>
+</svg>
+`, ce = `
+<svg width="20" height="20" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path d="m12.5 5-5 5 5 5" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>
+`, de = `
+<svg width="20" height="20" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path d="m7.5 15 5-5-5-5" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>
+`, ue = `
+<svg width="20" height="20" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path
+    d="m17.5 17.5-5-5m1.6667-4.16667c0 .76605-.1509 1.52459-.4441 2.23237-.2931.7077-.7228 1.3507-1.2645 1.8924-.5417.5417-1.1847.9714-1.8924 1.2645-.70778.2932-1.46632.4441-2.23237.4441-.76604 0-1.52458-.1509-2.23232-.4441-.70773-.2931-1.35079-.7228-1.89247-1.2645-.54167-.5417-.97135-1.1847-1.2645-1.8924C2.65088 9.85792 2.5 9.09938 2.5 8.33333c0-1.54709.61458-3.03082 1.70854-4.12479C5.30251 3.11458 6.78624 2.5 8.33333 2.5c1.5471 0 3.03087.61458 4.12477 1.70854 1.094 1.09397 1.7086 2.5777 1.7086 4.12479Z"
+    stroke="currentColor"
+    stroke-linecap="round"
+    stroke-linejoin="round"
+  />
+</svg>
+`, pe = `
+<svg width="20" height="20" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path
+    d="M3.33334 10H10m-6.66666 5V5M10 15V5m4.1667 5 2.5-1.66667V15"
+    stroke="currentColor"
+    stroke-linecap="round"
+    stroke-linejoin="round"
+  />
+</svg>
+`, ge = `
+<svg width="20" height="20" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path
+    d="M3.33334 10H10m-6.66666 5V5M10 15V5m7.5 10h-3.3333c0-3.3333 3.3333-2.5 3.3333-5 0-1.25-1.6667-2.08333-3.3333-.83333"
+    stroke="currentColor"
+    stroke-linecap="round"
+    stroke-linejoin="round"
+  />
+</svg>
+`, he = `
+<svg width="20" height="20" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path
+    d="M3.33334 10H10m-6.66666 5V5M10 15V5m4.5833 3.75C16 7.91667 17.5 8.75 17.5 10c0 .442-.1756.866-.4882 1.1785-.3125.3126-.7364.4882-1.1785.4882.4421 0 .866.1756 1.1785.4881.3126.3126.4882.7365.4882 1.1785 0 1.5-1.6667 2.5-3.3333 1.25"
+    stroke="currentColor"
+    stroke-linecap="round"
+    stroke-linejoin="round"
+  />
+</svg>
+`, fe = `
+<svg width="20" height="20" viewBox="0 0 20 20" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path
+    d="M10 15V5M14.1667 8.33333V10.8333C14.1667 11.0543 14.2545 11.2663 14.4107 11.4226C14.567 11.5789 14.779 11.6667 15 11.6667H17.5M17.5 8.33333V15M3.33334 10H10M3.33334 15V5"
+    stroke="black"
+    stroke-linecap="round"
+    stroke-linejoin="round"
+  />
+</svg>
+`, me = `
+<svg width="20" height="20" viewBox="0 0 20 20" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path
+    d="M3.33334 10H10M3.33334 15V5M10 15V5M17.5 8.33333H14.1667V10.8333H15.25C16.5 10.8333 17.5 11.75 17.5 12.9167C17.5 14.0833 16.5 15 15.25 15C14.8333 15 14.5 14.9167 14.1667 14.75"
+    stroke="black"
+    stroke-linecap="round"
+    stroke-linejoin="round"
+  />
+</svg>
+`, ke = `
+<svg width="20" height="20" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path
+    d="M3.33334 10H10m-6.66666 5V5M10 15V5m4.1667 8.3333c0 .9205.7462 1.6667 1.6666 1.6667.9205 0 1.6667-.7462 1.6667-1.6667 0-.9204-.7462-1.6666-1.6667-1.6666-.9204 0-1.6666.7462-1.6666 1.6666Zm0 0c0-2.0833.8333-3.3333 2.5-4.99997"
+    stroke="currentColor"
+    stroke-linecap="round"
+    stroke-linejoin="round"
+  />
+</svg>
+`, be = `
+<svg width="20" height="20" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path
+    d="M6.5 10h6.6667M6.5 15V5m6.6667 10V5"
+    stroke="currentColor"
+    stroke-linecap="round"
+    stroke-linejoin="round"
+  />
+</svg>
+`, ve = `
+<svg width="20" height="20" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path
+    d="M14.5 7.28571V6h-9v1.28571M10 6v9m0 0H8.71429M10 15h1.2857"
+    stroke="currentColor"
+    stroke-linecap="round"
+    stroke-linejoin="round"
+  />
+</svg>
+`, we = `
+<svg width="20" height="20" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path
+    d="M18.5667 18H1.5l8.5333-16 8.5334 16Z"
+    stroke="currentColor"
+    stroke-width="1.06667"
+    stroke-linecap="round"
+    stroke-linejoin="round"
+  />
+  <rect x="9.75" y="14.25" width=".5" height=".5" rx=".25" fill="currentColor" stroke="currentColor" stroke-width=".5"/>
+  <rect x="9.75" y="8.25" width=".5" height="4.5" rx=".25" fill="currentColor" stroke="currentColor" stroke-width=".5"/>
+</svg>
+`, Ce = `
+<svg width="20" height="20" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path
+    d="M8 5h9M8 10h9M8 15h9M4 5h.01M4 10h.01M4 15h.01"
+    stroke="currentColor"
+    stroke-linecap="round"
+    stroke-linejoin="round"
+  />
+</svg>
+`, ye = `
+<svg width="20" height="20" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path d="M7.90873 4.60317h9.61907M4.70238 6.20635V3L3.5 4.20238m1.60317 7.61512H3.5l1.52702-2.37514c.02625-.03721.04486-.07925.05477-.12369.0099-.04444.01091-.09039.00295-.13523-.04569-.2068-.20922-.57233-.78315-.57233-.80159 0-.80159.71261-.80159.71261v.17795m0 7.92693h.80159c.21259 0 .41648-.0845.56681-.2348.15032-.1503.23477-.3542.23477-.5668 0-.2126-.08445-.4165-.23477-.5668-.15033-.1503-.35422-.2348-.56681-.2348h-.4008l1.20238-1.6032H3.5m4.40873-4.0079h9.61907m-9.61907 5.6111h9.61907" stroke="#000" stroke-width=".841667" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>
+`, Ee = `
+<svg width="20" height="20" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path
+    d="M10 5h7M10 10h7M10 15h7M3 5l1 1 2-2M3 10l1 1 2-2M3 15l1 1 2-2"
+    stroke="currentColor"
+    stroke-linecap="round"
+    stroke-linejoin="round"
+  />
+</svg>
+`, G = class G {
+  /**
+   * @param api - Blok API
+   */
+  constructor({ api: t }) {
+    this.i18nAPI = t.i18n, this.blocksAPI = t.blocks, this.selectionAPI = t.selection, this.toolsAPI = t.tools, this.caretAPI = t.caret, this.i18nInstance = {
+      t: (e, n) => this.i18nAPI.t(e),
+      has: (e) => this.i18nAPI.t(e) !== e
+    };
+  }
+  /**
+   * Returns tool's UI config
+   */
+  async render() {
+    const t = v.get();
+    if (t === null)
+      return [];
+    const e = this.blocksAPI.getBlockByElement(t.anchorNode);
+    if (e === void 0)
+      return [];
+    const n = this.toolsAPI.getBlockTools(), r = await J(e, n);
+    if (r.length === 0)
+      return [];
+    const s = r.reduce((a, d) => {
+      var u;
+      return (u = d.toolbox) == null || u.forEach((g) => {
+        g.title !== void 0 && a.push({
+          icon: g.icon,
+          title: U(this.i18nInstance, g, d.name),
+          name: d.name,
+          closeOnActivate: !0,
+          onActivate: async () => {
+            const h = await this.blocksAPI.convert(e.id, d.name, g.data);
+            this.caretAPI.setToBlock(h, "end");
+          }
+        });
+      }), a;
+    }, []), i = await e.getActiveToolboxEntry(), l = i ? U(this.i18nInstance, i, e.name) : vt(this.i18nInstance, e.name, ut(e.name)), c = !gt();
+    return {
+      name: "convert-to",
+      title: l,
+      hint: {
+        title: this.i18nAPI.t("popover.convertTo")
+      },
+      children: {
+        items: s,
+        onOpen: () => {
+          c && (this.selectionAPI.setFakeBackground(), this.selectionAPI.save());
+        },
+        onClose: () => {
+          c && (this.selectionAPI.restore(), this.selectionAPI.removeFakeBackground());
+        }
+      }
+    };
+  }
+};
+G.isInline = !0;
+let z = G;
+export {
+  St as $,
+  U as A,
+  ie as B,
+  ne as C,
+  E as D,
+  $t as E,
+  le as F,
+  dt as G,
+  ae as H,
+  de as I,
+  qt as J,
+  vt as K,
+  Wt as L,
+  Yt as M,
+  ct as N,
+  Z as O,
+  Ct as P,
+  ee as Q,
+  Tt as R,
+  v as S,
+  Kt as T,
+  zt as U,
+  Mt as V,
+  Rt as W,
+  Jt as X,
+  Bt as Y,
+  it as Z,
+  we as _,
+  p as a,
+  z as a0,
+  Lt as a1,
+  Xt as a2,
+  Ft as a3,
+  Gt as a4,
+  pt as a5,
+  Zt as a6,
+  st as a7,
+  xt as a8,
+  Vt as a9,
+  ve as aa,
+  pe as ab,
+  ge as ac,
+  he as ad,
+  fe as ae,
+  me as af,
+  ke as ag,
+  be as ah,
+  Ce as ai,
+  ye as aj,
+  Ee as ak,
+  oe as al,
+  re as am,
+  se as an,
+  Ht as b,
+  F as c,
+  wt as d,
+  te as e,
+  R as f,
+  jt as g,
+  Dt as h,
+  q as i,
+  ut as j,
+  At as k,
+  M as l,
+  L as m,
+  Ot as n,
+  x as o,
+  Nt as p,
+  Ut as q,
+  It as r,
+  Et as s,
+  _t as t,
+  ue as u,
+  gt as v,
+  Pt as w,
+  ce as x,
+  Qt as y,
+  J as z
+};