y11n-spreadsheet 0.1.0

package/dist/index.js

@@ -0,0 +1,1470 @@
+import { css as k, LitElement as V, html as _, nothing as x } from "lit";
+import { property as w, state as E, customElement as D, query as A } from "lit/decorators.js";
+import { repeat as N } from "lit/directives/repeat.js";
+function y(i, e) {
+  return `${i}:${e}`;
+}
+function j(i) {
+  const [e, t] = i.split(":").map(Number);
+  return { row: e, col: t };
+}
+function R(i) {
+  let e = "", t = i;
+  for (; t >= 0; )
+    e = String.fromCharCode(t % 26 + 65) + e, t = Math.floor(t / 26) - 1;
+  return e;
+}
+function M(i) {
+  let e = 0;
+  for (let t = 0; t < i.length; t++)
+    e = e * 26 + (i.charCodeAt(t) - 64);
+  return e - 1;
+}
+function S(i) {
+  const e = i.match(/^([A-Z]+)(\d+)$/i);
+  if (!e) throw new Error(`Invalid cell reference: ${i}`);
+  const t = M(e[1].toUpperCase());
+  return { row: parseInt(e[2], 10) - 1, col: t };
+}
+function O(i) {
+  return `${R(i.col)}${i.row + 1}`;
+}
+class B {
+  constructor(e, t, s) {
+    this.anchor = { row: 0, col: 0 }, this.head = { row: 0, col: 0 }, this._isDragging = !1, this.host = e, this._maxRows = t, this._maxCols = s, e.addController(this);
+  }
+  hostConnected() {
+  }
+  hostDisconnected() {
+    this._isDragging = !1;
+  }
+  /** Update grid bounds (e.g., when rows/cols properties change) */
+  setBounds(e, t) {
+    this._maxRows = e, this._maxCols = t;
+  }
+  /** Get the normalized selection range (top-left to bottom-right) */
+  get range() {
+    return {
+      start: {
+        row: Math.min(this.anchor.row, this.head.row),
+        col: Math.min(this.anchor.col, this.head.col)
+      },
+      end: {
+        row: Math.max(this.anchor.row, this.head.row),
+        col: Math.max(this.anchor.col, this.head.col)
+      }
+    };
+  }
+  /** Get the currently active cell (head of selection) */
+  get activeCell() {
+    return { ...this.head };
+  }
+  /** Check if a cell is within the current selection */
+  isCellSelected(e, t) {
+    const s = this.range;
+    return e >= s.start.row && e <= s.end.row && t >= s.start.col && t <= s.end.col;
+  }
+  /** Check if a cell is the active cell (head) */
+  isCellActive(e, t) {
+    return e === this.head.row && t === this.head.col;
+  }
+  // ─── Mouse Interaction ──────────────────────────────
+  /** Called on mousedown/pointerdown on a cell */
+  startSelection(e, t, s = !1) {
+    if (s)
+      this.head = this.clamp({ row: e, col: t });
+    else {
+      const r = this.clamp({ row: e, col: t });
+      this.anchor = { ...r }, this.head = { ...r };
+    }
+    this._isDragging = !0, this.host.requestUpdate();
+  }
+  /** Called on mousemove during drag */
+  extendSelection(e, t) {
+    this._isDragging && (this.head = this.clamp({ row: e, col: t }), this.host.requestUpdate());
+  }
+  /** Called on mouseup */
+  endSelection() {
+    this._isDragging = !1;
+  }
+  get isDragging() {
+    return this._isDragging;
+  }
+  // ─── Keyboard Navigation ────────────────────────────
+  /** Move the active cell by delta. If extend=true, extends selection. */
+  move(e, t, s = !1) {
+    const r = this.clamp({
+      row: this.head.row + e,
+      col: this.head.col + t
+    });
+    this.head = r, s || (this.anchor = { ...r }), this.host.requestUpdate();
+  }
+  /** Move to a specific cell */
+  moveTo(e, t, s = !1) {
+    const r = this.clamp({ row: e, col: t });
+    this.head = r, s || (this.anchor = { ...r }), this.host.requestUpdate();
+  }
+  /** Select all cells */
+  selectAll() {
+    this.anchor = { row: 0, col: 0 }, this.head = { row: this._maxRows - 1, col: this._maxCols - 1 }, this.host.requestUpdate();
+  }
+  /** Clear selection (collapse to active cell) */
+  clearSelection() {
+    this.anchor = { ...this.head }, this.host.requestUpdate();
+  }
+  // ─── Helpers ────────────────────────────────────────
+  clamp(e) {
+    return {
+      row: Math.max(0, Math.min(e.row, this._maxRows - 1)),
+      col: Math.max(0, Math.min(e.col, this._maxCols - 1))
+    };
+  }
+}
+const U = 64;
+class F {
+  constructor() {
+    this.functions = /* @__PURE__ */ new Map(), this.data = /* @__PURE__ */ new Map(), this.evaluating = /* @__PURE__ */ new Set(), this._evalDepth = 0, this._deps = /* @__PURE__ */ new Map(), this._reverseDeps = /* @__PURE__ */ new Map(), this._trackingCellKey = null, this.registerBuiltins();
+  }
+  /** Register a user-defined function */
+  registerFunction(e, t) {
+    this.functions.set(e.toUpperCase(), t);
+  }
+  /** Update the data reference for evaluation */
+  setData(e) {
+    this.data = e, this._deps.clear(), this._reverseDeps.clear();
+  }
+  /**
+   * Evaluate a raw value. If it starts with '=', parse and execute the formula.
+   * Otherwise, return the value as-is (possibly coerced).
+   *
+   * @param forCellKey - If provided, tracks formula dependencies for this cell key.
+   */
+  evaluate(e, t) {
+    if (!e || e.trim() === "")
+      return t && this._clearDepsFor(t), { displayValue: "", type: "text" };
+    if (!e.startsWith("="))
+      return t && this._clearDepsFor(t), this.coerceValue(e);
+    try {
+      t && (this._clearDepsFor(t), this._trackingCellKey = t);
+      const s = e.substring(1), r = this.parseExpression(s);
+      return this.coerceValue(String(r));
+    } catch (s) {
+      const r = s instanceof Error ? s.message : "";
+      return r.startsWith("#") ? { displayValue: r, type: "error" } : { displayValue: "#ERROR!", type: "error" };
+    } finally {
+      this._trackingCellKey = null;
+    }
+  }
+  /**
+   * Re-evaluate all formula cells in the grid.
+   * Rebuilds the dependency graph. Returns a set of cell keys that changed.
+   */
+  recalculate() {
+    this._deps.clear(), this._reverseDeps.clear();
+    const e = /* @__PURE__ */ new Set();
+    for (const [t, s] of this.data)
+      if (s.rawValue.startsWith("=")) {
+        const r = this.evaluate(s.rawValue, t);
+        (s.displayValue !== r.displayValue || s.type !== r.type) && (s.displayValue = r.displayValue, s.type = r.type, e.add(t));
+      }
+    return e;
+  }
+  /**
+   * Recalculate only formulas affected by the given changed cell keys.
+   * Uses the dependency graph for targeted recalculation (BFS order).
+   */
+  recalculateAffected(e) {
+    if (this._reverseDeps.size === 0 && this.data.size > 0)
+      return this.recalculate();
+    const t = /* @__PURE__ */ new Set(), s = new Set(e);
+    for (const n of e) {
+      const l = this.data.get(n);
+      if (l != null && l.rawValue.startsWith("=")) {
+        const c = this.evaluate(l.rawValue, n);
+        (l.displayValue !== c.displayValue || l.type !== c.type) && (l.displayValue = c.displayValue, l.type = c.type, t.add(n));
+      }
+    }
+    const r = [], a = /* @__PURE__ */ new Set(), o = [...e];
+    for (; o.length > 0; ) {
+      const n = o.shift(), l = this._reverseDeps.get(n);
+      if (l)
+        for (const c of l)
+          !a.has(c) && !s.has(c) && (a.add(c), r.push(c), o.push(c));
+    }
+    for (const n of r) {
+      const l = this.data.get(n);
+      if (l != null && l.rawValue.startsWith("=")) {
+        const c = this.evaluate(l.rawValue, n);
+        (l.displayValue !== c.displayValue || l.type !== c.type) && (l.displayValue = c.displayValue, l.type = c.type, t.add(n));
+      }
+    }
+    return t;
+  }
+  // ─── Dependency Tracking ─────────────────────────────
+  _clearDepsFor(e) {
+    var s;
+    const t = this._deps.get(e);
+    if (t) {
+      for (const r of t)
+        (s = this._reverseDeps.get(r)) == null || s.delete(e);
+      this._deps.delete(e);
+    }
+  }
+  _trackDep(e) {
+    if (!this._trackingCellKey) return;
+    let t = this._deps.get(this._trackingCellKey);
+    t || (t = /* @__PURE__ */ new Set(), this._deps.set(this._trackingCellKey, t)), t.add(e);
+    let s = this._reverseDeps.get(e);
+    s || (s = /* @__PURE__ */ new Set(), this._reverseDeps.set(e, s)), s.add(this._trackingCellKey);
+  }
+  // ─── Value Coercion ──────────────────────────────────
+  coerceValue(e) {
+    if (e === "#ERROR!" || e === "#REF!" || e === "#DIV/0!" || e === "#NAME?" || e === "#CIRC!")
+      return { displayValue: e, type: "error" };
+    const t = e.toUpperCase();
+    if (t === "TRUE" || t === "FALSE")
+      return { displayValue: t, type: "boolean" };
+    const s = Number(e);
+    return e.trim() !== "" && !isNaN(s) ? { displayValue: String(s), type: "number" } : { displayValue: e, type: "text" };
+  }
+  // ─── Lexer ───────────────────────────────────────────
+  tokenize(e) {
+    const t = [];
+    let s = 0;
+    for (; s < e.length; ) {
+      const r = e[s];
+      if (/\s/.test(r)) {
+        s++;
+        continue;
+      }
+      if (r === '"') {
+        let a = "";
+        for (s++; s < e.length && e[s] !== '"'; )
+          a += e[s], s++;
+        s++, t.push({ type: "STRING", value: a });
+        continue;
+      }
+      if (/\d/.test(r) || r === "." && s + 1 < e.length && /\d/.test(e[s + 1])) {
+        let a = "";
+        for (; s < e.length && (/\d/.test(e[s]) || e[s] === "."); )
+          a += e[s], s++;
+        t.push({ type: "NUMBER", value: a });
+        continue;
+      }
+      if (r === "+" || r === "-" || r === "*" || r === "/" || r === "&") {
+        t.push({ type: "OPERATOR", value: r }), s++;
+        continue;
+      }
+      if (r === "<" || r === ">") {
+        s + 1 < e.length && e[s + 1] === "=" ? (t.push({ type: "OPERATOR", value: r + "=" }), s += 2) : r === "<" && s + 1 < e.length && e[s + 1] === ">" ? (t.push({ type: "OPERATOR", value: "<>" }), s += 2) : (t.push({ type: "OPERATOR", value: r }), s++);
+        continue;
+      }
+      if (r === "=") {
+        t.push({ type: "OPERATOR", value: "=" }), s++;
+        continue;
+      }
+      if (r === "(") {
+        t.push({ type: "LPAREN", value: "(" }), s++;
+        continue;
+      }
+      if (r === ")") {
+        t.push({ type: "RPAREN", value: ")" }), s++;
+        continue;
+      }
+      if (r === ",") {
+        t.push({ type: "COMMA", value: "," }), s++;
+        continue;
+      }
+      if (/[A-Za-z_]/.test(r)) {
+        let a = "";
+        for (; s < e.length && /[A-Za-z0-9_]/.test(e[s]); )
+          a += e[s], s++;
+        const o = a.toUpperCase();
+        if (o === "TRUE" || o === "FALSE") {
+          t.push({ type: "BOOLEAN", value: o });
+          continue;
+        }
+        if (s < e.length && e[s] === ":" && /^[A-Z]+\d+$/i.test(a)) {
+          s++;
+          let l = "";
+          for (; s < e.length && /[A-Za-z0-9]/.test(e[s]); )
+            l += e[s], s++;
+          if (/^[A-Z]+\d+$/i.test(l)) {
+            t.push({ type: "RANGE", value: `${a.toUpperCase()}:${l.toUpperCase()}` });
+            continue;
+          }
+          throw new Error(`Invalid range: ${a}:${l}`);
+        }
+        let n = s;
+        for (; n < e.length && /\s/.test(e[n]); ) n++;
+        if (n < e.length && e[n] === "(") {
+          t.push({ type: "FUNC", value: o });
+          continue;
+        }
+        if (/^[A-Z]+\d+$/i.test(a)) {
+          t.push({ type: "REF", value: a.toUpperCase() });
+          continue;
+        }
+        t.push({ type: "FUNC", value: o });
+        continue;
+      }
+      throw new Error(`Unexpected character: ${r}`);
+    }
+    return t.push({ type: "EOF", value: "" }), t;
+  }
+  // ─── Parser ──────────────────────────────────────────
+  //
+  // Parser state is passed as a mutable object through the recursive
+  // descent chain so that nested evaluations (resolveRef / resolveRange)
+  // each get their own independent state without save/restore.
+  _peek(e) {
+    return e.tokens[e.pos];
+  }
+  _consume(e, t) {
+    const s = e.tokens[e.pos];
+    if (t && s.type !== t)
+      throw new Error(`Expected ${t} but got ${s.type} (${s.value})`);
+    return e.pos++, s;
+  }
+  parseExpression(e) {
+    if (++this._evalDepth > U)
+      throw this._evalDepth--, new Error("#ERROR!");
+    try {
+      const t = { tokens: this.tokenize(e), pos: 0 };
+      return this._parseComparison(t);
+    } finally {
+      this._evalDepth--;
+    }
+  }
+  _parseComparison(e) {
+    let t = this._parseConcatenation(e);
+    for (; this._peek(e).type === "OPERATOR" && ["=", "<>", "<", ">", "<=", ">="].includes(this._peek(e).value); ) {
+      const s = this._consume(e).value, r = this._parseConcatenation(e);
+      t = this._compareValues(t, r, s);
+    }
+    return t;
+  }
+  _parseConcatenation(e) {
+    let t = this._parseAddSub(e);
+    for (; this._peek(e).type === "OPERATOR" && this._peek(e).value === "&"; ) {
+      this._consume(e);
+      const s = this._parseAddSub(e);
+      t = String(t) + String(s);
+    }
+    return t;
+  }
+  _parseAddSub(e) {
+    let t = this._parseMulDiv(e);
+    for (; this._peek(e).type === "OPERATOR" && (this._peek(e).value === "+" || this._peek(e).value === "-"); ) {
+      const s = this._consume(e).value, r = this._parseMulDiv(e);
+      s === "+" ? t = Number(t) + Number(r) : t = Number(t) - Number(r);
+    }
+    return t;
+  }
+  _parseMulDiv(e) {
+    let t = this._parseUnary(e);
+    for (; this._peek(e).type === "OPERATOR" && (this._peek(e).value === "*" || this._peek(e).value === "/"); ) {
+      const s = this._consume(e).value, r = this._parseUnary(e);
+      if (s === "*") t = Number(t) * Number(r);
+      else {
+        const a = Number(r);
+        if (a === 0) throw new Error("#DIV/0!");
+        t = Number(t) / a;
+      }
+    }
+    return t;
+  }
+  _parseUnary(e) {
+    return this._peek(e).type === "OPERATOR" && this._peek(e).value === "-" ? (this._consume(e), -Number(this._parsePrimary(e))) : this._peek(e).type === "OPERATOR" && this._peek(e).value === "+" ? (this._consume(e), Number(this._parsePrimary(e))) : this._parsePrimary(e);
+  }
+  _parsePrimary(e) {
+    const t = this._peek(e);
+    switch (t.type) {
+      case "NUMBER":
+        return this._consume(e), parseFloat(t.value);
+      case "STRING":
+        return this._consume(e), t.value;
+      case "BOOLEAN":
+        return this._consume(e), t.value === "TRUE";
+      case "REF":
+        return this._consume(e), this._resolveRef(t.value);
+      case "RANGE":
+        return this._consume(e), this._resolveRange(t.value);
+      case "FUNC":
+        return this._parseFunction(e);
+      case "LPAREN":
+        this._consume(e);
+        const s = this._parseComparison(e);
+        return this._consume(e, "RPAREN"), s;
+      default:
+        throw new Error(`Unexpected token: ${t.type} (${t.value})`);
+    }
+  }
+  _parseFunction(e) {
+    const t = this._consume(e, "FUNC").value;
+    this._consume(e, "LPAREN");
+    const s = [];
+    if (this._peek(e).type !== "RPAREN")
+      for (s.push(this._parseComparison(e)); this._peek(e).type === "COMMA"; )
+        this._consume(e), s.push(this._parseComparison(e));
+    this._consume(e, "RPAREN");
+    const r = this.functions.get(t);
+    if (!r) throw new Error("#NAME?");
+    const a = this._createContext(), o = [];
+    for (const n of s)
+      Array.isArray(n) ? o.push(...n) : o.push(n);
+    return r(a, ...o);
+  }
+  // ─── Comparison helper ────────────────────────────────
+  _compareValues(e, t, s) {
+    const r = Number(e), a = Number(t), o = !isNaN(r) && !isNaN(a) && String(e).trim() !== "" && String(t).trim() !== "";
+    switch (s) {
+      case "=":
+        return e === t || o && r === a;
+      case "<>":
+        return e !== t && (!o || r !== a);
+      case "<":
+        return o ? r < a : String(e) < String(t);
+      case ">":
+        return o ? r > a : String(e) > String(t);
+      case "<=":
+        return o ? r <= a : String(e) <= String(t);
+      case ">=":
+        return o ? r >= a : String(e) >= String(t);
+      default:
+        return !1;
+    }
+  }
+  // ─── Reference resolution ───────────────────────────
+  //
+  // Each nested evaluation calls parseExpression which creates its
+  // own ParserState, so no save/restore is needed.
+  _resolveRef(e) {
+    const t = S(e), s = y(t.row, t.col);
+    if (this._trackDep(s), this.evaluating.has(s))
+      throw new Error("#CIRC!");
+    const r = this.data.get(s);
+    if (!r) return 0;
+    if (r.rawValue.startsWith("=")) {
+      const o = this._trackingCellKey;
+      this._trackingCellKey = null, this.evaluating.add(s);
+      try {
+        return this.parseExpression(r.rawValue.substring(1));
+      } catch {
+        throw new Error("#ERROR!");
+      } finally {
+        this._trackingCellKey = o, this.evaluating.delete(s);
+      }
+    }
+    const a = Number(r.rawValue);
+    return !isNaN(a) && r.rawValue.trim() !== "" ? a : r.rawValue.toUpperCase() === "TRUE" ? !0 : r.rawValue.toUpperCase() === "FALSE" ? !1 : r.rawValue;
+  }
+  _resolveRange(e) {
+    const [t, s] = e.split(":"), r = S(t), a = S(s), o = Math.min(r.row, a.row), n = Math.max(r.row, a.row), l = Math.min(r.col, a.col), c = Math.max(r.col, a.col), h = [];
+    for (let d = o; d <= n; d++)
+      for (let g = l; g <= c; g++) {
+        const m = y(d, g);
+        this._trackDep(m);
+        const p = this.data.get(m);
+        if (p)
+          if (p.rawValue.startsWith("=")) {
+            const C = this._trackingCellKey;
+            this._trackingCellKey = null, this.evaluating.add(m);
+            try {
+              h.push(this.parseExpression(p.rawValue.substring(1)));
+            } catch {
+              h.push(0);
+            } finally {
+              this._trackingCellKey = C, this.evaluating.delete(m);
+            }
+          } else {
+            const C = Number(p.rawValue);
+            !isNaN(C) && p.rawValue.trim() !== "" ? h.push(C) : p.rawValue.toUpperCase() === "TRUE" ? h.push(!0) : p.rawValue.toUpperCase() === "FALSE" ? h.push(!1) : h.push(p.rawValue);
+          }
+      }
+    return h;
+  }
+  _createContext() {
+    return {
+      getCellValue: (e) => {
+        if (e.includes(":") && !/[A-Z]/i.test(e.charAt(0))) {
+          const t = this.data.get(e);
+          if (!t) return 0;
+          const s = Number(t.rawValue);
+          return !isNaN(s) && t.rawValue.trim() !== "" ? s : t.rawValue;
+        }
+        return this._resolveRef(e);
+      },
+      getRangeValues: (e, t) => {
+        const s = S(e), r = S(t), a = Math.min(s.row, r.row), o = Math.max(s.row, r.row), n = Math.min(s.col, r.col), l = Math.max(s.col, r.col), c = [];
+        for (let h = a; h <= o; h++)
+          for (let d = n; d <= l; d++) {
+            const g = y(h, d), m = this.data.get(g);
+            if (m) {
+              const p = Number(m.rawValue);
+              c.push(!isNaN(p) && m.rawValue.trim() !== "" ? p : m.rawValue);
+            }
+          }
+        return c;
+      }
+    };
+  }
+  // ─── Built-in Functions ─────────────────────────────
+  registerBuiltins() {
+    this.registerFunction("SUM", (e, ...t) => t.reduce((s, r) => s + (Number(r) || 0), 0)), this.registerFunction("AVERAGE", (e, ...t) => {
+      const s = t.filter((a) => typeof a == "number" || !isNaN(Number(a)));
+      return s.length === 0 ? 0 : s.reduce((a, o) => a + Number(o), 0) / s.length;
+    }), this.registerFunction("MIN", (e, ...t) => {
+      const s = t.map(Number).filter((r) => !isNaN(r));
+      return s.length ? Math.min(...s) : 0;
+    }), this.registerFunction("MAX", (e, ...t) => {
+      const s = t.map(Number).filter((r) => !isNaN(r));
+      return s.length ? Math.max(...s) : 0;
+    }), this.registerFunction("COUNT", (e, ...t) => t.filter((s) => typeof s == "number" || !isNaN(Number(s)) && String(s).trim() !== "").length), this.registerFunction("COUNTA", (e, ...t) => t.filter((s) => s !== "" && s !== null && s !== void 0).length), this.registerFunction("IF", (e, t, s, r) => t ? s : r), this.registerFunction("CONCAT", (e, ...t) => t.map(String).join("")), this.registerFunction("ABS", (e, t) => Math.abs(Number(t))), this.registerFunction("ROUND", (e, t, s) => {
+      const r = Number(s) || 0, a = Math.pow(10, r);
+      return Math.round(Number(t) * a) / a;
+    }), this.registerFunction("UPPER", (e, t) => String(t).toUpperCase()), this.registerFunction("LOWER", (e, t) => String(t).toLowerCase()), this.registerFunction("LEN", (e, t) => String(t).length), this.registerFunction("TRIM", (e, t) => String(t).trim());
+  }
+}
+class P {
+  /**
+   * Copy the selected range to the clipboard as TSV.
+   */
+  async copy(e, t) {
+    const s = this.serializeRange(e, t);
+    try {
+      await navigator.clipboard.writeText(s);
+    } catch {
+      this.fallbackCopy(s);
+    }
+  }
+  /**
+   * Cut: copy to clipboard and return the keys that should be cleared.
+   */
+  async cut(e, t) {
+    await this.copy(e, t);
+    const s = [];
+    for (let r = t.start.row; r <= t.end.row; r++)
+      for (let a = t.start.col; a <= t.end.col; a++)
+        s.push(y(r, a));
+    return s;
+  }
+  /**
+   * Parse clipboard content and return the updates to apply.
+   * The target is the top-left cell where paste begins.
+   */
+  async paste(e, t, s, r) {
+    let a;
+    try {
+      a = await navigator.clipboard.readText();
+    } catch {
+      return null;
+    }
+    return this.parseTSV(a, e, t, s, r);
+  }
+  /**
+   * Parse a TSV string and generate cell updates.
+   * Exported for testability with paste events where text is already available.
+   */
+  parseTSV(e, t, s, r, a) {
+    const o = e.split(/\r?\n/);
+    o.length > 0 && o[o.length - 1] === "" && o.pop();
+    const n = [];
+    for (let l = 0; l < o.length; l++) {
+      const c = o[l].split("	");
+      for (let h = 0; h < c.length; h++) {
+        const d = t + l, g = s + h;
+        d < r && g < a && n.push({ id: y(d, g), value: c[h] });
+      }
+    }
+    return n;
+  }
+  // ─── Serialization ──────────────────────────────────
+  serializeRange(e, t) {
+    const s = [];
+    for (let r = t.start.row; r <= t.end.row; r++) {
+      const a = [];
+      for (let o = t.start.col; o <= t.end.col; o++) {
+        const n = e.get(y(r, o));
+        a.push((n == null ? void 0 : n.displayValue) ?? "");
+      }
+      s.push(a.join("	"));
+    }
+    return s.join(`
+`);
+  }
+  // ─── Fallback ───────────────────────────────────────
+  /** @deprecated Uses document.execCommand('copy') which is deprecated. Only used as a fallback when the Clipboard API is unavailable. */
+  fallbackCopy(e) {
+    console.warn("y11n-spreadsheet: Clipboard API unavailable, using deprecated execCommand fallback.");
+    const t = document.createElement("textarea");
+    t.value = e, t.style.position = "fixed", t.style.left = "-9999px", document.body.appendChild(t), t.select();
+    try {
+      document.execCommand("copy");
+    } catch {
+    }
+    document.body.removeChild(t);
+  }
+}
+var T = Object.defineProperty, z = Object.getOwnPropertyDescriptor, b = (i, e, t, s) => {
+  for (var r = s > 1 ? void 0 : s ? z(e, t) : e, a = i.length - 1, o; a >= 0; a--)
+    (o = i[a]) && (r = (s ? o(e, t, r) : o(r)) || r);
+  return s && r && T(e, t, r), r;
+};
+let v = class extends V {
+  constructor() {
+    super(...arguments), this.cellRef = "A1", this.rawValue = "", this.displayValue = "", this.mode = "raw", this.readOnly = !1, this._draft = "", this._suppressNextBlur = !1;
+  }
+  willUpdate(i) {
+    (i.has("mode") || i.has("rawValue") || i.has("displayValue")) && (this._draft = this._sourceValue());
+  }
+  _sourceValue() {
+    return this.mode === "raw" ? this.rawValue : this.displayValue;
+  }
+  _setMode(i) {
+    this.mode !== i && this.dispatchEvent(
+      new CustomEvent("formula-bar-mode-change", {
+        detail: { mode: i },
+        bubbles: !0,
+        composed: !0
+      })
+    );
+  }
+  _onInput(i) {
+    this._draft = i.target.value;
+  }
+  _commit() {
+    this.dispatchEvent(
+      new CustomEvent("formula-bar-commit", {
+        detail: { value: this._draft },
+        bubbles: !0,
+        composed: !0
+      })
+    );
+  }
+  _onKeydown(i) {
+    i.key === "Enter" ? (i.preventDefault(), this._commit()) : i.key === "Escape" && (i.preventDefault(), this._draft = this._sourceValue(), this._suppressNextBlur = !0);
+  }
+  _onBlur() {
+    if (this._suppressNextBlur) {
+      this._suppressNextBlur = !1;
+      return;
+    }
+    this._commit();
+  }
+  render() {
+    return _`
+      <output class="cell-ref" aria-live="polite" aria-atomic="true">${this.cellRef}</output>
+      <div class="mode-toggle" role="group" aria-label="Formula bar mode">
+        <button
+          type="button"
+          aria-pressed="${this.mode === "raw"}"
+          @click="${() => this._setMode("raw")}"
+        >
+          Raw
+        </button>
+        <button
+          type="button"
+          aria-pressed="${this.mode === "formatted"}"
+          @click="${() => this._setMode("formatted")}"
+        >
+          Formatted
+        </button>
+      </div>
+      <input
+        type="text"
+        .value="${this._draft}"
+        ?disabled="${this.readOnly}"
+        @input="${this._onInput}"
+        @keydown="${this._onKeydown}"
+        @blur="${this._onBlur}"
+        aria-label="Formula bar"
+      />
+    `;
+  }
+};
+v.styles = k`
+    :host {
+      display: grid;
+      grid-template-columns: minmax(48px, auto) auto minmax(0, 1fr);
+      align-items: stretch;
+      gap: 8px;
+      padding: 8px;
+      border-bottom: 1px solid var(--ls-border-color, #e0e0e0);
+      background: var(--ls-formula-bar-bg, #f8fafc);
+      color: var(--ls-text-color, #333);
+      font-family: var(--ls-font-family, system-ui, -apple-system, sans-serif);
+      font-size: var(--ls-font-size, 13px);
+    }
+
+    .cell-ref {
+      display: inline-flex;
+      align-items: center;
+      justify-content: center;
+      min-width: 48px;
+      padding: 0 8px;
+      border: 1px solid var(--ls-border-color, #e0e0e0);
+      border-radius: 4px;
+      font-weight: 600;
+      background: var(--ls-formula-ref-bg, #fff);
+    }
+
+    .mode-toggle {
+      display: inline-flex;
+      border: 1px solid var(--ls-border-color, #e0e0e0);
+      border-radius: 4px;
+      overflow: hidden;
+      background: #fff;
+    }
+
+    .mode-toggle button {
+      border: 0;
+      background: transparent;
+      padding: 0 10px;
+      min-height: 32px;
+      cursor: pointer;
+      font: inherit;
+      color: inherit;
+    }
+
+    .mode-toggle button[aria-pressed='true'] {
+      background: var(--ls-formula-mode-active-bg, #dbeafe);
+      font-weight: 600;
+    }
+
+    input {
+      width: 100%;
+      min-height: 32px;
+      padding: 0 10px;
+      border: 1px solid var(--ls-border-color, #e0e0e0);
+      border-radius: 4px;
+      font: inherit;
+      color: inherit;
+      outline: none;
+      background: #fff;
+    }
+
+    input:focus {
+      border-color: #1a73e8;
+      box-shadow: 0 0 0 1px rgba(26, 115, 232, 0.2);
+    }
+
+    button:disabled,
+    input:disabled {
+      opacity: 0.7;
+      cursor: not-allowed;
+    }
+  `;
+b([
+  w({ type: String, attribute: "cell-ref" })
+], v.prototype, "cellRef", 2);
+b([
+  w({ type: String, attribute: "raw-value" })
+], v.prototype, "rawValue", 2);
+b([
+  w({ type: String, attribute: "display-value" })
+], v.prototype, "displayValue", 2);
+b([
+  w({ type: String })
+], v.prototype, "mode", 2);
+b([
+  w({ type: Boolean, attribute: "read-only", reflect: !0 })
+], v.prototype, "readOnly", 2);
+b([
+  E()
+], v.prototype, "_draft", 2);
+v = b([
+  D("y11n-formula-bar")
+], v);
+var I = Object.defineProperty, L = Object.getOwnPropertyDescriptor, f = (i, e, t, s) => {
+  for (var r = s > 1 ? void 0 : s ? L(e, t) : e, a = i.length - 1, o; a >= 0; a--)
+    (o = i[a]) && (r = (s ? o(e, t, r) : o(r)) || r);
+  return s && r && I(e, t, r), r;
+};
+let u = class extends V {
+  constructor() {
+    super(...arguments), this.rows = 100, this.cols = 26, this.data = /* @__PURE__ */ new Map(), this.readOnly = !1, this.functions = {}, this._isEditing = !1, this._editValue = "", this._formulaBarMode = "raw", this._scrollTop = 0, this._scrollLeft = 0, this._selection = new B(this, this.rows, this.cols), this._formulaEngine = new F(), this._clipboardManager = new P(), this._internalData = /* @__PURE__ */ new Map(), this._editingCellKey = null, this._undoStack = [], this._redoStack = [], this._maxHistory = 100;
+  }
+  // ─── Lifecycle ──────────────────────────────────────
+  connectedCallback() {
+    super.connectedCallback(), this._syncData();
+  }
+  willUpdate(i) {
+    if (i.has("data") && this._syncData(), (i.has("rows") || i.has("cols")) && (this.rows = Math.max(1, Math.round(this.rows)), this.cols = Math.max(1, Math.round(this.cols)), this._selection.setBounds(this.rows, this.cols)), i.has("functions"))
+      for (const [e, t] of Object.entries(this.functions))
+        this._formulaEngine.registerFunction(e, t);
+  }
+  // ─── Public API Methods ─────────────────────────────
+  /** Returns the current state of the grid data */
+  getData() {
+    return new Map(this._internalData);
+  }
+  /** Hard reset of the grid data */
+  setData(i) {
+    this.data = i, this._syncData(), this.requestUpdate();
+  }
+  /** Dynamically register a formula function */
+  registerFunction(i, e) {
+    this._formulaEngine.registerFunction(i, e), this._recalcAll();
+  }
+  // ─── Data Sync ──────────────────────────────────────
+  _syncData() {
+    this._internalData = new Map(this.data), this._undoStack = [], this._redoStack = [], this._formulaEngine.setData(this._internalData), this._recalcAll();
+  }
+  _recalcAll() {
+    this._formulaEngine.recalculate();
+  }
+  _recalcAffected(i) {
+    this._formulaEngine.recalculateAffected(i);
+  }
+  // ─── Cell Access ────────────────────────────────────
+  _getCell(i, e) {
+    return this._internalData.get(y(i, e));
+  }
+  _getCellDisplay(i, e) {
+    const t = this._getCell(i, e);
+    return (t == null ? void 0 : t.displayValue) ?? "";
+  }
+  _getCellRaw(i, e) {
+    const t = this._getCell(i, e);
+    return (t == null ? void 0 : t.rawValue) ?? "";
+  }
+  _getActiveCellKey() {
+    const { row: i, col: e } = this._selection.activeCell;
+    return y(i, e);
+  }
+  _getActiveCellRef() {
+    return O(this._selection.activeCell);
+  }
+  _setCellRaw(i, e) {
+    const t = this._internalData.get(i), s = this._formulaEngine.evaluate(e, i);
+    this._internalData.set(i, {
+      rawValue: e,
+      displayValue: s.displayValue,
+      type: s.type,
+      style: t == null ? void 0 : t.style
+    });
+  }
+  _applyRawValueByString(i, e) {
+    if (e === "") {
+      this._internalData.delete(i);
+      return;
+    }
+    this._setCellRaw(i, e);
+  }
+  _snapshotSelection() {
+    return {
+      anchor: { ...this._selection.anchor },
+      head: { ...this._selection.head }
+    };
+  }
+  _restoreSelection(i) {
+    this._selection.moveTo(i.anchor.row, i.anchor.col), this._selection.moveTo(i.head.row, i.head.col, !0), this._dispatchSelectionChange(), this.updateComplete.then(() => this._focusActiveCell());
+  }
+  _buildCommandBatch(i, e, t, s) {
+    var a;
+    const r = [];
+    for (const o of i) {
+      const n = ((a = this._internalData.get(o.id)) == null ? void 0 : a.rawValue) ?? "", l = o.value;
+      n !== l && r.push({ id: o.id, before: n, after: l });
+    }
+    return r.length === 0 ? null : {
+      deltas: r,
+      selectionBefore: t,
+      selectionAfter: s,
+      operation: e
+    };
+  }
+  _pushHistory(i) {
+    this._undoStack.push(i), this._redoStack = [], this._undoStack.length > this._maxHistory && this._undoStack.shift();
+  }
+  _finalizeBatch(i, e, t) {
+    this._recalcAffected(i.deltas.map((r) => r.id)), (e !== "user" || i.operation !== "edit") && this._dispatchDataChange({
+      updates: i.deltas.map((r) => ({ id: r.id, value: r[t] })),
+      source: e,
+      operation: i.operation
+    }), this.requestUpdate();
+  }
+  _applyBatch(i, e) {
+    for (const t of i.deltas)
+      this._applyRawValueByString(t.id, t.after);
+    this._restoreSelection(i.selectionAfter), this._finalizeBatch(i, e, "after");
+  }
+  _revertBatch(i) {
+    for (const e of i.deltas)
+      this._applyRawValueByString(e.id, e.before);
+    this._restoreSelection(i.selectionBefore), this._finalizeBatch(i, "undo", "before");
+  }
+  _executeUserBatch(i) {
+    this._applyBatch(i, "user"), this._pushHistory(i);
+  }
+  _commitRawValue(i, e) {
+    const t = this._internalData.get(i), s = (t == null ? void 0 : t.rawValue) ?? "";
+    if (e === s) return !1;
+    const r = this._snapshotSelection(), a = this._buildCommandBatch(
+      [{ id: i, value: e }],
+      "edit",
+      r,
+      r
+    );
+    return a ? (this._executeUserBatch(a), this._dispatchCellChange({ cellId: i, value: e, oldValue: s }), !0) : !1;
+  }
+  _undo() {
+    if (this.readOnly) return;
+    const i = this._undoStack.pop();
+    i && (this._revertBatch(i), this._redoStack.push(i));
+  }
+  _redo() {
+    if (this.readOnly) return;
+    const i = this._redoStack.pop();
+    i && (this._applyBatch(i, "redo"), this._undoStack.push(i), this._undoStack.length > this._maxHistory && this._undoStack.shift());
+  }
+  // ─── Editing ────────────────────────────────────────
+  _startEditing(i) {
+    if (this.readOnly || this._isEditing) return;
+    const { row: e, col: t } = this._selection.activeCell, s = y(e, t);
+    this._editingCellKey = s;
+    const r = this._internalData.get(s);
+    this._editValue = i ?? (r == null ? void 0 : r.rawValue) ?? "", this._isEditing = !0;
+  }
+  _commitEdit() {
+    if (!this._isEditing || !this._editingCellKey) return;
+    const i = this._editingCellKey, e = this._editValue;
+    this._isEditing = !1, this._editingCellKey = null, this._commitRawValue(i, e), this.updateComplete.then(() => this._focusActiveCell());
+  }
+  _cancelEdit() {
+    this._isEditing = !1, this._editingCellKey = null, this.updateComplete.then(() => this._focusActiveCell());
+  }
+  // ─── Focus Management ───────────────────────────────
+  _focusActiveCell() {
+    var s;
+    const { row: i, col: e } = this._selection.activeCell, t = (s = this.shadowRoot) == null ? void 0 : s.querySelector(
+      `[data-row="${i}"][data-col="${e}"]`
+    );
+    t && t.focus();
+  }
+  // ─── Keyboard Handling ──────────────────────────────
+  _handleGridKeydown(i) {
+    if (this._isEditing) {
+      this._handleEditorKeydown(i);
+      return;
+    }
+    const e = i.shiftKey, t = i.ctrlKey || i.metaKey;
+    switch (i.stopPropagation(), i.key) {
+      case "ArrowUp":
+        i.preventDefault(), this._selection.move(-1, 0, e), this._dispatchSelectionChange(), this.updateComplete.then(() => this._focusActiveCell());
+        break;
+      case "ArrowDown":
+        i.preventDefault(), this._selection.move(1, 0, e), this._dispatchSelectionChange(), this.updateComplete.then(() => this._focusActiveCell());
+        break;
+      case "ArrowLeft":
+        i.preventDefault(), this._selection.move(0, -1, e), this._dispatchSelectionChange(), this.updateComplete.then(() => this._focusActiveCell());
+        break;
+      case "ArrowRight":
+        i.preventDefault(), this._selection.move(0, 1, e), this._dispatchSelectionChange(), this.updateComplete.then(() => this._focusActiveCell());
+        break;
+      case "Tab":
+        i.preventDefault(), e ? this._selection.move(0, -1) : this._selection.move(0, 1), this._dispatchSelectionChange(), this.updateComplete.then(() => this._focusActiveCell());
+        break;
+      case "Enter":
+        i.preventDefault(), this.readOnly || this._startEditing();
+        break;
+      case "Escape":
+        i.preventDefault(), this._selection.clearSelection(), this._dispatchSelectionChange();
+        break;
+      case "Delete":
+      case "Backspace":
+        i.preventDefault(), this.readOnly || this._clearSelectedCells();
+        break;
+      case "a":
+        t && (i.preventDefault(), this._selection.selectAll(), this._dispatchSelectionChange());
+        break;
+      case "c":
+        t && (i.preventDefault(), this._handleCopy());
+        break;
+      case "x":
+        t && (i.preventDefault(), this._handleCut());
+        break;
+      case "v":
+        t && (i.preventDefault(), this._handlePaste());
+        break;
+      case "z":
+      case "Z":
+        t && (i.preventDefault(), e ? this._redo() : this._undo());
+        break;
+      default:
+        !t && !i.altKey && i.key.length === 1 && !this.readOnly && (i.preventDefault(), this._startEditing(i.key));
+        break;
+    }
+  }
+  _handleEditorKeydown(i) {
+    switch (i.stopPropagation(), i.key) {
+      case "Enter":
+        i.preventDefault(), this._commitEdit(), this._selection.move(1, 0), this._dispatchSelectionChange(), this.updateComplete.then(() => this._focusActiveCell());
+        break;
+      case "Tab":
+        i.preventDefault(), this._commitEdit(), i.shiftKey ? this._selection.move(0, -1) : this._selection.move(0, 1), this._dispatchSelectionChange(), this.updateComplete.then(() => this._focusActiveCell());
+        break;
+      case "Escape":
+        i.preventDefault(), this._cancelEdit();
+        break;
+    }
+  }
+  // ─── Mouse Handling ─────────────────────────────────
+  _handleCellPointerDown(i) {
+    const t = i.target.closest("[data-row]");
+    if (!t) return;
+    const s = parseInt(t.dataset.row, 10), r = parseInt(t.dataset.col, 10);
+    this._isEditing && this._commitEdit(), this._selection.startSelection(s, r, i.shiftKey), this._dispatchSelectionChange(), t.focus();
+    const a = new AbortController(), { signal: o } = a, n = () => a.abort(), l = (h) => {
+      var m, p;
+      const d = (m = this.shadowRoot) == null ? void 0 : m.elementFromPoint(h.clientX, h.clientY), g = (p = d == null ? void 0 : d.closest) == null ? void 0 : p.call(d, "[data-row]");
+      if (g) {
+        const C = parseInt(g.dataset.row, 10), $ = parseInt(g.dataset.col, 10);
+        this._selection.extendSelection(C, $), this._dispatchSelectionChange();
+      }
+    }, c = () => {
+      this._selection.endSelection(), n();
+    };
+    document.addEventListener("pointermove", l, { signal: o }), document.addEventListener("pointerup", c, { signal: o }), document.addEventListener("pointercancel", c, { signal: o }), window.addEventListener("blur", c, { signal: o });
+  }
+  _handleCellDblClick(i) {
+    if (this.readOnly) return;
+    const t = i.target.closest("[data-row]");
+    if (!t) return;
+    const s = parseInt(t.dataset.row, 10), r = parseInt(t.dataset.col, 10);
+    this._selection.moveTo(s, r), this._startEditing();
+  }
+  // ─── Clipboard ──────────────────────────────────────
+  async _handleCopy() {
+    await this._clipboardManager.copy(this._internalData, this._selection.range);
+  }
+  async _handleCut() {
+    if (this.readOnly) return;
+    const i = await this._clipboardManager.cut(
+      this._internalData,
+      this._selection.range
+    ), e = [], t = this._snapshotSelection();
+    for (const r of i)
+      this._internalData.has(r) && e.push({ id: r, value: "" });
+    const s = this._buildCommandBatch(e, "cut", t, t);
+    s && this._executeUserBatch(s);
+  }
+  async _handlePaste() {
+    if (this.readOnly) return;
+    const { row: i, col: e } = this._selection.activeCell, t = await this._clipboardManager.paste(i, e, this.rows, this.cols);
+    if (t && t.length > 0) {
+      const s = this._snapshotSelection(), r = this._buildCommandBatch(t, "paste", s, s);
+      r && this._executeUserBatch(r);
+    }
+  }
+  // ─── Cell Clearing ──────────────────────────────────
+  _clearSelectedCells() {
+    const i = this._selection.range, e = [], t = this._snapshotSelection();
+    for (let r = i.start.row; r <= i.end.row; r++)
+      for (let a = i.start.col; a <= i.end.col; a++) {
+        const o = y(r, a);
+        this._internalData.has(o) && e.push({ id: o, value: "" });
+      }
+    const s = this._buildCommandBatch(e, "clear", t, t);
+    s && this._executeUserBatch(s);
+  }
+  // ─── Scroll Handling ────────────────────────────────
+  _handleScroll(i) {
+    const e = i.target;
+    this._scrollTop = e.scrollTop, this._scrollLeft = e.scrollLeft;
+  }
+  // ─── Editor Input ───────────────────────────────────
+  _handleEditorInput(i) {
+    this._editValue = i.target.value;
+  }
+  _handleEditorBlur() {
+    this._isEditing && this._commitEdit();
+  }
+  _handleFormulaBarModeChange(i) {
+    this._formulaBarMode = i.detail.mode;
+  }
+  _handleFormulaBarCommit(i) {
+    this.readOnly || (this._isEditing && (this._isEditing = !1, this._editingCellKey = null), this._commitRawValue(this._getActiveCellKey(), i.detail.value));
+  }
+  // ─── Event Dispatching ──────────────────────────────
+  _dispatchCellChange(i) {
+    this.dispatchEvent(new CustomEvent("cell-change", { detail: i, bubbles: !0, composed: !0 }));
+  }
+  _dispatchSelectionChange() {
+    const i = { range: this._selection.range };
+    this.dispatchEvent(
+      new CustomEvent("selection-change", { detail: i, bubbles: !0, composed: !0 })
+    );
+  }
+  _dispatchDataChange(i) {
+    this.dispatchEvent(
+      new CustomEvent("data-change", { detail: i, bubbles: !0, composed: !0 })
+    );
+  }
+  // ─── Virtual Rendering ──────────────────────────────
+  /**
+   * Compute which rows and columns are visible based on scroll position.
+   * We add a buffer of extra rows/cols for smooth scrolling.
+   */
+  _getVisibleRange() {
+    const i = this._grid;
+    if (!i)
+      return { startRow: 0, endRow: Math.min(this.rows, 40), startCol: 0, endCol: this.cols };
+    const e = this._getCSSVarPx("--ls-cell-height", 28), t = this._getCSSVarPx("--ls-cell-width", 100), s = i.clientHeight, r = i.clientWidth, a = 5, o = Math.max(0, Math.floor(this._scrollTop / e) - a), n = Math.min(this.rows, Math.ceil((this._scrollTop + s) / e) + a), l = Math.max(0, Math.floor(this._scrollLeft / t) - a), c = Math.min(this.cols, Math.ceil((this._scrollLeft + r) / t) + a);
+    return { startRow: o, endRow: n, startCol: l, endCol: c };
+  }
+  _getCSSVarPx(i, e) {
+    const t = getComputedStyle(this).getPropertyValue(i);
+    if (t) {
+      const s = parseInt(t, 10);
+      if (!isNaN(s)) return s;
+    }
+    return e;
+  }
+  // ─── Editor Positioning ─────────────────────────────
+  _getEditorStyle() {
+    if (!this._isEditing) return "display:none;";
+    const { row: i, col: e } = this._selection.activeCell, t = this._getCSSVarPx("--ls-cell-height", 28), s = this._getCSSVarPx("--ls-cell-width", 100), r = 50, a = (i + 1) * t, o = r + e * s;
+    return `
+      display: block;
+      position: absolute;
+      top: ${a}px;
+      left: ${o}px;
+      width: ${s}px;
+      height: ${t}px;
+      z-index: 10;
+    `;
+  }
+  render() {
+    const { startRow: i, endRow: e, startCol: t, endCol: s } = this._getVisibleRange(), r = this._selection.activeCell, a = this._getCellRaw(r.row, r.col), o = this._getCellDisplay(r.row, r.col);
+    return _`
+      <div class="ls-wrapper">
+        <y11n-formula-bar
+          cell-ref="${this._getActiveCellRef()}"
+          raw-value="${a}"
+          display-value="${o}"
+          .mode="${this._formulaBarMode}"
+          .readOnly="${this.readOnly}"
+          @formula-bar-mode-change="${this._handleFormulaBarModeChange}"
+          @formula-bar-commit="${this._handleFormulaBarCommit}"
+        ></y11n-formula-bar>
+
+        <div class="ls-grid-shell">
+          <input
+            id="editor"
+            part="editor"
+            style="${this._getEditorStyle()}"
+            .value="${this._editValue}"
+            @input="${this._handleEditorInput}"
+            @keydown="${this._handleEditorKeydown}"
+            @blur="${this._handleEditorBlur}"
+            aria-label="Cell editor"
+          />
+
+          <div
+            class="ls-grid"
+            role="grid"
+            aria-rowcount="${this.rows + 1}"
+            aria-colcount="${this.cols + 1}"
+            aria-readonly="${this.readOnly}"
+            style="--cols: ${this.cols};"
+            tabindex="-1"
+            @keydown="${this._handleGridKeydown}"
+            @scroll="${this._handleScroll}"
+          >
+            ${this._renderHeaderRow(t, s)}
+            ${this._renderRows(i, e, t, s)}
+          </div>
+        </div>
+
+        <div class="sr-only" role="status" aria-live="polite" aria-atomic="true">
+          ${this._getAnnouncement(r)}
+        </div>
+      </div>
+    `;
+  }
+  _renderHeaderRow(i, e) {
+    const t = [];
+    for (let r = i; r < e; r++)
+      t.push({ letter: R(r), index: r });
+    const s = this._getCSSVarPx("--ls-cell-width", 100);
+    return _`
+      <div class="ls-header-row" role="row" aria-rowindex="1">
+        <div class="ls-corner-header" role="columnheader"></div>
+        ${i > 0 ? _`<div style="width: ${i * s}px;"></div>` : x}
+        ${t.map(
+      (r) => _`
+            <div
+              class="ls-col-header"
+              role="columnheader"
+              aria-colindex="${r.index + 2}"
+            >
+              ${r.letter}
+            </div>
+          `
+    )}
+        ${e < this.cols ? _`<div style="width: ${(this.cols - e) * s}px;"></div>` : x}
+      </div>
+    `;
+  }
+  _renderRows(i, e, t, s) {
+    const r = this._getCSSVarPx("--ls-cell-height", 28), a = Array.from({ length: e - i }, (o, n) => i + n);
+    return _`
+      ${i > 0 ? _`<div style="grid-column: 1 / -1; height: ${i * r}px;"></div>` : x}
+      ${N(a, (o) => o, (o) => this._renderRow(o, t, s))}
+      ${e < this.rows ? _`<div style="grid-column: 1 / -1; height: ${(this.rows - e) * r}px;"></div>` : x}
+    `;
+  }
+  _renderRow(i, e, t) {
+    const s = this._getCSSVarPx("--ls-cell-width", 100), r = [];
+    for (let a = e; a < t; a++) {
+      const o = this._selection.isCellSelected(i, a), n = this._selection.isCellActive(i, a), l = this._getCellDisplay(i, a), c = y(i, a);
+      r.push(_`
+        <div
+          class="ls-cell ${n ? "active-cell" : ""}"
+          role="gridcell"
+          aria-colindex="${a + 2}"
+          aria-selected="${o}"
+          aria-readonly="${this.readOnly}"
+          data-row="${i}"
+          data-col="${a}"
+          data-key="${c}"
+          tabindex="${n ? 0 : -1}"
+          @pointerdown="${this._handleCellPointerDown}"
+          @dblclick="${this._handleCellDblClick}"
+        >
+          <span class="cell-text">${l}</span>
+        </div>
+      `);
+    }
+    return _`
+      <div class="ls-row" role="row" aria-rowindex="${i + 2}">
+        <div class="ls-row-header" role="rowheader">${i + 1}</div>
+        ${e > 0 ? _`<div style="width: ${e * s}px;"></div>` : x}
+        ${r}
+        ${t < this.cols ? _`<div style="width: ${(this.cols - t) * s}px;"></div>` : x}
+      </div>
+    `;
+  }
+  _getAnnouncement(i) {
+    const e = `${R(i.col)}${i.row + 1}`, t = this._getCellDisplay(i.row, i.col);
+    return t ? `${e}: ${t}` : e;
+  }
+  updated() {
+    if (this._isEditing && this._editor) {
+      const i = this._editor, e = this._editValue.length;
+      i.focus(), i.setSelectionRange(e, e);
+    }
+  }
+};
+u.styles = k`
+    :host {
+      display: block;
+      position: relative;
+      font-family: var(--ls-font-family, system-ui, -apple-system, sans-serif);
+      font-size: var(--ls-font-size, 13px);
+      color: var(--ls-text-color, #333);
+      --_cell-width: var(--ls-cell-width, 100px);
+      --_cell-height: var(--ls-cell-height, 28px);
+      --_header-bg: var(--ls-header-bg, #f3f3f3);
+      --_border-color: var(--ls-border-color, #e0e0e0);
+      --_selection-border: var(--ls-selection-border, 2px solid #1a73e8);
+      --_selection-bg: var(--ls-selection-bg, rgba(26, 115, 232, 0.1));
+      --_focus-ring: var(--ls-focus-ring, 2px solid #1a73e8);
+      --_editor-bg: var(--ls-editor-bg, #fff);
+      --_editor-shadow: var(--ls-editor-shadow, 0 2px 6px rgba(0,0,0,0.2));
+      --_row-header-width: 50px;
+    }
+
+    *,
+    *::before,
+    *::after {
+      box-sizing: border-box;
+    }
+
+    .ls-wrapper {
+      position: relative;
+      display: flex;
+      flex-direction: column;
+      width: 100%;
+      height: 100%;
+      overflow: hidden;
+    }
+
+    .ls-grid-shell {
+      position: relative;
+      flex: 1 1 auto;
+      min-height: 0;
+      overflow: hidden;
+    }
+
+    .ls-grid {
+      display: grid;
+      grid-template-columns: var(--_row-header-width) repeat(var(--cols), var(--_cell-width));
+      overflow: auto;
+      position: relative;
+      width: 100%;
+      height: 100%;
+      outline: none;
+    }
+
+    .ls-header-row {
+      display: contents;
+    }
+
+    .ls-row {
+      display: contents;
+    }
+
+    .ls-corner-header,
+    .ls-col-header {
+      position: sticky;
+      top: 0;
+      z-index: 3;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      height: var(--_cell-height);
+      background: var(--_header-bg);
+      border-right: 1px solid var(--_border-color);
+      border-bottom: 2px solid var(--_border-color);
+      font-weight: 600;
+      user-select: none;
+    }
+
+    .ls-corner-header {
+      position: sticky;
+      left: 0;
+      z-index: 4;
+    }
+
+    .ls-row-header {
+      position: sticky;
+      left: 0;
+      z-index: 2;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      height: var(--_cell-height);
+      background: var(--_header-bg);
+      border-right: 2px solid var(--_border-color);
+      border-bottom: 1px solid var(--_border-color);
+      font-weight: 600;
+      user-select: none;
+    }
+
+    .ls-cell {
+      display: flex;
+      align-items: center;
+      padding: 0 4px;
+      height: var(--_cell-height);
+      border-right: 1px solid var(--_border-color);
+      border-bottom: 1px solid var(--_border-color);
+      overflow: hidden;
+      white-space: nowrap;
+      text-overflow: ellipsis;
+      cursor: cell;
+      outline: none;
+      user-select: none;
+    }
+
+    .ls-cell:focus {
+      outline: var(--_focus-ring);
+      outline-offset: -2px;
+      z-index: 1;
+    }
+
+    .ls-cell[aria-selected="true"] {
+      background: var(--_selection-bg);
+    }
+
+    .ls-cell.active-cell {
+      outline: var(--_selection-border);
+      outline-offset: -2px;
+      z-index: 1;
+    }
+
+    .ls-cell .cell-text {
+      overflow: hidden;
+      text-overflow: ellipsis;
+    }
+
+    #editor {
+      position: absolute;
+      box-sizing: border-box;
+      padding: 0 4px;
+      border: var(--_selection-border);
+      background: var(--_editor-bg);
+      box-shadow: var(--_editor-shadow);
+      font-family: inherit;
+      font-size: inherit;
+      color: inherit;
+      outline: none;
+      z-index: 10;
+    }
+
+    /* Visually hidden live region for screen reader announcements */
+    .sr-only {
+      position: absolute;
+      width: 1px;
+      height: 1px;
+      padding: 0;
+      margin: -1px;
+      overflow: hidden;
+      clip: rect(0, 0, 0, 0);
+      border: 0;
+    }
+  `;
+f([
+  w({ type: Number })
+], u.prototype, "rows", 2);
+f([
+  w({ type: Number })
+], u.prototype, "cols", 2);
+f([
+  w({ attribute: !1 })
+], u.prototype, "data", 2);
+f([
+  w({ type: Boolean, attribute: "read-only", reflect: !0 })
+], u.prototype, "readOnly", 2);
+f([
+  w({ attribute: !1 })
+], u.prototype, "functions", 2);
+f([
+  E()
+], u.prototype, "_isEditing", 2);
+f([
+  E()
+], u.prototype, "_editValue", 2);
+f([
+  E()
+], u.prototype, "_formulaBarMode", 2);
+f([
+  E()
+], u.prototype, "_scrollTop", 2);
+f([
+  E()
+], u.prototype, "_scrollLeft", 2);
+f([
+  A("#editor")
+], u.prototype, "_editor", 2);
+f([
+  A(".ls-grid")
+], u.prototype, "_grid", 2);
+u = f([
+  D("y11n-spreadsheet")
+], u);
+export {
+  P as ClipboardManager,
+  F as FormulaEngine,
+  B as SelectionManager,
+  v as Y11nFormulaBar,
+  u as Y11nSpreadsheet,
+  y as cellKey,
+  R as colToLetter,
+  O as coordToRef,
+  M as letterToCol,
+  j as parseKey,
+  S as refToCoord
+};