elixir-data-viewer 0.1.0

package/dist/index.js

@@ -0,0 +1,1581 @@
+var K = Object.defineProperty;
+var D = (r, t, e) => t in r ? K(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
+var a = (r, t, e) => D(r, typeof t != "symbol" ? t + "" : t, e);
+import { parser as M } from "lezer-elixir";
+import { highlightTree as R, tagHighlighter as N, tags as p } from "@lezer/highlight";
+function O(r) {
+  return M.parse(r);
+}
+const H = N([
+  // Atoms and keyword keys (:foo, key:)
+  { tag: p.atom, class: "tok-atom" },
+  // Module aliases (MyModule)
+  { tag: p.namespace, class: "tok-namespace" },
+  // Booleans: true, false
+  { tag: p.bool, class: "tok-bool" },
+  // nil
+  { tag: p.null, class: "tok-null" },
+  // Integer literals
+  { tag: p.integer, class: "tok-number" },
+  // Float literals
+  { tag: p.float, class: "tok-number" },
+  // Character literals (?a)
+  { tag: p.character, class: "tok-character" },
+  // Variable names (identifiers)
+  { tag: p.variableName, class: "tok-variableName" },
+  // Function calls: Call/Identifier, PipeOperator/Right/Identifier
+  { tag: p.function(p.variableName), class: "tok-function" },
+  // Function definitions: def foo, defp bar
+  {
+    tag: p.definition(p.function(p.variableName)),
+    class: "tok-definition"
+  },
+  // Special identifiers: __MODULE__, __DIR__, etc.
+  { tag: p.special(p.variableName), class: "tok-special" },
+  // Strings and charlists
+  { tag: p.string, class: "tok-string" },
+  // Sigils (~r/.../, ~w[...])
+  { tag: p.special(p.string), class: "tok-string" },
+  // Escape sequences (\n, \t, etc.)
+  { tag: p.escape, class: "tok-escape" },
+  // Keywords: do, end, fn, def, defmodule, when, not, etc.
+  { tag: p.keyword, class: "tok-keyword" },
+  // Operators: +, -, |>, ++, --, etc.
+  { tag: p.operator, class: "tok-operator" },
+  // Line comments (#...)
+  { tag: p.lineComment, class: "tok-comment" },
+  // Underscored identifiers (_foo) — mapped to tags.comment by lezer-elixir
+  { tag: p.comment, class: "tok-underscore" },
+  // Parentheses: (, )
+  { tag: p.paren, class: "tok-punctuation" },
+  // Square brackets: [, ]
+  { tag: p.squareBracket, class: "tok-punctuation" },
+  // Braces and percent: %, {, }
+  { tag: p.brace, class: "tok-punctuation" },
+  // Interpolation braces: #{, }
+  { tag: p.special(p.brace), class: "tok-punctuation" },
+  // Separators: comma, semicolon
+  { tag: p.separator, class: "tok-separator" },
+  // Angle brackets: <<, >>
+  { tag: p.angleBracket, class: "tok-angleBracket" },
+  // Module attributes: @attr
+  { tag: p.attributeName, class: "tok-attributeName" },
+  // Doc strings: @doc, @moduledoc, @typedoc
+  { tag: p.docString, class: "tok-docString" }
+]);
+function P(r, t) {
+  const e = [];
+  return R(t, H, (s, i, n) => {
+    e.push({ from: s, to: i, classes: n });
+  }), e;
+}
+function C(r, t, e) {
+  const s = [];
+  for (const i of r)
+    i.to <= t || i.from >= e || s.push({
+      from: Math.max(i.from, t) - t,
+      to: Math.min(i.to, e) - t,
+      classes: i.classes
+    });
+  return s;
+}
+const W = {
+  List: { open: "[", close: "]" },
+  Tuple: { open: "{", close: "}" },
+  Map: { open: "%{", close: "}" },
+  Bitstring: { open: "<<", close: ">>" },
+  AnonymousFunction: { open: "fn", close: "end" },
+  String: { open: '"""', close: '"""' },
+  Charlist: { open: "'''", close: "'''" }
+}, $ = /* @__PURE__ */ new Set(["List", "Tuple", "Map", "MapContent", "Keywords", "Bitstring"]), q = /* @__PURE__ */ new Set([",", "[", "]", "{", "}", "<<", ">>", "%", "|", "=>", ":"]);
+function k(r) {
+  const t = r.type.name;
+  if (!$.has(t)) return -1;
+  let e = 0, s = r.firstChild;
+  for (; s; ) {
+    const i = s.type.name;
+    if (q.has(i)) {
+      s = s.nextSibling;
+      continue;
+    }
+    if (i === "MapContent" || i === "Keywords")
+      return k(s);
+    if (i === "Struct") {
+      s = s.nextSibling;
+      continue;
+    }
+    e++, s = s.nextSibling;
+  }
+  return e;
+}
+function V(r) {
+  const t = [0];
+  for (let e = 0; e < r.length; e++)
+    r[e] === `
+` && t.push(e + 1);
+  return t;
+}
+function S(r, t) {
+  let e = 0, s = r.length - 1;
+  for (; e < s; ) {
+    const i = e + s + 1 >> 1;
+    r[i] <= t ? e = i : s = i - 1;
+  }
+  return e;
+}
+function x(r, t, e, s) {
+  const i = W[r.type.name];
+  if (i) {
+    const l = S(e, r.from), o = S(e, r.to - 1);
+    if (o > l) {
+      let c = i.open, d = r.from;
+      if (r.type.name === "String" || r.type.name === "Charlist") {
+        const m = t.slice(r.from, Math.min(r.from + 3, r.to));
+        m === '"""' || m === "'''" ? c = m : c = m[0] || i.open;
+      }
+      s.push({
+        startLine: l,
+        endLine: o,
+        startOffset: d,
+        endOffset: r.to,
+        openText: c,
+        closeText: i.close,
+        itemCount: k(r),
+        depth: 0
+        // computed after collection
+      });
+    }
+  }
+  let n = r.firstChild;
+  for (; n; )
+    x(n, t, e, s), n = n.nextSibling;
+}
+function _(r, t) {
+  const e = V(r), s = [];
+  x(t.topNode, r, e, s), s.sort((n, l) => n.startLine - l.startLine || n.startOffset - l.startOffset);
+  const i = [];
+  for (const n of s) {
+    for (; i.length > 0 && i[i.length - 1].endOffset <= n.startOffset; )
+      i.pop();
+    n.depth = i.length + 1, i.push(n);
+  }
+  return s;
+}
+function U(r) {
+  const t = /* @__PURE__ */ new Map();
+  for (const e of r)
+    t.has(e.startLine) || t.set(e.startLine, e);
+  return t;
+}
+class z {
+  constructor() {
+    /** Set of startLine indices that are currently folded */
+    a(this, "foldedLines", /* @__PURE__ */ new Set());
+    /** Map from startLine to FoldRegion */
+    a(this, "regionMap", /* @__PURE__ */ new Map());
+    /** All fold regions sorted by startLine */
+    a(this, "regions", []);
+  }
+  /**
+   * Update the fold regions (called when content changes).
+   * Clears all fold state.
+   */
+  setRegions(t, e) {
+    this.regions = t, this.regionMap = e, this.foldedLines.clear();
+  }
+  /**
+   * Toggle a fold at the given startLine.
+   */
+  toggle(t) {
+    this.foldedLines.has(t) ? this.foldedLines.delete(t) : this.regionMap.has(t) && this.foldedLines.add(t);
+  }
+  /**
+   * Check if a given startLine is folded.
+   */
+  isFolded(t) {
+    return this.foldedLines.has(t);
+  }
+  /**
+   * Get the FoldRegion for a startLine, if any.
+   */
+  getRegion(t) {
+    return this.regionMap.get(t);
+  }
+  /**
+   * Check if a given line is hidden due to being inside a folded region.
+   * Returns the folded parent region if hidden, or undefined.
+   */
+  isLineHidden(t) {
+    for (const e of this.foldedLines) {
+      const s = this.regionMap.get(e);
+      if (s && t > s.startLine && t <= s.endLine)
+        return s;
+    }
+  }
+  /**
+   * Check if a line has a fold indicator (is the start of a foldable region).
+   */
+  isFoldable(t) {
+    return this.regionMap.has(t);
+  }
+  /**
+   * Get all regions.
+   */
+  getRegions() {
+    return this.regions;
+  }
+  /**
+   * Fold all regions.
+   */
+  foldAll() {
+    for (const t of this.regions)
+      this.foldedLines.add(t.startLine);
+  }
+  /**
+   * Unfold all regions.
+   */
+  unfoldAll() {
+    this.foldedLines.clear();
+  }
+  /**
+   * Fold all regions whose nesting depth exceeds maxLevel.
+   * Level 1 = outermost structures. foldToLevel(3) shows levels 1–3 expanded,
+   * level 4+ folded. foldToLevel(0) or negative values unfold all.
+   */
+  foldToLevel(t) {
+    if (this.foldedLines.clear(), !(t <= 0))
+      for (const e of this.regions)
+        e.depth > t && this.foldedLines.add(e.startLine);
+  }
+  /**
+   * Reveal a specific line by unfolding any region that hides it.
+   * This ensures the line becomes visible in the rendered output.
+   */
+  revealLine(t) {
+    for (const e of this.foldedLines) {
+      const s = this.regionMap.get(e);
+      s && t > s.startLine && t <= s.endLine && this.foldedLines.delete(e);
+    }
+  }
+}
+class Q {
+  constructor() {
+    a(this, "query", "");
+    a(this, "caseSensitive", !1);
+    a(this, "matches", []);
+    a(this, "currentIndex", -1);
+  }
+  /**
+   * Perform a search across all lines.
+   * Returns true if matches changed.
+   */
+  search(t, e, s) {
+    if (this.query = e, this.caseSensitive = s, this.matches = [], this.currentIndex = -1, !e) return !0;
+    const i = s ? e : e.toLowerCase();
+    for (let n = 0; n < t.length; n++) {
+      const l = s ? t[n] : t[n].toLowerCase();
+      let o = 0;
+      for (; o <= l.length - i.length; ) {
+        const c = l.indexOf(i, o);
+        if (c === -1) break;
+        this.matches.push({
+          line: n,
+          from: c,
+          to: c + i.length
+        }), o = c + 1;
+      }
+    }
+    return this.matches.length > 0 && (this.currentIndex = 0), !0;
+  }
+  /**
+   * Clear search state.
+   */
+  clear() {
+    this.query = "", this.matches = [], this.currentIndex = -1;
+  }
+  /**
+   * Get the current search query.
+   */
+  getQuery() {
+    return this.query;
+  }
+  /**
+   * Get whether case-sensitive mode is active.
+   */
+  isCaseSensitive() {
+    return this.caseSensitive;
+  }
+  /**
+   * Get all matches.
+   */
+  getMatches() {
+    return this.matches;
+  }
+  /**
+   * Get matches for a specific line.
+   */
+  getLineMatches(t) {
+    return this.matches.filter((e) => e.line === t);
+  }
+  /**
+   * Get the current match index (0-based), or -1 if no matches.
+   */
+  getCurrentIndex() {
+    return this.currentIndex;
+  }
+  /**
+   * Get the current match, or undefined if none.
+   */
+  getCurrentMatch() {
+    if (!(this.currentIndex < 0 || this.currentIndex >= this.matches.length))
+      return this.matches[this.currentIndex];
+  }
+  /**
+   * Get total number of matches.
+   */
+  getMatchCount() {
+    return this.matches.length;
+  }
+  /**
+   * Move to the next match. Wraps around.
+   */
+  next() {
+    if (this.matches.length !== 0)
+      return this.currentIndex = (this.currentIndex + 1) % this.matches.length, this.matches[this.currentIndex];
+  }
+  /**
+   * Move to the previous match. Wraps around.
+   */
+  prev() {
+    if (this.matches.length !== 0)
+      return this.currentIndex = (this.currentIndex - 1 + this.matches.length) % this.matches.length, this.matches[this.currentIndex];
+  }
+  /**
+   * Set the current match to the nearest one at or after the given line.
+   * Used when opening search to start from the visible area.
+   */
+  setCurrentToLine(t) {
+    if (this.matches.length !== 0) {
+      for (let e = 0; e < this.matches.length; e++)
+        if (this.matches[e].line >= t) {
+          this.currentIndex = e;
+          return;
+        }
+      this.currentIndex = 0;
+    }
+  }
+  /**
+   * Check if a match at the given line/from is the current match.
+   */
+  isCurrentMatch(t, e) {
+    const s = this.getCurrentMatch();
+    return s ? s.line === t && s.from === e : !1;
+  }
+  /**
+   * Has active search query.
+   */
+  isActive() {
+    return this.query.length > 0;
+  }
+}
+class Y {
+  constructor() {
+    /** Keys to filter out (hide) */
+    a(this, "filteredKeys", /* @__PURE__ */ new Set());
+    /** All detected key-value ranges from the parsed content */
+    a(this, "keyRanges", []);
+    /** Pre-computed set of hidden line indices (rebuilt when filter changes) */
+    a(this, "hiddenLines", /* @__PURE__ */ new Set());
+  }
+  /**
+   * Detect all key-value ranges from the syntax tree and source code.
+   * Called when content changes via setContent().
+   */
+  detectKeys(t, e) {
+    const s = Z(e);
+    this.keyRanges = [], B(t.topNode, e, s, this.keyRanges, 0), this.rebuildHiddenLines();
+  }
+  /**
+   * Set the keys to filter out (replaces existing filter).
+   */
+  setKeys(t) {
+    this.filteredKeys = new Set(t), this.rebuildHiddenLines();
+  }
+  /**
+   * Add a single key to the filter.
+   */
+  addKey(t) {
+    this.filteredKeys.add(t), this.rebuildHiddenLines();
+  }
+  /**
+   * Remove a single key from the filter.
+   */
+  removeKey(t) {
+    this.filteredKeys.delete(t), this.rebuildHiddenLines();
+  }
+  /**
+   * Check if a key is currently being filtered.
+   */
+  hasKey(t) {
+    return this.filteredKeys.has(t);
+  }
+  /**
+   * Get all currently filtered keys.
+   */
+  getKeys() {
+    return Array.from(this.filteredKeys);
+  }
+  /**
+   * Get all available keys detected in the content.
+   * Returns unique key names sorted alphabetically.
+   */
+  getAvailableKeys() {
+    const t = /* @__PURE__ */ new Set();
+    for (const e of this.keyRanges)
+      t.add(e.key);
+    return Array.from(t).sort();
+  }
+  /**
+   * Clear all filters (show all keys).
+   */
+  clear() {
+    this.filteredKeys.clear(), this.hiddenLines.clear();
+  }
+  /**
+   * Check if a specific line should be hidden due to filtering.
+   */
+  isLineFiltered(t) {
+    return this.hiddenLines.has(t);
+  }
+  /**
+   * Check if any filter is active.
+   */
+  isActive() {
+    return this.filteredKeys.size > 0;
+  }
+  /**
+   * Get the total number of filtered keys.
+   */
+  getFilteredCount() {
+    return this.filteredKeys.size;
+  }
+  /**
+   * Rebuild the set of hidden line indices based on current filtered keys.
+   */
+  rebuildHiddenLines() {
+    if (this.hiddenLines.clear(), this.filteredKeys.size !== 0) {
+      for (const t of this.keyRanges)
+        if (this.filteredKeys.has(t.key))
+          for (let e = t.startLine; e <= t.endLine; e++)
+            this.hiddenLines.add(e);
+    }
+  }
+}
+function Z(r) {
+  const t = [0];
+  for (let e = 0; e < r.length; e++)
+    r[e] === `
+` && t.push(e + 1);
+  return t;
+}
+function L(r, t) {
+  let e = 0, s = r.length - 1;
+  for (; e < s; ) {
+    const i = e + s + 1 >> 1;
+    r[i] <= t ? e = i : s = i - 1;
+  }
+  return e;
+}
+function B(r, t, e, s, i) {
+  const n = r.type.name;
+  if (n === "Pair") {
+    const d = j(r, t);
+    if (d !== null) {
+      const m = L(e, r.from), f = L(e, r.to - 1);
+      s.push({
+        key: d,
+        startLine: m,
+        endLine: f,
+        depth: i
+      });
+    }
+  }
+  const o = n === "Map" || n === "List" || n === "Tuple" || n === "MapContent" || n === "Keywords" ? i + 1 : i;
+  let c = r.firstChild;
+  for (; c; )
+    B(c, t, e, s, o), c = c.nextSibling;
+}
+function j(r, t) {
+  const e = r.firstChild;
+  if (!e) return null;
+  const s = e.type.name, i = t.slice(e.from, e.to);
+  return s === "Keyword" ? i.replace(/:\s*$/, "") : s === "Atom" ? i.replace(/^:/, "") : s === "String" ? i.replace(/^"/, "").replace(/"$/, "") : i.length > 0 ? i : null;
+}
+const b = /* @__PURE__ */ new Set(["Map", "List", "Tuple", "Bitstring"]), X = /* @__PURE__ */ new Set(["{", "}", "[", "]", "<<", ">>"]), w = /* @__PURE__ */ new Set([
+  "String",
+  "Atom",
+  "Alias",
+  "Integer",
+  "Float",
+  "Boolean",
+  "Nil",
+  "Char",
+  "Charlist",
+  "Sigil"
+]), G = /* @__PURE__ */ new Set(["QuotedContent"]);
+function J(r, t, e) {
+  if (e < 0 || e >= t.length) return null;
+  const s = r.resolveInner(e, 1);
+  return s ? tt(s, t) : null;
+}
+function tt(r, t) {
+  const e = r.type.name;
+  if (X.has(e)) {
+    const i = r.parent;
+    if (i && b.has(i.type.name))
+      return {
+        from: i.from,
+        to: i.to,
+        copyText: t.slice(i.from, i.to),
+        isStructure: !0,
+        type: i.type.name
+      };
+  }
+  if (b.has(e))
+    return {
+      from: r.from,
+      to: r.to,
+      copyText: t.slice(r.from, r.to),
+      isStructure: !0,
+      type: e
+    };
+  const s = et(r, t);
+  if (s) return s;
+  if (G.has(e)) {
+    const i = r.parent;
+    if (i && w.has(i.type.name))
+      return {
+        from: i.from,
+        to: i.to,
+        copyText: t.slice(i.from, i.to),
+        isStructure: !1,
+        type: i.type.name
+      };
+  }
+  if (w.has(e))
+    return {
+      from: r.from,
+      to: r.to,
+      copyText: t.slice(r.from, r.to),
+      isStructure: !1,
+      type: e
+    };
+  if (e === "Keyword") {
+    const n = ":" + t.slice(r.from, r.to).replace(/:\s*$/, "");
+    return {
+      from: r.from,
+      to: r.to,
+      copyText: n,
+      isStructure: !1,
+      type: "Keyword"
+    };
+  }
+  return e === "Pair" ? {
+    from: r.from,
+    to: r.to,
+    copyText: t.slice(r.from, r.to),
+    isStructure: !1,
+    type: "Pair"
+  } : null;
+}
+function T(r, t) {
+  if (r.type.name !== "BinaryOperator") return !1;
+  let e = r.firstChild;
+  for (; e; ) {
+    if (e.type.name === "Operator" && t.slice(e.from, e.to) === "..")
+      return !0;
+    e = e.nextSibling;
+  }
+  return !1;
+}
+function I(r, t) {
+  if (r.type.name !== "BinaryOperator") return !1;
+  let e = !1, s = !1, i = r.firstChild;
+  for (; i; )
+    i.type.name === "Operator" && t.slice(i.from, i.to) === "//" && (e = !0), T(i, t) && (s = !0), i = i.nextSibling;
+  return e && s;
+}
+function et(r, t) {
+  let e = r;
+  for (; e; ) {
+    if (e.type.name === "BinaryOperator") {
+      if (I(e, t))
+        return {
+          from: e.from,
+          to: e.to,
+          copyText: t.slice(e.from, e.to),
+          isStructure: !1,
+          type: "Range"
+        };
+      if (T(e, t))
+        return e.parent && I(e.parent, t) ? {
+          from: e.parent.from,
+          to: e.parent.to,
+          copyText: t.slice(e.parent.from, e.parent.to),
+          isStructure: !1,
+          type: "Range"
+        } : {
+          from: e.from,
+          to: e.to,
+          copyText: t.slice(e.from, e.to),
+          isStructure: !1,
+          type: "Range"
+        };
+    }
+    e = e.parent;
+  }
+  return null;
+}
+const st = /#[A-Z][\w.]*<[^>\n]*>/g;
+function it(r) {
+  const t = [];
+  return { modifiedCode: r.replace(
+    st,
+    (s, i) => (t.push({
+      from: i,
+      to: i + s.length,
+      originalText: s
+    }), ":" + "_".repeat(s.length - 1))
+  ), inspectLiterals: t };
+}
+class at {
+  constructor(t, e) {
+    a(this, "container");
+    a(this, "innerEl");
+    a(this, "scrollEl");
+    a(this, "toolbarEl", null);
+    a(this, "wrapBtn", null);
+    a(this, "copyBtn", null);
+    a(this, "searchBtn", null);
+    a(this, "filterBtn", null);
+    a(this, "copyResetTimer", null);
+    a(this, "code", "");
+    a(this, "lines", []);
+    a(this, "lineOffsets", []);
+    a(this, "tokens", []);
+    a(this, "tree", null);
+    a(this, "foldState", new z());
+    a(this, "filterState", new Y());
+    a(this, "defaultFoldLevel", 0);
+    a(this, "defaultFilterKeys", []);
+    a(this, "searchState", new Q());
+    a(this, "onRenderCallback", null);
+    a(this, "wordWrap", !1);
+    a(this, "toolbarConfig");
+    // Search UI elements
+    a(this, "searchBarEl", null);
+    a(this, "searchInputEl", null);
+    a(this, "searchInfoEl", null);
+    a(this, "searchCaseBtn", null);
+    a(this, "searchVisible", !1);
+    // Filter UI elements
+    a(this, "filterBarEl", null);
+    a(this, "filterInputEl", null);
+    a(this, "filterTagsEl", null);
+    a(this, "filterInfoEl", null);
+    a(this, "filterDropdownEl", null);
+    a(this, "filterCopyBtn", null);
+    a(this, "filterCopyResetTimer", null);
+    a(this, "filterVisible", !1);
+    a(this, "filterDropdownIndex", -1);
+    a(this, "filterDropdownItems", []);
+    // Inspect state
+    a(this, "currentInspect", null);
+    a(this, "inspectCallback", null);
+    // Pre-processed inspect literals (#Reference<...>, #PID<...>, etc.)
+    a(this, "inspectLiterals", []);
+    this.container = t, this.container.classList.add("edv-container"), this.defaultFoldLevel = (e == null ? void 0 : e.defaultFoldLevel) ?? 0, this.defaultFilterKeys = (e == null ? void 0 : e.defaultFilterKeys) ?? [], this.wordWrap = (e == null ? void 0 : e.defaultWordWrap) ?? !1;
+    const s = (e == null ? void 0 : e.toolbar) ?? {};
+    this.toolbarConfig = {
+      foldAll: s.foldAll !== !1,
+      unfoldAll: s.unfoldAll !== !1,
+      wordWrap: s.wordWrap !== !1,
+      copy: s.copy !== !1,
+      search: s.search !== !1,
+      filter: s.filter !== !1
+    }, this.buildToolbar(), this.wordWrap && (this.container.classList.add("edv-word-wrap"), this.wrapBtn && this.wrapBtn.classList.add("edv-toolbar-btn--active")), this.buildSearchBar(), this.buildFilterBar(), this.innerEl = document.createElement("div"), this.innerEl.classList.add("edv-inner"), this.container.appendChild(this.innerEl), this.scrollEl = document.createElement("div"), this.scrollEl.classList.add("edv-scroll"), this.innerEl.appendChild(this.scrollEl), this.scrollEl.addEventListener("mouseover", (i) => this.handleInspectHover(i)), this.scrollEl.addEventListener("mouseout", (i) => this.handleInspectOut(i)), this.scrollEl.addEventListener("click", (i) => this.handleInspectClick(i)), this.container.setAttribute("tabindex", "0"), this.container.addEventListener("keydown", (i) => this.handleKeyDown(i));
+  }
+  /**
+   * Build the floating toolbar DOM and append to the container.
+   */
+  buildToolbar() {
+    const t = this.toolbarConfig;
+    if (t.foldAll || t.unfoldAll || t.wordWrap || t.copy || t.search || t.filter) {
+      if (this.toolbarEl = document.createElement("div"), this.toolbarEl.classList.add("edv-toolbar"), t.search && (this.searchBtn = this.createToolbarButton(
+        "⌕",
+        "Search (Ctrl+F)",
+        () => this.toggleSearch()
+      ), this.toolbarEl.appendChild(this.searchBtn)), t.filter && (this.filterBtn = this.createToolbarButton(
+        "⧩",
+        "Filter Keys",
+        () => this.toggleFilter()
+      ), this.toolbarEl.appendChild(this.filterBtn)), t.foldAll) {
+        const s = this.createToolbarButton("⊟", "Fold All", () => this.foldAll());
+        this.toolbarEl.appendChild(s);
+      }
+      if (t.unfoldAll) {
+        const s = this.createToolbarButton("⊞", "Unfold All", () => this.unfoldAll());
+        this.toolbarEl.appendChild(s);
+      }
+      t.wordWrap && (this.wrapBtn = this.createToolbarButton("↩", "Word Wrap (Alt+Z)", () => {
+        this.toggleWordWrap();
+      }), this.toolbarEl.appendChild(this.wrapBtn)), t.copy && (this.copyBtn = this.createToolbarButton("⎘", "Copy", () => this.copyContent()), this.toolbarEl.appendChild(this.copyBtn)), this.container.appendChild(this.toolbarEl);
+    }
+  }
+  /**
+   * Build the search bar DOM (hidden by default).
+   */
+  buildSearchBar() {
+    this.searchBarEl = document.createElement("div"), this.searchBarEl.classList.add("edv-search-bar");
+    const t = document.createElement("div");
+    t.classList.add("edv-search-input-wrapper"), this.searchInputEl = document.createElement("input"), this.searchInputEl.type = "text", this.searchInputEl.classList.add("edv-search-input"), this.searchInputEl.placeholder = "Search…", this.searchInputEl.addEventListener("input", () => this.onSearchInput()), this.searchInputEl.addEventListener(
+      "keydown",
+      (n) => this.handleSearchKeyDown(n)
+    ), this.searchCaseBtn = document.createElement("button"), this.searchCaseBtn.classList.add("edv-search-case-btn"), this.searchCaseBtn.textContent = "Aa", this.searchCaseBtn.title = "Match Case", this.searchCaseBtn.addEventListener("click", (n) => {
+      n.stopPropagation(), this.toggleCaseSensitive();
+    }), t.appendChild(this.searchInputEl), t.appendChild(this.searchCaseBtn), this.searchBarEl.appendChild(t), this.searchInfoEl = document.createElement("span"), this.searchInfoEl.classList.add("edv-search-info"), this.searchBarEl.appendChild(this.searchInfoEl);
+    const e = document.createElement("button");
+    e.classList.add("edv-search-nav-btn"), e.textContent = "↑", e.title = "Previous Match (Shift+Enter)", e.addEventListener("click", (n) => {
+      n.stopPropagation(), this.searchPrev();
+    }), this.searchBarEl.appendChild(e);
+    const s = document.createElement("button");
+    s.classList.add("edv-search-nav-btn"), s.textContent = "↓", s.title = "Next Match (Enter)", s.addEventListener("click", (n) => {
+      n.stopPropagation(), this.searchNext();
+    }), this.searchBarEl.appendChild(s);
+    const i = document.createElement("button");
+    i.classList.add("edv-search-nav-btn"), i.textContent = "✕", i.title = "Close (Escape)", i.addEventListener("click", (n) => {
+      n.stopPropagation(), this.closeSearch();
+    }), this.searchBarEl.appendChild(i), this.container.appendChild(this.searchBarEl);
+  }
+  /**
+   * Handle keyboard shortcuts on the container.
+   */
+  handleKeyDown(t) {
+    (t.metaKey || t.ctrlKey) && t.key === "f" && (t.preventDefault(), t.stopPropagation(), this.openSearch()), t.key === "Escape" && this.searchVisible && (t.preventDefault(), this.closeSearch());
+  }
+  /**
+   * Handle keyboard events inside the search input.
+   */
+  handleSearchKeyDown(t) {
+    t.key === "Enter" && (t.preventDefault(), t.shiftKey ? this.searchPrev() : this.searchNext()), t.key === "Escape" && (t.preventDefault(), this.closeSearch());
+  }
+  /**
+   * Create a toolbar button element.
+   */
+  createToolbarButton(t, e, s) {
+    const i = document.createElement("button");
+    return i.classList.add("edv-toolbar-btn"), i.textContent = t, i.title = e, i.addEventListener("click", (n) => {
+      n.stopPropagation(), s();
+    }), i;
+  }
+  /**
+   * Toggle word wrap mode for long lines.
+   */
+  toggleWordWrap() {
+    this.wordWrap = !this.wordWrap, this.container.classList.toggle("edv-word-wrap", this.wordWrap), this.wrapBtn && this.wrapBtn.classList.toggle("edv-toolbar-btn--active", this.wordWrap);
+  }
+  /**
+   * Get current word wrap state.
+   */
+  isWordWrap() {
+    return this.wordWrap;
+  }
+  /**
+   * Fold all foldable regions.
+   */
+  foldAll() {
+    this.foldState.foldAll(), this.render();
+  }
+  /**
+   * Unfold all folded regions.
+   */
+  unfoldAll() {
+    this.foldState.unfoldAll(), this.render();
+  }
+  /**
+   * Fold all regions deeper than the given level.
+   * Level 1 = top-level structures. foldToLevel(3) expands levels 1–3, folds 4+.
+   * foldToLevel(0) unfolds all.
+   */
+  foldToLevel(t) {
+    this.foldState.foldToLevel(t), this.render();
+  }
+  /**
+   * Get the raw Elixir data content.
+   */
+  getContent() {
+    return this.code;
+  }
+  /**
+   * Copy the raw Elixir data content to the clipboard.
+   * Shows a "✓" feedback on the copy button for 2 seconds.
+   * Returns a promise that resolves when copying is complete.
+   */
+  async copyContent() {
+    try {
+      await navigator.clipboard.writeText(this.code);
+    } catch {
+      const t = document.createElement("textarea");
+      t.value = this.code, t.style.position = "fixed", t.style.opacity = "0", document.body.appendChild(t), t.select(), document.execCommand("copy"), document.body.removeChild(t);
+    }
+    this.showCopyFeedback();
+  }
+  /**
+   * Show a brief "copied" feedback on the copy button.
+   */
+  showCopyFeedback() {
+    if (!this.copyBtn) return;
+    this.copyResetTimer && clearTimeout(this.copyResetTimer);
+    const t = "⎘";
+    this.copyBtn.textContent = "✓", this.copyBtn.classList.add("edv-toolbar-btn--active"), this.copyBtn.title = "Copied!", this.copyResetTimer = setTimeout(() => {
+      this.copyBtn && (this.copyBtn.textContent = t, this.copyBtn.classList.remove("edv-toolbar-btn--active"), this.copyBtn.title = "Copy"), this.copyResetTimer = null;
+    }, 2e3);
+  }
+  // ─── Search API ───────────────────────────────────────────────────────
+  /**
+   * Open the search bar and focus the input.
+   */
+  openSearch() {
+    var t;
+    this.searchVisible = !0, (t = this.searchBarEl) == null || t.classList.add("edv-search-bar--visible"), this.searchBtn && this.searchBtn.classList.add("edv-toolbar-btn--active"), this.searchInputEl && (this.searchInputEl.focus(), this.searchInputEl.select());
+  }
+  /**
+   * Close the search bar and clear highlights.
+   */
+  closeSearch() {
+    var t;
+    this.searchVisible = !1, (t = this.searchBarEl) == null || t.classList.remove("edv-search-bar--visible"), this.searchBtn && this.searchBtn.classList.remove("edv-toolbar-btn--active"), this.searchState.clear(), this.updateSearchInfo(), this.render(), this.container.focus();
+  }
+  /**
+   * Toggle search bar visibility.
+   */
+  toggleSearch() {
+    this.searchVisible ? this.closeSearch() : this.openSearch();
+  }
+  /**
+   * Navigate to the next search match.
+   */
+  searchNext() {
+    const t = this.searchState.next();
+    t && this.revealAndScrollToMatch(t), this.updateSearchInfo(), this.render();
+  }
+  /**
+   * Navigate to the previous search match.
+   */
+  searchPrev() {
+    const t = this.searchState.prev();
+    t && this.revealAndScrollToMatch(t), this.updateSearchInfo(), this.render();
+  }
+  /**
+   * Get the search state (for programmatic access / testing).
+   */
+  getSearchState() {
+    return this.searchState;
+  }
+  /**
+   * Programmatically search for a keyword.
+   * Highlights all matches and scrolls to the first one, but does NOT
+   * open/show the search bar UI. The search input is always kept in sync.
+   *
+   * @param query - The keyword to search for. Pass an empty string to clear.
+   * @param options - Optional settings. `caseSensitive` defaults to the
+   *                  current case-sensitivity state.
+   */
+  search(t, e) {
+    var n;
+    const s = (e == null ? void 0 : e.caseSensitive) ?? this.searchState.isCaseSensitive();
+    this.searchState.search(this.lines, t, s), this.searchInputEl && (this.searchInputEl.value = t), (n = this.searchCaseBtn) == null || n.classList.toggle(
+      "edv-search-case-btn--active",
+      s
+    ), this.updateSearchInfo();
+    const i = this.searchState.getCurrentMatch();
+    i && this.revealAndScrollToMatch(i), this.render();
+  }
+  /**
+   * Clear the current search state and remove all highlights.
+   * The search input is cleared but the search bar visibility is unchanged.
+   */
+  clearSearch() {
+    this.searchState.clear(), this.searchInputEl && (this.searchInputEl.value = ""), this.updateSearchInfo(), this.render();
+  }
+  /**
+   * Handle input in the search field.
+   */
+  onSearchInput() {
+    var s;
+    const t = ((s = this.searchInputEl) == null ? void 0 : s.value) ?? "";
+    this.searchState.search(
+      this.lines,
+      t,
+      this.searchState.isCaseSensitive()
+    ), this.updateSearchInfo();
+    const e = this.searchState.getCurrentMatch();
+    e && this.revealAndScrollToMatch(e), this.render();
+  }
+  /**
+   * Toggle case sensitivity and re-search.
+   */
+  toggleCaseSensitive() {
+    var i, n;
+    const t = !this.searchState.isCaseSensitive();
+    (i = this.searchCaseBtn) == null || i.classList.toggle("edv-search-case-btn--active", t);
+    const e = ((n = this.searchInputEl) == null ? void 0 : n.value) ?? "";
+    this.searchState.search(this.lines, e, t), this.updateSearchInfo();
+    const s = this.searchState.getCurrentMatch();
+    s && this.revealAndScrollToMatch(s), this.render();
+  }
+  /**
+   * Update the search info label (e.g. "3 of 12" or "No results").
+   */
+  updateSearchInfo() {
+    if (!this.searchInfoEl) return;
+    const t = this.searchState.getMatchCount();
+    if (!this.searchState.getQuery())
+      this.searchInfoEl.textContent = "", this.searchInfoEl.classList.remove("edv-search-info--no-results");
+    else if (t === 0)
+      this.searchInfoEl.textContent = "No results", this.searchInfoEl.classList.add("edv-search-info--no-results");
+    else {
+      const s = this.searchState.getCurrentIndex() + 1;
+      this.searchInfoEl.textContent = `${s} of ${t}`, this.searchInfoEl.classList.remove("edv-search-info--no-results");
+    }
+  }
+  /**
+   * Ensure the line containing a match is visible (unfold if needed)
+   * and scroll to it.
+   */
+  revealAndScrollToMatch(t) {
+    this.foldState.revealLine(t.line);
+  }
+  /**
+   * After render, scroll to the current search match element.
+   */
+  scrollToCurrentMatch() {
+    const t = this.scrollEl.querySelector(".edv-search-current");
+    t && t.scrollIntoView({ block: "center", behavior: "smooth" });
+  }
+  // ─── Filter API ─────────────────────────────────────────────────────────
+  /**
+   * Open the filter bar and focus the input.
+   */
+  openFilter() {
+    var t;
+    this.filterVisible = !0, (t = this.filterBarEl) == null || t.classList.add("edv-filter-bar--visible"), this.filterBtn && this.filterBtn.classList.add("edv-toolbar-btn--active"), this.updateFilterTags(), this.updateFilterInfo(), this.filterInputEl && this.filterInputEl.focus();
+  }
+  /**
+   * Close the filter bar (filters remain active).
+   */
+  closeFilter() {
+    var t;
+    this.filterVisible = !1, (t = this.filterBarEl) == null || t.classList.remove("edv-filter-bar--visible"), this.hideFilterDropdown(), this.filterBtn && this.filterBtn.classList.toggle(
+      "edv-toolbar-btn--active",
+      this.filterState.isActive()
+    ), this.container.focus();
+  }
+  /**
+   * Toggle filter bar visibility.
+   */
+  toggleFilter() {
+    this.filterVisible ? this.closeFilter() : this.openFilter();
+  }
+  /**
+   * Set keys to filter out (replaces existing filters). Re-renders.
+   */
+  setFilterKeys(t) {
+    this.filterState.setKeys(t), this.updateFilterTags(), this.updateFilterInfo(), this.updateFilterBtnState(), this.render();
+  }
+  /**
+   * Add a single key to the filter. Re-renders.
+   */
+  addFilterKey(t) {
+    this.filterState.addKey(t), this.updateFilterTags(), this.updateFilterInfo(), this.updateFilterBtnState(), this.render();
+  }
+  /**
+   * Remove a single key from the filter. Re-renders.
+   */
+  removeFilterKey(t) {
+    this.filterState.removeKey(t), this.updateFilterTags(), this.updateFilterInfo(), this.updateFilterBtnState(), this.render();
+  }
+  /**
+   * Get currently filtered keys.
+   */
+  getFilterKeys() {
+    return this.filterState.getKeys();
+  }
+  /**
+   * Get all keys detected in the current content.
+   */
+  getAvailableKeys() {
+    return this.filterState.getAvailableKeys();
+  }
+  /**
+   * Clear all key filters. Re-renders.
+   */
+  clearFilter() {
+    this.filterState.clear(), this.updateFilterTags(), this.updateFilterInfo(), this.updateFilterBtnState(), this.render();
+  }
+  /**
+   * Get the filter state (for programmatic access / testing).
+   */
+  getFilterState() {
+    return this.filterState;
+  }
+  /**
+   * Get the content with filtered lines removed.
+   * Returns lines that are not hidden by the current key filter.
+   */
+  getFilteredContent() {
+    if (!this.filterState.isActive())
+      return this.code;
+    const t = [];
+    for (let e = 0; e < this.lines.length; e++)
+      this.filterState.isLineFiltered(e) || t.push(this.lines[e]);
+    return t.join(`
+`);
+  }
+  /**
+   * Copy the filtered content (lines with filtered keys removed) to clipboard.
+   * Shows "✓" feedback on the filter copy button for 2 seconds.
+   */
+  async copyFilteredContent() {
+    const t = this.getFilteredContent();
+    try {
+      await navigator.clipboard.writeText(t);
+    } catch {
+      const e = document.createElement("textarea");
+      e.value = t, e.style.position = "fixed", e.style.opacity = "0", document.body.appendChild(e), e.select(), document.execCommand("copy"), document.body.removeChild(e);
+    }
+    this.showFilterCopyFeedback();
+  }
+  /**
+   * Show a brief "copied" feedback on the filter copy button.
+   */
+  showFilterCopyFeedback() {
+    this.filterCopyBtn && (this.filterCopyResetTimer && clearTimeout(this.filterCopyResetTimer), this.filterCopyBtn.textContent = "✓", this.filterCopyBtn.title = "Copied!", this.filterCopyResetTimer = setTimeout(() => {
+      this.filterCopyBtn && (this.filterCopyBtn.textContent = "⎘", this.filterCopyBtn.title = "Copy Filtered Content"), this.filterCopyResetTimer = null;
+    }, 2e3));
+  }
+  /**
+   * Build the filter bar DOM (hidden by default).
+   */
+  buildFilterBar() {
+    this.filterBarEl = document.createElement("div"), this.filterBarEl.classList.add("edv-filter-bar");
+    const t = document.createElement("div");
+    t.classList.add("edv-filter-input-wrapper"), this.filterInputEl = document.createElement("input"), this.filterInputEl.type = "text", this.filterInputEl.classList.add("edv-filter-input"), this.filterInputEl.placeholder = "Filter by key…", this.filterInputEl.addEventListener("input", () => this.onFilterInput()), this.filterInputEl.addEventListener(
+      "keydown",
+      (i) => this.handleFilterKeyDown(i)
+    ), this.filterInputEl.addEventListener("focus", () => this.onFilterInput()), t.appendChild(this.filterInputEl), this.filterDropdownEl = document.createElement("div"), this.filterDropdownEl.classList.add("edv-filter-dropdown"), t.appendChild(this.filterDropdownEl), this.filterBarEl.appendChild(t), this.filterTagsEl = document.createElement("div"), this.filterTagsEl.classList.add("edv-filter-tags"), this.filterBarEl.appendChild(this.filterTagsEl), this.filterInfoEl = document.createElement("span"), this.filterInfoEl.classList.add("edv-filter-info"), this.filterBarEl.appendChild(this.filterInfoEl), this.filterCopyBtn = document.createElement("button"), this.filterCopyBtn.classList.add("edv-search-nav-btn"), this.filterCopyBtn.textContent = "⎘", this.filterCopyBtn.title = "Copy Filtered Content", this.filterCopyBtn.addEventListener("click", (i) => {
+      i.stopPropagation(), this.copyFilteredContent();
+    }), this.filterBarEl.appendChild(this.filterCopyBtn);
+    const e = document.createElement("button");
+    e.classList.add("edv-search-nav-btn"), e.textContent = "⌫", e.title = "Clear All Filters", e.addEventListener("click", (i) => {
+      i.stopPropagation(), this.clearFilter();
+    }), this.filterBarEl.appendChild(e);
+    const s = document.createElement("button");
+    s.classList.add("edv-search-nav-btn"), s.textContent = "✕", s.title = "Close", s.addEventListener("click", (i) => {
+      i.stopPropagation(), this.closeFilter();
+    }), this.filterBarEl.appendChild(s), document.addEventListener("click", (i) => {
+      var n;
+      (n = this.filterBarEl) != null && n.contains(i.target) || this.hideFilterDropdown();
+    }), this.container.appendChild(this.filterBarEl);
+  }
+  /**
+   * Handle input in the filter field — show autocomplete dropdown.
+   */
+  onFilterInput() {
+    var n;
+    const t = ((n = this.filterInputEl) == null ? void 0 : n.value.trim().toLowerCase()) ?? "", e = this.filterState.getAvailableKeys(), s = this.filterState.getKeys(), i = e.filter(
+      (l) => !s.includes(l) && (t === "" || l.toLowerCase().includes(t))
+    );
+    this.showFilterDropdown(i);
+  }
+  /**
+   * Handle keyboard events in the filter input.
+   */
+  handleFilterKeyDown(t) {
+    var i, n, l;
+    const e = this.filterDropdownItems.length, s = (i = this.filterDropdownEl) == null ? void 0 : i.classList.contains("edv-filter-dropdown--visible");
+    if (t.key === "ArrowDown" && s && e > 0) {
+      t.preventDefault(), this.filterDropdownIndex = Math.min(this.filterDropdownIndex + 1, e - 1), this.updateFilterDropdownHighlight();
+      return;
+    }
+    if (t.key === "ArrowUp" && s && e > 0) {
+      t.preventDefault(), this.filterDropdownIndex = Math.max(this.filterDropdownIndex - 1, 0), this.updateFilterDropdownHighlight();
+      return;
+    }
+    if (t.key === "Enter") {
+      if (t.preventDefault(), s && this.filterDropdownIndex >= 0 && this.filterDropdownIndex < e) {
+        const c = this.filterDropdownItems[this.filterDropdownIndex];
+        c && !this.filterState.hasKey(c) && (this.addFilterKey(c), this.filterInputEl && (this.filterInputEl.value = ""), this.hideFilterDropdown());
+        return;
+      }
+      const o = ((n = this.filterInputEl) == null ? void 0 : n.value.trim()) ?? "";
+      if (o) {
+        const d = this.filterState.getAvailableKeys().find(
+          (m) => m.toLowerCase() === o.toLowerCase()
+        );
+        d && !this.filterState.hasKey(d) && (this.addFilterKey(d), this.filterInputEl && (this.filterInputEl.value = ""), this.hideFilterDropdown());
+      }
+    }
+    t.key === "Escape" && (t.preventDefault(), this.hideFilterDropdown(), (l = this.filterInputEl) != null && l.value ? this.filterInputEl && (this.filterInputEl.value = "") : this.closeFilter());
+  }
+  /**
+   * Update the visual highlight on the dropdown items.
+   */
+  updateFilterDropdownHighlight() {
+    if (!this.filterDropdownEl) return;
+    const t = this.filterDropdownEl.querySelectorAll(".edv-filter-dropdown-item");
+    t.forEach((s, i) => {
+      s.classList.toggle("edv-filter-dropdown-item--active", i === this.filterDropdownIndex);
+    });
+    const e = t[this.filterDropdownIndex];
+    e && e.scrollIntoView({ block: "nearest" });
+  }
+  /**
+   * Show the autocomplete dropdown with suggestions.
+   */
+  showFilterDropdown(t) {
+    if (this.filterDropdownEl) {
+      if (this.filterDropdownEl.innerHTML = "", this.filterDropdownItems = t, this.filterDropdownIndex = -1, t.length === 0) {
+        this.filterDropdownEl.classList.remove("edv-filter-dropdown--visible");
+        return;
+      }
+      for (const e of t) {
+        const s = document.createElement("div");
+        s.classList.add("edv-filter-dropdown-item"), s.textContent = e, s.addEventListener("mousedown", (i) => {
+          i.preventDefault(), i.stopPropagation(), this.addFilterKey(e), this.filterInputEl && (this.filterInputEl.value = "", this.filterInputEl.focus()), this.hideFilterDropdown();
+        }), this.filterDropdownEl.appendChild(s);
+      }
+      this.filterDropdownEl.classList.add("edv-filter-dropdown--visible");
+    }
+  }
+  /**
+   * Hide the autocomplete dropdown.
+   */
+  hideFilterDropdown() {
+    var t;
+    (t = this.filterDropdownEl) == null || t.classList.remove("edv-filter-dropdown--visible");
+  }
+  /**
+   * Rebuild the filter tag chips in the filter bar.
+   */
+  updateFilterTags() {
+    if (!this.filterTagsEl) return;
+    this.filterTagsEl.innerHTML = "";
+    const t = this.filterState.getKeys();
+    for (const e of t) {
+      const s = document.createElement("span");
+      s.classList.add("edv-filter-tag");
+      const i = document.createElement("span");
+      i.classList.add("edv-filter-tag-label"), i.textContent = e, s.appendChild(i);
+      const n = document.createElement("button");
+      n.classList.add("edv-filter-tag-remove"), n.textContent = "✕", n.title = `Remove filter: ${e}`, n.addEventListener("click", (l) => {
+        l.stopPropagation(), this.removeFilterKey(e);
+      }), s.appendChild(n), this.filterTagsEl.appendChild(s);
+    }
+  }
+  /**
+   * Update the filter info label.
+   */
+  updateFilterInfo() {
+    if (!this.filterInfoEl) return;
+    const t = this.filterState.getFilteredCount();
+    t === 0 ? this.filterInfoEl.textContent = "" : this.filterInfoEl.textContent = `${t} key${t > 1 ? "s" : ""} hidden`;
+  }
+  /**
+   * Update filter toolbar button active state.
+   */
+  updateFilterBtnState() {
+    this.filterBtn && this.filterBtn.classList.toggle(
+      "edv-toolbar-btn--active",
+      this.filterState.isActive()
+    );
+  }
+  // ─── Content ──────────────────────────────────────────────────────────
+  /**
+   * Set the Elixir data content and render it.
+   */
+  setContent(t) {
+    this.code = t, this.lines = t.split(`
+`), this.buildLineOffsets();
+    const { modifiedCode: e, inspectLiterals: s } = it(t);
+    this.inspectLiterals = s;
+    const i = O(e);
+    this.tree = i, this.tokens = P(e, i), this.fixInspectLiteralTokenClasses();
+    const n = _(e, i), l = U(n);
+    this.foldState.setRegions(n, l), this.filterState.detectKeys(i, e), this.defaultFilterKeys.length > 0 && !this.filterState.isActive() && (this.filterState.setKeys(this.defaultFilterKeys), this.updateFilterTags(), this.updateFilterInfo(), this.updateFilterBtnState()), this.defaultFoldLevel > 0 && this.foldState.foldToLevel(this.defaultFoldLevel), this.searchState.isActive() && (this.searchState.search(
+      this.lines,
+      this.searchState.getQuery(),
+      this.searchState.isCaseSensitive()
+    ), this.updateSearchInfo()), this.render();
+  }
+  /**
+   * Set a callback to be called after each render (for testing/animation).
+   */
+  onRender(t) {
+    this.onRenderCallback = t;
+  }
+  /**
+   * Post-process highlight tokens: replace CSS classes for spans that fall
+   * within pre-processed inspect literal ranges (e.g. #Reference<...>)
+   * so they render with the inspect-literal style instead of atom style.
+   */
+  fixInspectLiteralTokenClasses() {
+    if (this.inspectLiterals.length !== 0)
+      for (const t of this.inspectLiterals)
+        for (const e of this.tokens)
+          e.from >= t.from && e.to <= t.to && (e.classes = "tok-inspect-literal");
+  }
+  /**
+   * Check if an offset falls within a pre-processed inspect literal and
+   * return the literal if so, or null.
+   */
+  findInspectLiteral(t, e) {
+    for (const s of this.inspectLiterals)
+      if (t >= s.from && e <= s.to)
+        return s;
+    return null;
+  }
+  /**
+   * Build line offset table for mapping offsets to line-relative positions.
+   */
+  buildLineOffsets() {
+    this.lineOffsets = [0];
+    for (let t = 0; t < this.code.length; t++)
+      this.code[t] === `
+` && this.lineOffsets.push(t + 1);
+  }
+  /**
+   * Full re-render of the viewer.
+   */
+  render() {
+    var i;
+    this.scrollEl.innerHTML = "";
+    const t = this.lines.length, e = String(t).length;
+    let s = 0;
+    for (; s < t; ) {
+      if (this.foldState.isLineHidden(s)) {
+        s++;
+        continue;
+      }
+      if (this.filterState.isLineFiltered(s)) {
+        s++;
+        continue;
+      }
+      const l = this.foldState.isFoldable(s), o = this.foldState.isFolded(s), c = this.foldState.getRegion(s), d = this.createLineElement(
+        s,
+        e,
+        l,
+        o,
+        c
+      );
+      this.scrollEl.appendChild(d), s++;
+    }
+    (i = this.onRenderCallback) == null || i.call(this), this.searchState.isActive() && this.searchState.getCurrentMatch() && requestAnimationFrame(() => this.scrollToCurrentMatch());
+  }
+  /**
+   * Create a single line element with gutter and code content.
+   */
+  createLineElement(t, e, s, i, n) {
+    const l = document.createElement("div");
+    l.classList.add("edv-line"), l.dataset.line = String(t), this.searchState.getLineMatches(t).length > 0 && l.classList.add("edv-line--has-match");
+    const c = document.createElement("div");
+    c.classList.add("edv-gutter");
+    const d = document.createElement("span");
+    d.classList.add("edv-line-number"), d.textContent = String(t + 1).padStart(e, " "), c.appendChild(d);
+    const m = document.createElement("span");
+    m.classList.add("edv-fold-indicator"), s && (m.classList.add("edv-foldable"), m.textContent = i ? "▶" : "▼", m.addEventListener("click", (h) => {
+      h.stopPropagation(), this.foldState.toggle(t), this.render();
+    })), c.appendChild(m), l.appendChild(c);
+    const f = document.createElement("div");
+    return f.classList.add("edv-code"), i && n ? this.renderFoldedLine(f, t, n) : this.renderHighlightedLine(f, t), l.appendChild(f), l;
+  }
+  /**
+   * Render a normal highlighted line, with search match highlighting.
+   */
+  renderHighlightedLine(t, e) {
+    const s = this.lines[e], i = this.lineOffsets[e], n = i + s.length, l = C(this.tokens, i, n), o = this.searchState.getLineMatches(e);
+    if (s.length === 0) {
+      t.innerHTML = "&nbsp;";
+      return;
+    }
+    if (o.length === 0) {
+      this.renderTokenizedText(t, s, l, i);
+      return;
+    }
+    this.renderWithSearchHighlights(t, s, l, o, e);
+  }
+  /**
+   * Render tokenized text without search highlights.
+   */
+  renderTokenizedText(t, e, s, i) {
+    const n = i ?? 0;
+    if (s.length === 0) {
+      const o = document.createElement("span");
+      o.dataset.from = String(n), o.dataset.to = String(n + e.length), o.textContent = e, t.appendChild(o);
+      return;
+    }
+    let l = 0;
+    for (const o of s) {
+      if (o.from > l) {
+        const d = document.createElement("span");
+        d.dataset.from = String(n + l), d.dataset.to = String(n + o.from), d.textContent = e.slice(l, o.from), t.appendChild(d);
+      }
+      const c = document.createElement("span");
+      c.className = o.classes, c.dataset.from = String(n + o.from), c.dataset.to = String(n + o.to), c.textContent = e.slice(o.from, o.to), t.appendChild(c), l = o.to;
+    }
+    if (l < e.length) {
+      const o = document.createElement("span");
+      o.dataset.from = String(n + l), o.dataset.to = String(n + e.length), o.textContent = e.slice(l), t.appendChild(o);
+    }
+  }
+  /**
+   * Render a line with both syntax tokens and search highlight overlays.
+   * Search highlights take precedence visually (wrapping around tokens).
+   */
+  renderWithSearchHighlights(t, e, s, i, n) {
+    const l = new Array(e.length).fill(null);
+    for (const f of s)
+      for (let h = f.from; h < f.to && h < e.length; h++)
+        l[h] = f.classes;
+    const o = [], c = new Array(e.length).fill(null);
+    for (const f of i)
+      for (let h = f.from; h < f.to && h < e.length; h++)
+        c[h] = f;
+    let d = 0;
+    for (; d < e.length; ) {
+      const f = l[d], h = c[d], g = h !== null, v = h ? this.searchState.isCurrentMatch(n, h.from) : !1;
+      let u = d + 1;
+      for (; u < e.length; ) {
+        const y = l[u], E = c[u], F = E !== null, A = E ? this.searchState.isCurrentMatch(n, E.from) : !1;
+        if (y !== f || F !== g || A !== v) break;
+        u++;
+      }
+      o.push({ from: d, to: u, tokenClass: f, isMatch: g, isCurrent: v }), d = u;
+    }
+    const m = this.lineOffsets[n];
+    for (const f of o) {
+      const h = e.slice(f.from, f.to), g = m + f.from, v = m + f.to;
+      if (f.isMatch) {
+        const u = document.createElement("mark");
+        if (u.classList.add("edv-search-match"), f.isCurrent && u.classList.add("edv-search-current"), u.dataset.from = String(g), u.dataset.to = String(v), f.tokenClass) {
+          const y = document.createElement("span");
+          y.className = f.tokenClass, y.textContent = h, u.appendChild(y);
+        } else
+          u.textContent = h;
+        t.appendChild(u);
+      } else if (f.tokenClass) {
+        const u = document.createElement("span");
+        u.className = f.tokenClass, u.dataset.from = String(g), u.dataset.to = String(v), u.textContent = h, t.appendChild(u);
+      } else {
+        const u = document.createElement("span");
+        u.dataset.from = String(g), u.dataset.to = String(v), u.textContent = h, t.appendChild(u);
+      }
+    }
+  }
+  /**
+   * Render a folded line: shows the opening line content followed by … and closing bracket.
+   */
+  renderFoldedLine(t, e, s) {
+    const i = this.lines[e], n = this.lineOffsets[e], l = n + i.length, o = C(this.tokens, n, l);
+    let c = 0;
+    for (const h of o) {
+      if (h.from > c) {
+        const v = document.createElement("span");
+        v.dataset.from = String(n + c), v.dataset.to = String(n + h.from), v.textContent = i.slice(c, h.from), t.appendChild(v);
+      }
+      const g = document.createElement("span");
+      g.className = h.classes, g.dataset.from = String(n + h.from), g.dataset.to = String(n + h.to), g.textContent = i.slice(h.from, h.to), t.appendChild(g), c = h.to;
+    }
+    if (c < i.length) {
+      const h = document.createElement("span");
+      h.dataset.from = String(n + c), h.dataset.to = String(n + i.length), h.textContent = i.slice(c), t.appendChild(h);
+    }
+    const d = document.createElement("span");
+    d.classList.add("edv-fold-ellipsis");
+    const m = s.endLine - s.startLine;
+    if (s.itemCount > 0)
+      d.textContent = `${s.itemCount} items`, d.title = `${s.itemCount} items, ${m} lines folded`;
+    else {
+      const g = s.openText === '"""' || s.openText === "'''" ? m - 1 : m;
+      d.textContent = `${g} lines`, d.title = `${g} lines folded`;
+    }
+    d.dataset.from = String(s.startOffset), d.dataset.to = String(s.endOffset), d.addEventListener("click", (h) => {
+      h.stopPropagation(), this.foldState.toggle(e), this.render();
+    }), t.appendChild(d);
+    const f = document.createElement("span");
+    f.classList.add("tok-punctuation"), f.dataset.from = String(s.endOffset - s.closeText.length), f.dataset.to = String(s.endOffset), f.textContent = s.closeText, t.appendChild(f);
+  }
+  // ─── Inspect (Hover + Click-to-Copy) ──────────────────────────────────
+  /**
+   * Handle mouseover on spans to resolve inspect target and apply highlight.
+   */
+  handleInspectHover(t) {
+    const e = t.target;
+    if (!e || !this.tree) return;
+    const s = e.closest("[data-from]");
+    if (!s) {
+      this.clearInspectHighlight();
+      return;
+    }
+    const i = parseInt(s.dataset.from, 10);
+    if (isNaN(i)) return;
+    const n = J(this.tree, this.code, i);
+    if (!n) {
+      this.clearInspectHighlight();
+      return;
+    }
+    this.findInspectLiteral(n.from, n.to) && (n.type = "InspectLiteral"), !(this.currentInspect && this.currentInspect.from === n.from && this.currentInspect.to === n.to) && (this.clearInspectHighlight(), this.currentInspect = n, this.applyInspectHighlight(n));
+  }
+  /**
+   * Handle mouseout — clear highlight when leaving the scroll area.
+   */
+  handleInspectOut(t) {
+    const s = t.relatedTarget;
+    s && this.scrollEl.contains(s) || this.clearInspectHighlight();
+  }
+  /**
+   * Register a callback invoked when the user clicks an inspectable value.
+   * The callback receives an InspectEvent with type, copyText, DOM element,
+   * and a preventDefault() method to suppress the default copy behavior.
+   *
+   * Pass `null` to unregister the callback and restore default behavior.
+   */
+  onInspect(t) {
+    this.inspectCallback = t;
+  }
+  /**
+   * Handle click on an inspected token — copy to clipboard (unless prevented by callback).
+   */
+  handleInspectClick(t) {
+    if (!this.currentInspect) return;
+    const e = t.target;
+    if (!e) return;
+    const s = e.closest(".edv-fold-indicator, .edv-fold-ellipsis");
+    if (s && !s.dataset.from) return;
+    const i = e.closest("[data-from]");
+    if (!i) return;
+    const n = this.currentInspect.copyText;
+    let l = !1;
+    if (this.inspectCallback) {
+      const o = {
+        type: this.currentInspect.type,
+        copyText: n,
+        target: this.currentInspect,
+        element: i,
+        mouseEvent: t,
+        preventDefault() {
+          l = !0;
+        }
+      };
+      this.inspectCallback(o);
+    }
+    this.flashInspectHighlight(), l || (this.copyToClipboard(n), this.showInspectToast(t));
+  }
+  /**
+   * Apply highlight CSS classes to all spans within the inspect target range.
+   */
+  applyInspectHighlight(t) {
+    if (t.isStructure) {
+      const e = this.offsetToLine(t.from), s = this.offsetToLine(t.to - 1), i = this.scrollEl.querySelectorAll(".edv-line");
+      for (const n of i) {
+        const l = parseInt(n.dataset.line, 10);
+        isNaN(l) || l >= e && l <= s && n.classList.add("edv-inspect-line");
+      }
+      this.highlightSpansInRange(t.from, t.to, "edv-inspect-bracket");
+    } else
+      this.highlightSpansInRange(t.from, t.to, "edv-inspect-token");
+  }
+  /**
+   * Add a CSS class to all spans whose data-from/data-to overlap the given range.
+   */
+  highlightSpansInRange(t, e, s) {
+    const i = this.scrollEl.querySelectorAll("[data-from]");
+    for (const n of i) {
+      const l = parseInt(n.dataset.from, 10), o = parseInt(n.dataset.to, 10);
+      isNaN(l) || isNaN(o) || l < e && o > t && n.classList.add(s);
+    }
+  }
+  /**
+   * Clear all inspect highlight classes.
+   */
+  clearInspectHighlight() {
+    if (!this.currentInspect) return;
+    const t = this.scrollEl.querySelectorAll(".edv-inspect-line");
+    for (const s of t)
+      s.classList.remove("edv-inspect-line");
+    const e = this.scrollEl.querySelectorAll(
+      ".edv-inspect-token, .edv-inspect-bracket"
+    );
+    for (const s of e)
+      s.classList.remove("edv-inspect-token", "edv-inspect-bracket");
+    this.currentInspect = null;
+  }
+  /**
+   * Flash animation on currently highlighted elements.
+   */
+  flashInspectHighlight() {
+    const t = this.scrollEl.querySelectorAll(
+      ".edv-inspect-token, .edv-inspect-bracket"
+    );
+    for (const e of t)
+      e.classList.add("edv-inspect-copied"), e.addEventListener(
+        "animationend",
+        () => e.classList.remove("edv-inspect-copied"),
+        { once: !0 }
+      );
+  }
+  /**
+   * Show a small floating "Copied!" toast near the mouse click position.
+   */
+  showInspectToast(t) {
+    const e = document.createElement("div");
+    e.classList.add("edv-copied-toast"), e.textContent = "Copied!", e.style.left = `${t.clientX + 8}px`, e.style.top = `${t.clientY - 24}px`, document.body.appendChild(e), e.addEventListener("animationend", () => {
+      e.remove();
+    });
+  }
+  /**
+   * Copy text to clipboard with fallback.
+   */
+  async copyToClipboard(t) {
+    try {
+      await navigator.clipboard.writeText(t);
+    } catch {
+      const e = document.createElement("textarea");
+      e.value = t, e.style.position = "fixed", e.style.opacity = "0", document.body.appendChild(e), e.select(), document.execCommand("copy"), document.body.removeChild(e);
+    }
+  }
+  /**
+   * Convert an absolute character offset to a 0-indexed line number.
+   */
+  offsetToLine(t) {
+    let e = 0, s = this.lineOffsets.length - 1;
+    for (; e < s; ) {
+      const i = e + s + 1 >> 1;
+      this.lineOffsets[i] <= t ? e = i : s = i - 1;
+    }
+    return e;
+  }
+}
+export {
+  at as ElixirDataViewer,
+  Y as FilterState,
+  z as FoldState,
+  Q as SearchState,
+  U as buildFoldMap,
+  _ as detectFoldRegions,
+  C as getLineTokens,
+  P as highlight,
+  O as parseElixir,
+  it as preprocessInspectLiterals,
+  J as resolveInspectTarget
+};