typewright 0.2.1

package/dist/chunk-CZQO7TTL.js

@@ -0,0 +1,1533 @@
+import { walk } from './chunk-M6IVEMXO.js';
+
+// src/core/unified.ts
+function collectMarkers(doc, source) {
+  const markers = [];
+  const push = (from, to, kind) => {
+    if (to > from) markers.push({ from, to, kind });
+  };
+  walk(doc, (node) => {
+    switch (node.type) {
+      case "heading": {
+        push(node.from, node.contentFrom, "heading");
+        break;
+      }
+      case "emphasis":
+      case "strong":
+      case "strikethrough": {
+        const kind = node.type === "strikethrough" ? "strike" : node.type;
+        const kids = node.children;
+        const first = kids[0];
+        const last = kids[kids.length - 1];
+        const innerFrom = first ? first.from : node.to;
+        const innerTo = last ? last.to : node.from;
+        push(node.from, innerFrom, kind);
+        push(innerTo, node.to, kind);
+        break;
+      }
+      case "inlineCode": {
+        const ticks = Math.max(1, node.ticks);
+        const openTo = Math.min(node.from + ticks, node.to);
+        const closeFrom = Math.max(node.to - ticks, openTo);
+        push(node.from, openTo, "code");
+        push(closeFrom, node.to, "code");
+        break;
+      }
+      case "link": {
+        const kids = node.children;
+        const last = kids[kids.length - 1];
+        const textEnd = last ? last.to : node.from + 1;
+        const midTo = Math.min(textEnd + 2, node.to);
+        push(node.from, Math.min(node.from + 1, node.to), "link");
+        push(textEnd, midTo, "link");
+        push(midTo, node.to - 1, "link");
+        push(Math.max(node.to - 1, node.from), node.to, "link");
+        break;
+      }
+      case "image": {
+        const bracketOpen = node.from + 1;
+        const altStart = bracketOpen + 1;
+        const altEnd = Math.min(altStart + node.alt.length, node.to);
+        const midTo = Math.min(altEnd + 2, node.to);
+        push(node.from, Math.min(node.from + 1, node.to), "image");
+        push(bracketOpen, Math.min(bracketOpen + 1, node.to), "image");
+        push(altEnd, midTo, "image");
+        push(midTo, node.to - 1, "image");
+        push(Math.max(node.to - 1, node.from), node.to, "image");
+        break;
+      }
+      case "listItem": {
+        push(node.from, node.contentFrom, "listMarker");
+        break;
+      }
+      case "math": {
+        const delim = node.display ? 2 : 1;
+        const openTo = Math.min(node.from + delim, node.to);
+        const closeFrom = Math.max(node.to - delim, openTo);
+        push(node.from, openTo, "math");
+        push(closeFrom, node.to, "math");
+        break;
+      }
+      case "footnoteRef": {
+        const openTo = Math.min(node.from + 2, node.to);
+        const closeFrom = Math.max(node.to - 1, openTo);
+        push(node.from, openTo, "footnoteRef");
+        push(closeFrom, node.to, "footnoteRef");
+        break;
+      }
+      case "codeBlock": {
+        if (!source || !node.fenced) break;
+        let openTo = source.indexOf("\n", node.from);
+        if (openTo === -1 || openTo > node.to) openTo = node.to;
+        if (openTo > node.from && source[openTo - 1] === "\r") openTo--;
+        push(node.from, openTo, "fence");
+        const closeStart = source.lastIndexOf("\n", node.to - 1) + 1;
+        if (closeStart > node.from) {
+          const closeText = source.slice(closeStart, node.to);
+          const cm = /^( {0,3})(`{3,}|~{3,}) *$/.exec(closeText);
+          const om = /^ {0,3}([`~])/.exec(source.slice(node.from, openTo));
+          if (cm && om && cm[2][0] === om[1]) push(closeStart, node.to, "fence");
+        }
+        break;
+      }
+      case "blockquote": {
+        if (!source) break;
+        const lineStart2 = source.lastIndexOf("\n", node.from - 1) + 1;
+        if (lineStart2 !== node.from) break;
+        let p = node.from;
+        while (p < node.to) {
+          let end = source.indexOf("\n", p);
+          if (end === -1 || end > node.to) end = node.to;
+          const qm = /^(?: {0,3}> ?)+/.exec(source.slice(p, end));
+          if (qm) push(p, p + qm[0].length, "blockquote");
+          p = end + 1;
+        }
+        break;
+      }
+    }
+    return true;
+  });
+  return markers;
+}
+function hiddenMarkers(doc, sel, source) {
+  const lo = Math.min(sel.from, sel.to) - 1;
+  const hi = Math.max(sel.from, sel.to) + 1;
+  const intersects = (m) => m.from < hi && lo < m.to;
+  return collectMarkers(doc, source).filter((m) => !intersects(m));
+}
+function activeBlockIndex(doc, offset) {
+  const blocks = doc.children;
+  for (let i = 0; i < blocks.length; i++) {
+    const b = blocks[i];
+    if (b && offset >= b.from && offset <= b.to) return i;
+  }
+  return -1;
+}
+
+// src/core/fold.ts
+function headingFoldRanges(doc) {
+  const blocks = doc.children;
+  const ranges = [];
+  for (let i = 0; i < blocks.length; i++) {
+    const h = blocks[i];
+    if (!h || h.type !== "heading") continue;
+    let to = doc.to;
+    for (let j = i + 1; j < blocks.length; j++) {
+      const n = blocks[j];
+      if (n && n.type === "heading" && n.level <= h.level) {
+        to = n.from;
+        break;
+      }
+    }
+    const from = h.to;
+    if (to > from) {
+      ranges.push({ headingFrom: h.from, level: h.level, from, to });
+    }
+  }
+  return ranges;
+}
+
+// src/core/commands.ts
+var COMMANDS = [
+  { id: "bold", label: "Bold", kbd: "\u2318B", group: "inline" },
+  { id: "italic", label: "Italic", kbd: "\u2318I", group: "inline" },
+  { id: "strikethrough", label: "Strikethrough", group: "inline" },
+  { id: "inlineCode", label: "Inline Code", kbd: "\u2318E", group: "inline" },
+  { id: "link", label: "Link", kbd: "\u2318K", group: "inline" },
+  { id: "heading1", label: "Heading 1", group: "block" },
+  { id: "heading2", label: "Heading 2", group: "block" },
+  { id: "heading3", label: "Heading 3", group: "block" },
+  { id: "heading4", label: "Heading 4", group: "block" },
+  { id: "heading5", label: "Heading 5", group: "block" },
+  { id: "heading6", label: "Heading 6", group: "block" },
+  { id: "bulletList", label: "Bullet List", group: "block" },
+  { id: "orderedList", label: "Ordered List", group: "block" },
+  { id: "taskList", label: "Task List", group: "block" },
+  { id: "quote", label: "Quote", group: "block" },
+  { id: "horizontalRule", label: "Horizontal Rule", group: "insert" },
+  { id: "codeBlock", label: "Code Block", group: "insert" },
+  { id: "table", label: "Table", group: "insert" }
+];
+function norm(sel) {
+  return { from: Math.min(sel.from, sel.to), to: Math.max(sel.from, sel.to) };
+}
+function toggleWrap(text, sel, marker) {
+  const len = marker.length;
+  const { from, to } = norm(sel);
+  if (from >= len && text.slice(from - len, from) === marker && text.slice(to, to + len) === marker) {
+    const t2 = text.slice(0, from - len) + text.slice(from, to) + text.slice(to + len);
+    return { text: t2, selection: { from: from - len, to: to - len } };
+  }
+  const selected = text.slice(from, to);
+  if (selected.length >= 2 * len && selected.startsWith(marker) && selected.endsWith(marker)) {
+    const inner = selected.slice(len, selected.length - len);
+    const t2 = text.slice(0, from) + inner + text.slice(to);
+    return { text: t2, selection: { from, to: from + inner.length } };
+  }
+  const t = text.slice(0, from) + marker + selected + marker + text.slice(to);
+  if (from === to) return { text: t, selection: { from: from + len, to: from + len } };
+  return { text: t, selection: { from: from + len, to: to + len } };
+}
+function insertLink(text, sel) {
+  const { from, to } = norm(sel);
+  const label = text.slice(from, to) || "text";
+  const url = "https://";
+  const inserted = `[${label}](${url})`;
+  const t = text.slice(0, from) + inserted + text.slice(to);
+  const urlStart = from + label.length + 3;
+  return { text: t, selection: { from: urlStart, to: urlStart + url.length } };
+}
+var HEADING_RE = /^ {0,3}#{1,6}\s+/;
+var LIST_RE = /^ {0,3}(?:[-*+]\s(?:\[[ xX]\]\s)?|\d+[.)]\s)/;
+var QUOTE_RE = /^ {0,3}>\s?/;
+function applyLinePrefix(text, sel, p) {
+  const { from, to } = norm(sel);
+  const start = text.lastIndexOf("\n", from - 1) + 1;
+  const searchFrom = to > from ? to - 1 : to;
+  let end = text.indexOf("\n", searchFrom);
+  if (end === -1) end = text.length;
+  const lines = text.slice(start, end).split("\n");
+  const allHave = lines.every((l) => l.trim() === "" || p.has(l));
+  const out = lines.map((l, i) => l.trim() === "" ? l : allHave ? p.strip(l) : p.add(p.strip(l), i)).join("\n");
+  const t = text.slice(0, start) + out + text.slice(end);
+  return { text: t, selection: { from: start, to: start + out.length } };
+}
+function stripAllPrefixes(line) {
+  return line.replace(HEADING_RE, "").replace(LIST_RE, "").replace(QUOTE_RE, "");
+}
+function insertBlock(text, sel, block, selectInner) {
+  const { from, to } = norm(sel);
+  const before = text.slice(0, from);
+  const after = text.slice(to);
+  const lead = before === "" || before.endsWith("\n\n") ? "" : before.endsWith("\n") ? "\n" : "\n\n";
+  const trail = after === "" || after.startsWith("\n\n") ? "" : after.startsWith("\n") ? "\n" : "\n\n";
+  const insertedAt = from + lead.length;
+  const t = before + lead + block + trail + after;
+  const selection = selectInner ? { from: insertedAt + selectInner[0], to: insertedAt + selectInner[1] } : { from: insertedAt, to: insertedAt + block.length };
+  return { text: t, selection };
+}
+function applyCommand(text, sel, cmd) {
+  switch (cmd) {
+    case "bold":
+      return toggleWrap(text, sel, "**");
+    case "italic":
+      return toggleWrap(text, sel, "*");
+    case "strikethrough":
+      return toggleWrap(text, sel, "~~");
+    case "inlineCode":
+      return toggleWrap(text, sel, "`");
+    case "link":
+      return insertLink(text, sel);
+    case "heading1":
+    case "heading2":
+    case "heading3":
+    case "heading4":
+    case "heading5":
+    case "heading6": {
+      const level = cmd === "heading1" ? 1 : cmd === "heading2" ? 2 : cmd === "heading3" ? 3 : cmd === "heading4" ? 4 : cmd === "heading5" ? 5 : 6;
+      const marker = "#".repeat(level) + " ";
+      return applyLinePrefix(text, sel, {
+        has: (l) => new RegExp(`^ {0,3}#{${level}}\\s`).test(l),
+        strip: (l) => l.replace(HEADING_RE, ""),
+        add: (l) => marker + l
+      });
+    }
+    case "bulletList":
+      return applyLinePrefix(text, sel, {
+        has: (l) => /^ {0,3}[-*+]\s/.test(l),
+        strip: stripAllPrefixes,
+        add: (l) => "- " + l
+      });
+    case "orderedList":
+      return applyLinePrefix(text, sel, {
+        has: (l) => /^ {0,3}\d+[.)]\s/.test(l),
+        strip: stripAllPrefixes,
+        add: (l, i) => `${i + 1}. ` + l
+      });
+    case "taskList":
+      return applyLinePrefix(text, sel, {
+        has: (l) => /^ {0,3}[-*+]\s\[[ xX]\]\s/.test(l),
+        strip: stripAllPrefixes,
+        add: (l) => "- [ ] " + l
+      });
+    case "quote":
+      return applyLinePrefix(text, sel, {
+        has: (l) => QUOTE_RE.test(l),
+        strip: (l) => l.replace(QUOTE_RE, ""),
+        add: (l) => "> " + l
+      });
+    case "horizontalRule":
+      return insertBlock(text, sel, "---");
+    case "codeBlock": {
+      const selected = text.slice(norm(sel).from, norm(sel).to);
+      const block = "```\n" + selected + "\n```";
+      return insertBlock(text, sel, block, selected ? void 0 : [4, 4]);
+    }
+    case "table": {
+      const block = "| Column | Column |\n| --- | --- |\n| Cell | Cell |";
+      return insertBlock(text, sel, block, [2, 8]);
+    }
+    default: {
+      return { text, selection: norm(sel) };
+    }
+  }
+}
+
+// src/core/text.ts
+var TextDoc = class _TextDoc {
+  text;
+  _lineStarts = null;
+  constructor(text = "") {
+    this.text = text;
+  }
+  get length() {
+    return this.text.length;
+  }
+  /** Apply one change, returning a new document. */
+  apply(change) {
+    const { from, to, insert } = normalize(change, this.text.length);
+    return new _TextDoc(this.text.slice(0, from) + insert + this.text.slice(to));
+  }
+  /**
+   * Apply several changes, returning a new document. Changes are given in
+   * document coordinates of THIS doc; they are applied right-to-left so earlier
+   * offsets stay valid.
+   */
+  applyAll(changes) {
+    const sorted = [...changes].sort((a, b) => b.from - a.from);
+    let text = this.text;
+    for (const c of sorted) {
+      const { from, to, insert } = normalize(c, text.length);
+      text = text.slice(0, from) + insert + text.slice(to);
+    }
+    return new _TextDoc(text);
+  }
+  lineStarts() {
+    if (this._lineStarts) return this._lineStarts;
+    const starts = [0];
+    for (let i = 0; i < this.text.length; i++) {
+      if (this.text.charCodeAt(i) === 10) starts.push(i + 1);
+    }
+    this._lineStarts = starts;
+    return starts;
+  }
+  /** Total number of lines (a trailing newline yields an extra empty line). */
+  get lines() {
+    return this.lineStarts().length;
+  }
+  /** The line (1-based) containing `offset`. */
+  lineAt(offset) {
+    const off = clamp(offset, 0, this.text.length);
+    const starts = this.lineStarts();
+    let lo = 0;
+    let hi = starts.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (starts[mid] <= off) lo = mid;
+      else hi = mid - 1;
+    }
+    const from = starts[lo];
+    const nextStart = starts[lo + 1];
+    const to = nextStart === void 0 ? this.text.length : nextStart - 1;
+    return { number: lo + 1, from, to, text: this.text.slice(from, to) };
+  }
+  /** Line/column (both 1-based) for an offset. */
+  positionAt(offset) {
+    const line = this.lineAt(offset);
+    return { line: line.number, column: clamp(offset, 0, this.text.length) - line.from + 1 };
+  }
+  /** Offset for a 1-based line/column. */
+  offsetAt(line, column) {
+    const starts = this.lineStarts();
+    const idx = clamp(line, 1, starts.length) - 1;
+    const from = starts[idx];
+    const nextStart = starts[idx + 1];
+    const to = nextStart === void 0 ? this.text.length : nextStart - 1;
+    return clamp(from + (column - 1), from, to);
+  }
+  /**
+   * Map an offset from this document's coordinates to the coordinates AFTER the
+   * given change(s). `assoc` controls which side of an insertion at the offset
+   * the mapped position sticks to: -1 = before (default), 1 = after.
+   */
+  mapOffset(offset, changes, assoc = -1) {
+    const list = Array.isArray(changes) ? changes : [changes];
+    const ordered = [...list].sort((a, b) => a.from - b.from);
+    let result = offset;
+    for (const c of ordered) {
+      const { from, to, insert } = normalize(c, Number.MAX_SAFE_INTEGER);
+      const delta = insert.length - (to - from);
+      if (result < from) continue;
+      if (result > to) {
+        result += delta;
+      } else if (result === from && assoc < 0) ; else if (result === to && assoc > 0) {
+        result += delta;
+      } else {
+        result = assoc < 0 ? from : from + insert.length;
+      }
+    }
+    return result;
+  }
+  toString() {
+    return this.text;
+  }
+};
+function normalize(change, len) {
+  let from = clamp(Math.min(change.from, change.to), 0, len);
+  let to = clamp(Math.max(change.from, change.to), 0, len);
+  return { from, to, insert: change.insert };
+}
+function clamp(n, lo, hi) {
+  return n < lo ? lo : n > hi ? hi : n;
+}
+
+// src/core/highlight.ts
+function escapeHtml(value) {
+  let out = "";
+  for (let i = 0; i < value.length; i++) {
+    const ch = value.charCodeAt(i);
+    switch (ch) {
+      case 38:
+        out += "&amp;";
+        break;
+      case 60:
+        out += "&lt;";
+        break;
+      case 62:
+        out += "&gt;";
+        break;
+      case 34:
+        out += "&quot;";
+        break;
+      default:
+        out += value.charAt(i);
+    }
+  }
+  return out;
+}
+function span(kind, text) {
+  return `<span class="tw-tok-${kind}">${escapeHtml(text)}</span>`;
+}
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+function isIdentStart(ch) {
+  return ch >= 65 && ch <= 90 || // A-Z
+  ch >= 97 && ch <= 122 || // a-z
+  ch === 95 || // _
+  ch === 36;
+}
+function isIdentPart(ch) {
+  return isIdentStart(ch) || isDigit(ch);
+}
+function isNumberPart(ch) {
+  return isDigit(ch) || ch === 46 || // .
+  ch === 95 || // _ separator
+  ch === 120 || // x
+  ch === 88 || // X
+  ch === 111 || // o
+  ch === 79 || // O
+  ch === 98 || // b
+  ch === 66 || // B
+  ch >= 97 && ch <= 102 || // a-f (hex + exponent 'e')
+  ch >= 65 && ch <= 70;
+}
+function isPunct(ch) {
+  switch (ch) {
+    case 123:
+    // {
+    case 125:
+    // }
+    case 40:
+    // (
+    case 41:
+    // )
+    case 91:
+    // [
+    case 93:
+    // ]
+    case 60:
+    // <
+    case 62:
+    // >
+    case 61:
+    // =
+    case 43:
+    // +
+    case 45:
+    // -
+    case 42:
+    // *
+    case 47:
+    // /
+    case 37:
+    // %
+    case 33:
+    // !
+    case 63:
+    // ?
+    case 58:
+    // :
+    case 59:
+    // ;
+    case 44:
+    // ,
+    case 46:
+    // .
+    case 38:
+    // &
+    case 124:
+    // |
+    case 94:
+    // ^
+    case 126:
+    // ~
+    case 64:
+      return true;
+    default:
+      return false;
+  }
+}
+function prevNonSpace(code, i) {
+  let k = i - 1;
+  while (k >= 0) {
+    const c = code.charCodeAt(k);
+    if (c === 32 || c === 9 || c === 10 || c === 13) {
+      k--;
+      continue;
+    }
+    return c;
+  }
+  return 0;
+}
+function consumeString(code, start, quote) {
+  const n = code.length;
+  let j = start + 1;
+  while (j < n) {
+    const c = code.charCodeAt(j);
+    if (c === 92) {
+      j += 2;
+      continue;
+    }
+    if (c === quote) {
+      return j + 1;
+    }
+    if (quote !== 96 && c === 10) {
+      return j;
+    }
+    j++;
+  }
+  return n;
+}
+var JS_KEYWORDS = /* @__PURE__ */ new Set([
+  "abstract",
+  "any",
+  "as",
+  "asserts",
+  "async",
+  "await",
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "declare",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "from",
+  "function",
+  "get",
+  "if",
+  "implements",
+  "import",
+  "in",
+  "infer",
+  "instanceof",
+  "interface",
+  "is",
+  "keyof",
+  "let",
+  "namespace",
+  "new",
+  "null",
+  "of",
+  "override",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "readonly",
+  "return",
+  "satisfies",
+  "set",
+  "static",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "type",
+  "typeof",
+  "undefined",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield"
+]);
+var TS_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "object",
+  "symbol",
+  "bigint",
+  "unknown",
+  "never",
+  "Array",
+  "Record",
+  "Promise",
+  "Partial",
+  "Required",
+  "Readonly",
+  "Pick",
+  "Omit",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Date",
+  "RegExp",
+  "Error"
+]);
+var PY_KEYWORDS = /* @__PURE__ */ new Set([
+  "and",
+  "as",
+  "assert",
+  "async",
+  "await",
+  "break",
+  "case",
+  "class",
+  "continue",
+  "def",
+  "del",
+  "elif",
+  "else",
+  "except",
+  "False",
+  "finally",
+  "for",
+  "from",
+  "global",
+  "if",
+  "import",
+  "in",
+  "is",
+  "lambda",
+  "match",
+  "None",
+  "nonlocal",
+  "not",
+  "or",
+  "pass",
+  "raise",
+  "return",
+  "True",
+  "try",
+  "while",
+  "with",
+  "yield"
+]);
+var BASH_KEYWORDS = /* @__PURE__ */ new Set([
+  "if",
+  "then",
+  "else",
+  "elif",
+  "fi",
+  "for",
+  "while",
+  "until",
+  "do",
+  "done",
+  "case",
+  "esac",
+  "in",
+  "function",
+  "select",
+  "time",
+  "return",
+  "break",
+  "continue",
+  "echo",
+  "cd",
+  "export",
+  "local",
+  "read",
+  "printf",
+  "source",
+  "exit",
+  "set",
+  "unset",
+  "test",
+  "eval",
+  "exec",
+  "trap",
+  "shift"
+]);
+var SQL_KEYWORDS = /* @__PURE__ */ new Set([
+  "add",
+  "all",
+  "alter",
+  "and",
+  "as",
+  "asc",
+  "auto_increment",
+  "begin",
+  "between",
+  "by",
+  "case",
+  "column",
+  "commit",
+  "constraint",
+  "create",
+  "cross",
+  "default",
+  "delete",
+  "desc",
+  "distinct",
+  "drop",
+  "else",
+  "end",
+  "exists",
+  "foreign",
+  "from",
+  "full",
+  "group",
+  "having",
+  "if",
+  "in",
+  "index",
+  "inner",
+  "insert",
+  "into",
+  "is",
+  "join",
+  "key",
+  "left",
+  "like",
+  "limit",
+  "not",
+  "null",
+  "offset",
+  "on",
+  "or",
+  "order",
+  "outer",
+  "primary",
+  "references",
+  "right",
+  "rollback",
+  "select",
+  "set",
+  "table",
+  "then",
+  "union",
+  "unique",
+  "update",
+  "values",
+  "view",
+  "when",
+  "where",
+  "with",
+  // common types / functions
+  "int",
+  "integer",
+  "bigint",
+  "smallint",
+  "decimal",
+  "numeric",
+  "float",
+  "real",
+  "double",
+  "char",
+  "varchar",
+  "text",
+  "boolean",
+  "bool",
+  "date",
+  "datetime",
+  "timestamp",
+  "count",
+  "sum",
+  "avg",
+  "min",
+  "max",
+  "coalesce"
+]);
+function highlightCLike(code) {
+  const n = code.length;
+  let out = "";
+  let i = 0;
+  let prevWord = "";
+  while (i < n) {
+    const ch = code.charCodeAt(i);
+    if (ch === 47 && code.charCodeAt(i + 1) === 47) {
+      let j = i + 2;
+      while (j < n && code.charCodeAt(j) !== 10) j++;
+      out += span("comment", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (ch === 47 && code.charCodeAt(i + 1) === 42) {
+      let j = i + 2;
+      while (j < n && !(code.charCodeAt(j) === 42 && code.charCodeAt(j + 1) === 47)) {
+        j++;
+      }
+      j = Math.min(n, j + 2);
+      out += span("comment", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (ch === 34 || ch === 39 || ch === 96) {
+      const end = consumeString(code, i, ch);
+      out += span("string", code.slice(i, end));
+      i = end;
+      continue;
+    }
+    if (isDigit(ch) || ch === 46 && isDigit(code.charCodeAt(i + 1))) {
+      let j = i + 1;
+      while (j < n && isNumberPart(code.charCodeAt(j))) j++;
+      out += span("number", code.slice(i, j));
+      i = j;
+      prevWord = "";
+      continue;
+    }
+    if (isIdentStart(ch)) {
+      let j = i + 1;
+      while (j < n && isIdentPart(code.charCodeAt(j))) j++;
+      const word = code.slice(i, j);
+      if (JS_KEYWORDS.has(word)) {
+        out += span("keyword", word);
+      } else if (TS_TYPES.has(word)) {
+        out += span("type", word);
+      } else {
+        let k = j;
+        while (k < n) {
+          const c = code.charCodeAt(k);
+          if (c === 32 || c === 9) {
+            k++;
+            continue;
+          }
+          break;
+        }
+        const isCall = code.charCodeAt(k) === 40;
+        if (prevNonSpace(code, i) === 46) {
+          out += span("prop", word);
+        } else if (prevWord === "class" || prevWord === "interface") {
+          out += span("type", word);
+        } else if (isCall || prevWord === "function") {
+          out += span("fn", word);
+        } else {
+          out += escapeHtml(word);
+        }
+      }
+      prevWord = word;
+      i = j;
+      continue;
+    }
+    if (isPunct(ch)) {
+      out += span("punct", code.charAt(i));
+      i++;
+      continue;
+    }
+    out += escapeHtml(code.charAt(i));
+    i++;
+  }
+  return out;
+}
+function highlightJson(code) {
+  const n = code.length;
+  let out = "";
+  let i = 0;
+  while (i < n) {
+    const ch = code.charCodeAt(i);
+    if (ch === 34) {
+      const end = consumeString(code, i, 34);
+      const text = code.slice(i, end);
+      let k = end;
+      while (k < n) {
+        const c = code.charCodeAt(k);
+        if (c === 32 || c === 9 || c === 10 || c === 13) {
+          k++;
+          continue;
+        }
+        break;
+      }
+      out += span(code.charCodeAt(k) === 58 ? "prop" : "string", text);
+      i = end;
+      continue;
+    }
+    if (isDigit(ch) || ch === 45 && isDigit(code.charCodeAt(i + 1))) {
+      let j = i + 1;
+      while (j < n && isNumberPart(code.charCodeAt(j))) j++;
+      out += span("number", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (isIdentStart(ch)) {
+      let j = i + 1;
+      while (j < n && isIdentPart(code.charCodeAt(j))) j++;
+      const word = code.slice(i, j);
+      if (word === "true" || word === "false" || word === "null") {
+        out += span("keyword", word);
+      } else {
+        out += escapeHtml(word);
+      }
+      i = j;
+      continue;
+    }
+    if (isPunct(ch)) {
+      out += span("punct", code.charAt(i));
+      i++;
+      continue;
+    }
+    out += escapeHtml(code.charAt(i));
+    i++;
+  }
+  return out;
+}
+function highlightCss(code) {
+  const n = code.length;
+  let out = "";
+  let i = 0;
+  let depth = 0;
+  let beforeColon = true;
+  while (i < n) {
+    const ch = code.charCodeAt(i);
+    if (ch === 47 && code.charCodeAt(i + 1) === 42) {
+      let j = i + 2;
+      while (j < n && !(code.charCodeAt(j) === 42 && code.charCodeAt(j + 1) === 47)) {
+        j++;
+      }
+      j = Math.min(n, j + 2);
+      out += span("comment", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (ch === 34 || ch === 39) {
+      const end = consumeString(code, i, ch);
+      out += span("string", code.slice(i, end));
+      i = end;
+      continue;
+    }
+    if (ch === 64) {
+      let j = i + 1;
+      while (j < n && isIdentPart(code.charCodeAt(j))) j++;
+      out += span("keyword", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (ch === 123) {
+      out += span("punct", "{");
+      depth++;
+      beforeColon = true;
+      i++;
+      continue;
+    }
+    if (ch === 125) {
+      out += span("punct", "}");
+      if (depth > 0) depth--;
+      beforeColon = true;
+      i++;
+      continue;
+    }
+    if (ch === 59) {
+      out += span("punct", ";");
+      beforeColon = true;
+      i++;
+      continue;
+    }
+    if (ch === 58) {
+      out += span("punct", ":");
+      beforeColon = false;
+      i++;
+      continue;
+    }
+    if (isDigit(ch) || ch === 46 && isDigit(code.charCodeAt(i + 1))) {
+      let j = i + 1;
+      while (j < n && isNumberPart(code.charCodeAt(j))) j++;
+      out += span("number", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (isIdentStart(ch) || ch === 45) {
+      let j = i + 1;
+      while (j < n && (isIdentPart(code.charCodeAt(j)) || code.charCodeAt(j) === 45)) {
+        j++;
+      }
+      const word = code.slice(i, j);
+      if (depth > 0 && beforeColon) {
+        out += span("prop", word);
+      } else {
+        out += escapeHtml(word);
+      }
+      i = j;
+      continue;
+    }
+    if (isPunct(ch)) {
+      out += span("punct", code.charAt(i));
+      i++;
+      continue;
+    }
+    out += escapeHtml(code.charAt(i));
+    i++;
+  }
+  return out;
+}
+function isTagChar(ch) {
+  return isIdentPart(ch) || ch === 45 || ch === 58;
+}
+function highlightHtml(code) {
+  const n = code.length;
+  let out = "";
+  let i = 0;
+  while (i < n) {
+    const ch = code.charCodeAt(i);
+    if (ch === 60 && code.startsWith("<!--", i)) {
+      const idx = code.indexOf("-->", i + 4);
+      const j = idx === -1 ? n : idx + 3;
+      out += span("comment", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (ch === 60) {
+      let j = i + 1;
+      if (code.charCodeAt(j) === 47) j++;
+      out += span("punct", code.slice(i, j));
+      const nameStart = j;
+      while (j < n && isTagChar(code.charCodeAt(j))) j++;
+      if (j > nameStart) out += span("keyword", code.slice(nameStart, j));
+      while (j < n && code.charCodeAt(j) !== 62) {
+        const c = code.charCodeAt(j);
+        if (c === 34 || c === 39) {
+          const end = consumeString(code, j, c);
+          out += span("string", code.slice(j, end));
+          j = end;
+          continue;
+        }
+        if (c === 61) {
+          out += span("punct", "=");
+          j++;
+          continue;
+        }
+        if (isTagChar(c)) {
+          const a = j;
+          while (j < n && isTagChar(code.charCodeAt(j))) j++;
+          out += span("prop", code.slice(a, j));
+          continue;
+        }
+        out += escapeHtml(code.charAt(j));
+        j++;
+      }
+      if (j < n && code.charCodeAt(j) === 62) {
+        out += span("punct", ">");
+        j++;
+      }
+      i = j;
+      continue;
+    }
+    if (ch === 38) {
+      let j = i + 1;
+      while (j < n && j - i < 12 && code.charCodeAt(j) !== 59 && (isIdentPart(code.charCodeAt(j)) || code.charCodeAt(j) === 35)) {
+        j++;
+      }
+      if (j < n && code.charCodeAt(j) === 59) {
+        out += span("type", code.slice(i, j + 1));
+        i = j + 1;
+        continue;
+      }
+    }
+    out += escapeHtml(code.charAt(i));
+    i++;
+  }
+  return out;
+}
+function highlightMarkdownLine(line) {
+  const n = line.length;
+  let out = "";
+  let i = 0;
+  while (i < n && (line.charCodeAt(i) === 32 || line.charCodeAt(i) === 9)) {
+    out += line.charAt(i);
+    i++;
+  }
+  if (line.charCodeAt(i) === 35) {
+    let h = i;
+    while (h < n && line.charCodeAt(h) === 35) h++;
+    if (h - i <= 6 && (h >= n || line.charCodeAt(h) === 32)) {
+      out += span("keyword", line.slice(i, h));
+      i = h;
+    }
+  } else if (line.charCodeAt(i) === 62) {
+    out += span("keyword", ">");
+    i++;
+  } else {
+    const c = line.charCodeAt(i);
+    if ((c === 45 || c === 43 || c === 42) && line.charCodeAt(i + 1) === 32) {
+      out += span("punct", line.charAt(i));
+      i++;
+    }
+  }
+  while (i < n) {
+    const ch = line.charCodeAt(i);
+    if (ch === 96) {
+      let j = i + 1;
+      while (j < n && line.charCodeAt(j) !== 96) j++;
+      j = Math.min(n, j + 1);
+      out += span("string", line.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (ch === 42 || ch === 95 || ch === 126) {
+      let j = i;
+      while (j < n && line.charCodeAt(j) === ch) j++;
+      out += span("punct", line.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (ch === 91 || ch === 93 || ch === 40 || ch === 41) {
+      out += span("punct", line.charAt(i));
+      i++;
+      continue;
+    }
+    out += escapeHtml(line.charAt(i));
+    i++;
+  }
+  return out;
+}
+function highlightMarkdown(code) {
+  const lines = code.split("\n");
+  let out = "";
+  for (let i = 0; i < lines.length; i++) {
+    if (i > 0) out += "\n";
+    out += highlightMarkdownLine(lines[i] ?? "");
+  }
+  return out;
+}
+function highlightPython(code) {
+  const n = code.length;
+  let out = "";
+  let i = 0;
+  let prevWord = "";
+  while (i < n) {
+    const ch = code.charCodeAt(i);
+    if (ch === 35) {
+      let j = i + 1;
+      while (j < n && code.charCodeAt(j) !== 10) j++;
+      out += span("comment", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if ((ch === 34 || ch === 39) && code.charCodeAt(i + 1) === ch && code.charCodeAt(i + 2) === ch) {
+      const marker = code.slice(i, i + 3);
+      const idx = code.indexOf(marker, i + 3);
+      const j = idx === -1 ? n : idx + 3;
+      out += span("string", code.slice(i, j));
+      i = j;
+      prevWord = "";
+      continue;
+    }
+    if (ch === 34 || ch === 39) {
+      const end = consumeString(code, i, ch);
+      out += span("string", code.slice(i, end));
+      i = end;
+      prevWord = "";
+      continue;
+    }
+    if (ch === 64 && isIdentStart(code.charCodeAt(i + 1))) {
+      let j = i + 1;
+      while (j < n && isIdentPart(code.charCodeAt(j))) j++;
+      out += span("keyword", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (isDigit(ch) || ch === 46 && isDigit(code.charCodeAt(i + 1))) {
+      let j = i + 1;
+      while (j < n && isNumberPart(code.charCodeAt(j))) j++;
+      out += span("number", code.slice(i, j));
+      i = j;
+      prevWord = "";
+      continue;
+    }
+    if (isIdentStart(ch)) {
+      let j = i + 1;
+      while (j < n && isIdentPart(code.charCodeAt(j))) j++;
+      const word = code.slice(i, j);
+      if (PY_KEYWORDS.has(word)) {
+        out += span("keyword", word);
+      } else if (prevWord === "def") {
+        out += span("fn", word);
+      } else if (prevWord === "class") {
+        out += span("type", word);
+      } else {
+        let k = j;
+        while (k < n && (code.charCodeAt(k) === 32 || code.charCodeAt(k) === 9))
+          k++;
+        out += code.charCodeAt(k) === 40 ? span("fn", word) : escapeHtml(word);
+      }
+      prevWord = word;
+      i = j;
+      continue;
+    }
+    if (isPunct(ch)) {
+      out += span("punct", code.charAt(i));
+      i++;
+      continue;
+    }
+    out += escapeHtml(code.charAt(i));
+    i++;
+  }
+  return out;
+}
+function highlightBash(code) {
+  const n = code.length;
+  let out = "";
+  let i = 0;
+  while (i < n) {
+    const ch = code.charCodeAt(i);
+    if (ch === 35) {
+      const prev = i > 0 ? code.charCodeAt(i - 1) : 10;
+      if (i === 0 || prev === 32 || prev === 9 || prev === 10 || prev === 13 || prev === 59) {
+        let j = i + 1;
+        while (j < n && code.charCodeAt(j) !== 10) j++;
+        out += span("comment", code.slice(i, j));
+        i = j;
+        continue;
+      }
+    }
+    if (ch === 34 || ch === 39) {
+      const end = consumeString(code, i, ch);
+      out += span("string", code.slice(i, end));
+      i = end;
+      continue;
+    }
+    if (ch === 36) {
+      let j = i + 1;
+      if (code.charCodeAt(j) === 123) {
+        while (j < n && code.charCodeAt(j) !== 125) j++;
+        j = Math.min(n, j + 1);
+      } else {
+        while (j < n && isIdentPart(code.charCodeAt(j))) j++;
+      }
+      out += span("prop", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (isDigit(ch)) {
+      let j = i + 1;
+      while (j < n && isNumberPart(code.charCodeAt(j))) j++;
+      out += span("number", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (isIdentStart(ch)) {
+      let j = i + 1;
+      while (j < n && isIdentPart(code.charCodeAt(j))) j++;
+      const word = code.slice(i, j);
+      out += BASH_KEYWORDS.has(word) ? span("keyword", word) : escapeHtml(word);
+      i = j;
+      continue;
+    }
+    if (isPunct(ch)) {
+      out += span("punct", code.charAt(i));
+      i++;
+      continue;
+    }
+    out += escapeHtml(code.charAt(i));
+    i++;
+  }
+  return out;
+}
+function highlightSql(code) {
+  const n = code.length;
+  let out = "";
+  let i = 0;
+  while (i < n) {
+    const ch = code.charCodeAt(i);
+    if (ch === 45 && code.charCodeAt(i + 1) === 45) {
+      let j = i + 2;
+      while (j < n && code.charCodeAt(j) !== 10) j++;
+      out += span("comment", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (ch === 47 && code.charCodeAt(i + 1) === 42) {
+      let j = i + 2;
+      while (j < n && !(code.charCodeAt(j) === 42 && code.charCodeAt(j + 1) === 47)) {
+        j++;
+      }
+      j = Math.min(n, j + 2);
+      out += span("comment", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (ch === 39 || ch === 34) {
+      const end = consumeString(code, i, ch);
+      out += span("string", code.slice(i, end));
+      i = end;
+      continue;
+    }
+    if (isDigit(ch) || ch === 46 && isDigit(code.charCodeAt(i + 1))) {
+      let j = i + 1;
+      while (j < n && isNumberPart(code.charCodeAt(j))) j++;
+      out += span("number", code.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (isIdentStart(ch)) {
+      let j = i + 1;
+      while (j < n && isIdentPart(code.charCodeAt(j))) j++;
+      const word = code.slice(i, j);
+      out += SQL_KEYWORDS.has(word.toLowerCase()) ? span("keyword", word) : escapeHtml(word);
+      i = j;
+      continue;
+    }
+    if (isPunct(ch)) {
+      out += span("punct", code.charAt(i));
+      i++;
+      continue;
+    }
+    out += escapeHtml(code.charAt(i));
+    i++;
+  }
+  return out;
+}
+var ALIASES = {
+  js: "javascript",
+  jsx: "javascript",
+  javascript: "javascript",
+  mjs: "javascript",
+  cjs: "javascript",
+  ts: "typescript",
+  tsx: "typescript",
+  typescript: "typescript",
+  json: "json",
+  jsonc: "json",
+  json5: "json",
+  css: "css",
+  html: "html",
+  htm: "html",
+  xml: "html",
+  md: "markdown",
+  markdown: "markdown",
+  py: "python",
+  python: "python",
+  sh: "bash",
+  bash: "bash",
+  shell: "bash",
+  zsh: "bash",
+  sql: "sql"
+};
+var TOKENIZERS = {
+  javascript: highlightCLike,
+  typescript: highlightCLike,
+  json: highlightJson,
+  css: highlightCss,
+  html: highlightHtml,
+  markdown: highlightMarkdown,
+  python: highlightPython,
+  bash: highlightBash,
+  sql: highlightSql
+};
+function highlightToHtml(lang, code) {
+  const info = typeof lang === "string" ? lang : "";
+  const first = info.trim().split(/\s+/)[0] ?? "";
+  const key = first.toLowerCase();
+  const resolved = ALIASES[key] ?? key;
+  const tokenizer = TOKENIZERS[resolved];
+  if (!tokenizer) return escapeHtml(code);
+  return tokenizer(code);
+}
+
+// src/core/comments.ts
+var MAPPER = new TextDoc();
+var ASSOC_FROM = 1;
+var ASSOC_TO = 1;
+function mapAnchor(anchor, change) {
+  const from = MAPPER.mapOffset(anchor.from, change, ASSOC_FROM);
+  const to = MAPPER.mapOffset(anchor.to, change, ASSOC_TO);
+  const collapsed = from === to;
+  const deletedWholeRange = change.to > change.from && change.from <= anchor.from && change.to >= anchor.to;
+  if (collapsed && deletedWholeRange) return null;
+  return { from: Math.min(from, to), to: Math.max(from, to) };
+}
+
+// src/core/table.ts
+var clampInt = (n, lo, hi) => n < lo ? lo : n > hi ? hi : n;
+function delimCell(align) {
+  switch (align) {
+    case "left":
+      return ":---";
+    case "center":
+      return ":---:";
+    case "right":
+      return "---:";
+    default:
+      return "---";
+  }
+}
+var cellText = (text, cell) => text.slice(cell.from, cell.to);
+var emptyRow = (ncols) => Array.from({ length: ncols }, () => "");
+function tableToGrid(text, table) {
+  const ncols = Math.max(1, table.header.length);
+  const header = table.header.map((c) => cellText(text, c));
+  while (header.length < ncols) header.push("");
+  const align = [];
+  for (let i = 0; i < ncols; i++) align.push(table.align[i] ?? null);
+  const rows = table.rows.map((row) => {
+    const cells = row.map((c) => cellText(text, c));
+    while (cells.length < ncols) cells.push("");
+    cells.length = ncols;
+    return cells;
+  });
+  return { header, align, rows };
+}
+function cellsForLine(grid, lineIdx) {
+  const ncols = grid.header.length;
+  if (lineIdx === 0) return grid.header;
+  if (lineIdx === 1) {
+    const a = [];
+    for (let i = 0; i < ncols; i++) a.push(delimCell(grid.align[i] ?? null));
+    return a;
+  }
+  return grid.rows[lineIdx - 2] ?? grid.header;
+}
+function gridLines(grid) {
+  const ncols = grid.header.length;
+  const rowLine = (cells) => {
+    const out = cells.slice(0, ncols);
+    while (out.length < ncols) out.push("");
+    return `| ${out.join(" | ")} |`;
+  };
+  const delim = [];
+  for (let i = 0; i < ncols; i++) delim.push(delimCell(grid.align[i] ?? null));
+  const lines = [rowLine(grid.header), `| ${delim.join(" | ")} |`];
+  for (const r of grid.rows) lines.push(rowLine(r));
+  return lines;
+}
+function lineStart(lines, lineIdx) {
+  let off = 0;
+  for (const l of lines.slice(0, lineIdx)) off += l.length + 1;
+  return off;
+}
+function colOffsetInLine(cells, col) {
+  let off = 2;
+  for (const c of cells.slice(0, col)) off += c.length + 3;
+  return off;
+}
+function commit(text, table, grid, lineIdx, col) {
+  const lines = gridLines(grid);
+  const block = lines.join("\n");
+  const inBlock = lineStart(lines, lineIdx) + colOffsetInLine(cellsForLine(grid, lineIdx), col);
+  const newText = text.slice(0, table.from) + block + text.slice(table.to);
+  return { text: newText, selection: table.from + inBlock };
+}
+function cellSourceRange(table, row, col) {
+  const cell = row === 0 ? table.header[col] : table.rows[row - 1]?.[col];
+  if (!cell) return null;
+  return { from: cell.from, to: cell.to };
+}
+function addRow(text, table, atRow) {
+  const grid = tableToGrid(text, table);
+  const bodyIdx = clampInt(atRow - 1, 0, grid.rows.length);
+  grid.rows.splice(bodyIdx, 0, emptyRow(grid.header.length));
+  return commit(text, table, grid, 2 + bodyIdx, 0);
+}
+function addColumn(text, table, atCol) {
+  const grid = tableToGrid(text, table);
+  const idx = clampInt(atCol, 0, grid.header.length);
+  grid.header.splice(idx, 0, "");
+  grid.align.splice(idx, 0, null);
+  for (const r of grid.rows) r.splice(idx, 0, "");
+  return commit(text, table, grid, 0, idx);
+}
+function removeRow(text, table, atRow) {
+  const grid = tableToGrid(text, table);
+  const bodyIdx = atRow - 1;
+  if (bodyIdx >= 0 && bodyIdx < grid.rows.length) grid.rows.splice(bodyIdx, 1);
+  const lineIdx = grid.rows.length === 0 ? 0 : 2 + clampInt(bodyIdx, 0, grid.rows.length - 1);
+  return commit(text, table, grid, lineIdx, 0);
+}
+function removeColumn(text, table, atCol) {
+  const grid = tableToGrid(text, table);
+  if (grid.header.length > 1 && atCol >= 0 && atCol < grid.header.length) {
+    grid.header.splice(atCol, 1);
+    grid.align.splice(atCol, 1);
+    for (const r of grid.rows) r.splice(atCol, 1);
+  }
+  const caretCol = clampInt(atCol, 0, grid.header.length - 1);
+  return commit(text, table, grid, 0, caretCol);
+}
+function setAlignment(text, table, col, align) {
+  const grid = tableToGrid(text, table);
+  if (col >= 0 && col < grid.align.length) grid.align[col] = align;
+  const caretCol = clampInt(col, 0, grid.align.length - 1);
+  return commit(text, table, grid, 1, caretCol);
+}
+
+// src/core/index.ts
+var EditorView = class {
+  dom;
+  constructor(options) {
+    this.dom = options.parent;
+    throw new Error(
+      "typewright/core: engine not yet implemented (pre-alpha scaffold). See SPEC.md for the architecture and roadmap."
+    );
+  }
+  /** Current document string. */
+  get doc() {
+    return "";
+  }
+  /** Apply an edit. */
+  dispatch(_change) {
+  }
+  setSelection(_selection) {
+  }
+  destroy() {
+  }
+};
+
+export { COMMANDS, EditorView, TextDoc, activeBlockIndex, addColumn, addRow, applyCommand, cellSourceRange, collectMarkers, headingFoldRanges, hiddenMarkers, highlightToHtml, mapAnchor, removeColumn, removeRow, setAlignment };
+//# sourceMappingURL=chunk-CZQO7TTL.js.map
+//# sourceMappingURL=chunk-CZQO7TTL.js.map