@markput/react 0.1.0

package/index.js

@@ -0,0 +1,1755 @@
+import "./index.css";
+import { jsx as m, Fragment as oe, jsxs as ie } from "react/jsx-runtime";
+import ae, { createContext as ce, useContext as N, useEffect as x, useState as A, useRef as I, memo as W, useCallback as R, useImperativeHandle as le, useMemo as ue, forwardRef as de } from "react";
+function he(t) {
+  return t ? Object.fromEntries(
+    Object.entries(t).map(([e, n]) => e.startsWith("data") && e.length > 4 && e[4] === e[4].toUpperCase() ? [`data-${e.slice(4).replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase()}`, n] : [e, n])
+  ) : {};
+}
+const fe = {
+  container: "div",
+  span: "span"
+};
+function Z(t, e) {
+  return e.props.slots?.[t] ? e.props.slots[t] : fe[t];
+}
+function J(t, e) {
+  const n = e.props.slotProps?.[t];
+  return n ? he(n) : void 0;
+}
+function ge(...t) {
+  return t.filter(Boolean).join(" ") || void 0;
+}
+function pe(...t) {
+  const e = t.reduce((n, s) => (s && Object.assign(n, s), n), {});
+  return Object.keys(e).length > 0 ? e : void 0;
+}
+function Q(t) {
+  if (t == null) throw new Error("Value must be a non nullable!");
+}
+var k = /* @__PURE__ */ ((t) => (t.UP = "ArrowUp", t.DOWN = "ArrowDown", t.LEFT = "ArrowLeft", t.RIGHT = "ArrowRight", t.END = "End", t.HOME = "Home", t.PAGE_DOWN = "PageDown", t.PAGE_UP = "PageUp", t.ENTER = "Enter", t.TAB = "Tab", t.SPACE = " ", t.BACKSPACE = "Backspace", t.DELETE = "Delete", t.COMMA = ",", t.ESC = "Escape", t))(k || {});
+const me = "@", ve = "@[__value__](__meta__)", y = {
+  Value: "__value__",
+  Meta: "__meta__",
+  Nested: "__nested__"
+}, w = {
+  Value: "value",
+  Meta: "meta",
+  Nested: "nested"
+};
+function xe(t, e) {
+  const { segments: n, gapTypes: s, counts: r, valueGapIndices: o } = ye(t);
+  ke(r, t);
+  const i = r.value === 2, { segments: a, gapTypes: c } = i ? Se(n, s, o) : { segments: n, gapTypes: s };
+  return {
+    markup: t,
+    index: e,
+    segments: a,
+    gapTypes: c,
+    hasNested: r.nested === 1,
+    hasTwoValues: i,
+    segmentGlobalIndices: Array.from({ length: a.length })
+    // Will be populated by MarkupRegistry
+  };
+}
+function ye(t) {
+  const e = [], n = [], s = [], r = {
+    value: 0,
+    meta: 0,
+    nested: 0
+  }, o = [], i = [w.Value, w.Meta, w.Nested];
+  for (const l of i) {
+    const h = j[l];
+    let u = t.indexOf(h);
+    for (; u !== -1; )
+      o.push({ type: l, position: u }), u = t.indexOf(h, u + h.length);
+  }
+  o.sort((l, h) => l.position - h.position);
+  let a = 0;
+  for (const l of o) {
+    const h = t.substring(a, l.position);
+    h.length > 0 && e.push(h), n.push(l.type), r[l.type]++, l.type === w.Value && s.push(n.length - 1), a = l.position + j[l.type].length;
+  }
+  const c = t.substring(a);
+  return c.length > 0 && e.push(c), {
+    segments: e,
+    gapTypes: n,
+    counts: r,
+    valueGapIndices: s
+  };
+}
+function ke(t, e) {
+  const n = [
+    { count: t.value, max: 2, name: y.Value },
+    { count: t.meta, max: 1, name: y.Meta },
+    { count: t.nested, max: 1, name: y.Nested }
+  ];
+  for (const { count: s, max: r, name: o } of n)
+    if (s > r)
+      throw new Error(`Invalid markup: "${e}". Max ${r} "${o}" placeholders, got ${s}`);
+  if (t.value === 0 && t.nested === 0)
+    throw new Error(
+      `Invalid markup: "${e}". Need at least one "${y.Value}" or "${y.Nested}"`
+    );
+}
+const j = {
+  [w.Value]: y.Value,
+  [w.Meta]: y.Meta,
+  [w.Nested]: y.Nested
+};
+function Se(t, e, n) {
+  if (n.length !== 2)
+    return { segments: t, gapTypes: e };
+  const [s, r] = n, o = [], i = t[s], a = t[s + 1];
+  i && a && o.push(u(i, a, t[s + 2]));
+  for (let d = s + 2; d < r; d++)
+    o.push(t[d]);
+  const c = t[r], l = t[r + 1];
+  c && l && o.push(u(c, l, t[r + 2]));
+  const h = e.filter((d) => d !== w.Value);
+  return { segments: o, gapTypes: h };
+  function u(d, g, E) {
+    if (!E) return [d, g, ""];
+    const L = E.charAt(0), re = L && !g.includes(L) && !E.startsWith(d) ? L : "";
+    return [d, g, re];
+  }
+}
+class Ce {
+  markups;
+  descriptors;
+  /** Deduplicated list of unique segment definitions (static strings or dynamic patterns) */
+  segments = [];
+  /** Map from first segment index to descriptors that start with this segment (for O(1) lookup) */
+  firstSegmentIndexMap = /* @__PURE__ */ new Map();
+  constructor(e) {
+    this.markups = e;
+    const n = /* @__PURE__ */ new Map();
+    this.descriptors = e.map((s, r) => {
+      if (s === void 0)
+        return null;
+      const o = xe(s, r);
+      return o.segments.forEach((i, a) => {
+        this.processSegment(o, i, a, n);
+      }), this.addToFirstSegmentIndexMap(o), o;
+    }).filter((s) => s !== null);
+  }
+  /**
+   * Adds a descriptor to the firstSegmentIndexMap using its first segment's global index
+   */
+  addToFirstSegmentIndexMap(e) {
+    const n = e.segmentGlobalIndices[0];
+    if (n === void 0) return;
+    const s = this.firstSegmentIndexMap.get(n);
+    s ? s.push(e) : this.firstSegmentIndexMap.set(n, [e]);
+  }
+  processSegment(e, n, s, r) {
+    const o = this.getSegmentKey(n);
+    if (!o) return;
+    this.registerSegment(n, o, r);
+    const i = r.get(o);
+    if (e.segmentGlobalIndices[s] = i, typeof n != "string") {
+      const [a, c] = n;
+      a && this.registerSegment(a, a, r), c && this.registerSegment(c, c, r);
+    }
+  }
+  registerSegment(e, n, s) {
+    if (!s.has(n)) {
+      const r = this.segments.length;
+      this.segments.push(e), s.set(n, r);
+    }
+  }
+  /**
+   * Gets a unique key for a segment definition
+   * For static segments (strings), returns the string itself if non-empty
+   * For dynamic segments (arrays), returns before|after|exclusions if before or after is non-empty
+   * Returns empty string for segments that should be ignored
+   */
+  getSegmentKey(e) {
+    if (typeof e == "string")
+      return e;
+    const [n, s, r] = e;
+    return n || s ? `${n}|${s}|${r}` : "";
+  }
+}
+function K(t, e) {
+  if (!e)
+    return t;
+  let n = 5381;
+  for (let s = 0; s < e.length; s++)
+    n = n * 33 ^ e.charCodeAt(s);
+  return n = n >>> 0, t * 1e6 + (n & 1048575);
+}
+class we {
+  constructor(e, n) {
+    if (this.descriptor = e, this.expectedSegmentIndex = 1, this.start = n.start, this.end = n.end, e.segments.length === 1 && (this.expectedSegmentIndex = NaN, this.gaps.value = { start: this.start, end: this.end }), e.hasTwoValues && n.captured) {
+      this.captured = n.captured;
+      const s = n.start + n.value.indexOf(n.captured), r = s + n.captured.length;
+      this.gaps.value = { start: s, end: r };
+    }
+  }
+  gaps = {};
+  /** Captured value from first dynamic segment (for hasTwoValues patterns) */
+  captured;
+  /**
+   * Index of expected next segment:
+   * - >= 0: active, waiting for segment at this index
+   * - NaN: completed successfully
+   * - -1: invalid, should be discarded
+   */
+  expectedSegmentIndex;
+  start;
+  end;
+  /**
+   * Check if the match is invalid and should be discarded
+   */
+  get isInvalid() {
+    return this.expectedSegmentIndex === -1;
+  }
+  /**
+   * Check if the pattern is completed (computed property)
+   */
+  get isCompleted() {
+    return isNaN(this.expectedSegmentIndex);
+  }
+  /**
+   * Check if the match is waiting for the last segment (high priority)
+   */
+  get isAwaitingLastSegment() {
+    return this.expectedSegmentIndex === this.descriptor.segments.length - 1;
+  }
+  /**
+   * Get the next expected segment index
+   */
+  get nextSegment() {
+    if (this.isCompleted || this.isInvalid)
+      return;
+    const e = this.descriptor.segmentGlobalIndices[this.expectedSegmentIndex], n = this.descriptor.segments[this.expectedSegmentIndex];
+    if (typeof n == "object" && this.descriptor.hasTwoValues && this.captured && this.isAwaitingLastSegment) {
+      const [s, r] = n, o = s + this.captured + r;
+      return K(e, o);
+    }
+    return e;
+  }
+  /**
+   * Update state with new segment by setting gap positions
+   */
+  processNext(e) {
+    const n = this.end, s = e.start, r = this.descriptor.gapTypes[this.expectedSegmentIndex - 1];
+    if (s < n) {
+      this.expectedSegmentIndex = -1;
+      return;
+    }
+    this.gaps[r] = { start: n, end: s }, this.end = e.end, this.expectedSegmentIndex++, this.expectedSegmentIndex >= this.descriptor.segments.length && (this.expectedSegmentIndex = NaN);
+  }
+  /**
+   * Checks if this match conflicts with another match (overlaps and cannot nest properly)
+   */
+  conflictsWith(e) {
+    return !e || this.start >= e.end ? !1 : !e.descriptor.hasNested || e.gaps.nested === void 0 ? !0 : !(this.start >= e.gaps.nested.start && this.end <= e.gaps.nested.end);
+  }
+}
+class Te {
+  constructor(e) {
+    this.registry = e;
+  }
+  pendingStates = /* @__PURE__ */ new Map();
+  completingStates = /* @__PURE__ */ new Map();
+  completedStates = [];
+  /** Main method that converts found segments into structured matches */
+  process(e) {
+    this.pendingStates.clear(), this.completingStates.clear(), this.completedStates.length = 0;
+    for (const n of e)
+      this.processWaitingStates(n), this.tryStartNewStates(n);
+    return this.completedStates.map((n) => n.match);
+  }
+  /**
+   * Process states waiting for this segment
+   * Try states by priority until one is valid, keeping rejected states for later attempts
+   * Process completing states first (higher priority), then pending states
+   * Process only one state per call
+   */
+  processWaitingStates(e) {
+    const n = this.dequeueWaitingMatch(e);
+    if (n && (n.processNext(e), !n.isInvalid)) {
+      if (n.isCompleted) return this.addToCompleted(n);
+      this.addToWaiting(n);
+    }
+  }
+  tryStartNewStates(e) {
+    this.registry.firstSegmentIndexMap.get(e.index)?.forEach((n) => {
+      const s = new we(n, e);
+      if (!s.isInvalid) {
+        if (s.isCompleted) return this.addToCompleted(s);
+        this.addToWaiting(s);
+      }
+    });
+  }
+  /**
+   * Gets the next waiting match for the given segment
+   * Uses value-specific index for dynamic segments, base index for static segments
+   */
+  dequeueWaitingMatch(e) {
+    const n = e.captured ? K(e.index, e.value) : e.index, s = this.completingStates.get(n);
+    if (s?.length) return s.pop();
+    const r = this.pendingStates.get(n);
+    if (r?.length) return r.pop();
+  }
+  /**
+   * Adds a state to the waiting list for the next expected segment
+   */
+  addToWaiting(e) {
+    const n = e.nextSegment;
+    if (e.isAwaitingLastSegment) {
+      const s = this.completingStates.get(n) || [];
+      s.length === 0 && this.completingStates.set(n, s), s.push(e);
+    } else {
+      const s = this.pendingStates.get(n) || [];
+      s.length === 0 && this.pendingStates.set(n, s), s.push(e);
+    }
+  }
+  /**
+   * Add match to position-indexed array, replacing any existing match at the same position
+   * Uses binary search to find insertion point and maintains sorted order
+   * Relies on processing order to determine which match to keep
+   */
+  addToCompleted(e) {
+    const n = e.start;
+    let s = 0, r = this.completedStates.length;
+    for (; s < r; ) {
+      const o = Math.floor((s + r) / 2);
+      this.completedStates[o].position < n ? s = o + 1 : r = o;
+    }
+    s < this.completedStates.length && this.completedStates[s].position === n ? this.completedStates[s].match = e : this.completedStates.splice(s, 0, { position: n, match: e });
+  }
+}
+const b = (t) => t.replace(/[.*+?^${}()|[\]\\\\]/g, "\\$&");
+function Ee(t, e, n) {
+  const s = b(t), r = b(e), o = b(e + n);
+  return `${s}([^${o}]+?)${r}`;
+}
+class be {
+  staticRegex;
+  staticToIndex;
+  dynamicRegex;
+  dynamicEntries;
+  dynamicIndices;
+  constructor(e) {
+    this.initializeDual(e);
+  }
+  initializeDual(e) {
+    const n = [], s = [], r = /* @__PURE__ */ new Map();
+    if (e.forEach((o, i) => {
+      typeof o == "string" ? (n.push(o), r.set(o, i)) : s.push(o);
+    }), n.length > 0) {
+      const i = [...n].sort((a, c) => c.length - a.length).map(b);
+      this.staticRegex = new RegExp(`(?:${i.join("|")})`, "gu"), this.staticToIndex = r;
+    }
+    if (s.length > 0) {
+      const o = /* @__PURE__ */ new Set(), i = [];
+      s.forEach((a) => {
+        const c = e.indexOf(a);
+        if (typeof a == "string")
+          i.push({ index: c, pattern: b(a), definition: a });
+        else {
+          const [l, h, u] = a;
+          o.add(c);
+          const g = Ee(l, h, u).replace("(", `(?<content${c}>`);
+          i.push({ index: c, pattern: g, definition: a });
+        }
+      }), i.sort((a, c) => {
+        const l = typeof a.definition == "string" ? a.definition.length : a.pattern.length;
+        return (typeof c.definition == "string" ? c.definition.length : c.pattern.length) - l;
+      }), this.dynamicEntries = i, this.dynamicIndices = o, this.dynamicRegex = new RegExp(i.map((a, c) => `(?<seg${c}>${a.pattern})`).join("|"), "gu");
+    }
+  }
+  search(e) {
+    const n = [], s = [];
+    if (this.staticRegex && this.staticToIndex)
+      for (const o of e.matchAll(this.staticRegex)) {
+        const i = this.staticToIndex.get(o[0]);
+        i !== void 0 && n.push({
+          index: i,
+          start: o.index,
+          end: o.index + o[0].length,
+          value: o[0]
+        });
+      }
+    if (this.dynamicRegex && this.dynamicEntries && this.dynamicIndices)
+      for (const o of e.matchAll(this.dynamicRegex)) {
+        const i = o[0], a = o.index;
+        let c, l;
+        if (o.groups) {
+          for (let h = 0; h < this.dynamicEntries.length; h++)
+            if (o.groups[`seg${h}`] !== void 0) {
+              c = this.dynamicEntries[h].index, this.dynamicIndices.has(c) && (l = o.groups[`content${c}`]);
+              break;
+            }
+        }
+        c !== void 0 && s.push({
+          index: c,
+          start: a,
+          end: a + i.length,
+          value: i,
+          captured: l
+        });
+      }
+    const r = [...s];
+    for (const o of n)
+      s.some(
+        (a) => o.start < a.end && o.end > a.start
+      ) || r.push(o);
+    return r.sort((o, i) => o.start - i.start), r;
+  }
+}
+const Y = (t, e = 0, n = t.length) => ({
+  type: "text",
+  content: t.substring(e, n),
+  position: { start: e, end: n }
+});
+class Ie {
+  // Instance fields - only what's needed for single pass
+  input;
+  // ===== PUBLIC API =====
+  /**
+   * Builds nested token tree from pre-processed matches in a single pass
+   *
+   * Algorithm:
+   * 1. Iterate through matches in order
+   * 2. For each match:
+   *    - Close any parents whose content ends before this match
+   *    - Skip matches that conflict with the last accepted match
+   *    - Add text token before this match
+   *    - Create mark token and push to appropriate parent
+   *    - If match has nested content, push to active parents stack
+   * 3. After all matches, close remaining parents and add final text
+   *
+   * Complexity: O(M) where M is number of matches
+   * Memory: O(D) for active parents stack where D is nesting depth
+   */
+  build(e, n) {
+    return this.input = n, e.length === 0 ? [this.createTextToken(0, n.length)] : this.buildSinglePass(e);
+  }
+  // ===== SINGLE-PASS ALGORITHM =====
+  /**
+   * Builds token tree in a single pass through matches
+   *
+   * This is the core algorithm that processes matches sequentially,
+   * maintaining a stack of active parents and creating tokens directly.
+   */
+  buildSinglePass(e) {
+    const n = [], s = [];
+    let r = null, o = 0;
+    for (const i of e) {
+      if (r && i.conflictsWith(r))
+        continue;
+      for (r = i; s.length > 0; ) {
+        const l = s[s.length - 1], h = this.getContentBounds(l.match);
+        if (h.end <= i.start)
+          this.finalizeParent(l, h.end), s.pop(), s.length > 0 ? s[s.length - 1].token.children.push(l.token) : n.push(l.token);
+        else
+          break;
+      }
+      const a = s.length > 0 ? s[s.length - 1] : null;
+      if (a) {
+        const l = this.createTextToken(a.textPos, i.start);
+        a.token.children.push(l), a.textPos = i.end;
+      } else {
+        const l = this.createTextToken(o, i.start);
+        n.push(l), o = i.end;
+      }
+      const c = this.createMarkToken(i);
+      if (this.hasNestedContent(i)) {
+        const l = this.getContentBounds(i);
+        s.push({
+          match: i,
+          token: c,
+          textPos: l.start
+        });
+      } else
+        a ? a.token.children.push(c) : n.push(c);
+    }
+    for (; s.length > 0; ) {
+      const i = s.pop(), a = this.getContentBounds(i.match);
+      this.finalizeParent(i, a.end), s.length > 0 ? s[s.length - 1].token.children.push(i.token) : n.push(i.token);
+    }
+    return n.push(this.createTextToken(o, this.input.length)), n;
+  }
+  /**
+   * Finalizes a parent token by adding final text token if needed
+   */
+  finalizeParent(e, n) {
+    const s = this.createTextToken(e.textPos, n);
+    e.token.children.push(s), e.token.children.some((o) => o.type === "mark") || (e.token.children = []);
+  }
+  /**
+   * Creates a mark token from a match (without children - those are added later)
+   */
+  createMarkToken(e) {
+    const n = this.extractSubstring(e.gaps.value?.start, e.gaps.value?.end), s = this.extractSubstring(e.gaps.nested?.start, e.gaps.nested?.end), r = this.extractSubstring(e.gaps.meta?.start, e.gaps.meta?.end), o = s || void 0, i = e.gaps.meta !== void 0 ? r : void 0, a = n || o || "";
+    return {
+      type: "mark",
+      content: this.input.substring(e.start, e.end),
+      children: [],
+      // Will be populated if match has nested content
+      descriptor: e.descriptor,
+      value: a,
+      meta: i,
+      position: { start: e.start, end: e.end },
+      nested: this.createNestedInfo(e, o)
+    };
+  }
+  // ===== UTILITY METHODS =====
+  /**
+   * Gets the content boundaries for a match
+   * Priority: nested content if present, otherwise value content
+   */
+  getContentBounds(e) {
+    return e.gaps.nested ? e.gaps.nested : e.gaps.value ? e.gaps.value : {
+      start: e.start,
+      end: e.start
+    };
+  }
+  /**
+   * Checks if a match has nested content capability
+   */
+  hasNestedContent(e) {
+    return e.gaps.nested !== void 0;
+  }
+  /**
+   * Extracts substring safely, returns empty string if positions are undefined
+   */
+  extractSubstring(e, n) {
+    return e !== void 0 && n !== void 0 ? this.input.substring(e, n) : "";
+  }
+  /**
+   * Creates a text token for a range in the input
+   */
+  createTextToken(e, n) {
+    return Y(this.input, e, n);
+  }
+  /**
+   * Creates nested info object if nested content exists
+   */
+  createNestedInfo(e, n) {
+    if (!(!n || e.gaps.nested === void 0))
+      return {
+        content: n,
+        start: e.gaps.nested.start,
+        end: e.gaps.nested.end
+      };
+  }
+}
+function $(t, e) {
+  let n = t;
+  return e.value !== void 0 && (n = n.replaceAll(y.Value, e.value)), e.meta !== void 0 && (n = n.replaceAll(y.Meta, e.meta)), e.nested !== void 0 && (n = n.replaceAll(y.Nested, e.nested)), n;
+}
+function T(t) {
+  let e = "";
+  for (const n of t) {
+    if (n.type === "text") {
+      e += n.content;
+      continue;
+    }
+    const s = n.descriptor.markup, r = s.includes(y.Nested) ? n.children.length > 0 ? T(n.children) : n.nested?.content : void 0;
+    e += $(s, {
+      value: n.value,
+      meta: n.meta,
+      nested: r
+    });
+  }
+  return e;
+}
+function G(t, e) {
+  let n = "";
+  for (const s of t)
+    if (s.type === "text")
+      n += s.content;
+    else if (s.children.length > 0) {
+      const r = G(s.children, e), o = {
+        ...s,
+        value: r
+      };
+      n += e(o);
+    } else
+      n += e(s);
+  return n;
+}
+class O {
+  registry;
+  segmentMatcher;
+  patternMatcher;
+  treeBuilder;
+  /**
+   * Creates a new Parser instance with the specified markup patterns
+   *
+   * @param markups - Array of markup pattern strings with placeholders (can include undefined values):
+   *   - `__value__` - main content (plain text, no nesting)
+   *   - `__meta__` - metadata (plain text, no nesting)
+   *   - `__nested__` - content supporting nested structures
+   *   - `undefined` - skipped, but original array indices are preserved for descriptor matching
+   *
+   * @example
+   * ```typescript
+   * const parser = new Parser([
+   *   '@[__value__](__meta__)',  // @[label](value) - descriptor.index = 0
+   *   undefined,                 // skipped
+   *   '#[__nested__]',           // #[nested content] - descriptor.index = 2
+   *   '**__nested__**'           // **bold text** - descriptor.index = 3
+   * ])
+   * ```
+   */
+  constructor(e) {
+    this.registry = new Ce(e), this.segmentMatcher = new be(this.registry.segments), this.patternMatcher = new Te(this.registry), this.treeBuilder = new Ie();
+  }
+  /**
+   * Parses text into tokens (static convenience method)
+   *
+   * @param value - Text to parse
+   * @param options - Options with markup patterns
+   * @returns Array of tokens (TextToken and MarkToken)
+   *
+   * @example
+   * ```typescript
+   * const tokens = Parser.parse('Hello @[world]', {
+   *   markup: ['@[__value__]']
+   * })
+   * ```
+   */
+  static parse(e, n) {
+    const s = n?.markup;
+    return !s || s.length === 0 ? [Y(e)] : new O(s).parse(e);
+  }
+  /**
+   * Converts tokens back to text (static convenience method)
+   *
+   * @param tokens - Array of tokens to convert
+   * @returns Reconstructed text string
+   *
+   * @example
+   * ```typescript
+   * const text = Parser.stringify(tokens)
+   * ```
+   */
+  static stringify(e) {
+    return T(e);
+  }
+  /**
+   * Parses text into a nested token tree
+   *
+   * This is the main parsing method. It processes the input text through
+   * three stages:
+   * 1. Segment matching - finds all markup segments (O(N + M))
+   * 2. Pattern matching - builds complete patterns from segments (O(M))
+   * 3. Tree building - constructs nested token tree (O(M·D))
+   *
+   * @param value - Text to parse
+   * @returns Array of tokens representing the parsed structure
+   *
+   * @example
+   * ```typescript
+   * const parser = new Parser(['@[__value__](__meta__)'])
+   * const tokens = parser.parse('Hello @[world](test)')
+   * // Returns: [
+   * //   TextToken('Hello '),
+   * //   MarkToken('@[world](test)', value='world', meta='test'),
+   * //   TextToken('')
+   * // ]
+   * ```
+   */
+  parse(e) {
+    const n = this.segmentMatcher.search(e), s = this.patternMatcher.process(n);
+    return this.treeBuilder.build(s, e);
+  }
+  /**
+   * Converts tokens back to the original text
+   *
+   * This is the inverse operation of parse(). It reconstructs the original
+   * text from a token tree, preserving all markup and structure.
+   *
+   * @param tokens - Array of tokens to convert
+   * @returns Reconstructed text string
+   *
+   * @example
+   * ```typescript
+   * const text = 'Hello @[world](test)'
+   * const tokens = parser.parse(text)
+   * const reconstructed = parser.stringify(tokens)
+   * console.log(reconstructed === text) // true
+   * ```
+   */
+  stringify(e) {
+    return T(e);
+  }
+  /**
+   * Transforms annotated text by processing all mark tokens with a callback
+   *
+   * This method parses the text, recursively processes all MarkTokens
+   * (including nested ones) with the provided callback, and returns
+   * the transformed text.
+   *
+   * @param value - Annotated text to process
+   * @param callback - Function to transform each MarkToken
+   * @returns Transformed text
+   *
+   * @example
+   * ```typescript
+   * // Extract all values
+   * const text = '@[Hello](world) and #[tag]'
+   * const result = parser.transform(text, mark => mark.value)
+   * // Returns: 'Hello and tag'
+   *
+   * // Custom transformation
+   * const result = parser.transform(text, mark =>
+   *   mark.meta ? `${mark.value}:${mark.meta}` : mark.value
+   * )
+   * // Returns: 'Hello:world and tag'
+   * ```
+   */
+  transform(e, n) {
+    const s = this.parse(e);
+    return G(s, n);
+  }
+  /**
+   * Escapes markup segments in the given text using backslash
+   *
+   * This method uses the registry's unique segments and escapes them by adding
+   * a backslash before each character of each segment, preventing them from being
+   * parsed as markup when the text is processed again.
+   *
+   * @param text - Text to escape segments in
+   * @returns Text with escaped segments
+   *
+   * @example
+   * ```typescript
+   * const parser = new Parser(['**__nested__**', '@[__value__]'])
+   * const escaped = parser.escape('Hello **world** and @[user]')
+   * // Returns: 'Hello \*\*world\*\* and \@[user]'
+   * ```
+   */
+  escape(e) {
+    return this.registry.segments.filter((n) => typeof n == "string").sort((n, s) => s.length - n.length).reduce((n, s) => n.replaceAll(s, s.replace(/(.)/g, "\\$1")), e);
+  }
+  /**
+   * Unescapes markup patterns in the given text
+   *
+   * This method removes escape characters from segments that were previously
+   * escaped using escape(), allowing the patterns to be parsed normally.
+   *
+   * @param text - Text to unescape patterns in
+   * @returns Text with unescaped patterns
+   *
+   * @example
+   * ```typescript
+   * const parser = new Parser(['**__nested__**', '@[__value__]'])
+   * const unescaped = parser.unescape('Hello \*\*world\*\* and \@[user]')
+   * // Returns: 'Hello **world** and @[user]'
+   * ```
+   */
+  unescape(e) {
+    return e.replaceAll(/\\(.)/g, "$1");
+  }
+}
+function kt(t, e, n) {
+  if (!n.length) return t;
+  const s = new O(n).parse(t);
+  return G(s, e);
+}
+function Me(t = "", e = "") {
+  if (t === e) return {};
+  let n;
+  for (let r = 0; r < t.length; r++)
+    if (t[r] !== e[r]) {
+      n = r;
+      break;
+    }
+  let s;
+  for (let r = 1; r <= t.length; r++)
+    if (t.at(-r) !== e.at(-r)) {
+      s = t.length - r + 1;
+      break;
+    }
+  return { left: n, right: s };
+}
+function q(t, e) {
+  let n = -1, s = t.length;
+  for (; s - n > 1; ) {
+    const r = Math.round((n + s) / 2);
+    t[r] <= e ? n = r : s = r;
+  }
+  return t[n] == e && (s = n), [n, s].filter((r) => t[r] !== void 0);
+}
+function Pe(t, e) {
+  if (Object.is(t, e))
+    return !0;
+  if (typeof t != "object" || t === null || typeof e != "object" || e === null)
+    return !1;
+  const n = Object.keys(t);
+  if (n.length !== Object.keys(e).length)
+    return !1;
+  for (let s = 0; s < n.length; s++)
+    if (!Object.prototype.hasOwnProperty.call(e, n[s]) || !Object.is(t[n[s]], e[n[s]]))
+      return !1;
+  return !0;
+}
+function Ne(t, e, n, s) {
+  return t.slice(0, n) + e + t.slice(n + s.length);
+}
+function _(t, e) {
+  const s = {
+    prev: 2,
+    self: 1,
+    next: 0
+  }[t], { focus: r } = e.nodes, [o, , i] = e.tokens.splice(r.index - s, 3), a = (o.type === "text", o.content), c = (i.type === "text", i.content);
+  e.tokens = e.tokens.toSpliced(r.index - s, 0, {
+    type: "text",
+    content: a + c,
+    position: {
+      start: o.position.start,
+      end: i.position.end
+    }
+  });
+  let l = r;
+  for (let u = 0; u < s; u++)
+    l = l.prev;
+  const h = l.length;
+  e.recovery = { anchor: l.prev, caret: h }, e.props.onChange?.(T(e.tokens));
+}
+class Ae {
+  #t = /* @__PURE__ */ new Map();
+  send(e, n) {
+    this.#e(e).forEach((s) => s(n));
+  }
+  on(e, n) {
+    return this.#e(e).add(n), () => this.#e(e).delete(n);
+  }
+  #e(e) {
+    return this.#t.has(e) || this.#t.set(e, /* @__PURE__ */ new Set()), this.#t.get(e);
+  }
+}
+const p = {
+  STORE_UPDATED: Symbol(),
+  ClearTrigger: Symbol(),
+  CheckTrigger: Symbol(),
+  Change: Symbol(),
+  Parse: Symbol(),
+  Delete: Symbol(),
+  Select: Symbol()
+};
+class S {
+  static get isSelectedPosition() {
+    const e = window.getSelection();
+    if (e)
+      return e.isCollapsed;
+  }
+  static getCurrentPosition() {
+    return window.getSelection()?.anchorOffset ?? 0;
+  }
+  //TODO get span from state?
+  static getFocusedSpan() {
+    return window.getSelection()?.anchorNode?.textContent ?? "";
+  }
+  static getSelectedNode() {
+    const e = window.getSelection()?.anchorNode;
+    if (e) return e;
+    throw new Error("Anchor node of selection is not exists!");
+  }
+  //TODO add the returned type: "{left: CSSProperties["left"], top: CSSProperties["top"]}"?
+  static getAbsolutePosition() {
+    const e = window.getSelection()?.getRangeAt(0).getBoundingClientRect?.();
+    return e ? { left: e.left, top: e.top + e.height + 1 } : { left: 0, top: 0 };
+  }
+  static trySetIndex(e, n) {
+    try {
+      this.setIndex(e, n);
+    } catch (s) {
+      console.error(s);
+    }
+  }
+  static setIndex(e, n) {
+    const s = window.getSelection();
+    if (!s?.anchorNode || !s.rangeCount) return;
+    const r = s.getRangeAt(0);
+    r?.setStart(e.firstChild || e, n), r?.setEnd(e.firstChild || e, n);
+  }
+  static getCaretIndex(e) {
+    let n = 0;
+    const s = window.getSelection();
+    if (!s?.rangeCount) return n;
+    const r = s.getRangeAt(0), o = r.cloneRange();
+    return o.selectNodeContents(e), o.setEnd(r.endContainer, r.endOffset), n = o.toString().length, n;
+  }
+  static setCaretToEnd(e) {
+    if (!e) return;
+    window.getSelection()?.setPosition(e, 1);
+  }
+  static getIndex() {
+    return window.getSelection()?.anchorOffset ?? NaN;
+  }
+  static setIndex1(e) {
+    const n = window.getSelection();
+    if (!n?.anchorNode || !n.rangeCount) return;
+    const s = n.getRangeAt(0);
+    s?.setStart(s.startContainer.firstChild || s.startContainer, e), s?.setEnd(s.startContainer.firstChild || s.startContainer, e);
+  }
+  setCaretRightTo(e, n) {
+    const r = window.getSelection()?.getRangeAt(0);
+    r?.setStart(r.endContainer, n), r?.setEnd(r.endContainer, n);
+  }
+}
+const Oe = new RegExp(/^\w*/);
+class U {
+  span;
+  node;
+  dividedText;
+  constructor() {
+    const e = S.getCurrentPosition();
+    this.node = S.getSelectedNode(), this.span = S.getFocusedSpan(), this.dividedText = this.getDividedTextBy(e);
+  }
+  /**
+   * Find overlay match in text using provided options and trigger extractor.
+   * @template T - Type of option objects
+   * @param options - Array of options to search through
+   * @param getTrigger - Function that extracts trigger from each option
+   * @returns OverlayMatch with correct option type or undefined
+   *
+   * @example
+   * // React usage
+   * TriggerFinder.find(options, (opt) => opt.slotProps?.overlay?.trigger ?? '@')
+   *
+   * @example
+   * // Other framework usage
+   * TriggerFinder.find(vueOptions, (opt) => opt.overlay?.trigger ?? '@')
+   */
+  static find(e, n) {
+    if (e && S.isSelectedPosition)
+      return new U().find(e, n);
+  }
+  getDividedTextBy(e) {
+    return { left: this.span.slice(0, e), right: this.span.slice(e) };
+  }
+  /**
+   * Find overlay match in provided options.
+   * @template T - Type of option objects
+   * @param options - Array of options
+   * @param getTrigger - Function to extract trigger from each option
+   */
+  find(e, n) {
+    for (let s = 0; s < e.length; s++) {
+      const r = e[s], o = n(r, s);
+      if (!o) continue;
+      const i = this.matchInTextVia(o);
+      if (i)
+        return {
+          value: i.word,
+          source: i.annotation,
+          index: i.index,
+          span: this.span,
+          node: this.node,
+          option: r
+        };
+    }
+  }
+  matchInTextVia(e = "@") {
+    const n = this.matchRightPart(), s = this.matchLeftPart(e);
+    if (s)
+      return {
+        word: s.word + n.word,
+        annotation: s.annotation + n.word,
+        index: s.index
+      };
+  }
+  matchRightPart() {
+    const { right: e } = this.dividedText;
+    return { word: e.match(Oe)?.[0] };
+  }
+  matchLeftPart(e) {
+    const n = this.makeTriggerRegex(e), { left: s } = this.dividedText, r = s.match(n);
+    if (!r) return;
+    const [o, i] = r;
+    return { word: i, annotation: o, index: r.index ?? 0 };
+  }
+  //TODO new overlayMatch option if (isSpaceBeforeRequired) append space check for not first words '\\s'
+  makeTriggerRegex(e) {
+    const n = b(e) + "(\\w*)$";
+    return new RegExp(n);
+  }
+}
+class M {
+  #t;
+  #e;
+  get target() {
+    return this.#t;
+  }
+  set target(e) {
+    this.#t = e;
+  }
+  get next() {
+    return new M(this.target?.nextSibling, this.#e);
+  }
+  get prev() {
+    return new M(this.target?.previousSibling, this.#e);
+  }
+  get isSpan() {
+    return this.index % 2 === 0;
+  }
+  get isMark() {
+    return !this.isSpan;
+  }
+  get isEditable() {
+    return this.target?.isContentEditable ?? !1;
+  }
+  get isCaretAtBeginning() {
+    return this.target ? S.getCaretIndex(this.target) === 0 : void 0;
+  }
+  get isCaretAtEnd() {
+    return this.target ? S.getCaretIndex(this.target) === this.target.textContent?.length : void 0;
+  }
+  get index() {
+    return this.target?.parentElement ? [...this.target.parentElement.children].indexOf(this.target) : -1;
+  }
+  get caret() {
+    return this.target ? S.getCaretIndex(this.target) : -1;
+  }
+  set caret(e) {
+    this.target && S.trySetIndex(this.target, e);
+  }
+  get length() {
+    return this.target?.textContent?.length ?? -1;
+  }
+  get content() {
+    return this.target?.textContent ?? "";
+  }
+  set content(e) {
+    this.target && (this.target.textContent = e ?? "");
+  }
+  get head() {
+    return this.#e.refs.container?.firstChild;
+  }
+  get tail() {
+    return this.#e.refs.container?.lastChild;
+  }
+  get isFocused() {
+    return this.target === document.activeElement;
+  }
+  constructor(e, n) {
+    this.target = e, this.#e = n;
+  }
+  setCaretToEnd() {
+    S.setCaretToEnd(this.target);
+  }
+  focus() {
+    this.target?.focus();
+  }
+  clear() {
+    this.target = void 0;
+  }
+}
+class Le {
+  #t = 1;
+  #e = /* @__PURE__ */ new WeakMap();
+  get(e) {
+    return this.#e.has(e) ? this.#e.get(e) : (this.#e.set(e, this.#t), this.#t++);
+  }
+}
+class B {
+  // Utils domain
+  bus = new Ae();
+  key = new Le();
+  // Config domain
+  props;
+  // Document domain
+  tokens = [];
+  parser;
+  previousValue;
+  // Navigation domain
+  nodes = {
+    focus: new M(void 0, this),
+    input: new M(void 0, this)
+  };
+  recovery;
+  // UI domain
+  refs = {
+    container: null,
+    overlay: null,
+    setContainer: (e) => {
+      this.refs.container = e;
+    },
+    setOverlay: (e) => {
+      this.refs.overlay = e;
+    }
+  };
+  selecting;
+  // Overlay domain
+  overlayMatch;
+  constructor(e) {
+    this.props = e;
+  }
+  static create = (e) => new Proxy(new B(e), { set: De });
+}
+const _e = /* @__PURE__ */ new Set(["bus", "refs", "nodes", "key"]);
+function De(t, e, n, s) {
+  return _e.has(String(e)) ? !1 : (t[e] === n || (t[e] = n, t.bus.send(p.STORE_UPDATED, s)), !0);
+}
+const P = ce(void 0);
+P.displayName = "StoreContext";
+function v(t, e, n) {
+  typeof t == "string" ? $e(t, e, n) : Re(t, e, n);
+}
+function Re(t, e, n) {
+  const s = N(P);
+  Q(s), x(() => s.bus.on(t, e), n);
+}
+function $e(t, e, n) {
+  const s = N(P);
+  x(() => (s?.refs.container?.addEventListener(t, e), () => s?.refs.container?.removeEventListener(t, e)), n);
+}
+function f(t, e) {
+  const n = N(P);
+  Q(n);
+  const [s, r] = A(() => t?.(n));
+  return v(
+    p.STORE_UPDATED,
+    () => {
+      r((o) => {
+        const i = t?.(n);
+        return e && Pe(o, i) ? o : i;
+      });
+    },
+    []
+  ), t ? s : n;
+}
+const Ve = (t) => {
+  const e = ae.createContext(void 0);
+  e.displayName = t;
+  const n = o(e), s = e.Provider;
+  return [n, s, e];
+  function o(i) {
+    return () => {
+      const a = N(i);
+      if (a) return a;
+      throw new Error(`The context ${i.displayName} didn't found!`);
+    };
+  }
+}, [H, X] = Ve("NodeProvider");
+function ee(t, e, n, s) {
+  const r = f((c) => t === "mark" ? c.props.Mark : c.props.Overlay), o = t === "mark" ? e?.mark : e?.overlay;
+  let i;
+  o !== void 0 ? typeof o == "function" ? i = o(n) : i = o : i = n ?? {};
+  const a = i.slot || r || s;
+  if (!a)
+    throw new Error(
+      `No ${t} component found. Provide either option.${t}.slot, global ${t === "mark" ? "Mark" : "Overlay"}, or a defaultComponent.`
+    );
+  return [a, i];
+}
+function Fe() {
+  const t = H(), { options: e, key: n } = f((c) => ({ options: c.props.options, key: c.key }), !0), s = e?.[t.descriptor.index], r = t.children.map((c) => /* @__PURE__ */ m(z, { mark: c, isNested: !0 }, n.get(c))), o = {
+    value: t.value,
+    meta: t.meta,
+    nested: t.nested?.content,
+    children: t.children.length > 0 ? r : void 0
+  }, [i, a] = ee("mark", s, o);
+  return /* @__PURE__ */ m(i, { ...a });
+}
+const We = () => {
+  const t = H(), e = I(null), { readOnly: n, SpanComponent: s, spanProps: r } = f(
+    (o) => ({
+      readOnly: o.props.readOnly,
+      SpanComponent: Z("span", o),
+      spanProps: J("span", o)
+    }),
+    !0
+  );
+  if (t.type !== "text")
+    throw new Error("TextSpan component expects a TextToken");
+  return /* @__PURE__ */ m(
+    s,
+    {
+      ...r,
+      ref: e,
+      contentEditable: !n,
+      onPaste: Ge,
+      suppressContentEditableWarning: !0,
+      children: t.content
+    }
+  );
+};
+function Ge(t) {
+  t.preventDefault();
+  const e = t.clipboardData.getData("text");
+  document.execCommand("insertText", !1, e);
+}
+const z = W(({ mark: t, isNested: e = !1 }) => t.type === "mark" ? /* @__PURE__ */ m(X, { value: t, children: /* @__PURE__ */ m(Fe, {}) }) : e ? /* @__PURE__ */ m(oe, { children: t.content }) : /* @__PURE__ */ m(X, { value: t, children: /* @__PURE__ */ m(We, {}) }));
+z.displayName = "Token";
+const te = W(() => {
+  const { className: t, style: e, tokens: n, bus: s, key: r, ContainerComponent: o, containerProps: i, refs: a } = f(
+    (c) => ({
+      className: c.props.className,
+      style: c.props.style,
+      tokens: c.tokens,
+      bus: c.bus,
+      key: c.key,
+      refs: c.refs,
+      ContainerComponent: Z("container", c),
+      containerProps: J("container", c)
+    }),
+    !0
+  );
+  return v("input", () => s.send(p.Change), []), /* @__PURE__ */ m(o, { ref: a.setContainer, ...i, className: t, style: e, children: n.map((c) => /* @__PURE__ */ m(z, { mark: c }, r.get(c))) });
+});
+te.displayName = "Container";
+function Ue() {
+  const { match: t, bus: e } = f(
+    (n) => ({
+      match: n.overlayMatch,
+      bus: n.bus
+    }),
+    !0
+  );
+  x(() => {
+    if (!t) return;
+    const n = (s) => {
+      s.key === k.ESC && e.send(p.ClearTrigger);
+    };
+    return window.addEventListener("keydown", n), () => window.removeEventListener("keydown", n);
+  }, [t, e]);
+}
+function Be() {
+  const t = f(), e = f((n) => n.overlayMatch);
+  x(() => {
+    if (!e) return;
+    const n = (s) => {
+      const r = s.target;
+      t.refs.overlay?.contains(r) || t.refs.container?.contains(r) || t.bus.send(p.ClearTrigger);
+    };
+    return document.addEventListener("click", n), () => document.removeEventListener("click", n);
+  }, [e]);
+}
+function C(t, e, n = []) {
+  v(
+    "keydown",
+    (s) => {
+      s.key === t && e(s);
+    },
+    n
+  );
+}
+function He() {
+  const t = f();
+  C(k.LEFT, e), C(k.RIGHT, n), C(k.DELETE, s), C(k.BACKSPACE, s), C(k.DELETE, o), C(k.BACKSPACE, r), v("keydown", i, []), v("paste", l, []), x(() => {
+    const u = t.refs.container;
+    if (!u) return;
+    const d = (g) => {
+      c(g);
+    };
+    return u.addEventListener("beforeinput", d, !0), () => u.removeEventListener("beforeinput", d, !0);
+  }, []);
+  function e(u) {
+    const { focus: d } = t.nodes;
+    if (d.isMark && !d.isEditable || d.isCaretAtBeginning) {
+      const g = d.prev;
+      g.focus(), g.isFocused || (g.prev.focus(), u.preventDefault()), d.setCaretToEnd();
+    }
+  }
+  function n(u) {
+    const { focus: d } = t.nodes;
+    if (d.isMark && !d.isEditable || d.isCaretAtEnd) {
+      const g = d.next;
+      g.focus(), g.isFocused || (g.next.focus(), u.preventDefault());
+    }
+  }
+  function s() {
+    t.nodes.focus.isMark && _("self", t);
+  }
+  function r(u) {
+    t.nodes.focus.isSpan && t.nodes.focus.isCaretAtBeginning && t.nodes.focus.prev.target && (u.preventDefault(), _("prev", t));
+  }
+  function o(u) {
+    t.nodes.focus.isSpan && t.nodes.focus.isCaretAtEnd && t.nodes.focus.next.target && (u.preventDefault(), _("next", t));
+  }
+  function i(u) {
+    if ((u.ctrlKey || u.metaKey) && u.code === "KeyA") {
+      u.preventDefault();
+      const d = window.getSelection(), g = t.refs.container?.firstChild, E = t.refs.container?.lastChild;
+      if (!d || !g || !E) return;
+      d.setBaseAndExtent(g, 0, E, 1), t.selecting = "all";
+    }
+  }
+  function a() {
+    const u = window.getSelection(), d = t.refs.container;
+    if (!u?.rangeCount || !d?.firstChild || !d?.lastChild) return !1;
+    try {
+      const g = u.getRangeAt(0);
+      return d.contains(g.startContainer) && d.contains(g.endContainer) && g.toString().length > 0;
+    } catch {
+      return !1;
+    }
+  }
+  function c(u) {
+    if (t.selecting !== "all" || !a()) {
+      t.selecting === "all" && (t.selecting = void 0);
+      return;
+    }
+    if (u.inputType === "insertFromPaste") return;
+    u.preventDefault();
+    const d = u.inputType.startsWith("delete") ? "" : u.data ?? "";
+    h(d);
+  }
+  function l(u) {
+    if (t.selecting !== "all" || !a()) {
+      t.selecting === "all" && (t.selecting = void 0);
+      return;
+    }
+    u.preventDefault();
+    const d = u.clipboardData?.getData("text/plain") ?? "";
+    h(d);
+  }
+  function h(u) {
+    t.nodes.focus.target = null, t.selecting = void 0, t.props.onChange?.(u), t.props.value === void 0 && (t.tokens = t.parser?.parse(u) ?? [
+      {
+        type: "text",
+        content: u,
+        position: { start: 0, end: u.length }
+      }
+    ]), queueMicrotask(() => {
+      const d = t.refs.container?.firstChild;
+      d && (t.recovery = {
+        anchor: t.nodes.focus,
+        caret: u.length
+      }, d.focus());
+    });
+  }
+}
+function ze() {
+  const t = f();
+  v(
+    p.Change,
+    () => {
+      const { onChange: e } = t.props;
+      if (!t.nodes.focus.target) return;
+      const n = t.tokens[t.nodes.focus.index];
+      n.type === "text" ? n.content = t.nodes.focus.content : n.type === "mark" && (n.value = t.nodes.focus.content), e?.(T(t.tokens)), t.bus.send(p.Parse);
+    },
+    []
+  ), v(
+    p.Delete,
+    ({ token: e }) => {
+      const { onChange: n } = t.props;
+      t.tokens.splice(t.tokens.indexOf(e), 1), n?.(T(t.tokens));
+    },
+    []
+  ), v(
+    p.Select,
+    (e) => {
+      const { Mark: n, onChange: s } = t.props, {
+        mark: r,
+        match: { option: o, span: i, index: a, source: c }
+      } = e, l = r.type === "mark" ? $(o.markup, {
+        value: r.value,
+        meta: r.meta
+      }) : $(o.markup, {
+        value: r.content
+      }), h = Ne(i, l, a, c);
+      if (t.recovery = n ? { caret: 0, anchor: t.nodes.input.next, isNext: !0 } : { caret: a + l.length, anchor: t.nodes.input }, t.nodes.input.target) {
+        t.nodes.input.content = h;
+        const u = t.tokens[t.nodes.input.index];
+        u.type === "text" && (u.content = h), t.nodes.focus.target = t.nodes.input.target, t.nodes.input.clear(), s?.(T(t.tokens)), t.bus.send(p.Parse);
+      }
+    },
+    []
+  );
+}
+const je = () => {
+  const t = f();
+  v("focusin", (e) => t.nodes.focus.target = e.target, []), v("focusout", (e) => t.nodes.focus.target = void 0, []);
+}, qe = () => {
+  const t = f(), e = f((n) => n.tokens);
+  v(
+    "click",
+    () => {
+      e.length === 1 && e[0].type === "text" && e[0].content === "" && t.refs.container?.firstElementChild?.focus();
+    },
+    [e]
+  );
+}, Xe = () => {
+  const t = f(), e = f((s) => s.tokens), n = t.props.Mark ? [e] : void 0;
+  x(() => {
+    if (!t.recovery) return;
+    const { anchor: s, caret: r, isNext: o } = t.recovery;
+    switch (!0) {
+      case (o && !s.target):
+        t.nodes.focus.tail.focus();
+        break;
+      case o:
+        s.prev.focus();
+        break;
+      case !s.target:
+        t.nodes.focus.head.focus();
+        break;
+      default:
+        s.next.focus();
+    }
+    t.nodes.focus.caret = r, t.recovery = void 0;
+  }, n);
+};
+function Ze() {
+  const t = f(), e = I(!1), n = I(null);
+  x(() => {
+    const s = (r) => {
+      n.current = r.target, e.current = !0;
+    };
+    return document.addEventListener("mousedown", s), () => document.removeEventListener("mousedown", s);
+  }, []), x(() => {
+    const s = (r) => {
+      const o = e.current, i = !t.refs.container?.contains(n.current) || n.current !== r.target, a = window.getSelection()?.containsNode(t.refs.container, !0);
+      o && i && a && (t.selecting = "drag");
+    };
+    return document.addEventListener("mousemove", s), () => document.removeEventListener("mousemove", s);
+  }, []), x(() => {
+    const s = () => {
+      e.current = !1, n.current = null, t.selecting = void 0;
+    };
+    return document.addEventListener("mouseup", s), () => document.removeEventListener("mouseup", s);
+  }, []), Je();
+}
+function Je() {
+  const t = f(), e = f((n) => n.selecting);
+  x(() => {
+    if (e !== "drag") return;
+    const n = [...t.refs.container.children], s = n.map((r) => r.contentEditable);
+    return n.forEach((r) => r.contentEditable = "false"), () => n.forEach((r, o) => r.contentEditable = s[o]);
+  }, [e]);
+}
+function Qe() {
+  const t = f(), e = R(() => {
+    const n = t.props.showOverlayOn, s = "selectionChange";
+    (n === s || n.includes(s)) && t.bus.send(p.CheckTrigger);
+  }, []);
+  v(
+    "focusin",
+    () => {
+      document.addEventListener("selectionchange", e);
+    },
+    []
+  ), v(
+    "focusout",
+    () => {
+      document.removeEventListener("selectionchange", e);
+    },
+    []
+  ), v(
+    p.Change,
+    () => {
+      const n = t.props.showOverlayOn, s = "change";
+      (n === s || n.includes(s)) && t.bus.send(p.CheckTrigger);
+    },
+    []
+  );
+}
+const Ke = () => {
+  const t = f();
+  v(p.ClearTrigger, (e) => t.overlayMatch = void 0, []), v(
+    p.CheckTrigger,
+    (e) => t.overlayMatch = U.find(t.props.options, (n) => n.overlay?.trigger),
+    []
+  );
+}, Ye = () => {
+  const t = f(), e = I(!1), { value: n, options: s } = f(
+    (r) => ({
+      value: r.props.value,
+      options: r.props.Mark ? r.props.options : void 0
+    }),
+    !0
+  );
+  x(() => {
+    const r = s?.map((i) => i.markup);
+    if (r && r.some(Boolean) ? t.parser = new O(r) : t.parser = void 0, e.current) {
+      t.bus.send(p.Parse);
+      return;
+    }
+    const o = n ?? t.props.defaultValue ?? "";
+    t.parser ? t.tokens = t.parser.parse(o) : t.tokens = [
+      {
+        type: "text",
+        content: o,
+        position: { start: 0, end: o.length }
+      }
+    ], e.current = !0;
+  }, [n, s]), v(
+    p.Parse,
+    () => {
+      t.tokens = t.nodes.focus.target ? et(t) : tt(t);
+    },
+    []
+  );
+};
+function et(t) {
+  const { focus: e } = t.nodes;
+  if (!t.parser)
+    return t.tokens;
+  const n = t.parser.parse(e.content);
+  return n.length === 1 ? t.tokens : t.tokens.toSpliced(e.index, 1, ...n);
+}
+function tt(t) {
+  const {
+    props: { value: e }
+  } = t, n = nt(t), s = Me(t.previousValue, e);
+  switch (t.previousValue = e, !0) {
+    //Mark removing happen
+    case (s.left && n.includes(s.left) && s.right && Math.abs(s.left - s.right) > 1): {
+      const r = n.indexOf(s.left), o = D(t, r - 1, r);
+      return t.tokens.toSpliced(r - 1, 2, ...o);
+    }
+    //Changing in label
+    case s.left !== void 0: {
+      const [r] = q(n, s.left), o = D(t, r);
+      return o.length === 1 ? t.tokens : t.tokens.toSpliced(r, 1, ...o);
+    }
+    case s.right !== void 0: {
+      const [r] = q(n, s.right), o = D(t, r);
+      return o.length === 1 ? t.tokens : t.tokens.toSpliced(r, 1, ...o);
+    }
+    default:
+      return ne(t, e ?? "");
+  }
+}
+function D(t, ...e) {
+  let n = "";
+  for (const s of e) {
+    const r = t.tokens[s];
+    n += r.content;
+  }
+  return ne(t, n);
+}
+function nt(t) {
+  let e = 0;
+  return t.tokens.map((n) => {
+    const s = n.content.length;
+    return e += s, e - s;
+  }) ?? [];
+}
+function ne(t, e) {
+  return t.parser ? t.parser.parse(e) : [
+    {
+      type: "text",
+      content: e,
+      position: { start: 0, end: e.length }
+    }
+  ];
+}
+const st = (t) => ({
+  get container() {
+    return t.refs.container;
+  },
+  get overlay() {
+    return t.refs.overlay;
+  },
+  focus() {
+    t.nodes.focus.head?.focus();
+  }
+});
+function rt(t) {
+  const e = f();
+  le(t, () => st(e), [e]);
+}
+const ot = ({ inRef: t }) => (rt(t), ze(), Ye(), je(), He(), qe(), Xe(), Ke(), Qe(), Ue(), Be(), Ze(), null), it = "_Container_1lmfr_1", at = "_Suggestions_1lmfr_10", ct = "_suggestionActive_1lmfr_38", V = {
+  Container: it,
+  Suggestions: at,
+  suggestionActive: ct
+}, lt = [
+  {
+    markup: ve,
+    overlay: {
+      trigger: me,
+      data: []
+    }
+  }
+], ut = ({ props: t, children: e }) => {
+  const n = dt(t), [s] = A(() => B.create(n));
+  return x(() => {
+    s.props = n;
+  }), /* @__PURE__ */ m(P.Provider, { value: s, children: e });
+};
+function dt(t) {
+  const e = ge(V.Container, t.className, t.slotProps?.container?.className), n = pe(t.style, t.slotProps?.container?.style);
+  return {
+    value: t.value,
+    defaultValue: t.defaultValue,
+    onChange: t.onChange,
+    readOnly: t.readOnly,
+    options: t.options ?? lt,
+    showOverlayOn: t.showOverlayOn ?? "change",
+    className: e,
+    style: n,
+    Mark: t.Mark,
+    Overlay: t.Overlay,
+    slots: t.slots,
+    slotProps: t.slotProps
+  };
+}
+function ht() {
+  const t = f(), e = f((o) => o.overlayMatch), n = S.getAbsolutePosition(), s = R(() => t.bus.send(p.ClearTrigger), []), r = R(
+    (o) => {
+      const i = {
+        type: "mark",
+        value: o.value,
+        meta: o.meta,
+        content: "",
+        position: { start: e.index, end: e.index + e.span.length },
+        descriptor: {
+          index: 0,
+          // TODO: get correct index
+          markup: e.option.markup
+        },
+        // TODO: fix typing
+        children: [],
+        nested: void 0
+      };
+      t.bus.send(p.Select, { mark: i, match: e }), t.bus.send(p.ClearTrigger);
+    },
+    [e]
+  );
+  return { match: e, style: n, select: r, close: s, ref: { current: t.refs.overlay } };
+}
+const ft = () => {
+  const { match: t, select: e, style: n, ref: s } = ht(), [r, o] = A(NaN), i = t.option.overlay?.data || [], a = ue(
+    () => i.filter((l) => l.toLowerCase().indexOf(t.value.toLowerCase()) > -1),
+    [t.value, i]
+  ), c = a.length;
+  return C(
+    k.UP,
+    (l) => {
+      l.preventDefault(), o((h) => isNaN(h) ? 0 : (c + (h - 1) % c) % c);
+    },
+    [c]
+  ), C(
+    k.DOWN,
+    (l) => {
+      l.preventDefault(), o((h) => isNaN(h) ? 0 : (h + 1) % c);
+    },
+    [c]
+  ), C(
+    k.ENTER,
+    (l) => {
+      l.preventDefault();
+      const h = a[r];
+      e({ value: h, meta: r.toString() });
+    },
+    [a, r]
+  ), a.length ? /* @__PURE__ */ m("ul", { ref: s, className: V.Suggestions, style: n, children: a.map((l, h) => {
+    const u = h === r ? V.suggestionActive : void 0;
+    return /* @__PURE__ */ m(
+      "li",
+      {
+        ref: (d) => u && d?.scrollIntoView(!1),
+        className: u,
+        onClick: (d) => e({ value: l, meta: h.toString() }),
+        children: l
+      },
+      l
+    );
+  }) }) : null;
+}, se = W(() => {
+  const t = f(), e = f((o) => o.overlayMatch), n = f((o) => o.overlayMatch ? o.key.get(o.overlayMatch.option) : void 0), [s, r] = ee("overlay", e?.option, void 0, ft);
+  if (x(() => {
+    t.nodes.input.target = t.nodes.focus.target;
+  }, [n]), n) return /* @__PURE__ */ m(s, { ...r ?? {} }, n);
+});
+se.displayName = "Whisper";
+const gt = (t, e) => /* @__PURE__ */ ie(ut, { props: t, children: [
+  /* @__PURE__ */ m(te, {}),
+  /* @__PURE__ */ m(se, {}),
+  /* @__PURE__ */ m(ot, { inRef: e })
+] }), St = de(gt);
+function F(t, e, n = 0, s) {
+  for (const r of t) {
+    if (r === e) return { depth: n, parent: s };
+    if (r.type === "mark") {
+      const o = F(r.children, e, n + 1, r);
+      if (o) return o;
+    }
+  }
+}
+class pt {
+  ref;
+  #t;
+  #e;
+  readOnly;
+  constructor(e) {
+    this.ref = e.ref, this.#t = e.store, this.#e = e.token;
+  }
+  // ─── Data Properties ─────────────────────────────────────────────────────────
+  /** Displayed text of the mark */
+  get content() {
+    return this.#e.content;
+  }
+  set content(e) {
+    this.#e.content = e, this.#n();
+  }
+  /** Data value associated with the mark */
+  get value() {
+    return this.#e.value;
+  }
+  set value(e) {
+    this.#e.value = e ?? "", this.#n();
+  }
+  /** Optional metadata for the mark */
+  get meta() {
+    return this.#e.meta;
+  }
+  set meta(e) {
+    this.#e.meta = e, this.#n();
+  }
+  // ─── Navigation Properties ───────────────────────────────────────────────────
+  /** Nesting depth (0 for root-level marks) */
+  get depth() {
+    return F(this.#t.tokens, this.#e).depth;
+  }
+  /** Whether this mark has nested children */
+  get hasChildren() {
+    return this.#e.children.length > 0;
+  }
+  /** Parent mark token (undefined for root-level marks) */
+  get parent() {
+    return F(this.#t.tokens, this.#e)?.parent;
+  }
+  /** Child tokens of this mark */
+  get tokens() {
+    return this.#e.children;
+  }
+  // ─── Mutation Methods ────────────────────────────────────────────────────────
+  /** Update multiple properties in a single operation */
+  change = (e) => {
+    this.#e.content = e.content, this.#e.value = e.value ?? "", e.meta !== void 0 && (this.#e.meta = e.meta), this.#n();
+  };
+  /** Delete this mark from the editor */
+  remove = () => this.#t.bus.send(p.Delete, { token: this.#e });
+  // ─── Private ─────────────────────────────────────────────────────────────────
+  #n() {
+    this.#t.bus.send(p.Change, { node: this.#e });
+  }
+}
+const Ct = (t = {}) => {
+  const e = f(), n = H(), s = I();
+  if (n.type !== "mark")
+    throw new Error("useMark can only be used with mark tokens");
+  const [r] = A(() => new pt({ ref: s, store: e, token: n }));
+  mt(s, t, n);
+  const o = f((i) => i.props.readOnly);
+  return x(() => {
+    r.readOnly = o;
+  }, [o]), r;
+};
+function mt(t, e, n) {
+  x(() => {
+    t.current && !e.controlled && (t.current.textContent = n.content);
+  }, []);
+}
+export {
+  St as MarkedInput,
+  $ as annotate,
+  kt as denote,
+  v as useListener,
+  Ct as useMark,
+  ht as useOverlay
+};