hintorium-react 1.0.0

package/dist/index.js

@@ -0,0 +1,2826 @@
+var ot = Object.defineProperty;
+var at = (r, e, t) => e in r ? ot(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var u = (r, e, t) => at(r, typeof e != "symbol" ? e + "" : e, t);
+import { jsx as ye, Fragment as qe } from "react/jsx-runtime";
+import { createContext as lt, useContext as ct, useRef as R, useEffect as z, useCallback as w, isValidElement as ht, cloneElement as ut, useState as ne } from "react";
+const Me = [
+  "top",
+  "bottom",
+  "left",
+  "right"
+], g = {
+  ATTRIBUTES: {
+    TOOLTIP: "data-hintorium-tooltip",
+    HINT_TOOLTIP: "data-hintorium-hint",
+    TOOLTIP_POSITION: "data-hintorium-tooltip-position",
+    TOOLTIP_THEME: "data-hintorium-tooltip-theme",
+    TOOLTIP_ANIMATION: "data-hintorium-tooltip-animation",
+    TOOLTIP_DELAY: "data-hintorium-tooltip-delay"
+  },
+  STORAGE_KEYS: {
+    TOOLTIP_ANALYTICS: "tooltip-hintorium_analytics"
+  },
+  CSS_CLASSES: {
+    BASE: "hintorium-tooltip",
+    HINT: "hintorium-inline-hint",
+    RTL: "hintorium-tooltip-rtl",
+    WRAPPER: "hintorium-tooltip-inner",
+    HINTORIUM_TOUR: "hintorium-tooltip-tour",
+    SHOW: "show",
+    HIDDEN: "hidden",
+    MOBILE: "mobile"
+  },
+  ARIA: {
+    ROLE_TOOLTIP: "tooltip"
+  },
+  KEYS: {
+    ESCAPE: "Escape",
+    ENTER: "Enter",
+    SPACE: " ",
+    TAB: "Tab"
+  },
+  EVENTS: {
+    MOUSE_DOWN: "mousedown",
+    KEYDOWN: "keydown"
+  },
+  DEFAULT: {
+    POSITION: "top",
+    THEME: "dark",
+    ANIMATION: "fade",
+    ID_PREFIX: "hintorium-tooltip-",
+    ANIMATION_PREFIX: "anim-",
+    MOBILE_BREAKPOINT: 768,
+    TOUCH_DELAY: 500,
+    DEFAULT_OFFSET: 8,
+    VIEWPORT_PADDING: 4,
+    DELAY: 0
+  }
+};
+class N {
+  static init() {
+    typeof document > "u" || (this.setupKeyboardDetection(), this.setupFocusListeners());
+  }
+  /**
+   * Detects whether the user is using the keyboard (e.g., Tab vs. Mouse).
+   */
+  static setupKeyboardDetection() {
+    document.addEventListener(
+      g.EVENTS.KEYDOWN,
+      (e) => {
+        e.key === g.KEYS.TAB && (this.isKeyboardUser = !0);
+      },
+      !0
+    ), document.addEventListener(
+      g.EVENTS.MOUSE_DOWN,
+      () => {
+        this.isKeyboardUser = !1;
+      },
+      !0
+    );
+  }
+  /**
+   * Returns whether the user is currently using the keyboard.
+   */
+  static isKeyboardMode() {
+    return this.isKeyboardUser;
+  }
+  /**
+   * Checks whether a given element can be focused.
+   * @param element - the element to check
+   */
+  static isFocusable(e) {
+    return [
+      "a[href]",
+      "button",
+      "input",
+      "textarea",
+      "select",
+      '[tabindex]:not([tabindex="-1"])',
+      '[contenteditable="true"]'
+    ].some((t) => e.matches(t)) || e.hasAttribute("tabindex") && e.getAttribute("tabindex") !== "-1";
+  }
+  /**
+   * Configures the ARIA relationship between the tooltip and the target element.
+   * @param tooltip - the tooltip element
+   * @param target - the element to which the tooltip is assigned
+   * @param options - tooltip options (from section a11y)
+   */
+  static setupTooltipAccessibility(e, t, i) {
+    var n;
+    e.setAttribute("role", g.ARIA.ROLE_TOOLTIP);
+    const s = (t.getAttribute("aria-describedby") || "").split(/\s+/).filter(Boolean);
+    s.includes(e.id) || (s.push(e.id), t.setAttribute("aria-describedby", s.join(" "))), ((n = i.a11y) == null ? void 0 : n.keyboard) !== !1 && this.addKeyboardSupport(t), this.ensureFocusable(t, i);
+  }
+  /**
+   * Sets a global focus event listener for the document,
+   * to add and remove the visual focus class (`.keyboard-focus`)
+   * only when the user is using the keyboard (e.g., pressing Tab).
+   */
+  static setupFocusListeners() {
+    typeof document > "u" || (document.addEventListener("focusin", (e) => {
+      const t = e.target;
+      t && this.isKeyboardUser && t.classList.add(this.FOCUS_VISIBLE_CLASS);
+    }), document.addEventListener("focusout", (e) => {
+      const t = e.target;
+      t && t.classList.remove(this.FOCUS_VISIBLE_CLASS);
+    }));
+  }
+  /**
+   * Adds keyboard support to the tooltip's target element.
+   * Responds to the following keys: ESC (close), Enter / Space (toggle).
+   * @param target - the element to which the tooltip is assigned
+   */
+  static addKeyboardSupport(e) {
+    if (e.getAttribute("data-has-keyboard-support") === "true") return;
+    const t = (i) => {
+      switch (i.key) {
+        case g.KEYS.ESCAPE:
+          e.dispatchEvent(
+            new CustomEvent("tooltip:hide", { bubbles: !0 })
+          ), i.preventDefault();
+          break;
+        case g.KEYS.ENTER:
+        case g.KEYS.SPACE:
+          e.dispatchEvent(
+            new CustomEvent("tooltip:toggle", { bubbles: !0 })
+          ), i.preventDefault();
+          break;
+      }
+    };
+    e.addEventListener("keydown", t), e.setAttribute("data-has-keyboard-support", "true");
+  }
+  /**
+   * Removes ARIA relationships after the tooltip is destroyed.
+   * @param tooltip - tooltip element
+   * @param target - target element
+   */
+  static removeTooltipAccessibility(e, t) {
+    const i = t.getAttribute("aria-describedby");
+    if (i) {
+      const s = i.split(" ").filter((n) => n !== e.id);
+      s.length > 0 ? t.setAttribute("aria-describedby", s.join(" ")) : t.removeAttribute("aria-describedby");
+    }
+  }
+  /**
+   * Sends a message to the screen reader (aria-live).
+   * @param message - the message content to be announced
+   */
+  static announceToScreenReader(e) {
+    const t = document.createElement("div");
+    t.setAttribute("aria-live", "polite"), t.setAttribute("aria-atomic", "true"), t.className = "sr-only", t.textContent = e, document.body.appendChild(t), setTimeout(() => t.remove(), 1e3);
+  }
+  /**
+   * Ensures that the tooltip target is focusable.
+   * @param target - tooltip target
+   * @param options - tooltip options
+   */
+  static ensureFocusable(e, t) {
+    var i;
+    !this.isFocusable(e) && ((i = t.a11y) == null ? void 0 : i.focusable) !== !1 && e.setAttribute("tabindex", "0");
+  }
+}
+/** CSS class added when keyboard focus is applied. */
+u(N, "FOCUS_VISIBLE_CLASS", "keyboard-focus"), /** Flag indicating whether the user is currently using the keyboard. */
+u(N, "isKeyboardUser", !1);
+class B {
+  constructor(e, t, i) {
+    u(this, "manager");
+    u(this, "icon");
+    this.manager = ee.getInstance(), this.icon = this.createHintIcon(), e.appendChild(this.icon);
+    const s = i ?? B.extractOptionsFromElement(e, this.manager);
+    this.manager.add(this.icon, t, s);
+  }
+  /**
+   * Initializes all inline hints in the DOM with [data-hintorium-hint].
+   */
+  static initFromDOM() {
+    const e = ee.getInstance();
+    document.querySelectorAll(
+      `[${g.ATTRIBUTES.HINT_TOOLTIP}]`
+    ).forEach((t) => {
+      if (t.querySelector(`.${g.CSS_CLASSES.HINT}`))
+        return;
+      const i = t.getAttribute(
+        g.ATTRIBUTES.HINT_TOOLTIP
+      );
+      if (!i) return;
+      const s = B.extractOptionsFromElement(
+        t,
+        e
+      );
+      new B(t, i, s);
+    });
+  }
+  /**
+   * Remove hint from DOM and TooltipManager
+   */
+  destroy() {
+    this.manager.remove(this.icon), this.icon.remove();
+  }
+  /**
+   * Reuseable hintorium options on hint tooltip.
+   */
+  static extractOptionsFromElement(e, t) {
+    return typeof t.extractOptions == "function" ? t.extractOptions(e) : {};
+  }
+  /**
+   * Create Hint Icon with custom css class and a11y.
+   */
+  createHintIcon() {
+    const e = document.createElement("span");
+    return e.classList.add(g.CSS_CLASSES.HINT), e.setAttribute("tabindex", "0"), e.setAttribute("aria-label", "Show hint"), e.innerHTML = `
+    <svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+      <circle cx="12" cy="12" r="10"/>
+      <path d="M9 9a3 3 0 0 1 6 0c0 2-3 2-3 4"/>
+      <line x1="12" y1="17" x2="12" y2="17"/>
+    </svg>
+  `, e;
+  }
+}
+const G = class G {
+  /**
+   * Checks whether the current environment is a mobile or touch-enabled device.
+   * Uses several heuristics: window width, presence of `ontouchstart`, and `maxTouchPoints`.
+   *
+   * @returns {boolean} `true` if the device supports touch or has a small viewport.
+   */
+  static isMobile() {
+    return typeof window > "u" ? !1 : window.innerWidth <= g.DEFAULT.MOBILE_BREAKPOINT || "ontouchstart" in window || navigator.maxTouchPoints > 0;
+  }
+  /**
+   * Resolves mobile configuration for tooltip behavior.
+   * Decides whether mobile support should be enabled based on user options and environment.
+   *
+   * @param globalOptions - The global tooltip options provided by the user.
+   * @returns A normalized mobile options object.
+   */
+  static resolveMobileOptions(e) {
+    return {
+      enabled: (e == null ? void 0 : e.enabled) !== void 0 ? e.enabled : G.isMobile(),
+      longPress: (e == null ? void 0 : e.longPress) ?? !0,
+      touchDelay: (e == null ? void 0 : e.touchDelay) ?? g.DEFAULT.TOUCH_DELAY
+    };
+  }
+  /**
+   * Initializes touch support for a specific tooltip.
+   * Adds classes and listens for gestures (tap, long-press).
+   *
+   * @param tooltip - Tooltip instance.
+   * @param target - Element on which the tooltip is activated.
+   * @param options - Tooltip options (including mobile).
+   */
+  static setupMobileSupport(e, t, i) {
+    !(i.mobile ?? this.resolveMobileOptions()).enabled || !this.isMobile() || t.getAttribute("data-mobile-handlers") !== "true" && (e.element.classList.add(g.CSS_CLASSES.MOBILE), this.addTouchEvents(e, t, i), t.addEventListener("contextmenu", this.handleContextMenu), t.setAttribute("data-mobile-handlers", "true"));
+  }
+  /**
+   * Adds touch event handling to the target element.
+   * Supports both long-presses (after the specified `touchDelay`)
+   * and single taps if `longPress` is disabled.
+   *
+   * @private
+   */
+  static addTouchEvents(e, t, i) {
+    const { mobile: { longPress: s, touchDelay: n } = {} } = i, a = () => {
+      this.touchTimer && (clearTimeout(this.touchTimer), this.touchTimer = null);
+    }, o = () => {
+      a(), this.activeTouchTooltip && this.activeTouchTooltip !== e && (this.activeTouchTooltip.hide(), this.activeTouchTooltip = null), s ? this.touchTimer = window.setTimeout(() => {
+        e.element.classList.contains(
+          g.CSS_CLASSES.SHOW
+        ) ? (e.hide(), this.activeTouchTooltip = null) : (e.show(), this.activeTouchTooltip = e), this.touchTimer = null;
+      }, n) : e.element.classList.contains(
+        g.CSS_CLASSES.SHOW
+      ) ? (e.hide(), this.activeTouchTooltip = null) : (e.show(), this.activeTouchTooltip = e);
+    }, h = () => a(), l = () => a(), p = window.PointerEvent ? "pointerdown" : "touchstart", m = window.PointerEvent ? "pointerup" : "touchend", c = window.PointerEvent ? "pointercancel" : "touchcancel";
+    t.addEventListener(p, o, { passive: !0 }), t.addEventListener(m, h, { passive: !0 }), t.addEventListener(c, l, { passive: !0 }), this.touchHandlers.set(t, {
+      start: o,
+      end: h,
+      cancel: l
+    });
+  }
+  /**
+   * Blocks the display of the context menu (long-press menu).
+   * @private
+   */
+  static handleContextMenu(e) {
+    e.preventDefault();
+  }
+  /**
+   * Hides the currently active touch tooltip (if any)
+   * and clears any active long-press timer.
+   */
+  static hideMobileTooltips() {
+    this.activeTouchTooltip && (this.activeTouchTooltip.hide(), this.activeTouchTooltip = null), this.touchTimer && clearTimeout(this.touchTimer), this.touchTimer = null;
+  }
+  /**
+   * Removes all event listeners and clears the touch state
+   * assigned to the target element.
+   *
+   * @param target - The element for which cleanup should be performed.
+   */
+  static cleanup(e) {
+    e.removeEventListener("contextmenu", this.handleContextMenu);
+    const t = this.touchHandlers.get(e);
+    if (t) {
+      const i = window.PointerEvent ? "pointerdown" : "touchstart", s = window.PointerEvent ? "pointerup" : "touchend", n = window.PointerEvent ? "pointercancel" : "touchcancel";
+      e.removeEventListener(i, t.start), e.removeEventListener(s, t.end), e.removeEventListener(n, t.cancel), this.touchHandlers.delete(e);
+    }
+    e.removeAttribute("data-mobile-handlers"), this.touchTimer && (clearTimeout(this.touchTimer), this.touchTimer = null), this.activeTouchTooltip = null;
+  }
+};
+/** Timer that supports long-press / touch-delay */
+u(G, "touchTimer", null), /** Currently active tooltip triggered by touch */
+u(G, "activeTouchTooltip", null), /** Stores assigned event handlers for a given element */
+u(G, "touchHandlers", /* @__PURE__ */ new WeakMap());
+let j = G;
+const he = class he {
+  constructor(e) {
+    u(this, "cache", {});
+    u(this, "keyPrefix");
+    this.keyPrefix = e, this.load();
+  }
+  static getInstance(e) {
+    return this.instances.has(e) || this.instances.set(e, new he(e)), this.instances.get(e);
+  }
+  /**
+   * Save a value under a key
+   * @param key - key to store value
+   * @param value - any JSON-serializable value
+   */
+  set(e, t) {
+    this.cache[e] = t, this.save();
+  }
+  /**
+   * Get the full data object
+   */
+  getAll() {
+    return { ...this.cache };
+  }
+  /**
+   * Remove a key from storage
+   */
+  remove(e) {
+    delete this.cache[e], this.save();
+  }
+  /**
+   * Get all keys stored in this namespace
+   */
+  keys() {
+    return Object.keys(this.cache);
+  }
+  /**
+   * Clear all data in this namespace
+   */
+  clear() {
+    this.cache = {}, this.save();
+  }
+  /**
+   * Retrieve a value by key, optionally with a default
+   * @param key - key to retrieve
+   * @param defaultValue - value if key not found
+   */
+  get(e, t) {
+    if (e in this.cache) return this.cache[e];
+    if (t)
+      return t;
+  }
+  /**
+   * Save data to localStorage
+   */
+  save() {
+    try {
+      localStorage.setItem(this.keyPrefix, JSON.stringify(this.cache));
+    } catch (e) {
+      console.warn(
+        `[StorageManager:${this.keyPrefix}] Failed to save to LocalStorage`,
+        e
+      );
+    }
+  }
+  /**
+   * Load data from localStorage
+   */
+  load() {
+    try {
+      const e = localStorage.getItem(this.keyPrefix);
+      e && (this.cache = JSON.parse(e));
+    } catch (e) {
+      console.warn(
+        `[StorageManager:${this.keyPrefix}] Failed to load from LocalStorage`,
+        e
+      ), this.cache = {};
+    }
+  }
+};
+/**
+ * Get singleton instance for a given namespace
+ * @param keyPrefix - unique namespace key
+ */
+u(he, "instances", /* @__PURE__ */ new Map());
+let oe = he;
+const ue = class ue {
+  constructor() {
+    u(this, "storage");
+    this.storage = oe.getInstance(
+      g.STORAGE_KEYS.TOOLTIP_ANALYTICS
+    );
+  }
+  static getInstance() {
+    return this.instance || (this.instance = new ue()), this.instance;
+  }
+  /**
+   * Increment tooltip show count
+   * @param tooltipId - unique identifier for the tooltip
+   */
+  increment(e) {
+    const t = (this.storage.get(e, 0) ?? 0) + 1;
+    this.storage.set(e, t);
+  }
+  /**
+   * Get the number of times a tooltip has been shown
+   * @param tooltipId - unique identifier for the tooltip
+   */
+  getCount(e) {
+    return this.storage.get(e, 0) || 0;
+  }
+  /**
+   * Get all tooltip counts as an object
+   */
+  getAll() {
+    return this.storage.getAll();
+  }
+  /**
+   * Reset all tooltip counts
+   */
+  resetAll() {
+    this.storage.clear();
+  }
+};
+u(ue, "instance", null);
+let me = ue;
+const K = me.getInstance();
+class ze {
+  /**
+   * Removes all existing animation classes from the tooltip and
+   * applies the new animation class based on the given animation type.
+   *
+   * @private
+   * @param {HTMLElement} tooltip - The tooltip element to prepare.
+   * @param {TooltipAnimation} animation - The animation type (e.g., `'fade'`, `'scale'`, `'slide'`).
+   *
+   * @example
+   * ```ts
+   * AnimationManager.prepareAnimation(tooltip, 'scale');
+   * ```
+   */
+  static prepareAnimation(e, t) {
+    e.classList.forEach((i) => {
+      i.startsWith(g.DEFAULT.ANIMATION_PREFIX) && e.classList.remove(i);
+    }), e.classList.add(
+      `${g.DEFAULT.ANIMATION_PREFIX}${t}`
+    );
+  }
+  /**
+   * Displays the tooltip with the specified animation effect.
+   * Automatically removes the `hidden` class, adds the `show` class,
+   * and waits for the CSS transition to finish before resolving.
+   *
+   * @async
+   * @param {HTMLDivElement} tooltip - The tooltip element to animate.
+   * @param {TooltipAnimation} [animation='fade'] - The animation style to apply.
+   * @param {number} [delay=0] - The delay (in milliseconds) before starting the animation.
+   * @returns {Promise<void>} Resolves once the animation completes.
+   *
+   * @example
+   * ```ts
+   * await AnimationManager.show(tooltip, 'fade', 150);
+   * ```
+   */
+  static async show(e, t = "fade", i = 0) {
+    if (!e) return Promise.resolve();
+    this.prepareAnimation(e, t), await this.wait(i), e.classList.remove(g.CSS_CLASSES.HIDDEN), e.classList.add(g.CSS_CLASSES.SHOW), await this.waitForTransition(e);
+  }
+  /**
+   * Hides the tooltip with the currently active animation effect.
+   * Removes the `show` class, waits for the transition to complete,
+   * and finally adds the `hidden` class.
+   *
+   * @async
+   * @param {HTMLDivElement} tooltip - The tooltip element to hide.
+   * @param {number} [delay=0] - Optional delay (in milliseconds) before hiding.
+   * @returns {Promise<void>} Resolves once the hide transition finishes.
+   *
+   * @example
+   * ```ts
+   * await AnimationManager.hide(tooltip, 200);
+   * ```
+   */
+  static async hide(e, t = 0) {
+    e && (await this.wait(t), e.classList.remove(g.CSS_CLASSES.SHOW), await this.waitForTransition(e), e.classList.add(g.CSS_CLASSES.HIDDEN));
+  }
+  /**
+   * Waits for the CSS transition on the given element to complete.
+   * If no `transitionend` event is fired, it resolves automatically after
+   * the computed transition duration (as a safety fallback).
+   *
+   * @private
+   * @param {HTMLElement} element - The element undergoing a CSS transition.
+   * @returns {Promise<void>} Resolves after the transition completes or timeout elapses.
+   */
+  static waitForTransition(e) {
+    return new Promise((t) => {
+      const i = this.getTransitionDuration(e);
+      e.addEventListener("transitionend", () => t(), {
+        once: !0
+      }), setTimeout(t, i);
+    });
+  }
+  /**
+   * Reads the element’s computed transition duration and delay from CSS.
+   * Returns the total transition time in milliseconds.
+   *
+   * @private
+   * @param {HTMLElement} element - The element whose transition timing is computed.
+   * @returns {number} Total transition time (duration + delay) in milliseconds.
+   */
+  static getTransitionDuration(e) {
+    const t = getComputedStyle(e), i = parseFloat(t.transitionDuration) || 0, s = parseFloat(t.transitionDelay) || 0;
+    return (i + s) * 1e3;
+  }
+  /**
+   * A simple delay helper that pauses execution for the specified time.
+   *
+   * @private
+   * @param {number} ms - Time in milliseconds to wait.
+   * @returns {Promise<void>} Resolves after the delay.
+   *
+   * @example
+   * ```ts
+   * await AnimationManager.wait(300) ;
+   * console.log('Waited 300ms');
+   * ```
+   */
+  static wait(e) {
+    return new Promise((t) => setTimeout(t, e));
+  }
+}
+function Se() {
+  return { async: !1, breaks: !1, extensions: null, gfm: !0, hooks: null, pedantic: !1, renderer: null, silent: !1, tokenizer: null, walkTokens: null };
+}
+var q = Se();
+function We(r) {
+  q = r;
+}
+var Q = { exec: () => null };
+function k(r, e = "") {
+  let t = typeof r == "string" ? r : r.source, i = { replace: (s, n) => {
+    let a = typeof n == "string" ? n : n.source;
+    return a = a.replace(x.caret, "$1"), t = t.replace(s, a), i;
+  }, getRegex: () => new RegExp(t, e) };
+  return i;
+}
+var x = { codeRemoveIndent: /^(?: {1,4}| {0,3}\t)/gm, outputLinkReplace: /\\([\[\]])/g, indentCodeCompensation: /^(\s+)(?:```)/, beginningSpace: /^\s+/, endingHash: /#$/, startingSpaceChar: /^ /, endingSpaceChar: / $/, nonSpaceChar: /[^ ]/, newLineCharGlobal: /\n/g, tabCharGlobal: /\t/g, multipleSpaceGlobal: /\s+/g, blankLine: /^[ \t]*$/, doubleBlankLine: /\n[ \t]*\n[ \t]*$/, blockquoteStart: /^ {0,3}>/, blockquoteSetextReplace: /\n {0,3}((?:=+|-+) *)(?=\n|$)/g, blockquoteSetextReplace2: /^ {0,3}>[ \t]?/gm, listReplaceTabs: /^\t+/, listReplaceNesting: /^ {1,4}(?=( {4})*[^ ])/g, listIsTask: /^\[[ xX]\] /, listReplaceTask: /^\[[ xX]\] +/, anyLine: /\n.*\n/, hrefBrackets: /^<(.*)>$/, tableDelimiter: /[:|]/, tableAlignChars: /^\||\| *$/g, tableRowBlankLine: /\n[ \t]*$/, tableAlignRight: /^ *-+: *$/, tableAlignCenter: /^ *:-+: *$/, tableAlignLeft: /^ *:-+ *$/, startATag: /^<a /i, endATag: /^<\/a>/i, startPreScriptTag: /^<(pre|code|kbd|script)(\s|>)/i, endPreScriptTag: /^<\/(pre|code|kbd|script)(\s|>)/i, startAngleBracket: /^</, endAngleBracket: />$/, pedanticHrefTitle: /^([^'"]*[^\s])\s+(['"])(.*)\2/, unicodeAlphaNumeric: /[\p{L}\p{N}]/u, escapeTest: /[&<>"']/, escapeReplace: /[&<>"']/g, escapeTestNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/, escapeReplaceNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/g, unescapeTest: /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig, caret: /(^|[^\[])\^/g, percentDecode: /%25/g, findPipe: /\|/g, splitPipe: / \|/, slashPipe: /\\\|/g, carriageReturn: /\r\n|\r/g, spaceLine: /^ +$/gm, notSpaceStart: /^\S*/, endingNewline: /\n$/, listItemRegex: (r) => new RegExp(`^( {0,3}${r})((?:[	 ][^\\n]*)?(?:\\n|$))`), nextBulletRegex: (r) => new RegExp(`^ {0,${Math.min(3, r - 1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ 	][^\\n]*)?(?:\\n|$))`), hrRegex: (r) => new RegExp(`^ {0,${Math.min(3, r - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`), fencesBeginRegex: (r) => new RegExp(`^ {0,${Math.min(3, r - 1)}}(?:\`\`\`|~~~)`), headingBeginRegex: (r) => new RegExp(`^ {0,${Math.min(3, r - 1)}}#`), htmlBeginRegex: (r) => new RegExp(`^ {0,${Math.min(3, r - 1)}}<(?:[a-z].*>|!--)`, "i") }, pt = /^(?:[ \t]*(?:\n|$))+/, dt = /^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/, gt = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/, te = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/, mt = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/, Ae = /(?:[*+-]|\d{1,9}[.)])/, Ke = /^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\n {0,3}(=+|-+) *(?:\n+|$)/, Ge = k(Ke).replace(/bull/g, Ae).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/\|table/g, "").getRegex(), ft = k(Ke).replace(/bull/g, Ae).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/table/g, / {0,3}\|?(?:[:\- ]*\|)+[\:\- ]*\n/).getRegex(), Ee = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/, kt = /^[^\n]+/, Le = /(?!\s*\])(?:\\[\s\S]|[^\[\]\\])+/, bt = k(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace("label", Le).replace("title", /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex(), Tt = k(/^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g, Ae).getRegex(), de = "address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul", ve = /<!--(?:-?>|[\s\S]*?(?:-->|$))/, wt = k("^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|<![A-Z][\\s\\S]*?(?:>\\n*|$)|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$)|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$))", "i").replace("comment", ve).replace("tag", de).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex(), Ve = k(Ee).replace("hr", te).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("|table", "").replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", de).getRegex(), xt = k(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph", Ve).getRegex(), Pe = { blockquote: xt, code: dt, def: bt, fences: gt, heading: mt, hr: te, html: wt, lheading: Ge, list: Tt, newline: pt, paragraph: Ve, table: Q, text: kt }, _e = k("^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr", te).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("blockquote", " {0,3}>").replace("code", "(?: {4}| {0,3}	)[^\\n]").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", de).getRegex(), yt = { ...Pe, lheading: ft, table: _e, paragraph: k(Ee).replace("hr", te).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("table", _e).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", de).getRegex() }, St = { ...Pe, html: k(`^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)|<tag(?:"[^"]*"|'[^']*'|\\s[^'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`).replace("comment", ve).replace(/tag/g, "(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(), def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/, heading: /^(#{1,6})(.*)(?:\n+|$)/, fences: Q, lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/, paragraph: k(Ee).replace("hr", te).replace("heading", ` *#{1,6} *[^
+]`).replace("lheading", Ge).replace("|table", "").replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").replace("|tag", "").getRegex() }, At = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/, Et = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/, je = /^( {2,}|\\)\n(?!\s*$)/, Lt = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/, ge = /[\p{P}\p{S}]/u, Ie = /[\s\p{P}\p{S}]/u, Ze = /[^\s\p{P}\p{S}]/u, vt = k(/^((?![*_])punctSpace)/, "u").replace(/punctSpace/g, Ie).getRegex(), Ye = /(?!~)[\p{P}\p{S}]/u, Pt = /(?!~)[\s\p{P}\p{S}]/u, It = /(?:[^\s\p{P}\p{S}]|~)/u, Rt = k(/link|code|html/, "g").replace("link", new RegExp("\\[(?:[^\\[\\]`]|(?<!`)(?<a>`+)[^`]+\\k<a>(?!`))*?\\]\\((?:\\\\[\\s\\S]|[^\\\\\\(\\)]|\\((?:\\\\[\\s\\S]|[^\\\\\\(\\)])*\\))*\\)")).replace("code", new RegExp("(?<!`)(?<b>`+)[^`]+\\k<b>(?!`)")).replace("html", /<(?! )[^<>]*?>/).getRegex(), Xe = /^(?:\*+(?:((?!\*)punct)|[^\s*]))|^_+(?:((?!_)punct)|([^\s_]))/, $t = k(Xe, "u").replace(/punct/g, ge).getRegex(), Ct = k(Xe, "u").replace(/punct/g, Ye).getRegex(), Qe = "^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)punct(\\*+)(?=[\\s]|$)|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)|(?!\\*)punctSpace(\\*+)(?=notPunctSpace)|[\\s](\\*+)(?!\\*)(?=punct)|(?!\\*)punct(\\*+)(?!\\*)(?=punct)|notPunctSpace(\\*+)(?=notPunctSpace)", Ot = k(Qe, "gu").replace(/notPunctSpace/g, Ze).replace(/punctSpace/g, Ie).replace(/punct/g, ge).getRegex(), Dt = k(Qe, "gu").replace(/notPunctSpace/g, It).replace(/punctSpace/g, Pt).replace(/punct/g, Ye).getRegex(), Mt = k("^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)punct(_+)(?=[\\s]|$)|notPunctSpace(_+)(?!_)(?=punctSpace|$)|(?!_)punctSpace(_+)(?=notPunctSpace)|[\\s](_+)(?!_)(?=punct)|(?!_)punct(_+)(?!_)(?=punct)", "gu").replace(/notPunctSpace/g, Ze).replace(/punctSpace/g, Ie).replace(/punct/g, ge).getRegex(), zt = k(/\\(punct)/, "gu").replace(/punct/g, ge).getRegex(), _t = k(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace("scheme", /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace("email", /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/).getRegex(), Ft = k(ve).replace("(?:-->|$)", "-->").getRegex(), Nt = k("^comment|^</[a-zA-Z][\\w:-]*\\s*>|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^<![a-zA-Z]+\\s[\\s\\S]*?>|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>").replace("comment", Ft).replace("attribute", /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex(), ae = /(?:\[(?:\\[\s\S]|[^\[\]\\])*\]|\\[\s\S]|`+[^`]*?`+(?!`)|[^\[\]\\`])*?/, Bt = k(/^!?\[(label)\]\(\s*(href)(?:(?:[ \t]*(?:\n[ \t]*)?)(title))?\s*\)/).replace("label", ae).replace("href", /<(?:\\.|[^\n<>\\])+>|[^ \t\n\x00-\x1f]*/).replace("title", /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex(), Je = k(/^!?\[(label)\]\[(ref)\]/).replace("label", ae).replace("ref", Le).getRegex(), et = k(/^!?\[(ref)\](?:\[\])?/).replace("ref", Le).getRegex(), Ht = k("reflink|nolink(?!\\()", "g").replace("reflink", Je).replace("nolink", et).getRegex(), Fe = /[hH][tT][tT][pP][sS]?|[fF][tT][pP]/, Re = { _backpedal: Q, anyPunctuation: zt, autolink: _t, blockSkip: Rt, br: je, code: Et, del: Q, emStrongLDelim: $t, emStrongRDelimAst: Ot, emStrongRDelimUnd: Mt, escape: At, link: Bt, nolink: et, punctuation: vt, reflink: Je, reflinkSearch: Ht, tag: Nt, text: Lt, url: Q }, Ut = { ...Re, link: k(/^!?\[(label)\]\((.*?)\)/).replace("label", ae).getRegex(), reflink: k(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label", ae).getRegex() }, fe = { ...Re, emStrongRDelimAst: Dt, emStrongLDelim: Ct, url: k(/^((?:protocol):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/).replace("protocol", Fe).replace("email", /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/).getRegex(), _backpedal: /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/, del: /^(~~?)(?=[^\s~])((?:\\[\s\S]|[^\\])*?(?:\\[\s\S]|[^\s~\\]))\1(?=[^~]|$)/, text: k(/^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|protocol:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)))/).replace("protocol", Fe).getRegex() }, qt = { ...fe, br: k(je).replace("{2,}", "*").getRegex(), text: k(fe.text).replace("\\b_", "\\b_| {2,}\\n").replace(/\{2,\}/g, "*").getRegex() }, se = { normal: Pe, gfm: yt, pedantic: St }, Z = { normal: Re, gfm: fe, breaks: qt, pedantic: Ut }, Wt = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }, Ne = (r) => Wt[r];
+function v(r, e) {
+  if (e) {
+    if (x.escapeTest.test(r)) return r.replace(x.escapeReplace, Ne);
+  } else if (x.escapeTestNoEncode.test(r)) return r.replace(x.escapeReplaceNoEncode, Ne);
+  return r;
+}
+function Be(r) {
+  try {
+    r = encodeURI(r).replace(x.percentDecode, "%");
+  } catch {
+    return null;
+  }
+  return r;
+}
+function He(r, e) {
+  var n;
+  let t = r.replace(x.findPipe, (a, o, h) => {
+    let l = !1, p = o;
+    for (; --p >= 0 && h[p] === "\\"; ) l = !l;
+    return l ? "|" : " |";
+  }), i = t.split(x.splitPipe), s = 0;
+  if (i[0].trim() || i.shift(), i.length > 0 && !((n = i.at(-1)) != null && n.trim()) && i.pop(), e) if (i.length > e) i.splice(e);
+  else for (; i.length < e; ) i.push("");
+  for (; s < i.length; s++) i[s] = i[s].trim().replace(x.slashPipe, "|");
+  return i;
+}
+function Y(r, e, t) {
+  let i = r.length;
+  if (i === 0) return "";
+  let s = 0;
+  for (; s < i && r.charAt(i - s - 1) === e; )
+    s++;
+  return r.slice(0, i - s);
+}
+function Kt(r, e) {
+  if (r.indexOf(e[1]) === -1) return -1;
+  let t = 0;
+  for (let i = 0; i < r.length; i++) if (r[i] === "\\") i++;
+  else if (r[i] === e[0]) t++;
+  else if (r[i] === e[1] && (t--, t < 0)) return i;
+  return t > 0 ? -2 : -1;
+}
+function Ue(r, e, t, i, s) {
+  let n = e.href, a = e.title || null, o = r[1].replace(s.other.outputLinkReplace, "$1");
+  i.state.inLink = !0;
+  let h = { type: r[0].charAt(0) === "!" ? "image" : "link", raw: t, href: n, title: a, text: o, tokens: i.inlineTokens(o) };
+  return i.state.inLink = !1, h;
+}
+function Gt(r, e, t) {
+  let i = r.match(t.other.indentCodeCompensation);
+  if (i === null) return e;
+  let s = i[1];
+  return e.split(`
+`).map((n) => {
+    let a = n.match(t.other.beginningSpace);
+    if (a === null) return n;
+    let [o] = a;
+    return o.length >= s.length ? n.slice(s.length) : n;
+  }).join(`
+`);
+}
+var le = class {
+  constructor(r) {
+    u(this, "options");
+    u(this, "rules");
+    u(this, "lexer");
+    this.options = r || q;
+  }
+  space(r) {
+    let e = this.rules.block.newline.exec(r);
+    if (e && e[0].length > 0) return { type: "space", raw: e[0] };
+  }
+  code(r) {
+    let e = this.rules.block.code.exec(r);
+    if (e) {
+      let t = e[0].replace(this.rules.other.codeRemoveIndent, "");
+      return { type: "code", raw: e[0], codeBlockStyle: "indented", text: this.options.pedantic ? t : Y(t, `
+`) };
+    }
+  }
+  fences(r) {
+    let e = this.rules.block.fences.exec(r);
+    if (e) {
+      let t = e[0], i = Gt(t, e[3] || "", this.rules);
+      return { type: "code", raw: t, lang: e[2] ? e[2].trim().replace(this.rules.inline.anyPunctuation, "$1") : e[2], text: i };
+    }
+  }
+  heading(r) {
+    let e = this.rules.block.heading.exec(r);
+    if (e) {
+      let t = e[2].trim();
+      if (this.rules.other.endingHash.test(t)) {
+        let i = Y(t, "#");
+        (this.options.pedantic || !i || this.rules.other.endingSpaceChar.test(i)) && (t = i.trim());
+      }
+      return { type: "heading", raw: e[0], depth: e[1].length, text: t, tokens: this.lexer.inline(t) };
+    }
+  }
+  hr(r) {
+    let e = this.rules.block.hr.exec(r);
+    if (e) return { type: "hr", raw: Y(e[0], `
+`) };
+  }
+  blockquote(r) {
+    let e = this.rules.block.blockquote.exec(r);
+    if (e) {
+      let t = Y(e[0], `
+`).split(`
+`), i = "", s = "", n = [];
+      for (; t.length > 0; ) {
+        let a = !1, o = [], h;
+        for (h = 0; h < t.length; h++) if (this.rules.other.blockquoteStart.test(t[h])) o.push(t[h]), a = !0;
+        else if (!a) o.push(t[h]);
+        else break;
+        t = t.slice(h);
+        let l = o.join(`
+`), p = l.replace(this.rules.other.blockquoteSetextReplace, `
+    $1`).replace(this.rules.other.blockquoteSetextReplace2, "");
+        i = i ? `${i}
+${l}` : l, s = s ? `${s}
+${p}` : p;
+        let m = this.lexer.state.top;
+        if (this.lexer.state.top = !0, this.lexer.blockTokens(p, n, !0), this.lexer.state.top = m, t.length === 0) break;
+        let c = n.at(-1);
+        if ((c == null ? void 0 : c.type) === "code") break;
+        if ((c == null ? void 0 : c.type) === "blockquote") {
+          let f = c, d = f.raw + `
+` + t.join(`
+`), T = this.blockquote(d);
+          n[n.length - 1] = T, i = i.substring(0, i.length - f.raw.length) + T.raw, s = s.substring(0, s.length - f.text.length) + T.text;
+          break;
+        } else if ((c == null ? void 0 : c.type) === "list") {
+          let f = c, d = f.raw + `
+` + t.join(`
+`), T = this.list(d);
+          n[n.length - 1] = T, i = i.substring(0, i.length - c.raw.length) + T.raw, s = s.substring(0, s.length - f.raw.length) + T.raw, t = d.substring(n.at(-1).raw.length).split(`
+`);
+          continue;
+        }
+      }
+      return { type: "blockquote", raw: i, tokens: n, text: s };
+    }
+  }
+  list(r) {
+    let e = this.rules.block.list.exec(r);
+    if (e) {
+      let t = e[1].trim(), i = t.length > 1, s = { type: "list", raw: "", ordered: i, start: i ? +t.slice(0, -1) : "", loose: !1, items: [] };
+      t = i ? `\\d{1,9}\\${t.slice(-1)}` : `\\${t}`, this.options.pedantic && (t = i ? t : "[*+-]");
+      let n = this.rules.other.listItemRegex(t), a = !1;
+      for (; r; ) {
+        let h = !1, l = "", p = "";
+        if (!(e = n.exec(r)) || this.rules.block.hr.test(r)) break;
+        l = e[0], r = r.substring(l.length);
+        let m = e[2].split(`
+`, 1)[0].replace(this.rules.other.listReplaceTabs, ($) => " ".repeat(3 * $.length)), c = r.split(`
+`, 1)[0], f = !m.trim(), d = 0;
+        if (this.options.pedantic ? (d = 2, p = m.trimStart()) : f ? d = e[1].length + 1 : (d = e[2].search(this.rules.other.nonSpaceChar), d = d > 4 ? 1 : d, p = m.slice(d), d += e[1].length), f && this.rules.other.blankLine.test(c) && (l += c + `
+`, r = r.substring(c.length + 1), h = !0), !h) {
+          let $ = this.rules.other.nextBulletRegex(d), P = this.rules.other.hrRegex(d), I = this.rules.other.fencesBeginRegex(d), _ = this.rules.other.headingBeginRegex(d), ie = this.rules.other.htmlBeginRegex(d);
+          for (; r; ) {
+            let C = r.split(`
+`, 1)[0], O;
+            if (c = C, this.options.pedantic ? (c = c.replace(this.rules.other.listReplaceNesting, "  "), O = c) : O = c.replace(this.rules.other.tabCharGlobal, "    "), I.test(c) || _.test(c) || ie.test(c) || $.test(c) || P.test(c)) break;
+            if (O.search(this.rules.other.nonSpaceChar) >= d || !c.trim()) p += `
+` + O.slice(d);
+            else {
+              if (f || m.replace(this.rules.other.tabCharGlobal, "    ").search(this.rules.other.nonSpaceChar) >= 4 || I.test(m) || _.test(m) || P.test(m)) break;
+              p += `
+` + c;
+            }
+            !f && !c.trim() && (f = !0), l += C + `
+`, r = r.substring(C.length + 1), m = O.slice(d);
+          }
+        }
+        s.loose || (a ? s.loose = !0 : this.rules.other.doubleBlankLine.test(l) && (a = !0));
+        let T = null, L;
+        this.options.gfm && (T = this.rules.other.listIsTask.exec(p), T && (L = T[0] !== "[ ] ", p = p.replace(this.rules.other.listReplaceTask, ""))), s.items.push({ type: "list_item", raw: l, task: !!T, checked: L, loose: !1, text: p, tokens: [] }), s.raw += l;
+      }
+      let o = s.items.at(-1);
+      if (o) o.raw = o.raw.trimEnd(), o.text = o.text.trimEnd();
+      else return;
+      s.raw = s.raw.trimEnd();
+      for (let h = 0; h < s.items.length; h++) if (this.lexer.state.top = !1, s.items[h].tokens = this.lexer.blockTokens(s.items[h].text, []), !s.loose) {
+        let l = s.items[h].tokens.filter((m) => m.type === "space"), p = l.length > 0 && l.some((m) => this.rules.other.anyLine.test(m.raw));
+        s.loose = p;
+      }
+      if (s.loose) for (let h = 0; h < s.items.length; h++) s.items[h].loose = !0;
+      return s;
+    }
+  }
+  html(r) {
+    let e = this.rules.block.html.exec(r);
+    if (e) return { type: "html", block: !0, raw: e[0], pre: e[1] === "pre" || e[1] === "script" || e[1] === "style", text: e[0] };
+  }
+  def(r) {
+    let e = this.rules.block.def.exec(r);
+    if (e) {
+      let t = e[1].toLowerCase().replace(this.rules.other.multipleSpaceGlobal, " "), i = e[2] ? e[2].replace(this.rules.other.hrefBrackets, "$1").replace(this.rules.inline.anyPunctuation, "$1") : "", s = e[3] ? e[3].substring(1, e[3].length - 1).replace(this.rules.inline.anyPunctuation, "$1") : e[3];
+      return { type: "def", tag: t, raw: e[0], href: i, title: s };
+    }
+  }
+  table(r) {
+    var a;
+    let e = this.rules.block.table.exec(r);
+    if (!e || !this.rules.other.tableDelimiter.test(e[2])) return;
+    let t = He(e[1]), i = e[2].replace(this.rules.other.tableAlignChars, "").split("|"), s = (a = e[3]) != null && a.trim() ? e[3].replace(this.rules.other.tableRowBlankLine, "").split(`
+`) : [], n = { type: "table", raw: e[0], header: [], align: [], rows: [] };
+    if (t.length === i.length) {
+      for (let o of i) this.rules.other.tableAlignRight.test(o) ? n.align.push("right") : this.rules.other.tableAlignCenter.test(o) ? n.align.push("center") : this.rules.other.tableAlignLeft.test(o) ? n.align.push("left") : n.align.push(null);
+      for (let o = 0; o < t.length; o++) n.header.push({ text: t[o], tokens: this.lexer.inline(t[o]), header: !0, align: n.align[o] });
+      for (let o of s) n.rows.push(He(o, n.header.length).map((h, l) => ({ text: h, tokens: this.lexer.inline(h), header: !1, align: n.align[l] })));
+      return n;
+    }
+  }
+  lheading(r) {
+    let e = this.rules.block.lheading.exec(r);
+    if (e) return { type: "heading", raw: e[0], depth: e[2].charAt(0) === "=" ? 1 : 2, text: e[1], tokens: this.lexer.inline(e[1]) };
+  }
+  paragraph(r) {
+    let e = this.rules.block.paragraph.exec(r);
+    if (e) {
+      let t = e[1].charAt(e[1].length - 1) === `
+` ? e[1].slice(0, -1) : e[1];
+      return { type: "paragraph", raw: e[0], text: t, tokens: this.lexer.inline(t) };
+    }
+  }
+  text(r) {
+    let e = this.rules.block.text.exec(r);
+    if (e) return { type: "text", raw: e[0], text: e[0], tokens: this.lexer.inline(e[0]) };
+  }
+  escape(r) {
+    let e = this.rules.inline.escape.exec(r);
+    if (e) return { type: "escape", raw: e[0], text: e[1] };
+  }
+  tag(r) {
+    let e = this.rules.inline.tag.exec(r);
+    if (e) return !this.lexer.state.inLink && this.rules.other.startATag.test(e[0]) ? this.lexer.state.inLink = !0 : this.lexer.state.inLink && this.rules.other.endATag.test(e[0]) && (this.lexer.state.inLink = !1), !this.lexer.state.inRawBlock && this.rules.other.startPreScriptTag.test(e[0]) ? this.lexer.state.inRawBlock = !0 : this.lexer.state.inRawBlock && this.rules.other.endPreScriptTag.test(e[0]) && (this.lexer.state.inRawBlock = !1), { type: "html", raw: e[0], inLink: this.lexer.state.inLink, inRawBlock: this.lexer.state.inRawBlock, block: !1, text: e[0] };
+  }
+  link(r) {
+    let e = this.rules.inline.link.exec(r);
+    if (e) {
+      let t = e[2].trim();
+      if (!this.options.pedantic && this.rules.other.startAngleBracket.test(t)) {
+        if (!this.rules.other.endAngleBracket.test(t)) return;
+        let n = Y(t.slice(0, -1), "\\");
+        if ((t.length - n.length) % 2 === 0) return;
+      } else {
+        let n = Kt(e[2], "()");
+        if (n === -2) return;
+        if (n > -1) {
+          let a = (e[0].indexOf("!") === 0 ? 5 : 4) + e[1].length + n;
+          e[2] = e[2].substring(0, n), e[0] = e[0].substring(0, a).trim(), e[3] = "";
+        }
+      }
+      let i = e[2], s = "";
+      if (this.options.pedantic) {
+        let n = this.rules.other.pedanticHrefTitle.exec(i);
+        n && (i = n[1], s = n[3]);
+      } else s = e[3] ? e[3].slice(1, -1) : "";
+      return i = i.trim(), this.rules.other.startAngleBracket.test(i) && (this.options.pedantic && !this.rules.other.endAngleBracket.test(t) ? i = i.slice(1) : i = i.slice(1, -1)), Ue(e, { href: i && i.replace(this.rules.inline.anyPunctuation, "$1"), title: s && s.replace(this.rules.inline.anyPunctuation, "$1") }, e[0], this.lexer, this.rules);
+    }
+  }
+  reflink(r, e) {
+    let t;
+    if ((t = this.rules.inline.reflink.exec(r)) || (t = this.rules.inline.nolink.exec(r))) {
+      let i = (t[2] || t[1]).replace(this.rules.other.multipleSpaceGlobal, " "), s = e[i.toLowerCase()];
+      if (!s) {
+        let n = t[0].charAt(0);
+        return { type: "text", raw: n, text: n };
+      }
+      return Ue(t, s, t[0], this.lexer, this.rules);
+    }
+  }
+  emStrong(r, e, t = "") {
+    let i = this.rules.inline.emStrongLDelim.exec(r);
+    if (!(!i || i[3] && t.match(this.rules.other.unicodeAlphaNumeric)) && (!(i[1] || i[2]) || !t || this.rules.inline.punctuation.exec(t))) {
+      let s = [...i[0]].length - 1, n, a, o = s, h = 0, l = i[0][0] === "*" ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd;
+      for (l.lastIndex = 0, e = e.slice(-1 * r.length + s); (i = l.exec(e)) != null; ) {
+        if (n = i[1] || i[2] || i[3] || i[4] || i[5] || i[6], !n) continue;
+        if (a = [...n].length, i[3] || i[4]) {
+          o += a;
+          continue;
+        } else if ((i[5] || i[6]) && s % 3 && !((s + a) % 3)) {
+          h += a;
+          continue;
+        }
+        if (o -= a, o > 0) continue;
+        a = Math.min(a, a + o + h);
+        let p = [...i[0]][0].length, m = r.slice(0, s + i.index + p + a);
+        if (Math.min(s, a) % 2) {
+          let f = m.slice(1, -1);
+          return { type: "em", raw: m, text: f, tokens: this.lexer.inlineTokens(f) };
+        }
+        let c = m.slice(2, -2);
+        return { type: "strong", raw: m, text: c, tokens: this.lexer.inlineTokens(c) };
+      }
+    }
+  }
+  codespan(r) {
+    let e = this.rules.inline.code.exec(r);
+    if (e) {
+      let t = e[2].replace(this.rules.other.newLineCharGlobal, " "), i = this.rules.other.nonSpaceChar.test(t), s = this.rules.other.startingSpaceChar.test(t) && this.rules.other.endingSpaceChar.test(t);
+      return i && s && (t = t.substring(1, t.length - 1)), { type: "codespan", raw: e[0], text: t };
+    }
+  }
+  br(r) {
+    let e = this.rules.inline.br.exec(r);
+    if (e) return { type: "br", raw: e[0] };
+  }
+  del(r) {
+    let e = this.rules.inline.del.exec(r);
+    if (e) return { type: "del", raw: e[0], text: e[2], tokens: this.lexer.inlineTokens(e[2]) };
+  }
+  autolink(r) {
+    let e = this.rules.inline.autolink.exec(r);
+    if (e) {
+      let t, i;
+      return e[2] === "@" ? (t = e[1], i = "mailto:" + t) : (t = e[1], i = t), { type: "link", raw: e[0], text: t, href: i, tokens: [{ type: "text", raw: t, text: t }] };
+    }
+  }
+  url(r) {
+    var t;
+    let e;
+    if (e = this.rules.inline.url.exec(r)) {
+      let i, s;
+      if (e[2] === "@") i = e[0], s = "mailto:" + i;
+      else {
+        let n;
+        do
+          n = e[0], e[0] = ((t = this.rules.inline._backpedal.exec(e[0])) == null ? void 0 : t[0]) ?? "";
+        while (n !== e[0]);
+        i = e[0], e[1] === "www." ? s = "http://" + e[0] : s = e[0];
+      }
+      return { type: "link", raw: e[0], text: i, href: s, tokens: [{ type: "text", raw: i, text: i }] };
+    }
+  }
+  inlineText(r) {
+    let e = this.rules.inline.text.exec(r);
+    if (e) {
+      let t = this.lexer.state.inRawBlock;
+      return { type: "text", raw: e[0], text: e[0], escaped: t };
+    }
+  }
+}, A = class ke {
+  constructor(e) {
+    u(this, "tokens");
+    u(this, "options");
+    u(this, "state");
+    u(this, "tokenizer");
+    u(this, "inlineQueue");
+    this.tokens = [], this.tokens.links = /* @__PURE__ */ Object.create(null), this.options = e || q, this.options.tokenizer = this.options.tokenizer || new le(), this.tokenizer = this.options.tokenizer, this.tokenizer.options = this.options, this.tokenizer.lexer = this, this.inlineQueue = [], this.state = { inLink: !1, inRawBlock: !1, top: !0 };
+    let t = { other: x, block: se.normal, inline: Z.normal };
+    this.options.pedantic ? (t.block = se.pedantic, t.inline = Z.pedantic) : this.options.gfm && (t.block = se.gfm, this.options.breaks ? t.inline = Z.breaks : t.inline = Z.gfm), this.tokenizer.rules = t;
+  }
+  static get rules() {
+    return { block: se, inline: Z };
+  }
+  static lex(e, t) {
+    return new ke(t).lex(e);
+  }
+  static lexInline(e, t) {
+    return new ke(t).inlineTokens(e);
+  }
+  lex(e) {
+    e = e.replace(x.carriageReturn, `
+`), this.blockTokens(e, this.tokens);
+    for (let t = 0; t < this.inlineQueue.length; t++) {
+      let i = this.inlineQueue[t];
+      this.inlineTokens(i.src, i.tokens);
+    }
+    return this.inlineQueue = [], this.tokens;
+  }
+  blockTokens(e, t = [], i = !1) {
+    var s, n, a;
+    for (this.options.pedantic && (e = e.replace(x.tabCharGlobal, "    ").replace(x.spaceLine, "")); e; ) {
+      let o;
+      if ((n = (s = this.options.extensions) == null ? void 0 : s.block) != null && n.some((l) => (o = l.call({ lexer: this }, e, t)) ? (e = e.substring(o.raw.length), t.push(o), !0) : !1)) continue;
+      if (o = this.tokenizer.space(e)) {
+        e = e.substring(o.raw.length);
+        let l = t.at(-1);
+        o.raw.length === 1 && l !== void 0 ? l.raw += `
+` : t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.code(e)) {
+        e = e.substring(o.raw.length);
+        let l = t.at(-1);
+        (l == null ? void 0 : l.type) === "paragraph" || (l == null ? void 0 : l.type) === "text" ? (l.raw += (l.raw.endsWith(`
+`) ? "" : `
+`) + o.raw, l.text += `
+` + o.text, this.inlineQueue.at(-1).src = l.text) : t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.fences(e)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.heading(e)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.hr(e)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.blockquote(e)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.list(e)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.html(e)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.def(e)) {
+        e = e.substring(o.raw.length);
+        let l = t.at(-1);
+        (l == null ? void 0 : l.type) === "paragraph" || (l == null ? void 0 : l.type) === "text" ? (l.raw += (l.raw.endsWith(`
+`) ? "" : `
+`) + o.raw, l.text += `
+` + o.raw, this.inlineQueue.at(-1).src = l.text) : this.tokens.links[o.tag] || (this.tokens.links[o.tag] = { href: o.href, title: o.title }, t.push(o));
+        continue;
+      }
+      if (o = this.tokenizer.table(e)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.lheading(e)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      let h = e;
+      if ((a = this.options.extensions) != null && a.startBlock) {
+        let l = 1 / 0, p = e.slice(1), m;
+        this.options.extensions.startBlock.forEach((c) => {
+          m = c.call({ lexer: this }, p), typeof m == "number" && m >= 0 && (l = Math.min(l, m));
+        }), l < 1 / 0 && l >= 0 && (h = e.substring(0, l + 1));
+      }
+      if (this.state.top && (o = this.tokenizer.paragraph(h))) {
+        let l = t.at(-1);
+        i && (l == null ? void 0 : l.type) === "paragraph" ? (l.raw += (l.raw.endsWith(`
+`) ? "" : `
+`) + o.raw, l.text += `
+` + o.text, this.inlineQueue.pop(), this.inlineQueue.at(-1).src = l.text) : t.push(o), i = h.length !== e.length, e = e.substring(o.raw.length);
+        continue;
+      }
+      if (o = this.tokenizer.text(e)) {
+        e = e.substring(o.raw.length);
+        let l = t.at(-1);
+        (l == null ? void 0 : l.type) === "text" ? (l.raw += (l.raw.endsWith(`
+`) ? "" : `
+`) + o.raw, l.text += `
+` + o.text, this.inlineQueue.pop(), this.inlineQueue.at(-1).src = l.text) : t.push(o);
+        continue;
+      }
+      if (e) {
+        let l = "Infinite loop on byte: " + e.charCodeAt(0);
+        if (this.options.silent) {
+          console.error(l);
+          break;
+        } else throw new Error(l);
+      }
+    }
+    return this.state.top = !0, t;
+  }
+  inline(e, t = []) {
+    return this.inlineQueue.push({ src: e, tokens: t }), t;
+  }
+  inlineTokens(e, t = []) {
+    var o, h, l, p, m;
+    let i = e, s = null;
+    if (this.tokens.links) {
+      let c = Object.keys(this.tokens.links);
+      if (c.length > 0) for (; (s = this.tokenizer.rules.inline.reflinkSearch.exec(i)) != null; ) c.includes(s[0].slice(s[0].lastIndexOf("[") + 1, -1)) && (i = i.slice(0, s.index) + "[" + "a".repeat(s[0].length - 2) + "]" + i.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex));
+    }
+    for (; (s = this.tokenizer.rules.inline.anyPunctuation.exec(i)) != null; ) i = i.slice(0, s.index) + "++" + i.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);
+    for (; (s = this.tokenizer.rules.inline.blockSkip.exec(i)) != null; ) i = i.slice(0, s.index) + "[" + "a".repeat(s[0].length - 2) + "]" + i.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);
+    i = ((h = (o = this.options.hooks) == null ? void 0 : o.emStrongMask) == null ? void 0 : h.call({ lexer: this }, i)) ?? i;
+    let n = !1, a = "";
+    for (; e; ) {
+      n || (a = ""), n = !1;
+      let c;
+      if ((p = (l = this.options.extensions) == null ? void 0 : l.inline) != null && p.some((d) => (c = d.call({ lexer: this }, e, t)) ? (e = e.substring(c.raw.length), t.push(c), !0) : !1)) continue;
+      if (c = this.tokenizer.escape(e)) {
+        e = e.substring(c.raw.length), t.push(c);
+        continue;
+      }
+      if (c = this.tokenizer.tag(e)) {
+        e = e.substring(c.raw.length), t.push(c);
+        continue;
+      }
+      if (c = this.tokenizer.link(e)) {
+        e = e.substring(c.raw.length), t.push(c);
+        continue;
+      }
+      if (c = this.tokenizer.reflink(e, this.tokens.links)) {
+        e = e.substring(c.raw.length);
+        let d = t.at(-1);
+        c.type === "text" && (d == null ? void 0 : d.type) === "text" ? (d.raw += c.raw, d.text += c.text) : t.push(c);
+        continue;
+      }
+      if (c = this.tokenizer.emStrong(e, i, a)) {
+        e = e.substring(c.raw.length), t.push(c);
+        continue;
+      }
+      if (c = this.tokenizer.codespan(e)) {
+        e = e.substring(c.raw.length), t.push(c);
+        continue;
+      }
+      if (c = this.tokenizer.br(e)) {
+        e = e.substring(c.raw.length), t.push(c);
+        continue;
+      }
+      if (c = this.tokenizer.del(e)) {
+        e = e.substring(c.raw.length), t.push(c);
+        continue;
+      }
+      if (c = this.tokenizer.autolink(e)) {
+        e = e.substring(c.raw.length), t.push(c);
+        continue;
+      }
+      if (!this.state.inLink && (c = this.tokenizer.url(e))) {
+        e = e.substring(c.raw.length), t.push(c);
+        continue;
+      }
+      let f = e;
+      if ((m = this.options.extensions) != null && m.startInline) {
+        let d = 1 / 0, T = e.slice(1), L;
+        this.options.extensions.startInline.forEach(($) => {
+          L = $.call({ lexer: this }, T), typeof L == "number" && L >= 0 && (d = Math.min(d, L));
+        }), d < 1 / 0 && d >= 0 && (f = e.substring(0, d + 1));
+      }
+      if (c = this.tokenizer.inlineText(f)) {
+        e = e.substring(c.raw.length), c.raw.slice(-1) !== "_" && (a = c.raw.slice(-1)), n = !0;
+        let d = t.at(-1);
+        (d == null ? void 0 : d.type) === "text" ? (d.raw += c.raw, d.text += c.text) : t.push(c);
+        continue;
+      }
+      if (e) {
+        let d = "Infinite loop on byte: " + e.charCodeAt(0);
+        if (this.options.silent) {
+          console.error(d);
+          break;
+        } else throw new Error(d);
+      }
+    }
+    return t;
+  }
+}, ce = class {
+  constructor(r) {
+    u(this, "options");
+    u(this, "parser");
+    this.options = r || q;
+  }
+  space(r) {
+    return "";
+  }
+  code({ text: r, lang: e, escaped: t }) {
+    var n;
+    let i = (n = (e || "").match(x.notSpaceStart)) == null ? void 0 : n[0], s = r.replace(x.endingNewline, "") + `
+`;
+    return i ? '<pre><code class="language-' + v(i) + '">' + (t ? s : v(s, !0)) + `</code></pre>
+` : "<pre><code>" + (t ? s : v(s, !0)) + `</code></pre>
+`;
+  }
+  blockquote({ tokens: r }) {
+    return `<blockquote>
+${this.parser.parse(r)}</blockquote>
+`;
+  }
+  html({ text: r }) {
+    return r;
+  }
+  def(r) {
+    return "";
+  }
+  heading({ tokens: r, depth: e }) {
+    return `<h${e}>${this.parser.parseInline(r)}</h${e}>
+`;
+  }
+  hr(r) {
+    return `<hr>
+`;
+  }
+  list(r) {
+    let e = r.ordered, t = r.start, i = "";
+    for (let a = 0; a < r.items.length; a++) {
+      let o = r.items[a];
+      i += this.listitem(o);
+    }
+    let s = e ? "ol" : "ul", n = e && t !== 1 ? ' start="' + t + '"' : "";
+    return "<" + s + n + `>
+` + i + "</" + s + `>
+`;
+  }
+  listitem(r) {
+    var t;
+    let e = "";
+    if (r.task) {
+      let i = this.checkbox({ checked: !!r.checked });
+      r.loose ? ((t = r.tokens[0]) == null ? void 0 : t.type) === "paragraph" ? (r.tokens[0].text = i + " " + r.tokens[0].text, r.tokens[0].tokens && r.tokens[0].tokens.length > 0 && r.tokens[0].tokens[0].type === "text" && (r.tokens[0].tokens[0].text = i + " " + v(r.tokens[0].tokens[0].text), r.tokens[0].tokens[0].escaped = !0)) : r.tokens.unshift({ type: "text", raw: i + " ", text: i + " ", escaped: !0 }) : e += i + " ";
+    }
+    return e += this.parser.parse(r.tokens, !!r.loose), `<li>${e}</li>
+`;
+  }
+  checkbox({ checked: r }) {
+    return "<input " + (r ? 'checked="" ' : "") + 'disabled="" type="checkbox">';
+  }
+  paragraph({ tokens: r }) {
+    return `<p>${this.parser.parseInline(r)}</p>
+`;
+  }
+  table(r) {
+    let e = "", t = "";
+    for (let s = 0; s < r.header.length; s++) t += this.tablecell(r.header[s]);
+    e += this.tablerow({ text: t });
+    let i = "";
+    for (let s = 0; s < r.rows.length; s++) {
+      let n = r.rows[s];
+      t = "";
+      for (let a = 0; a < n.length; a++) t += this.tablecell(n[a]);
+      i += this.tablerow({ text: t });
+    }
+    return i && (i = `<tbody>${i}</tbody>`), `<table>
+<thead>
+` + e + `</thead>
+` + i + `</table>
+`;
+  }
+  tablerow({ text: r }) {
+    return `<tr>
+${r}</tr>
+`;
+  }
+  tablecell(r) {
+    let e = this.parser.parseInline(r.tokens), t = r.header ? "th" : "td";
+    return (r.align ? `<${t} align="${r.align}">` : `<${t}>`) + e + `</${t}>
+`;
+  }
+  strong({ tokens: r }) {
+    return `<strong>${this.parser.parseInline(r)}</strong>`;
+  }
+  em({ tokens: r }) {
+    return `<em>${this.parser.parseInline(r)}</em>`;
+  }
+  codespan({ text: r }) {
+    return `<code>${v(r, !0)}</code>`;
+  }
+  br(r) {
+    return "<br>";
+  }
+  del({ tokens: r }) {
+    return `<del>${this.parser.parseInline(r)}</del>`;
+  }
+  link({ href: r, title: e, tokens: t }) {
+    let i = this.parser.parseInline(t), s = Be(r);
+    if (s === null) return i;
+    r = s;
+    let n = '<a href="' + r + '"';
+    return e && (n += ' title="' + v(e) + '"'), n += ">" + i + "</a>", n;
+  }
+  image({ href: r, title: e, text: t, tokens: i }) {
+    i && (t = this.parser.parseInline(i, this.parser.textRenderer));
+    let s = Be(r);
+    if (s === null) return v(t);
+    r = s;
+    let n = `<img src="${r}" alt="${t}"`;
+    return e && (n += ` title="${v(e)}"`), n += ">", n;
+  }
+  text(r) {
+    return "tokens" in r && r.tokens ? this.parser.parseInline(r.tokens) : "escaped" in r && r.escaped ? r.text : v(r.text);
+  }
+}, $e = class {
+  strong({ text: r }) {
+    return r;
+  }
+  em({ text: r }) {
+    return r;
+  }
+  codespan({ text: r }) {
+    return r;
+  }
+  del({ text: r }) {
+    return r;
+  }
+  html({ text: r }) {
+    return r;
+  }
+  text({ text: r }) {
+    return r;
+  }
+  link({ text: r }) {
+    return "" + r;
+  }
+  image({ text: r }) {
+    return "" + r;
+  }
+  br() {
+    return "";
+  }
+}, E = class be {
+  constructor(e) {
+    u(this, "options");
+    u(this, "renderer");
+    u(this, "textRenderer");
+    this.options = e || q, this.options.renderer = this.options.renderer || new ce(), this.renderer = this.options.renderer, this.renderer.options = this.options, this.renderer.parser = this, this.textRenderer = new $e();
+  }
+  static parse(e, t) {
+    return new be(t).parse(e);
+  }
+  static parseInline(e, t) {
+    return new be(t).parseInline(e);
+  }
+  parse(e, t = !0) {
+    var s, n;
+    let i = "";
+    for (let a = 0; a < e.length; a++) {
+      let o = e[a];
+      if ((n = (s = this.options.extensions) == null ? void 0 : s.renderers) != null && n[o.type]) {
+        let l = o, p = this.options.extensions.renderers[l.type].call({ parser: this }, l);
+        if (p !== !1 || !["space", "hr", "heading", "code", "table", "blockquote", "list", "html", "def", "paragraph", "text"].includes(l.type)) {
+          i += p || "";
+          continue;
+        }
+      }
+      let h = o;
+      switch (h.type) {
+        case "space": {
+          i += this.renderer.space(h);
+          continue;
+        }
+        case "hr": {
+          i += this.renderer.hr(h);
+          continue;
+        }
+        case "heading": {
+          i += this.renderer.heading(h);
+          continue;
+        }
+        case "code": {
+          i += this.renderer.code(h);
+          continue;
+        }
+        case "table": {
+          i += this.renderer.table(h);
+          continue;
+        }
+        case "blockquote": {
+          i += this.renderer.blockquote(h);
+          continue;
+        }
+        case "list": {
+          i += this.renderer.list(h);
+          continue;
+        }
+        case "html": {
+          i += this.renderer.html(h);
+          continue;
+        }
+        case "def": {
+          i += this.renderer.def(h);
+          continue;
+        }
+        case "paragraph": {
+          i += this.renderer.paragraph(h);
+          continue;
+        }
+        case "text": {
+          let l = h, p = this.renderer.text(l);
+          for (; a + 1 < e.length && e[a + 1].type === "text"; ) l = e[++a], p += `
+` + this.renderer.text(l);
+          t ? i += this.renderer.paragraph({ type: "paragraph", raw: p, text: p, tokens: [{ type: "text", raw: p, text: p, escaped: !0 }] }) : i += p;
+          continue;
+        }
+        default: {
+          let l = 'Token with "' + h.type + '" type was not found.';
+          if (this.options.silent) return console.error(l), "";
+          throw new Error(l);
+        }
+      }
+    }
+    return i;
+  }
+  parseInline(e, t = this.renderer) {
+    var s, n;
+    let i = "";
+    for (let a = 0; a < e.length; a++) {
+      let o = e[a];
+      if ((n = (s = this.options.extensions) == null ? void 0 : s.renderers) != null && n[o.type]) {
+        let l = this.options.extensions.renderers[o.type].call({ parser: this }, o);
+        if (l !== !1 || !["escape", "html", "link", "image", "strong", "em", "codespan", "br", "del", "text"].includes(o.type)) {
+          i += l || "";
+          continue;
+        }
+      }
+      let h = o;
+      switch (h.type) {
+        case "escape": {
+          i += t.text(h);
+          break;
+        }
+        case "html": {
+          i += t.html(h);
+          break;
+        }
+        case "link": {
+          i += t.link(h);
+          break;
+        }
+        case "image": {
+          i += t.image(h);
+          break;
+        }
+        case "strong": {
+          i += t.strong(h);
+          break;
+        }
+        case "em": {
+          i += t.em(h);
+          break;
+        }
+        case "codespan": {
+          i += t.codespan(h);
+          break;
+        }
+        case "br": {
+          i += t.br(h);
+          break;
+        }
+        case "del": {
+          i += t.del(h);
+          break;
+        }
+        case "text": {
+          i += t.text(h);
+          break;
+        }
+        default: {
+          let l = 'Token with "' + h.type + '" type was not found.';
+          if (this.options.silent) return console.error(l), "";
+          throw new Error(l);
+        }
+      }
+    }
+    return i;
+  }
+}, re, X = (re = class {
+  constructor(r) {
+    u(this, "options");
+    u(this, "block");
+    this.options = r || q;
+  }
+  preprocess(r) {
+    return r;
+  }
+  postprocess(r) {
+    return r;
+  }
+  processAllTokens(r) {
+    return r;
+  }
+  emStrongMask(r) {
+    return r;
+  }
+  provideLexer() {
+    return this.block ? A.lex : A.lexInline;
+  }
+  provideParser() {
+    return this.block ? E.parse : E.parseInline;
+  }
+}, u(re, "passThroughHooks", /* @__PURE__ */ new Set(["preprocess", "postprocess", "processAllTokens", "emStrongMask"])), u(re, "passThroughHooksRespectAsync", /* @__PURE__ */ new Set(["preprocess", "postprocess", "processAllTokens"])), re), Vt = class {
+  constructor(...r) {
+    u(this, "defaults", Se());
+    u(this, "options", this.setOptions);
+    u(this, "parse", this.parseMarkdown(!0));
+    u(this, "parseInline", this.parseMarkdown(!1));
+    u(this, "Parser", E);
+    u(this, "Renderer", ce);
+    u(this, "TextRenderer", $e);
+    u(this, "Lexer", A);
+    u(this, "Tokenizer", le);
+    u(this, "Hooks", X);
+    this.use(...r);
+  }
+  walkTokens(r, e) {
+    var i, s;
+    let t = [];
+    for (let n of r) switch (t = t.concat(e.call(this, n)), n.type) {
+      case "table": {
+        let a = n;
+        for (let o of a.header) t = t.concat(this.walkTokens(o.tokens, e));
+        for (let o of a.rows) for (let h of o) t = t.concat(this.walkTokens(h.tokens, e));
+        break;
+      }
+      case "list": {
+        let a = n;
+        t = t.concat(this.walkTokens(a.items, e));
+        break;
+      }
+      default: {
+        let a = n;
+        (s = (i = this.defaults.extensions) == null ? void 0 : i.childTokens) != null && s[a.type] ? this.defaults.extensions.childTokens[a.type].forEach((o) => {
+          let h = a[o].flat(1 / 0);
+          t = t.concat(this.walkTokens(h, e));
+        }) : a.tokens && (t = t.concat(this.walkTokens(a.tokens, e)));
+      }
+    }
+    return t;
+  }
+  use(...r) {
+    let e = this.defaults.extensions || { renderers: {}, childTokens: {} };
+    return r.forEach((t) => {
+      let i = { ...t };
+      if (i.async = this.defaults.async || i.async || !1, t.extensions && (t.extensions.forEach((s) => {
+        if (!s.name) throw new Error("extension name required");
+        if ("renderer" in s) {
+          let n = e.renderers[s.name];
+          n ? e.renderers[s.name] = function(...a) {
+            let o = s.renderer.apply(this, a);
+            return o === !1 && (o = n.apply(this, a)), o;
+          } : e.renderers[s.name] = s.renderer;
+        }
+        if ("tokenizer" in s) {
+          if (!s.level || s.level !== "block" && s.level !== "inline") throw new Error("extension level must be 'block' or 'inline'");
+          let n = e[s.level];
+          n ? n.unshift(s.tokenizer) : e[s.level] = [s.tokenizer], s.start && (s.level === "block" ? e.startBlock ? e.startBlock.push(s.start) : e.startBlock = [s.start] : s.level === "inline" && (e.startInline ? e.startInline.push(s.start) : e.startInline = [s.start]));
+        }
+        "childTokens" in s && s.childTokens && (e.childTokens[s.name] = s.childTokens);
+      }), i.extensions = e), t.renderer) {
+        let s = this.defaults.renderer || new ce(this.defaults);
+        for (let n in t.renderer) {
+          if (!(n in s)) throw new Error(`renderer '${n}' does not exist`);
+          if (["options", "parser"].includes(n)) continue;
+          let a = n, o = t.renderer[a], h = s[a];
+          s[a] = (...l) => {
+            let p = o.apply(s, l);
+            return p === !1 && (p = h.apply(s, l)), p || "";
+          };
+        }
+        i.renderer = s;
+      }
+      if (t.tokenizer) {
+        let s = this.defaults.tokenizer || new le(this.defaults);
+        for (let n in t.tokenizer) {
+          if (!(n in s)) throw new Error(`tokenizer '${n}' does not exist`);
+          if (["options", "rules", "lexer"].includes(n)) continue;
+          let a = n, o = t.tokenizer[a], h = s[a];
+          s[a] = (...l) => {
+            let p = o.apply(s, l);
+            return p === !1 && (p = h.apply(s, l)), p;
+          };
+        }
+        i.tokenizer = s;
+      }
+      if (t.hooks) {
+        let s = this.defaults.hooks || new X();
+        for (let n in t.hooks) {
+          if (!(n in s)) throw new Error(`hook '${n}' does not exist`);
+          if (["options", "block"].includes(n)) continue;
+          let a = n, o = t.hooks[a], h = s[a];
+          X.passThroughHooks.has(n) ? s[a] = (l) => {
+            if (this.defaults.async && X.passThroughHooksRespectAsync.has(n)) return (async () => {
+              let m = await o.call(s, l);
+              return h.call(s, m);
+            })();
+            let p = o.call(s, l);
+            return h.call(s, p);
+          } : s[a] = (...l) => {
+            if (this.defaults.async) return (async () => {
+              let m = await o.apply(s, l);
+              return m === !1 && (m = await h.apply(s, l)), m;
+            })();
+            let p = o.apply(s, l);
+            return p === !1 && (p = h.apply(s, l)), p;
+          };
+        }
+        i.hooks = s;
+      }
+      if (t.walkTokens) {
+        let s = this.defaults.walkTokens, n = t.walkTokens;
+        i.walkTokens = function(a) {
+          let o = [];
+          return o.push(n.call(this, a)), s && (o = o.concat(s.call(this, a))), o;
+        };
+      }
+      this.defaults = { ...this.defaults, ...i };
+    }), this;
+  }
+  setOptions(r) {
+    return this.defaults = { ...this.defaults, ...r }, this;
+  }
+  lexer(r, e) {
+    return A.lex(r, e ?? this.defaults);
+  }
+  parser(r, e) {
+    return E.parse(r, e ?? this.defaults);
+  }
+  parseMarkdown(r) {
+    return (e, t) => {
+      let i = { ...t }, s = { ...this.defaults, ...i }, n = this.onError(!!s.silent, !!s.async);
+      if (this.defaults.async === !0 && i.async === !1) return n(new Error("marked(): The async option was set to true by an extension. Remove async: false from the parse options object to return a Promise."));
+      if (typeof e > "u" || e === null) return n(new Error("marked(): input parameter is undefined or null"));
+      if (typeof e != "string") return n(new Error("marked(): input parameter is of type " + Object.prototype.toString.call(e) + ", string expected"));
+      if (s.hooks && (s.hooks.options = s, s.hooks.block = r), s.async) return (async () => {
+        let a = s.hooks ? await s.hooks.preprocess(e) : e, o = await (s.hooks ? await s.hooks.provideLexer() : r ? A.lex : A.lexInline)(a, s), h = s.hooks ? await s.hooks.processAllTokens(o) : o;
+        s.walkTokens && await Promise.all(this.walkTokens(h, s.walkTokens));
+        let l = await (s.hooks ? await s.hooks.provideParser() : r ? E.parse : E.parseInline)(h, s);
+        return s.hooks ? await s.hooks.postprocess(l) : l;
+      })().catch(n);
+      try {
+        s.hooks && (e = s.hooks.preprocess(e));
+        let a = (s.hooks ? s.hooks.provideLexer() : r ? A.lex : A.lexInline)(e, s);
+        s.hooks && (a = s.hooks.processAllTokens(a)), s.walkTokens && this.walkTokens(a, s.walkTokens);
+        let o = (s.hooks ? s.hooks.provideParser() : r ? E.parse : E.parseInline)(a, s);
+        return s.hooks && (o = s.hooks.postprocess(o)), o;
+      } catch (a) {
+        return n(a);
+      }
+    };
+  }
+  onError(r, e) {
+    return (t) => {
+      if (t.message += `
+Please report this to https://github.com/markedjs/marked.`, r) {
+        let i = "<p>An error occurred:</p><pre>" + v(t.message + "", !0) + "</pre>";
+        return e ? Promise.resolve(i) : i;
+      }
+      if (e) return Promise.reject(t);
+      throw t;
+    };
+  }
+}, H = new Vt();
+function b(r, e) {
+  return H.parse(r, e);
+}
+b.options = b.setOptions = function(r) {
+  return H.setOptions(r), b.defaults = H.defaults, We(b.defaults), b;
+};
+b.getDefaults = Se;
+b.defaults = q;
+b.use = function(...r) {
+  return H.use(...r), b.defaults = H.defaults, We(b.defaults), b;
+};
+b.walkTokens = function(r, e) {
+  return H.walkTokens(r, e);
+};
+b.parseInline = H.parseInline;
+b.Parser = E;
+b.parser = E.parse;
+b.Renderer = ce;
+b.TextRenderer = $e;
+b.Lexer = A;
+b.lexer = A.lex;
+b.Tokenizer = le;
+b.Hooks = X;
+b.parse = b;
+b.options;
+b.setOptions;
+b.use;
+b.walkTokens;
+b.parseInline;
+E.parse;
+A.lex;
+const pe = class pe {
+  constructor() {
+    u(this, "currentLang", "en");
+    u(this, "fallbackLang", "en");
+    u(this, "translations", {});
+    u(this, "supportedLangs", /* @__PURE__ */ new Set(["en", "pl"]));
+    u(this, "loadingPromises", /* @__PURE__ */ new Map());
+  }
+  /** Returns the global singleton instance */
+  static getInstance() {
+    return this.instance || (this.instance = new pe()), this.instance;
+  }
+  /**
+   * Sets the current active language.
+   * Emits a change event if language was updated.
+   */
+  setLanguage(e) {
+    if (!this.supportedLangs.has(e)) {
+      console.warn(`[HintoriumI18n] Unsupported language: ${e}`);
+      return;
+    }
+    this.currentLang !== e && (this.currentLang = e);
+  }
+  /**
+   * Sets the fallback language used when a translation key is missing.
+   */
+  setFallbackLanguage(e) {
+    if (!this.supportedLangs.has(e)) {
+      console.warn(`[HintoriumI18n] Unsupported fallback language: ${e}`);
+      return;
+    }
+    this.fallbackLang = e;
+  }
+  /**
+   * Loads multiple language files at once.
+   * @param langs - Array of language configurations
+   * @returns Promise that resolves when all translations are loaded
+   */
+  async loadMultipleTranslations(e) {
+    await Promise.all(
+      e.map(({ lang: t, url: i }) => this.loadTranslations(t, i))
+    );
+  }
+  /**
+   * Loads translations from an external file (JSON).
+   * @param lang - Language code
+   * @param url - URL to the JSON file
+   * @returns Promise that resolves when translations are loaded
+   */
+  async loadTranslations(e, t) {
+    if (this.loadingPromises.has(e))
+      return this.loadingPromises.get(e);
+    const i = (async () => {
+      try {
+        const s = await fetch(t);
+        if (!s.ok)
+          throw new Error(
+            `Failed to load translations: ${s.statusText}`
+          );
+        const n = await s.json();
+        this.setTranslations(e, n);
+      } catch (s) {
+        throw console.error(
+          `[HintoriumI18n] Error loading translations for ${e}:`,
+          s
+        ), s;
+      } finally {
+        this.loadingPromises.delete(e);
+      }
+    })();
+    return this.loadingPromises.set(e, i), i;
+  }
+  /**
+   * Returns the fallback language.
+   */
+  getFallbackLanguage() {
+    return this.fallbackLang;
+  }
+  /**
+   * Returns the currently active language.
+   */
+  getLanguage() {
+    return this.currentLang;
+  }
+  /** Dynamically adds a supported language (e.g. "fr", "de", "ar"). */
+  addLanguage(e) {
+    this.supportedLangs.has(e) || this.supportedLangs.add(e);
+  }
+  /**
+   * Returns the list of supported languages.
+   */
+  getSupportedLanguages() {
+    return Array.from(this.supportedLangs);
+  }
+  /** Adds or merges translations for a given language. */
+  setTranslations(e, t) {
+    this.addLanguage(e), this.translations[e] = {
+      ...this.translations[e] || {},
+      ...t
+    };
+  }
+  /**
+   * Translates a key.
+   * - Looks up the current language first.
+   * - Falls back to the fallback language.
+   * - Falls back to `fallback` param or the key itself if not found.
+   */
+  t(e, t) {
+    const i = this.currentLang, s = this.translations[i], n = this.translations[this.fallbackLang], a = (o, h) => h.split(".").reduce((l, p) => l == null ? void 0 : l[p], o);
+    return s ? a(s, e) || a(n, e) || s[e] || t || e : (n == null ? void 0 : n[e]) || t || e;
+  }
+  /** Detects browser or document language. */
+  detectLanguage() {
+    const e = (document.documentElement.lang || document.body.lang || navigator.language || "en").split("-")[0].toLowerCase();
+    return this.supportedLangs.has(e) && (this.currentLang = e), this.currentLang;
+  }
+};
+u(pe, "instance", null);
+let Te = pe;
+const S = Te.getInstance(), V = class V {
+  constructor(e) {
+    u(this, "LOADING_HTML", '<span class="hintorium-loading">⏳ Loading...</span>');
+    u(this, "ERROR_HTML", '<span class="hintorium-error">⚠️ Failed to load content</span>');
+    u(this, "content");
+    this.content = e;
+  }
+  /**
+   * Render the tooltip content.
+   * Supports string, HTMLElement, sync callback, or async callback.
+   */
+  async render() {
+    try {
+      if (this.content instanceof HTMLElement)
+        return this.content;
+      if (typeof this.content == "string") {
+        const i = S.t(this.content);
+        return i ? this.renderString(i) : this.renderString(this.content);
+      }
+      let e = this.LOADING_HTML;
+      const t = await this.resolveDynamicContent(this.content);
+      return t instanceof HTMLElement ? e = t : e = await this.renderString(t), e;
+    } catch {
+      return this.ERROR_HTML;
+    }
+  }
+  /**
+   * Convert a string to HTML, treating it as Markdown
+   * and then sanitizing it.
+   */
+  async renderString(e) {
+    const t = await b.parse(e);
+    return this.sanitizeHTML(t);
+  }
+  /**
+   * Resolves dynamic tooltip content (callback, promise, or URL fetch).
+   */
+  async resolveDynamicContent(e) {
+    let t;
+    if (typeof e == "function") {
+      const i = e();
+      t = i instanceof Promise ? await i : i;
+    } else
+      t = e;
+    if (typeof t == "string" && this.isURL(t)) {
+      if (V.cache.has(t))
+        return V.cache.get(t);
+      try {
+        const i = await fetch(t);
+        if (!i.ok) throw new Error(`HTTP ${i.status}`);
+        const s = await i.text(), n = await this.renderString(s);
+        return V.cache.set(t, n), n;
+      } catch {
+        return this.ERROR_HTML;
+      }
+    }
+    return t;
+  }
+  /**
+   * Simple URL validator.
+   */
+  isURL(e) {
+    return /^https?:\/\//i.test(e);
+  }
+  /**
+   * Sanitizes HTML string manually.
+   * Removes <script>, <iframe>, <object>, <embed>, <link>, <meta>
+   * and dangerous inline event handlers (onmouseover, onclick, etc.).
+   *
+   * @param html - Raw HTML to sanitize.
+   * @returns Safe HTML string.
+   */
+  sanitizeHTML(e) {
+    const t = document.createElement("div");
+    return t.innerHTML = e, [
+      "script",
+      "iframe",
+      "object",
+      "embed",
+      "link",
+      "meta"
+    ].forEach(
+      (i) => t.querySelectorAll(i).forEach((s) => s.remove())
+    ), t.querySelectorAll("*").forEach((i) => {
+      [...i.attributes].forEach((s) => {
+        const n = s.name.toLowerCase();
+        n.startsWith("on") && i.removeAttribute(s.name), ["srcdoc", "srcset", "formaction"].includes(n) && i.removeAttribute(s.name);
+      });
+    }), t.querySelectorAll("a, area, iframe").forEach((i) => {
+      const s = i.getAttribute("href");
+      s && s.trim().toLowerCase().startsWith("javascript:") && i.removeAttribute("href");
+    }), t.innerHTML;
+  }
+};
+u(V, "cache", /* @__PURE__ */ new Map());
+let we = V;
+const J = class J {
+  /**
+   * Positions a tooltip element relative to its trigger element.
+   * Handles flipping and edge detection automatically.
+   *
+   * @param triggerElement - The element that triggers the tooltip.
+   * @param tooltipElement - The tooltip element to be positioned.
+   * @param position - Desired position ("top" | "bottom" | "left" | "right" | "auto").
+   * @param offset - Distance in pixels between the trigger and the tooltip.
+   * @param rtl - If direction is rtl or ltr.
+   */
+  static position(e, t, i = "top", s, n = J.DEFAULT_OFFSET) {
+    if (typeof window > "u" || !e || !t)
+      return;
+    const a = this.calculatePosition(
+      e,
+      t,
+      i,
+      n,
+      s
+    );
+    t.style.top = `${a.top}px`, t.style.left = `${a.left}px`;
+  }
+  /**
+   * Calculates the tooltip's top and left coordinates in the document.
+   * Automatically flips the tooltip if it doesn't fit in the viewport.
+   */
+  static calculatePosition(e, t, i, s, n) {
+    const a = e.getBoundingClientRect();
+    let o = t.getBoundingClientRect();
+    const h = window.scrollX, l = window.scrollY, p = window.innerWidth, m = window.innerHeight, {
+      top: c,
+      left: f,
+      bottom: d,
+      right: T,
+      width: L,
+      height: $
+    } = a;
+    o = t.getBoundingClientRect();
+    const P = o.width, I = o.height, _ = {
+      top: c - s - this.VIEWPORT_PADDING,
+      bottom: m - d - s - this.VIEWPORT_PADDING,
+      left: f - s - this.VIEWPORT_PADDING,
+      right: p - T - s - this.VIEWPORT_PADDING
+    }, ie = {
+      top: _.top >= I,
+      bottom: _.bottom >= I,
+      left: _.left >= P,
+      right: _.right >= P
+    };
+    n && (i === "left" ? i = "right" : i === "right" && (i = "left"));
+    let C = i;
+    if (!ie[i]) {
+      const nt = {
+        top: ["bottom", "right", "left"],
+        bottom: ["top", "right", "left"],
+        left: ["right", "top", "bottom"],
+        right: ["left", "top", "bottom"]
+      };
+      for (const De of nt[i])
+        if (ie[De]) {
+          C = De;
+          break;
+        }
+    }
+    const O = f + h + (L - P) / 2, Oe = c + l + ($ - I) / 2;
+    let D = 0, M = 0;
+    switch (C) {
+      case "top":
+        D = c + l - I - s, M = O;
+        break;
+      case "bottom":
+        D = d + l + s, M = O;
+        break;
+      case "left":
+        D = Oe, M = f + h - P - s;
+        break;
+      case "right":
+        D = Oe, M = T + h + s;
+        break;
+    }
+    D = Math.max(
+      l + this.VIEWPORT_PADDING,
+      Math.min(D, l + m - I - this.VIEWPORT_PADDING)
+    ), M = Math.max(
+      h + this.VIEWPORT_PADDING,
+      Math.min(M, h + p - P - this.VIEWPORT_PADDING)
+    );
+    const st = Math.max(
+      10,
+      Math.min(L / 2 + (f - M), P - 10)
+    ), rt = Math.max(
+      10,
+      Math.min($ / 2 + (c - D), I - 10)
+    );
+    return t.style.setProperty("--arrow-offset-x", `${st}px`), t.style.setProperty("--arrow-offset-y", `${rt}px`), t.setAttribute("data-position", C), t.setAttribute("dir", n ? "rtl" : "ltr"), { top: D, left: M, actualPosition: C };
+  }
+};
+/** Default pixel offset between trigger and tooltip */
+u(J, "DEFAULT_OFFSET", g.DEFAULT.DEFAULT_OFFSET), /** Minimal padding from viewport edges (in px). */
+u(J, "VIEWPORT_PADDING", g.DEFAULT.VIEWPORT_PADDING);
+let xe = J;
+const y = class y {
+  constructor(e, t, i) {
+    u(this, "element");
+    u(this, "contentManager");
+    u(this, "tooltipEl", null);
+    u(this, "options", {});
+    u(this, "id");
+    u(this, "listeners", /* @__PURE__ */ new Map());
+    u(this, "outsideClickListener", null);
+    u(this, "showTimeout", null);
+    u(this, "rtl");
+    u(this, "handleTooltipShow", () => this.show());
+    u(this, "handleTooltipHide", () => this.hide());
+    u(this, "handleTooltipToggle", () => this.tooltipEl ? this.hide() : this.show());
+    u(this, "handleMouseEnter", () => {
+      y.tourActive || this.show();
+    });
+    u(this, "handleMouseLeave", () => this.hide());
+    u(this, "handleClick", () => {
+      y.tourActive || (this.tooltipEl ? this.hide() : this.show());
+    });
+    this.element = e, this.rtl = this.detectRTL(), this.contentManager = new we(t), this.id = (i == null ? void 0 : i.id) ?? this.generateId(), i && (this.options = i), N.ensureFocusable(this.element, this.options), j.setupMobileSupport(this, this.element, this.options), this.setupListeners();
+  }
+  async createElement() {
+    const e = document.createElement("div");
+    e.id = this.id, e.classList.add(g.CSS_CLASSES.BASE), e.classList.add(
+      this.options.theme || g.DEFAULT.THEME
+    ), this.rtl && (e.setAttribute("dir", "rtl"), e.classList.add(g.CSS_CLASSES.RTL));
+    const t = document.createElement("div");
+    t.classList.add(g.CSS_CLASSES.WRAPPER), this.options.isTour && t.classList.add(g.CSS_CLASSES.HINTORIUM_TOUR);
+    const i = await this.contentManager.render();
+    return typeof i == "string" ? t.innerHTML = i : t.appendChild(i), e.appendChild(t), e.setAttribute("data-position", this.options.position || "top"), e;
+  }
+  generateId() {
+    return `${g.DEFAULT.ID_PREFIX}${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+  }
+  setupAccessibility() {
+    this.tooltipEl && N.setupTooltipAccessibility(
+      this.tooltipEl,
+      this.element,
+      this.options
+    );
+  }
+  setupListeners() {
+    const e = {
+      mouseenter: this.handleMouseEnter,
+      mouseleave: this.options.sticky ? () => {
+      } : this.handleMouseLeave,
+      // 👈 ignore mouseleave if sticky
+      focus: this.handleMouseEnter,
+      blur: this.options.sticky ? () => {
+      } : this.handleMouseLeave,
+      "tooltip:show": this.handleTooltipShow,
+      "tooltip:hide": this.handleTooltipHide,
+      "tooltip:toggle": this.handleTooltipToggle
+    };
+    this.options.sticky && (this.element.addEventListener("click", this.handleClick), this.listeners.set("click", this.handleClick)), Object.entries(e).forEach(([t, i]) => {
+      this.element.addEventListener(t, i), this.listeners.set(t, i);
+    });
+  }
+  removeListeners() {
+    this.listeners.forEach((e, t) => {
+      this.element.removeEventListener(t, e);
+    }), this.listeners.clear();
+  }
+  async show() {
+    if (y.activeTooltip && y.activeTooltip !== this && await y.activeTooltip.hide(), y.activeTooltip = this, this.tooltipEl) return;
+    const e = this.options.delay ?? 0;
+    if (e > 0)
+      return new Promise((t) => {
+        this.showTimeout = window.setTimeout(async () => {
+          this.showTimeout = null, await this.showTooltip(), t();
+        }, e);
+      });
+    await this.showTooltip();
+  }
+  async showTooltip() {
+    var e, t, i;
+    this.tooltipEl = await this.createElement(), this.setupAccessibility(), this.options.onInjectContent && this.options.onInjectContent(this.tooltipEl), document.body.appendChild(this.tooltipEl), xe.position(
+      this.element,
+      this.tooltipEl,
+      this.options.position,
+      this.rtl
+    ), K.increment(this.id), (t = (e = this.options).onShow) == null || t.call(e, this.id), (i = this.options.a11y) != null && i.announceOnShow && N.announceToScreenReader(
+      `Tooltip shown: ${this.element.textContent}`
+    ), this.options.sticky && this.addOutsideClickListener(), await ze.show(this.tooltipEl, this.options.animation);
+  }
+  addOutsideClickListener() {
+    this.outsideClickListener = (e) => {
+      var i;
+      const t = e.target;
+      (i = this.tooltipEl) != null && i.contains(t) || this.element.contains(t) || this.hide();
+    }, document.addEventListener("mousedown", this.outsideClickListener), document.addEventListener("touchstart", this.outsideClickListener);
+  }
+  async hide() {
+    var e, t;
+    if (this.showTimeout) {
+      clearTimeout(this.showTimeout), this.showTimeout = null;
+      return;
+    }
+    if (this.tooltipEl)
+      try {
+        await ze.hide(this.tooltipEl), (t = (e = this.tooltipEl) == null ? void 0 : e.parentNode) == null || t.removeChild(this.tooltipEl);
+      } catch (i) {
+        console.warn("[Hintorium Tooltip] Error hiding tooltip:", i);
+      } finally {
+        this.tooltipEl = null, y.activeTooltip === this && (y.activeTooltip = null);
+      }
+  }
+  /**
+   * Detect if RTL is enabled.
+   */
+  detectRTL() {
+    var i;
+    if (this.options.rtl) return this.options.rtl;
+    const e = this.element.dir || document.documentElement.dir || document.body.dir;
+    if (e) return e.toLowerCase() === "rtl";
+    const t = ((i = document.documentElement.lang) == null ? void 0 : i.toLowerCase()) ?? "";
+    return ["ar", "he", "fa", "ur"].some((s) => t.startsWith(s));
+  }
+  isRTL() {
+    return this.rtl;
+  }
+  destroy() {
+    this.hide(), this.tooltipEl && N.removeTooltipAccessibility(
+      this.tooltipEl,
+      this.element
+    ), this.removeListeners();
+  }
+};
+u(y, "activeTooltip", null), u(y, "tourActive", !1);
+let U = y;
+class W {
+  /**
+   * Checks if the provided NodeList contains at least one valid tooltip element.
+   * @param elements - List of elements to validate.
+   * @returns True if at least one element exists, false otherwise.
+   */
+  static isValidTooltipElements(e) {
+    const t = e.length > 0;
+    return t || console.warn(
+      `⚠️ No valid tooltip elements found. Please ensure elements have the correct data attribute to initialize tooltip - (${g.ATTRIBUTES.TOOLTIP}).`
+    ), t;
+  }
+  /**
+   * Validates that the element has tooltip content.
+   * @param element - The HTML element to check.
+   * @returns True if the element has non-empty tooltip content, false otherwise.
+   */
+  static hasValidTooltipContent(e, t) {
+    const i = !!t && t.trim().length > 0;
+    return i || console.warn(
+      "⚠️ Tooltip element missing content: ",
+      e,
+      `Please provide a non-empty ${g.ATTRIBUTES.TOOLTIP} attribute.`
+    ), i;
+  }
+  /**
+   * Validates whether the provided animation string is a supported tooltip animation.
+   *
+   * Logs a console warning if the animation is invalid or unsupported.
+   *
+   * @param theme - The raw animation string to validate.
+   * @param element - The HTML element associated with the tooltip, used for contextual logging.
+   * @returns {theme is TooltipAnimation} `true` if the animation is valid, otherwise `false`.
+   */
+  static validateAnimation(e, t) {
+    const i = [
+      "fade",
+      "slide",
+      "zoom",
+      "bounce"
+    ], s = i.includes(e);
+    return s || console.warn(
+      `⚠️ Invalid tooltip animation: "${e}" for element`,
+      t,
+      `
+ Valid animations are: ${i.join(", ")}.`
+    ), s;
+  }
+  /**
+   * Validates the delay value for a tooltip.
+   * Ensures that the provided value is a finite number and non-negative.
+   *
+   * Logs a console warning if the value is invalid.
+   *
+   * @param delay - The raw delay value (string from data attribute or number from options).
+   * @param element - The HTML element associated with the tooltip, used for logging.
+   * @returns A valid number delay (>= 0). Falls back to 0 if invalid.
+   */
+  static validateDelay(e, t) {
+    if (e == null) return 0;
+    const i = typeof e == "number" ? e : Number(e);
+    return Number.isNaN(i) || i < 0 ? (console.warn(
+      `⚠️ Invalid tooltip delay "${e}" on element`,
+      t,
+      `
+Delay must be a non-negative number in milliseconds. Falling back to 0.`
+    ), 0) : i;
+  }
+  /**
+   * Validates whether the provided theme string is a supported tooltip theme.
+   *
+   * Logs a console warning if the theme is invalid or unsupported.
+   *
+   * @param theme - The raw theme string to validate (e.g. "light", "dark").
+   * @param element - The HTML element associated with the tooltip, used for contextual logging.
+   * @returns {theme is TooltipTheme} `true` if the theme is valid, otherwise `false`.
+   */
+  static validateTheme(e, t) {
+    const i = [
+      "light",
+      "dark",
+      "glass",
+      "pastel",
+      "neon",
+      "gradient"
+    ], s = i.includes(e);
+    return s || console.warn(
+      `⚠️ Invalid tooltip theme: "${e}" for element`,
+      t,
+      `
+ Valid themes are: ${i.join(", ")}.`
+    ), s;
+  }
+  /**
+   * Checks if a given position string is a valid TooltipPosition.
+   * Logs a warning if invalid.
+   *
+   * @param position - Raw position string to validate.
+   * @returns True if position is valid, false otherwise.
+   */
+  static validatePosition(e, t) {
+    if (!e) return !1;
+    const i = Me.includes(
+      e
+    );
+    return i || console.warn(
+      `Invalid tooltip position : ${e} for element`,
+      t,
+      `
+ Valid positions are : ${Me.join(", ")}`
+    ), i;
+  }
+  /**
+   * Returns a valid tooltip position, falling back to default if invalid.
+   *
+   * @param raw - Raw position string.
+   * @param element - The HTML element to check.
+   * @param defaultPosition - Default position to use if raw is invalid.
+   * @returns Valid TooltipPosition.
+   */
+  static getValidPosition(e, t, i = "top") {
+    return e && this.validatePosition(e, t) ? e : i;
+  }
+  /**
+   * Returns a valid tooltip theme, falling back to default if invalid.
+   *
+   * @param raw - Raw theme string.
+   * @param element - The HTML element to check.
+   * @param defaultPosition - Default theme to use if raw is invalid.
+   * @returns Valid TooltipTheme.
+   */
+  static getValidTheme(e, t, i = "dark") {
+    return e && this.validateTheme(e, t) ? e : i;
+  }
+  /**
+   * Returns a valid tooltip animation, falling back to default if invalid.
+   *
+   * @param raw - Raw animation string.
+   * @param element - The HTML element to check.
+   * @param defaultAnimation - Default animation to use if raw is invalid.
+   * @returns Valid TooltipAnimation.
+   */
+  static getValidAnimation(e, t, i = "fade") {
+    return e && this.validateAnimation(e, t) ? e : i;
+  }
+}
+const F = class F {
+  constructor(e) {
+    u(this, "options", {});
+    u(this, "tooltips", /* @__PURE__ */ new Map());
+    u(this, "isInitialized", !1);
+    this.options = {
+      ...e
+    };
+  }
+  /**
+   * Returns the single instance of TooltipManager (Singleton pattern).
+   */
+  static getInstance() {
+    return F.instance || (F.instance = new F()), F.instance;
+  }
+  /**
+   * Initializes all tooltips found in the DOM that contain the tooltip attribute.
+   * Also sets up global listeners for touch devices and initializes accessibility support.
+   */
+  init() {
+    return this.isInitialized ? this : (this.isInitialized = !0, N.init(), this.registerGlobalTouchListener(), this.initializeAllTooltips(), B.initFromDOM(), this);
+  }
+  /**
+   * Creates and registers a new tooltip instance for the given element.
+   *
+   * If a tooltip already exists for the same element, it will be removed
+   * and replaced with a new instance. This ensures that each element has
+   * at most one active tooltip at any given time.
+   *
+   * The provided options are merged with both global manager defaults
+   * and tooltip-level overrides to ensure consistent configuration.
+   *
+   * @param {HTMLElement} element - The target element to which the tooltip is bound.
+   * @param {string} content - The text or HTML content displayed inside the tooltip.
+   * @param {TooltipOptions} [options] - Optional configuration overrides for this tooltip.
+   * @returns {Tooltip} The newly created {@link Tooltip} instance.
+   *
+   * @example
+   * const manager = TooltipManager.getInstance();
+   * const button = document.querySelector('#save');
+   * manager.add(button, 'Click to save your progress', { position: 'bottom' });
+   */
+  add(e, t, i) {
+    this.tooltips.has(e) && this.remove(e);
+    const s = {
+      ...this.options,
+      ...i
+    }, n = new U(e, t, s);
+    return this.tooltips.set(e, n), n;
+  }
+  /**
+   * Removes and destroys an existing tooltip associated with a specific element.
+   *
+   * This method ensures full cleanup by calling the tooltip’s internal `destroy()`
+   * method, removing mobile-related listeners via {@link MobileManager.cleanup},
+   * and deleting the reference from the manager’s internal Map.
+   *
+   * @param {HTMLElement} element - The element whose tooltip should be removed.
+   *
+   * @example
+   * const button = document.querySelector('#save');
+   * tooltipManager.remove(button);
+   */
+  remove(e) {
+    if (!e) return;
+    const t = this.tooltips.get(e);
+    t && (t.destroy(), j.cleanup(e), this.tooltips.delete(e));
+  }
+  /**
+   * Extracts and normalizes tooltip configuration options from a given HTML element.
+   *
+   * This method reads tooltip-related attributes from the target element (such as
+   * position, theme, and animation), validates them using {@link TooltipValidator},
+   * and merges them with global and default configuration values.
+   *
+   * Additionally, mobile-specific behavior is automatically resolved via
+   * {@link MobileManager.resolveMobileOptions}, which determines whether mobile
+   * support should be enabled based on the current environment and user-provided options.
+   *
+   * The resulting configuration object ensures consistent, validated tooltip behavior
+   * across all initialization methods (attribute-based and programmatic).
+   *
+   * @private
+   * @param {HTMLElement} element - The target element containing tooltip attributes.
+   * @returns {TooltipOptions} A fully merged and validated tooltip configuration object.
+   *
+   * @example
+   * // Example element markup:
+   * // <button data-tooltip="Hello" data-tooltip-position="bottom" data-tooltip-theme="dark"></button>
+   *
+   * const options = tooltipManager['extractOptions'](buttonEl);
+   * // Returns something like:
+   * // {
+   * //   position: "bottom",
+   * //   theme: "dark",
+   * //   animation: "fade",
+   * //   mobile: { enabled: true, longPress: true, touchDelay: 300 },
+   * //   ...
+   * // }
+   */
+  extractOptions(e) {
+    const t = e.getAttribute(
+      g.ATTRIBUTES.TOOLTIP_POSITION
+    ), i = e.getAttribute(
+      g.ATTRIBUTES.TOOLTIP_THEME
+    ), s = e.getAttribute(
+      g.ATTRIBUTES.TOOLTIP_ANIMATION
+    ), n = e.getAttribute(
+      g.ATTRIBUTES.TOOLTIP_DELAY
+    );
+    return {
+      position: t ? W.getValidPosition(t, e) : this.options.position ?? g.DEFAULT.POSITION,
+      theme: i ? W.getValidTheme(i, e) : this.options.theme ?? g.DEFAULT.THEME,
+      animation: s ? W.getValidAnimation(s, e) : this.options.animation ?? g.DEFAULT.ANIMATION,
+      mobile: this.options.mobile !== void 0 ? j.resolveMobileOptions(this.options.mobile) : {},
+      delay: n ? W.validateDelay(n, e) : this.options.delay ?? g.DEFAULT.DELAY
+    };
+  }
+  /**
+   * Initializes a single tooltip element from the DOM.
+   */
+  initializeTooltip(e) {
+    const t = e.getAttribute(g.ATTRIBUTES.TOOLTIP);
+    if (!W.hasValidTooltipContent(e, t)) return;
+    const i = this.extractOptions(e);
+    this.add(e, t, i);
+  }
+  /**
+   * Initializes tooltips for all DOM elements that contain the tooltip attribute.
+   */
+  initializeAllTooltips() {
+    const e = document.querySelectorAll(
+      `[${g.ATTRIBUTES.TOOLTIP}]`
+    );
+    W.isValidTooltipElements(e) && e.forEach((t) => {
+      this.initializeTooltip(t);
+    });
+  }
+  /**
+   * Registers a global event listener that hides mobile tooltips when tapping outside.
+   */
+  registerGlobalTouchListener() {
+    document.addEventListener("touchstart", (e) => {
+      e.target instanceof HTMLElement && (Array.from(this.tooltips.values()).map(
+        (t) => t.element
+      ).includes(e.target) || j.hideMobileTooltips());
+    });
+  }
+};
+u(F, "instance");
+let ee = F;
+function jt(r) {
+  return console.info("🎨 Hintorium Tooltip Library Loaded!"), new ee(r).init();
+}
+const Zt = JSON.parse(
+  JSON.stringify({
+    hintorium: {
+      tour: {
+        next: "Next →",
+        done: "Done",
+        prev: "← Back"
+      }
+    }
+  })
+), Yt = JSON.parse(
+  JSON.stringify({
+    hintorium: {
+      tour: {
+        next: "Następny →",
+        done: "Gotowe",
+        prev: "← Wstecz"
+      }
+    }
+  })
+);
+class Xt {
+  constructor({ steps: e, localStorageKey: t, auto: i }) {
+    u(this, "steps", []);
+    u(this, "current", 0);
+    u(this, "activeTooltip", null);
+    u(this, "storage", null);
+    u(this, "completedTour", !1);
+    /**
+     * Tour state keys (localStorage)
+     */
+    u(this, "tourProgress", "hintorium_tour_progress");
+    u(this, "tourCompleted", "hintorium_tour_completed");
+    u(this, "tourStorageKey");
+    /**
+     * Auto play
+     */
+    u(this, "autoPlay", !1);
+    u(this, "autoPlayDelay", 3e3);
+    // default 3s
+    u(this, "autoPlayTimeout", null);
+    u(this, "progressBar");
+    u(this, "autoPlayStartTime", 0);
+    u(this, "autoPlayAnimationFrame", null);
+    this.steps = e, t && (this.storage = oe.getInstance(t), this.tourStorageKey = t), i != null && i.enabled && (this.autoPlay = !0), i != null && i.delay && (this.autoPlayDelay = i.delay), this.registerDefaultTranslations(), this.initializeState();
+  }
+  registerDefaultTranslations() {
+    S.setTranslations("en", Zt), S.setTranslations("pl", Yt);
+  }
+  initializeState() {
+    if (!this.storage || !this.tourStorageKey) return;
+    if (this.storage.get(
+      `${this.tourStorageKey}-${this.tourCompleted}`,
+      !1
+    )) {
+      this.completedTour = !0;
+      return;
+    }
+    const e = this.storage.get(
+      `${this.tourStorageKey}-${this.tourProgress}`,
+      0
+    );
+    e && (this.current = e);
+  }
+  start() {
+    this.steps.length && (this.completedTour || (U.tourActive = !0, this.showStep(this.current)));
+  }
+  startProgressBarAnimation() {
+    if (!this.progressBar || !this.autoPlay) return;
+    this.autoPlayStartTime = Date.now();
+    const e = () => {
+      const t = Date.now() - this.autoPlayStartTime, i = Math.min(t / this.autoPlayDelay, 1);
+      this.progressBar.style.width = `${i * 100}%`, i < 1 ? this.autoPlayAnimationFrame = requestAnimationFrame(e) : (this.autoPlayAnimationFrame = null, this.current === this.steps.length - 1 ? this.finish() : this.next());
+    };
+    this.autoPlayAnimationFrame && cancelAnimationFrame(this.autoPlayAnimationFrame), this.autoPlayAnimationFrame = requestAnimationFrame(e);
+  }
+  async showStep(e) {
+    if (e < 0 || e >= this.steps.length) return;
+    this.activeTooltip && (this.activeTooltip.hide(), this.activeTooltip = null);
+    const t = this.steps[e], i = document.querySelector(t.target);
+    if (!i) return;
+    const s = new U(i, t.content, {
+      ...t.options,
+      sticky: !0,
+      isTour: !0,
+      onInjectContent: (n) => {
+        this.createNavigation(n), this.createProgressBar(n);
+      }
+    });
+    this.activeTooltip = s, await s.show(), this.autoPlay && (this.clearAutoPlay(), this.startProgressBarAnimation());
+  }
+  clearAutoPlay() {
+    this.autoPlayTimeout && (clearTimeout(this.autoPlayTimeout), this.autoPlayTimeout = null), this.autoPlayAnimationFrame && (cancelAnimationFrame(this.autoPlayAnimationFrame), this.autoPlayAnimationFrame = null);
+  }
+  createProgressBar(e) {
+    const t = document.createElement("div");
+    t.className = "hintorium-tour-progress-bar-wrapper";
+    const i = e.querySelector(
+      `.${g.CSS_CLASSES.WRAPPER}`
+    );
+    if (!i) return;
+    const s = document.createElement("div");
+    s.className = "hintorium-tour-progress-bar-fill", t.appendChild(s), i.appendChild(t), this.progressBar = s, this.autoPlay && this.startProgressBarAnimation();
+  }
+  createNavigation(e) {
+    const t = document.createElement("div");
+    t.className = "hintorium-tour-nav";
+    const i = e.querySelector(
+      `.${g.CSS_CLASSES.WRAPPER}`
+    );
+    if (!i) return;
+    const s = this.current === 0, n = this.current === this.steps.length - 1;
+    t.innerHTML = `
+    <div class="hintorium-tour-progress">
+      <span class="hintorium-tour-step">${this.current + 1}</span>
+      <span class="hintorium-tour-separator">/</span>
+      <span class="hintorium-tour-total">${this.steps.length}</span>
+    </div>
+    <div class="hintorium-tour-buttons">
+      <button class= "hintorium-tour-btn hintorium-tour-prev" ${s ? "disabled" : ""}>
+        ${S.t("hintorium.tour.prev")}
+      </button>
+      ${n ? `<button class="hintorium-tour-btn hintorium-tour-done">${S.t(
+      "hintorium.tour.done"
+    )}</button>` : `<button class="hintorium-tour-btn hintorium-tour-next">${S.t(
+      "hintorium.tour.next"
+    )}</button>`}
+    </div>
+  `;
+    const a = t.querySelector(
+      ".hintorium-tour-prev"
+    ), o = t.querySelector(
+      ".hintorium-tour-next"
+    ), h = t.querySelector(
+      ".hintorium-tour-done"
+    );
+    a == null || a.addEventListener("click", this.prev.bind(this)), o == null || o.addEventListener("click", this.next.bind(this)), h == null || h.addEventListener("click", this.finish.bind(this)), i.appendChild(t);
+  }
+  prev() {
+    this.current > 0 && (this.clearAutoPlay(), this.current--, this.showStep(this.current), this.saveProgress());
+  }
+  next() {
+    this.current < this.steps.length - 1 && (this.clearAutoPlay(), this.current++, this.showStep(this.current), this.saveProgress());
+  }
+  finish() {
+    this.clearAutoPlay(), this.activeTooltip && (this.activeTooltip.hide(), this.activeTooltip.destroy(), this.activeTooltip = null), this.current = 0, this.markCompleted();
+  }
+  saveProgress() {
+    this.storage && this.storage.set(
+      `${this.tourStorageKey}-${this.tourProgress}`,
+      this.current
+    );
+  }
+  markCompleted() {
+    !this.storage || !this.tourStorageKey || (this.storage.set(`${this.tourStorageKey}-${this.tourCompleted}`, !0), this.storage.remove(`${this.tourStorageKey}-${this.tourProgress}`));
+  }
+  resetProgress() {
+    !this.storage || !this.tourStorageKey || (this.current = 0, this.storage.remove(`${this.tourStorageKey}-${this.tourProgress}`), this.storage.remove(`${this.tourStorageKey}-${this.tourCompleted}`));
+  }
+}
+const tt = lt(null);
+function Ce() {
+  return ct(tt);
+}
+function Qt(r) {
+  const e = R(null), t = R(!1);
+  return z(() => {
+    if (!t.current) {
+      try {
+        e.current = jt(r), t.current = !0;
+      } catch (i) {
+        console.error(
+          "[hintorium-react] Failed to initialize TooltipManager:",
+          i
+        );
+      }
+      return () => {
+        t.current = !1, e.current = null;
+      };
+    }
+  }, []), e.current;
+}
+function ri({
+  children: r,
+  options: e = {},
+  initManager: t = !0
+}) {
+  return t && Qt(e), /* @__PURE__ */ ye(tt.Provider, { value: { options: e }, children: r });
+}
+function it(r) {
+  return w(
+    (e) => (t) => {
+      e == null || e(t), r != null && r.id && K.increment(r.id);
+    },
+    [r == null ? void 0 : r.id]
+  );
+}
+function Jt(r, e) {
+  const t = Ce(), i = R(null), s = R(null), n = it(e), a = w(() => {
+    i.current && (i.current.destroy(), i.current = null);
+  }, []), o = w(
+    (h) => {
+      if (a(), !h || e != null && e.disabled) {
+        s.current = null;
+        return;
+      }
+      s.current = h;
+      const l = {
+        ...t == null ? void 0 : t.options,
+        ...e,
+        onShow: n(e == null ? void 0 : e.onShow)
+      };
+      try {
+        i.current = new U(h, r, l);
+      } catch (p) {
+        throw p;
+      }
+    },
+    [r, e, t, a]
+  );
+  return z(() => a, [a]), o;
+}
+function ni(r, e) {
+  const t = Ce(), i = R(null), s = R(null), n = it(e), a = w(() => {
+    i.current && (i.current.destroy(), i.current = null);
+  }, []), o = w(
+    (h) => {
+      if (a(), !h || e != null && e.disabled) {
+        s.current = null;
+        return;
+      }
+      s.current = h;
+      const l = {
+        ...t == null ? void 0 : t.options,
+        ...e,
+        onShow: n(e == null ? void 0 : e.onShow)
+      };
+      try {
+        i.current = new U(h, r, l);
+      } catch (p) {
+        throw p;
+      }
+    },
+    [r, e, t, a]
+  );
+  return z(() => a, [a]), {
+    ref: o,
+    tooltip: i.current
+  };
+}
+function oi({
+  content: r,
+  children: e,
+  className: t,
+  disabled: i,
+  ...s
+}) {
+  const n = typeof r == "string" ? r : String(r), a = Jt(n, { ...s, disabled: i });
+  if (!ht(e))
+    return console.error(
+      "[hintorium-react] Tooltip children must be a valid React element"
+    ), /* @__PURE__ */ ye(qe, { children: e });
+  const o = e;
+  return ut(o, {
+    ref: a,
+    className: t ? `${o.props.className || ""} ${t}`.trim() : o.props.className
+  });
+}
+function ei(r) {
+  const e = Ce(), t = R(null), [i, s] = ne(0), [n, a] = ne(!1);
+  z(() => {
+    if (r.length === 0) return;
+    const c = r.map((f) => ({
+      target: typeof f.element == "string" ? f.element : "",
+      content: typeof f.content == "string" ? f.content : String(f.content),
+      options: {
+        ...e == null ? void 0 : e.options,
+        ...f.options,
+        isTour: !0
+      }
+    }));
+    try {
+      t.current = new Xt({
+        steps: c
+      });
+    } catch (f) {
+      console.error("[hintorium-react] Failed to create tour:", f);
+    }
+    return () => {
+      t.current && (t.current.finish(), t.current = null);
+    };
+  }, [r, e]);
+  const o = w(() => {
+    if (t.current)
+      try {
+        t.current.start(), a(!0), s(0);
+      } catch (c) {
+        console.error("[hintorium-react] Failed to start tour:", c);
+      }
+  }, []), h = w(() => {
+    if (t.current)
+      try {
+        t.current.finish(), a(!1), s(0);
+      } catch (c) {
+        console.error("[hintorium-react] Failed to stop tour:", c);
+      }
+  }, []), l = w(() => {
+    if (!(!t.current || !n))
+      try {
+        t.current.next(), s((c) => Math.min(c + 1, r.length - 1));
+      } catch (c) {
+        console.error("[hintorium-react] Failed to go to next step:", c);
+      }
+  }, [n, r.length]), p = w(() => {
+    if (!(!t.current || !n))
+      try {
+        t.current.prev(), s((c) => Math.max(c - 1, 0));
+      } catch (c) {
+        console.error("[hintorium-react] Failed to go to previous step:", c);
+      }
+  }, [n]), m = w(
+    (c) => {
+      if (!t.current || !n || c < 0 || c >= r.length) return;
+      const f = c - i;
+      if (f > 0)
+        for (let d = 0; d < f; d++)
+          t.current.next();
+      else if (f < 0)
+        for (let d = 0; d < Math.abs(f); d++)
+          t.current.prev();
+      s(c);
+    },
+    [n, i, r.length]
+  );
+  return {
+    start: o,
+    stop: h,
+    next: l,
+    prev: p,
+    goTo: m,
+    currentStep: i,
+    isActive: n
+  };
+}
+function ai({ steps: r, children: e }) {
+  const t = ei(r);
+  return /* @__PURE__ */ ye(qe, { children: e(t) });
+}
+function li() {
+  const [r, e] = ne(S.getLanguage());
+  return z(() => {
+    S.detectLanguage(), e(S.getLanguage());
+  }, []), {
+    language: r,
+    setLanguage: (s) => {
+      S.setLanguage(s), e(s);
+    },
+    t: (s, n) => S.t(s, n),
+    supportedLanguages: S.getSupportedLanguages()
+  };
+}
+function ci() {
+  const [r, e] = ne({}), t = w(() => {
+    e(K.getAll());
+  }, []);
+  z(() => {
+    t();
+  }, [t]);
+  const i = w(
+    (a) => {
+      K.increment(a), t();
+    },
+    [t]
+  ), s = w((a) => K.getCount(a), []), n = w(() => {
+    K.resetAll(), t();
+  }, [t]);
+  return {
+    data: r,
+    getCount: s,
+    increment: i,
+    resetAll: n,
+    refresh: t
+  };
+}
+function hi(r) {
+  const e = R(null), t = w(() => {
+    e.current && (e.current.destroy(), e.current = null);
+  }, []), i = w(
+    (s) => {
+      if (t(), !!s)
+        try {
+          e.current = new B(s, r);
+        } catch (n) {
+          console.error("[hintorium-react] Failed to create inline hint:", n);
+        }
+    },
+    [r, t]
+  );
+  return z(() => t, [t]), i;
+}
+function ui() {
+  const r = R(!1);
+  z(() => {
+    if (!r.current)
+      try {
+        B.initFromDOM(), r.current = !0;
+      } catch (e) {
+        console.error("[hintorium-react] Failed to initialize inline hints:", e);
+      }
+  }, []);
+}
+export {
+  K as Analytics,
+  S as I18n,
+  oi as Tooltip,
+  ri as TooltipProvider,
+  ai as Tour,
+  ci as useAnalytics,
+  li as useHintoriumI18n,
+  hi as useInlineHint,
+  ui as useInlineHintManager,
+  Jt as useTooltip,
+  it as useTooltipAnalytics,
+  Ce as useTooltipContext,
+  ni as useTooltipInstance,
+  Qt as useTooltipManager,
+  ei as useTour
+};
+//# sourceMappingURL=index.js.map