@scrider/formatter 1.0.0

package/dist/index.js

@@ -0,0 +1,4844 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+export * from "@scrider/delta";
+
+// src/schema/Registry.ts
+var Registry = class {
+  constructor() {
+    this.formats = /* @__PURE__ */ new Map();
+  }
+  register(formatOrFormats) {
+    const formats = Array.isArray(formatOrFormats) ? formatOrFormats : [formatOrFormats];
+    for (const format of formats) {
+      if (this.formats.has(format.name)) {
+        throw new Error(`Format "${format.name}" is already registered`);
+      }
+      this.formats.set(format.name, format);
+    }
+    return this;
+  }
+  /**
+   * Get a format by name
+   *
+   * @param name - Format name
+   * @returns Format or undefined if not found
+   */
+  get(name) {
+    return this.formats.get(name);
+  }
+  /**
+   * Check if a format is registered
+   *
+   * @param name - Format name
+   * @returns true if format exists
+   */
+  has(name) {
+    return this.formats.has(name);
+  }
+  /**
+   * Get all formats with a specific scope
+   *
+   * @param scope - Format scope to filter by
+   * @returns Array of formats with the given scope
+   */
+  getByScope(scope) {
+    const result = [];
+    for (const format of this.formats.values()) {
+      if (format.scope === scope) {
+        result.push(format);
+      }
+    }
+    return result;
+  }
+  /**
+   * Get all registered format names
+   *
+   * @returns Array of format names
+   */
+  getNames() {
+    return Array.from(this.formats.keys());
+  }
+  /**
+   * Normalize all attributes using registered formats
+   *
+   * Applies normalize() for each attribute that has a registered format.
+   * Unknown attributes are passed through unchanged.
+   *
+   * @param attributes - Attributes to normalize
+   * @returns New object with normalized attributes
+   */
+  normalize(attributes) {
+    if (!attributes) return void 0;
+    const result = {};
+    let hasChanges = false;
+    for (const [key, value] of Object.entries(attributes)) {
+      const format = this.formats.get(key);
+      if (format?.normalize) {
+        const normalized = format.normalize(value);
+        result[key] = normalized;
+        if (normalized !== value) {
+          hasChanges = true;
+        }
+      } else {
+        result[key] = value;
+      }
+    }
+    return hasChanges ? result : attributes;
+  }
+  /**
+   * Validate all attributes
+   *
+   * @param attributes - Attributes to validate
+   * @returns true if all known attributes are valid
+   */
+  validate(attributes) {
+    if (!attributes) return true;
+    for (const [key, value] of Object.entries(attributes)) {
+      const format = this.formats.get(key);
+      if (format?.validate && !format.validate(value)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Sanitize attributes by removing invalid values
+   *
+   * Removes attributes that:
+   * - Are not registered (unknown formats)
+   * - Fail validation
+   *
+   * @param attributes - Attributes to sanitize
+   * @param removeUnknown - If true, remove unregistered attributes (default: true)
+   * @returns New object with only valid attributes
+   */
+  sanitize(attributes, removeUnknown = true) {
+    if (!attributes) return void 0;
+    const result = {};
+    let hasKeys = false;
+    for (const [key, value] of Object.entries(attributes)) {
+      const format = this.formats.get(key);
+      if (!format && removeUnknown) {
+        continue;
+      }
+      if (format?.validate && !format.validate(value)) {
+        continue;
+      }
+      if (format?.normalize) {
+        result[key] = format.normalize(value);
+      } else {
+        result[key] = value;
+      }
+      hasKeys = true;
+    }
+    return hasKeys ? result : void 0;
+  }
+  /**
+   * Get the number of registered formats
+   */
+  get size() {
+    return this.formats.size;
+  }
+};
+
+// src/schema/BlockHandlerRegistry.ts
+var BlockHandlerRegistry = class {
+  constructor() {
+    this.handlers = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a block handler
+   *
+   * @param handler - BlockHandler to register
+   * @returns this for chaining
+   * @throws Error if handler with same type is already registered
+   */
+  register(handler) {
+    if (this.handlers.has(handler.type)) {
+      throw new Error(`BlockHandler "${handler.type}" is already registered`);
+    }
+    this.handlers.set(handler.type, handler);
+    return this;
+  }
+  /**
+   * Get a handler by block type
+   *
+   * @param type - Block type (e.g. "table")
+   * @returns BlockHandler or undefined if not found
+   */
+  get(type) {
+    return this.handlers.get(type);
+  }
+  /**
+   * Check if a handler is registered for a block type
+   *
+   * @param type - Block type
+   * @returns true if handler exists
+   */
+  has(type) {
+    return this.handlers.has(type);
+  }
+  /**
+   * Get the number of registered handlers
+   */
+  get size() {
+    return this.handlers.size;
+  }
+  /**
+   * Get all registered block type names
+   */
+  getTypes() {
+    return Array.from(this.handlers.keys());
+  }
+};
+
+// src/schema/blocks/table.ts
+import { Delta as Delta2 } from "@scrider/delta";
+
+// src/conversion/sanitize.ts
+import { Delta, isInsert, isRetain, isEmbedInsert, deepClone } from "@scrider/delta";
+var DEFAULT_OPTIONS = {
+  removeUnknown: true,
+  normalize: true,
+  removeInvalidEmbeds: false,
+  allowedEmbeds: []
+};
+function sanitizeDelta(delta, registry, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const result = new Delta();
+  for (const op of delta.ops) {
+    const sanitizedOp = sanitizeOp(op, registry, opts);
+    if (sanitizedOp !== null) {
+      result.push(sanitizedOp);
+    }
+  }
+  return result;
+}
+function sanitizeOp(op, registry, options) {
+  if (isInsert(op)) {
+    if (isEmbedInsert(op)) {
+      const embedValue = op.insert;
+      const embedType = Object.keys(embedValue)[0];
+      if (!embedType) {
+        return options.removeInvalidEmbeds ? null : op;
+      }
+      if (options.allowedEmbeds.length > 0) {
+        if (!options.allowedEmbeds.includes(embedType)) {
+          return options.removeInvalidEmbeds ? null : op;
+        }
+      }
+      if (!registry.has(embedType)) {
+        return options.removeInvalidEmbeds ? null : op;
+      }
+      const format = registry.get(embedType);
+      if (format?.validate && !format.validate(embedValue[embedType])) {
+        return options.removeInvalidEmbeds ? null : op;
+      }
+    }
+    const sanitizedAttrs = sanitizeAttributes(op.attributes, registry, options);
+    if (sanitizedAttrs === op.attributes) {
+      return op;
+    }
+    const newOp = { insert: op.insert };
+    if (sanitizedAttrs !== void 0) {
+      newOp.attributes = sanitizedAttrs;
+    }
+    return newOp;
+  }
+  if (isRetain(op)) {
+    const sanitizedAttrs = sanitizeAttributes(op.attributes, registry, options);
+    if (sanitizedAttrs === op.attributes) {
+      return op;
+    }
+    const newOp = { retain: op.retain };
+    if (sanitizedAttrs !== void 0) {
+      newOp.attributes = sanitizedAttrs;
+    }
+    return newOp;
+  }
+  return op;
+}
+function sanitizeAttributes(attributes, registry, options) {
+  if (!attributes) {
+    return void 0;
+  }
+  let result;
+  let hasChanges = false;
+  for (const [key, value] of Object.entries(attributes)) {
+    const format = registry.get(key);
+    if (!format && options.removeUnknown) {
+      hasChanges = true;
+      continue;
+    }
+    if (format?.validate && !format.validate(value)) {
+      hasChanges = true;
+      continue;
+    }
+    if (!result) {
+      result = {};
+    }
+    if (format?.normalize && options.normalize) {
+      const normalized = format.normalize(value);
+      result[key] = normalized;
+      if (normalized !== value) {
+        hasChanges = true;
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+  if (!hasChanges) {
+    return attributes;
+  }
+  return result && Object.keys(result).length > 0 ? result : void 0;
+}
+function normalizeDelta(delta, registry) {
+  return sanitizeDelta(delta, registry, {
+    removeUnknown: false,
+    normalize: true,
+    removeInvalidEmbeds: false
+  });
+}
+function validateDelta(delta, registry) {
+  for (const op of delta.ops) {
+    if (isInsert(op) && isEmbedInsert(op)) {
+      const embedValue = op.insert;
+      const embedType = Object.keys(embedValue)[0];
+      if (!embedType) {
+        return false;
+      }
+      if (!registry.has(embedType)) {
+        return false;
+      }
+      const format = registry.get(embedType);
+      if (format?.validate && !format.validate(embedValue[embedType])) {
+        return false;
+      }
+    }
+    if ("attributes" in op && op.attributes) {
+      if (!registry.validate(op.attributes)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function cloneDelta(delta) {
+  return new Delta(deepClone(delta.ops));
+}
+
+// src/conversion/adapters/types.ts
+var NODE_TYPE = {
+  ELEMENT_NODE: 1,
+  TEXT_NODE: 3,
+  DOCUMENT_NODE: 9,
+  DOCUMENT_FRAGMENT_NODE: 11
+};
+function isElement(node) {
+  return node.nodeType === NODE_TYPE.ELEMENT_NODE;
+}
+function isTextNode(node) {
+  return node.nodeType === NODE_TYPE.TEXT_NODE;
+}
+
+// src/schema/blocks/table.ts
+var CELL_KEY_RE = /^(\d+):(\d+)$/;
+function parseCellKey(key) {
+  const match = CELL_KEY_RE.exec(key);
+  if (!match) return null;
+  return [parseInt(match[1], 10), parseInt(match[2], 10)];
+}
+function getGridDimensions(cells) {
+  let maxRow = -1;
+  let maxCol = -1;
+  for (const key of Object.keys(cells)) {
+    const parsed = parseCellKey(key);
+    if (!parsed) return null;
+    const [r, c] = parsed;
+    if (r > maxRow) maxRow = r;
+    if (c > maxCol) maxCol = c;
+  }
+  if (maxRow < 0 || maxCol < 0) return null;
+  return [maxRow + 1, maxCol + 1];
+}
+function isValidCellData(cell) {
+  return typeof cell === "object" && cell !== null && Array.isArray(cell.ops) && cell.ops.length > 0 && (cell.colspan === void 0 || Number.isInteger(cell.colspan) && cell.colspan >= 1) && (cell.rowspan === void 0 || Number.isInteger(cell.rowspan) && cell.rowspan >= 1);
+}
+function validateMergedCells(cells, rows, cols) {
+  const covered = /* @__PURE__ */ new Set();
+  for (const [key, cell] of Object.entries(cells)) {
+    if (cell === null) continue;
+    const parsed = parseCellKey(key);
+    if (!parsed) return false;
+    const [r, c] = parsed;
+    const cs = cell.colspan ?? 1;
+    const rs = cell.rowspan ?? 1;
+    if (r + rs > rows || c + cs > cols) return false;
+    for (let dr = 0; dr < rs; dr++) {
+      for (let dc = 0; dc < cs; dc++) {
+        if (dr === 0 && dc === 0) continue;
+        const coveredKey = `${r + dr}:${c + dc}`;
+        if (covered.has(coveredKey)) return false;
+        covered.add(coveredKey);
+      }
+    }
+  }
+  for (const [key, cell] of Object.entries(cells)) {
+    if (cell === null) {
+      if (!covered.has(key)) return false;
+    } else {
+      if (covered.has(key)) return false;
+    }
+  }
+  return true;
+}
+function renderExtendedRow(data, row, cols, defaultCellTag, context, pretty) {
+  const nl = pretty ? "\n" : "";
+  const ind = (level) => pretty ? "  ".repeat(level) : "";
+  let html = `${ind(2)}<tr>${nl}`;
+  for (let c = 0; c < cols; c++) {
+    const key = `${row}:${c}`;
+    const cell = data.cells[key];
+    if (cell === null) continue;
+    if (cell === void 0) continue;
+    const cellTag = row < (data.headerRows ?? 0) ? "th" : defaultCellTag;
+    const attrs = [];
+    if (cell.colspan && cell.colspan > 1) {
+      attrs.push(`colspan="${cell.colspan}"`);
+    }
+    if (cell.rowspan && cell.rowspan > 1) {
+      attrs.push(`rowspan="${cell.rowspan}"`);
+    }
+    if (data.colAligns) {
+      const align = data.colAligns[c];
+      if (align && align !== "left") {
+        attrs.push(`style="text-align: ${align}"`);
+      }
+    }
+    const attrStr = attrs.length > 0 ? " " + attrs.join(" ") : "";
+    let content = "";
+    if (context.renderDelta) {
+      content = context.renderDelta(cell.ops);
+    }
+    html += `${ind(3)}<${cellTag}${attrStr}>${content}</${cellTag}>${nl}`;
+  }
+  html += `${ind(2)}</tr>${nl}`;
+  return html;
+}
+function isGfmCompatible(data) {
+  if (data.colWidths && data.colWidths.some((w) => w > 0)) {
+    return false;
+  }
+  for (const cell of Object.values(data.cells)) {
+    if (cell === null) return false;
+    if (cell.colspan && cell.colspan > 1) return false;
+    if (cell.rowspan && cell.rowspan > 1) return false;
+  }
+  return true;
+}
+function stripCellContent(rendered) {
+  return rendered.replace(/\n+$/, "").replace(/\n/g, " ");
+}
+function renderGfmTable(data, context) {
+  const dims = getGridDimensions(data.cells);
+  if (!dims) return "";
+  const [rows, cols] = dims;
+  const headerRows = data.headerRows ?? 0;
+  const lines = [];
+  if (headerRows === 0) {
+    const emptyParts = [];
+    for (let c = 0; c < cols; c++) {
+      emptyParts.push(" ");
+    }
+    lines.push("| " + emptyParts.join(" | ") + " |");
+    lines.push(renderGfmSeparator(cols, data.colAligns));
+  }
+  for (let r = 0; r < rows; r++) {
+    const parts = [];
+    for (let c = 0; c < cols; c++) {
+      const cell = data.cells[`${r}:${c}`];
+      let text = "";
+      if (cell && context.renderDelta) {
+        text = stripCellContent(context.renderDelta(cell.ops));
+      }
+      parts.push(text.replace(/\|/g, "\\|"));
+    }
+    lines.push("| " + parts.join(" | ") + " |");
+    if (headerRows > 0 && r === headerRows - 1) {
+      lines.push(renderGfmSeparator(cols, data.colAligns));
+    }
+  }
+  return lines.join("\n");
+}
+function renderGfmSeparator(cols, colAligns) {
+  const sepParts = [];
+  for (let c = 0; c < cols; c++) {
+    const align = colAligns?.[c];
+    if (align === "center") {
+      sepParts.push(":---:");
+    } else if (align === "right") {
+      sepParts.push("---:");
+    } else if (align === "left") {
+      sepParts.push(":---");
+    } else {
+      sepParts.push("---");
+    }
+  }
+  return "| " + sepParts.join(" | ") + " |";
+}
+function collectTableRows(table) {
+  const rows = [];
+  let headerRowCount = 0;
+  const children = table.childNodes;
+  for (let i = 0; i < children.length; i++) {
+    const section = children[i];
+    if (!section || !isElement(section)) continue;
+    const sectionTag = section.tagName.toLowerCase();
+    if (sectionTag === "thead" || sectionTag === "tbody" || sectionTag === "tfoot") {
+      const isHeader = sectionTag === "thead";
+      const sectionChildren = section.childNodes;
+      for (let j = 0; j < sectionChildren.length; j++) {
+        const row = sectionChildren[j];
+        if (!row || !isElement(row) || row.tagName.toLowerCase() !== "tr") continue;
+        rows.push(row);
+        if (isHeader) headerRowCount++;
+      }
+    } else if (sectionTag === "tr") {
+      rows.push(section);
+    }
+  }
+  return { rows, headerRowCount };
+}
+function extractColWidths(table) {
+  const children = table.childNodes;
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i];
+    if (!child || !isElement(child) || child.tagName.toLowerCase() !== "colgroup") continue;
+    const widths = [];
+    const cols = child.childNodes;
+    for (let j = 0; j < cols.length; j++) {
+      const col = cols[j];
+      if (!col || !isElement(col) || col.tagName.toLowerCase() !== "col") continue;
+      let width = 0;
+      const style = col.getAttribute("style") || "";
+      const widthMatch = style.match(/width:\s*([\d.]+)(%|px)/);
+      if (widthMatch?.[1]) {
+        width = parseFloat(widthMatch[1]);
+      } else {
+        const widthAttr = col.getAttribute("width");
+        if (widthAttr) {
+          width = parseFloat(widthAttr) || 0;
+        }
+      }
+      widths.push(width);
+    }
+    if (widths.length > 0) return widths;
+  }
+  return void 0;
+}
+function extractCellAlign(cell) {
+  const textAlign = cell.style?.textAlign || cell.style?.getPropertyValue?.("text-align");
+  if (textAlign === "left" || textAlign === "center" || textAlign === "right") {
+    return textAlign;
+  }
+  const style = cell.getAttribute("style") || "";
+  const match = style.match(/text-align:\s*(left|center|right)/);
+  if (match?.[1]) {
+    return match[1];
+  }
+  return null;
+}
+function parseTableElement(table, context) {
+  const { rows, headerRowCount } = collectTableRows(table);
+  if (rows.length === 0) return null;
+  const cells = {};
+  const colAligns = [];
+  let maxCol = 0;
+  let firstRowProcessed = false;
+  const occupied = /* @__PURE__ */ new Set();
+  for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
+    const row = rows[rowIdx];
+    let colIdx = 0;
+    const cellChildren = row.childNodes;
+    for (let ci = 0; ci < cellChildren.length; ci++) {
+      const cell = cellChildren[ci];
+      if (!cell || !isElement(cell)) continue;
+      const cellTag = cell.tagName.toLowerCase();
+      if (cellTag !== "td" && cellTag !== "th") continue;
+      while (occupied.has(`${rowIdx}:${colIdx}`)) {
+        colIdx++;
+      }
+      const colspanAttr = cell.getAttribute("colspan");
+      const rowspanAttr = cell.getAttribute("rowspan");
+      const colspan = colspanAttr ? parseInt(colspanAttr, 10) || 1 : 1;
+      const rowspan = rowspanAttr ? parseInt(rowspanAttr, 10) || 1 : 1;
+      let ops;
+      if (context.parseElement) {
+        ops = context.parseElement(cell);
+        if (ops.length === 0) {
+          ops = [{ insert: "\n" }];
+        }
+      } else {
+        ops = [{ insert: "\n" }];
+      }
+      const cellData = { ops };
+      if (colspan > 1) cellData.colspan = colspan;
+      if (rowspan > 1) cellData.rowspan = rowspan;
+      cells[`${rowIdx}:${colIdx}`] = cellData;
+      for (let dr = 0; dr < rowspan; dr++) {
+        for (let dc = 0; dc < colspan; dc++) {
+          if (dr === 0 && dc === 0) continue;
+          const coveredKey = `${rowIdx + dr}:${colIdx + dc}`;
+          occupied.add(coveredKey);
+          cells[coveredKey] = null;
+        }
+      }
+      for (let dc = 1; dc < colspan; dc++) {
+        occupied.add(`${rowIdx}:${colIdx + dc}`);
+      }
+      if (!firstRowProcessed) {
+        const align = extractCellAlign(cell);
+        for (let dc = 0; dc < colspan; dc++) {
+          colAligns.push(align);
+        }
+      }
+      const cellEndCol = colIdx + colspan - 1;
+      if (cellEndCol > maxCol) maxCol = cellEndCol;
+      colIdx += colspan;
+    }
+    while (occupied.has(`${rowIdx}:${colIdx}`)) {
+      colIdx++;
+    }
+    if (colIdx - 1 > maxCol) maxCol = colIdx - 1;
+    if (!firstRowProcessed) firstRowProcessed = true;
+  }
+  const totalCols = maxCol + 1;
+  const totalRows = rows.length;
+  for (let r = 0; r < totalRows; r++) {
+    for (let c = 0; c < totalCols; c++) {
+      const key = `${r}:${c}`;
+      if (!(key in cells)) {
+        cells[key] = { ops: [{ insert: "\n" }] };
+      }
+    }
+  }
+  const result = {
+    type: "table",
+    cells
+  };
+  if (headerRowCount > 0) {
+    result.headerRows = headerRowCount;
+  }
+  const colWidths = extractColWidths(table);
+  if (colWidths) {
+    while (colWidths.length < totalCols) colWidths.push(0);
+    if (colWidths.length > totalCols) colWidths.length = totalCols;
+    result.colWidths = colWidths;
+  }
+  if (colAligns.length > 0 && colAligns.some((a) => a !== null)) {
+    while (colAligns.length < totalCols) colAligns.push(null);
+    if (colAligns.length > totalCols) colAligns.length = totalCols;
+    result.colAligns = colAligns;
+  }
+  return result;
+}
+var tableBlockHandler = {
+  type: "table",
+  validate(data) {
+    if (!data || typeof data !== "object" || data.type !== "table") {
+      return false;
+    }
+    if (!data.cells || typeof data.cells !== "object" || Array.isArray(data.cells)) {
+      return false;
+    }
+    const cellKeys = Object.keys(data.cells);
+    if (cellKeys.length === 0) return false;
+    for (const key of cellKeys) {
+      if (!CELL_KEY_RE.test(key)) return false;
+    }
+    const dims = getGridDimensions(data.cells);
+    if (!dims) return false;
+    const [rows, cols] = dims;
+    if (cellKeys.length !== rows * cols) return false;
+    for (let r = 0; r < rows; r++) {
+      for (let c = 0; c < cols; c++) {
+        if (!(`${r}:${c}` in data.cells)) return false;
+      }
+    }
+    for (const [, cell] of Object.entries(data.cells)) {
+      if (cell !== null && !isValidCellData(cell)) return false;
+    }
+    if (!validateMergedCells(data.cells, rows, cols)) return false;
+    if (data.headerRows !== void 0) {
+      if (!Number.isInteger(data.headerRows) || data.headerRows < 0 || data.headerRows > rows) {
+        return false;
+      }
+    }
+    if (data.colWidths !== void 0) {
+      if (!Array.isArray(data.colWidths) || data.colWidths.length !== cols) {
+        return false;
+      }
+      for (const w of data.colWidths) {
+        if (typeof w !== "number" || w < 0) return false;
+      }
+    }
+    if (data.colAligns !== void 0) {
+      if (!Array.isArray(data.colAligns) || data.colAligns.length !== cols) {
+        return false;
+      }
+      const validAligns = ["left", "center", "right", null];
+      for (const a of data.colAligns) {
+        if (!validAligns.includes(a)) return false;
+      }
+    }
+    return true;
+  },
+  // ── Conversion ──────────────────────────────────────────────
+  toHtml(data, context) {
+    const pretty = context.options?.pretty ?? false;
+    const nl = pretty ? "\n" : "";
+    const ind = (level) => pretty ? "  ".repeat(level) : "";
+    const dims = getGridDimensions(data.cells);
+    if (!dims) return "";
+    const [rows, cols] = dims;
+    const headerRows = data.headerRows ?? 0;
+    let html = `<table>${nl}`;
+    if (data.colWidths && data.colWidths.length > 0) {
+      const widthMode = context.options?.tableWidthMode ?? "percent";
+      html += `${ind(1)}<colgroup>${nl}`;
+      for (let c = 0; c < cols; c++) {
+        const w = data.colWidths[c];
+        if (w !== void 0 && w > 0) {
+          const unit = widthMode === "pixel" ? "px" : "%";
+          html += `${ind(2)}<col style="width: ${w}${unit}">${nl}`;
+        } else {
+          html += `${ind(2)}<col>${nl}`;
+        }
+      }
+      html += `${ind(1)}</colgroup>${nl}`;
+    }
+    if (headerRows > 0) {
+      html += `${ind(1)}<thead>${nl}`;
+      for (let r = 0; r < headerRows; r++) {
+        html += renderExtendedRow(data, r, cols, "th", context, pretty);
+      }
+      html += `${ind(1)}</thead>${nl}`;
+    }
+    const bodyStart = headerRows;
+    if (bodyStart < rows) {
+      html += `${ind(1)}<tbody>${nl}`;
+      for (let r = bodyStart; r < rows; r++) {
+        html += renderExtendedRow(data, r, cols, "td", context, pretty);
+      }
+      html += `${ind(1)}</tbody>${nl}`;
+    }
+    html += `</table>`;
+    return html;
+  },
+  fromHtml(element, context) {
+    return parseTableElement(element, context);
+  },
+  toMarkdown(data, context) {
+    if (isGfmCompatible(data)) {
+      return renderGfmTable(data, context);
+    }
+    return null;
+  },
+  // ── Normalize ─────────────────────────────────────────────
+  normalize(data, registry) {
+    const newCells = {};
+    let changed = false;
+    for (const [key, cell] of Object.entries(data.cells)) {
+      if (cell !== null) {
+        const normalized = normalizeDelta(new Delta2(cell.ops), registry);
+        if (normalized.ops !== cell.ops) {
+          newCells[key] = { ...cell, ops: normalized.ops };
+          changed = true;
+        } else {
+          newCells[key] = cell;
+        }
+      } else {
+        newCells[key] = null;
+      }
+    }
+    return changed ? { ...data, cells: newCells } : data;
+  },
+  // ── Nested Deltas ──────────────────────────────────────────
+  getNestedDeltas(data) {
+    const deltas = [];
+    for (const cell of Object.values(data.cells)) {
+      if (cell !== null) {
+        deltas.push(cell.ops);
+      }
+    }
+    return deltas;
+  },
+  setNestedDeltas(data, deltas) {
+    const newCells = {};
+    let idx = 0;
+    for (const [key, cell] of Object.entries(data.cells)) {
+      if (cell !== null) {
+        newCells[key] = { ...cell, ops: deltas[idx++] };
+      } else {
+        newCells[key] = null;
+      }
+    }
+    return { ...data, cells: newCells };
+  }
+};
+
+// src/schema/blocks/footnotes.ts
+import { isTextInsert, Delta as Delta3 } from "@scrider/delta";
+function isValidNoteData(note) {
+  return typeof note === "object" && note !== null && Array.isArray(note.ops) && note.ops.length > 0;
+}
+function extractFootnoteId(element) {
+  const id = element.getAttribute("id") || "";
+  if (id.startsWith("fn-")) {
+    return id.slice(3);
+  }
+  return null;
+}
+var footnotesBlockHandler = {
+  type: "footnotes",
+  validate(data) {
+    if (!data || typeof data !== "object" || data.type !== "footnotes") {
+      return false;
+    }
+    if (!data.notes || typeof data.notes !== "object" || Array.isArray(data.notes)) {
+      return false;
+    }
+    const noteIds = Object.keys(data.notes);
+    if (noteIds.length === 0) return false;
+    for (const id of noteIds) {
+      if (typeof id !== "string" || id.trim().length === 0) return false;
+    }
+    for (const note of Object.values(data.notes)) {
+      if (!isValidNoteData(note)) return false;
+    }
+    return true;
+  },
+  // ── Conversion ──────────────────────────────────────────────
+  toHtml(data, context) {
+    const pretty = context.options?.pretty ?? false;
+    const nl = pretty ? "\n" : "";
+    const ind = (level) => pretty ? "  ".repeat(level) : "";
+    const noteEntries = Object.entries(data.notes);
+    if (noteEntries.length === 0) return "";
+    let html = `<section class="footnotes">${nl}`;
+    html += `${ind(1)}<ol>${nl}`;
+    for (const [id, note] of noteEntries) {
+      html += `${ind(2)}<li id="fn-${id}">${nl}`;
+      let content = "";
+      if (context.renderDelta) {
+        content = context.renderDelta(note.ops);
+      }
+      const backref = ` <a href="#fnref-${id}" class="footnote-backref">\u21A9</a>`;
+      const lastPClose = content.lastIndexOf("</p>");
+      if (lastPClose !== -1) {
+        content = content.slice(0, lastPClose) + backref + content.slice(lastPClose);
+      } else {
+        content += backref;
+      }
+      html += `${ind(3)}${content}${nl}`;
+      html += `${ind(2)}</li>${nl}`;
+    }
+    html += `${ind(1)}</ol>${nl}`;
+    html += `</section>`;
+    return html;
+  },
+  fromHtml(element, context) {
+    const tag = element.tagName.toLowerCase();
+    if (tag !== "section" && tag !== "div") return null;
+    const className = element.getAttribute("class") || "";
+    if (!className.includes("footnotes")) return null;
+    let ol = null;
+    const children = element.childNodes;
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      if (child && isElement(child) && child.tagName.toLowerCase() === "ol") {
+        ol = child;
+        break;
+      }
+    }
+    if (!ol) return null;
+    const notes = {};
+    const liChildren = ol.childNodes;
+    for (let i = 0; i < liChildren.length; i++) {
+      const li = liChildren[i];
+      if (!li || !isElement(li) || li.tagName.toLowerCase() !== "li") continue;
+      const id = extractFootnoteId(li);
+      if (!id) continue;
+      let ops;
+      if (context.parseElement) {
+        ops = context.parseElement(li);
+        ops = ops.map((op) => {
+          if (isTextInsert(op) && op.insert.includes("\u21A9")) {
+            return { ...op, insert: op.insert.replace(/\u21a9/g, "") };
+          }
+          return op;
+        }).filter((op) => !isTextInsert(op) || op.insert !== "");
+        if (ops.length === 0) {
+          ops = [{ insert: "\n" }];
+        }
+      } else {
+        ops = [{ insert: "\n" }];
+      }
+      notes[id] = { ops };
+    }
+    if (Object.keys(notes).length === 0) return null;
+    return { type: "footnotes", notes };
+  },
+  toMarkdown(data, context) {
+    const noteEntries = Object.entries(data.notes);
+    if (noteEntries.length === 0) return null;
+    const lines = [];
+    for (const [id, note] of noteEntries) {
+      let content;
+      if (context.renderDelta) {
+        content = context.renderDelta(note.ops).trim();
+      } else {
+        content = "";
+      }
+      const contentLines = content.split("\n");
+      const indented = contentLines.map((line, idx) => idx === 0 ? `[^${id}]: ${line}` : `    ${line}`).join("\n");
+      lines.push(indented);
+    }
+    return "\n" + lines.join("\n\n");
+  },
+  // ── Normalize ─────────────────────────────────────────────
+  normalize(data, registry) {
+    const newNotes = {};
+    let changed = false;
+    for (const [id, note] of Object.entries(data.notes)) {
+      const normalized = normalizeDelta(new Delta3(note.ops), registry);
+      if (normalized.ops !== note.ops) {
+        newNotes[id] = { ops: normalized.ops };
+        changed = true;
+      } else {
+        newNotes[id] = note;
+      }
+    }
+    return changed ? { ...data, notes: newNotes } : data;
+  },
+  // ── Nested Deltas ──────────────────────────────────────────
+  getNestedDeltas(data) {
+    return Object.values(data.notes).map((note) => note.ops);
+  },
+  setNestedDeltas(data, deltas) {
+    const ids = Object.keys(data.notes);
+    const newNotes = {};
+    ids.forEach((id, i) => {
+      newNotes[id] = { ops: deltas[i] };
+    });
+    return { ...data, notes: newNotes };
+  }
+};
+
+// src/schema/blocks/alert.ts
+import { Delta as Delta4 } from "@scrider/delta";
+var ALERT_TYPES = ["note", "tip", "important", "warning", "caution"];
+function isAlertType(value) {
+  return ALERT_TYPES.includes(value);
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+var alertBlockHandler = {
+  type: "alert",
+  validate(data) {
+    if (!data || typeof data !== "object" || data.type !== "alert") {
+      return false;
+    }
+    if (typeof data.alertType !== "string" || !isAlertType(data.alertType)) {
+      return false;
+    }
+    if (!data.content || typeof data.content !== "object" || !Array.isArray(data.content.ops) || data.content.ops.length === 0) {
+      return false;
+    }
+    return true;
+  },
+  // ── Conversion ──────────────────────────────────────────────
+  toHtml(data, context) {
+    const pretty = context.options?.pretty ?? false;
+    const nl = pretty ? "\n" : "";
+    const ind = (level) => pretty ? "  ".repeat(level) : "";
+    const alertClass = `markdown-alert markdown-alert-${data.alertType}`;
+    const title = capitalize(data.alertType);
+    let html = `<div class="${alertClass}">${nl}`;
+    html += `${ind(1)}<p class="markdown-alert-title">${title}</p>${nl}`;
+    if (context.renderDelta) {
+      html += `${ind(1)}${context.renderDelta(data.content.ops)}${nl}`;
+    }
+    html += `</div>`;
+    return html;
+  },
+  fromHtml(element, context) {
+    const tag = element.tagName.toLowerCase();
+    if (tag !== "div" && tag !== "section") return null;
+    const className = element.getAttribute("class") || "";
+    if (!className.includes("markdown-alert")) return null;
+    let alertType = "note";
+    for (const t of ALERT_TYPES) {
+      if (className.includes(`markdown-alert-${t}`)) {
+        alertType = t;
+        break;
+      }
+    }
+    let ops = [];
+    const children = element.childNodes;
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      if (!child || !isElement(child)) continue;
+      const childClass = child.getAttribute("class") || "";
+      if (childClass.includes("markdown-alert-title")) continue;
+      if (context.parseElement) {
+        const parsed = context.parseElement(child);
+        ops = ops.concat(parsed);
+      }
+    }
+    if (ops.length === 0) {
+      ops = [{ insert: "\n" }];
+    }
+    return {
+      type: "alert",
+      alertType,
+      content: { ops }
+    };
+  },
+  toMarkdown(data, context) {
+    const tag = `[!${data.alertType.toUpperCase()}]`;
+    let contentMd = "";
+    if (context.renderDelta) {
+      contentMd = context.renderDelta(data.content.ops);
+    }
+    const lines = contentMd.split("\n");
+    while (lines.length > 0 && (lines[lines.length - 1] ?? "").trim() === "") {
+      lines.pop();
+    }
+    const prefixed = lines.map((line) => `> ${line}`).join("\n");
+    return `> ${tag}
+${prefixed}`;
+  },
+  // ── Normalization ──────────────────────────────────────────
+  normalize(data, registry) {
+    const normalized = normalizeDelta(new Delta4(data.content.ops), registry);
+    return {
+      ...data,
+      content: { ops: normalized.ops }
+    };
+  },
+  // ── Nested Deltas ──────────────────────────────────────────
+  getNestedDeltas(data) {
+    return [data.content.ops];
+  },
+  setNestedDeltas(data, deltas) {
+    const first = deltas[0];
+    if (!first) return data;
+    return {
+      ...data,
+      content: { ops: first }
+    };
+  }
+};
+
+// src/schema/blocks/columns.ts
+import { Delta as Delta5 } from "@scrider/delta";
+var WIDTHS_SUM_TOLERANCE = 1;
+var columnsBlockHandler = {
+  type: "columns",
+  validate(data) {
+    if (!data || typeof data !== "object" || data.type !== "columns") {
+      return false;
+    }
+    if (!Array.isArray(data.columns) || data.columns.length < 2) {
+      return false;
+    }
+    for (const col of data.columns) {
+      if (!col || typeof col !== "object" || !Array.isArray(col.ops) || col.ops.length === 0) {
+        return false;
+      }
+    }
+    if (data.widths !== void 0) {
+      if (!Array.isArray(data.widths)) {
+        return false;
+      }
+      if (data.widths.length !== data.columns.length) {
+        return false;
+      }
+      for (const w of data.widths) {
+        if (typeof w !== "number" || w <= 0 || !isFinite(w)) {
+          return false;
+        }
+      }
+      const sum = data.widths.reduce((a, b) => a + b, 0);
+      if (Math.abs(sum - 100) > WIDTHS_SUM_TOLERANCE) {
+        return false;
+      }
+    }
+    return true;
+  },
+  // ── Conversion ──────────────────────────────────────────────
+  toHtml(data, context) {
+    const n = data.columns.length;
+    const pretty = context.options?.pretty ?? false;
+    const nl = pretty ? "\n" : "";
+    const ind = (level) => pretty ? "  ".repeat(level) : "";
+    const classAttr = `columns columns-${n}`;
+    let styleAttr = "";
+    if (data.widths && data.widths.length === n) {
+      const cols = data.widths.map((w) => `${w}%`).join(" ");
+      styleAttr = ` style="grid-template-columns: ${cols}"`;
+    }
+    let html = `<div class="${classAttr}"${styleAttr}>${nl}`;
+    for (const col of data.columns) {
+      html += `${ind(1)}<div class="column">${nl}`;
+      if (context.renderDelta) {
+        html += `${ind(2)}${context.renderDelta(col.ops)}${nl}`;
+      }
+      html += `${ind(1)}</div>${nl}`;
+    }
+    html += `</div>`;
+    return html;
+  },
+  fromHtml(element, context) {
+    const tag = element.tagName.toLowerCase();
+    if (tag !== "div") return null;
+    const className = element.getAttribute("class") || "";
+    if (!className.includes("columns")) return null;
+    if (!/\bcolumns\b/.test(className)) return null;
+    const columns = [];
+    const children = element.childNodes;
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      if (!child || !isElement(child)) continue;
+      const childClass = child.getAttribute("class") || "";
+      if (!/\bcolumn\b/.test(childClass)) continue;
+      let ops = [];
+      if (context.parseElement) {
+        const childChildren = child.childNodes;
+        for (let j = 0; j < childChildren.length; j++) {
+          const el = childChildren[j];
+          if (el && isElement(el)) {
+            const parsed = context.parseElement(el);
+            ops = ops.concat(parsed);
+          }
+        }
+      }
+      if (ops.length === 0) {
+        ops = [{ insert: "\n" }];
+      }
+      columns.push({ ops });
+    }
+    if (columns.length === 0) return null;
+    let widths;
+    const style = element.getAttribute("style") || "";
+    const match = style.match(/grid-template-columns:\s*(.+?)(?:;|$)/);
+    if (match && match[1]) {
+      const parts = match[1].trim().split(/\s+/);
+      const parsed = parts.map((p) => parseFloat(p)).filter((n) => !isNaN(n) && n > 0);
+      if (parsed.length === columns.length) {
+        widths = parsed;
+      }
+    }
+    const result = {
+      type: "columns",
+      columns
+    };
+    if (widths) {
+      result.widths = widths;
+    }
+    return result;
+  },
+  toMarkdown(_data, _context) {
+    return null;
+  },
+  // ── Normalization ──────────────────────────────────────────
+  normalize(data, registry) {
+    return {
+      ...data,
+      columns: data.columns.map((col) => ({
+        ops: normalizeDelta(new Delta5(col.ops), registry).ops
+      }))
+    };
+  },
+  // ── Nested Deltas ──────────────────────────────────────────
+  getNestedDeltas(data) {
+    return data.columns.map((col) => col.ops);
+  },
+  setNestedDeltas(data, deltas) {
+    return {
+      ...data,
+      columns: data.columns.map((col, i) => ({
+        ...col,
+        ops: deltas[i] ?? col.ops
+      }))
+    };
+  }
+};
+
+// src/schema/blocks/box.ts
+import { Delta as Delta6 } from "@scrider/delta";
+var BOX_FLOAT_VALUES = ["left", "right", "center"];
+var BOX_OVERFLOW_VALUES = ["auto", "hidden", "visible"];
+function isBoxFloat(value) {
+  return BOX_FLOAT_VALUES.includes(value);
+}
+function isBoxOverflow(value) {
+  return BOX_OVERFLOW_VALUES.includes(value);
+}
+var boxBlockHandler = {
+  type: "box",
+  validate(data) {
+    if (!data || typeof data !== "object" || data.type !== "box") {
+      return false;
+    }
+    if (!data.content || typeof data.content !== "object" || !Array.isArray(data.content.ops) || data.content.ops.length === 0) {
+      return false;
+    }
+    return true;
+  },
+  // ── Conversion ──────────────────────────────────────────────
+  toHtml(data, context) {
+    const pretty = context.options?.pretty ?? false;
+    const nl = pretty ? "\n" : "";
+    const ind = (level) => pretty ? "  ".repeat(level) : "";
+    const opAttrs = context.opAttributes;
+    const float = opAttrs?.float || "left";
+    const width = opAttrs?.width;
+    const height = opAttrs?.height;
+    const overflow = opAttrs?.overflow || "auto";
+    let attrs = `class="inline-box" data-float="${float}"`;
+    if (overflow !== "auto") {
+      attrs += ` data-overflow="${overflow}"`;
+    }
+    const styles = [];
+    if (width && width !== "auto") styles.push(`width: ${width}`);
+    if (height && height !== "auto") styles.push(`height: ${height}`);
+    if (styles.length > 0) {
+      attrs += ` style="${styles.join("; ")}"`;
+    }
+    let html = `<div ${attrs}>${nl}`;
+    if (context.renderDelta) {
+      html += `${ind(1)}${context.renderDelta(data.content.ops)}${nl}`;
+    }
+    html += `</div>`;
+    return html;
+  },
+  fromHtml(element, context) {
+    const tag = element.tagName.toLowerCase();
+    if (tag !== "div") return null;
+    const className = element.getAttribute("class") || "";
+    if (!className.includes("inline-box")) return null;
+    let ops = [];
+    const children = element.childNodes;
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      if (!child || !isElement(child)) continue;
+      if (context.parseElement) {
+        const parsed = context.parseElement(child);
+        ops = ops.concat(parsed);
+      }
+    }
+    if (ops.length === 0) {
+      ops = [{ insert: "\n" }];
+    }
+    return {
+      type: "box",
+      content: { ops }
+    };
+  },
+  toMarkdown(_data, _context) {
+    return null;
+  },
+  // ── Normalization ──────────────────────────────────────────
+  normalize(data, registry) {
+    const normalized = normalizeDelta(new Delta6(data.content.ops), registry);
+    return {
+      ...data,
+      content: { ops: normalized.ops }
+    };
+  },
+  // ── Nested Deltas ──────────────────────────────────────────
+  getNestedDeltas(data) {
+    return [data.content.ops];
+  },
+  setNestedDeltas(data, deltas) {
+    const first = deltas[0];
+    if (!first) return data;
+    return {
+      ...data,
+      content: { ops: first }
+    };
+  }
+};
+function extractBoxOpAttributes(element) {
+  const attrs = {};
+  const dataFloat = element.getAttribute("data-float");
+  if (dataFloat && isBoxFloat(dataFloat)) {
+    attrs.float = dataFloat;
+  }
+  const dataOverflow = element.getAttribute("data-overflow");
+  if (dataOverflow && isBoxOverflow(dataOverflow)) {
+    attrs.overflow = dataOverflow;
+  }
+  const style = element.getAttribute("style") || "";
+  const widthMatch = style.match(/(?:^|;\s*)width:\s*([^;]+)/);
+  if (widthMatch?.[1]) {
+    attrs.width = widthMatch[1].trim();
+  }
+  const heightMatch = style.match(/(?:^|;\s*)height:\s*([^;]+)/);
+  if (heightMatch?.[1]) {
+    attrs.height = heightMatch[1].trim();
+  }
+  return attrs;
+}
+
+// src/schema/utils/color.ts
+var NAMED_COLORS = {
+  // Basic colors
+  black: "#000000",
+  silver: "#c0c0c0",
+  gray: "#808080",
+  white: "#ffffff",
+  maroon: "#800000",
+  red: "#ff0000",
+  purple: "#800080",
+  fuchsia: "#ff00ff",
+  green: "#008000",
+  lime: "#00ff00",
+  olive: "#808000",
+  yellow: "#ffff00",
+  navy: "#000080",
+  blue: "#0000ff",
+  teal: "#008080",
+  aqua: "#00ffff",
+  // Extended colors
+  aliceblue: "#f0f8ff",
+  antiquewhite: "#faebd7",
+  aquamarine: "#7fffd4",
+  azure: "#f0ffff",
+  beige: "#f5f5dc",
+  bisque: "#ffe4c4",
+  blanchedalmond: "#ffebcd",
+  blueviolet: "#8a2be2",
+  brown: "#a52a2a",
+  burlywood: "#deb887",
+  cadetblue: "#5f9ea0",
+  chartreuse: "#7fff00",
+  chocolate: "#d2691e",
+  coral: "#ff7f50",
+  cornflowerblue: "#6495ed",
+  cornsilk: "#fff8dc",
+  crimson: "#dc143c",
+  cyan: "#00ffff",
+  darkblue: "#00008b",
+  darkcyan: "#008b8b",
+  darkgoldenrod: "#b8860b",
+  darkgray: "#a9a9a9",
+  darkgreen: "#006400",
+  darkgrey: "#a9a9a9",
+  darkkhaki: "#bdb76b",
+  darkmagenta: "#8b008b",
+  darkolivegreen: "#556b2f",
+  darkorange: "#ff8c00",
+  darkorchid: "#9932cc",
+  darkred: "#8b0000",
+  darksalmon: "#e9967a",
+  darkseagreen: "#8fbc8f",
+  darkslateblue: "#483d8b",
+  darkslategray: "#2f4f4f",
+  darkslategrey: "#2f4f4f",
+  darkturquoise: "#00ced1",
+  darkviolet: "#9400d3",
+  deeppink: "#ff1493",
+  deepskyblue: "#00bfff",
+  dimgray: "#696969",
+  dimgrey: "#696969",
+  dodgerblue: "#1e90ff",
+  firebrick: "#b22222",
+  floralwhite: "#fffaf0",
+  forestgreen: "#228b22",
+  gainsboro: "#dcdcdc",
+  ghostwhite: "#f8f8ff",
+  gold: "#ffd700",
+  goldenrod: "#daa520",
+  greenyellow: "#adff2f",
+  grey: "#808080",
+  honeydew: "#f0fff0",
+  hotpink: "#ff69b4",
+  indianred: "#cd5c5c",
+  indigo: "#4b0082",
+  ivory: "#fffff0",
+  khaki: "#f0e68c",
+  lavender: "#e6e6fa",
+  lavenderblush: "#fff0f5",
+  lawngreen: "#7cfc00",
+  lemonchiffon: "#fffacd",
+  lightblue: "#add8e6",
+  lightcoral: "#f08080",
+  lightcyan: "#e0ffff",
+  lightgoldenrodyellow: "#fafad2",
+  lightgray: "#d3d3d3",
+  lightgreen: "#90ee90",
+  lightgrey: "#d3d3d3",
+  lightpink: "#ffb6c1",
+  lightsalmon: "#ffa07a",
+  lightseagreen: "#20b2aa",
+  lightskyblue: "#87cefa",
+  lightslategray: "#778899",
+  lightslategrey: "#778899",
+  lightsteelblue: "#b0c4de",
+  lightyellow: "#ffffe0",
+  limegreen: "#32cd32",
+  linen: "#faf0e6",
+  magenta: "#ff00ff",
+  mediumaquamarine: "#66cdaa",
+  mediumblue: "#0000cd",
+  mediumorchid: "#ba55d3",
+  mediumpurple: "#9370db",
+  mediumseagreen: "#3cb371",
+  mediumslateblue: "#7b68ee",
+  mediumspringgreen: "#00fa9a",
+  mediumturquoise: "#48d1cc",
+  mediumvioletred: "#c71585",
+  midnightblue: "#191970",
+  mintcream: "#f5fffa",
+  mistyrose: "#ffe4e1",
+  moccasin: "#ffe4b5",
+  navajowhite: "#ffdead",
+  oldlace: "#fdf5e6",
+  olivedrab: "#6b8e23",
+  orange: "#ffa500",
+  orangered: "#ff4500",
+  orchid: "#da70d6",
+  palegoldenrod: "#eee8aa",
+  palegreen: "#98fb98",
+  paleturquoise: "#afeeee",
+  palevioletred: "#db7093",
+  papayawhip: "#ffefd5",
+  peachpuff: "#ffdab9",
+  peru: "#cd853f",
+  pink: "#ffc0cb",
+  plum: "#dda0dd",
+  powderblue: "#b0e0e6",
+  rosybrown: "#bc8f8f",
+  royalblue: "#4169e1",
+  saddlebrown: "#8b4513",
+  salmon: "#fa8072",
+  sandybrown: "#f4a460",
+  seagreen: "#2e8b57",
+  seashell: "#fff5ee",
+  sienna: "#a0522d",
+  skyblue: "#87ceeb",
+  slateblue: "#6a5acd",
+  slategray: "#708090",
+  slategrey: "#708090",
+  snow: "#fffafa",
+  springgreen: "#00ff7f",
+  steelblue: "#4682b4",
+  tan: "#d2b48c",
+  thistle: "#d8bfd8",
+  tomato: "#ff6347",
+  turquoise: "#40e0d0",
+  violet: "#ee82ee",
+  wheat: "#f5deb3",
+  whitesmoke: "#f5f5f5",
+  yellowgreen: "#9acd32",
+  // CSS4 colors
+  rebeccapurple: "#663399"
+};
+function toHexColor(value) {
+  const trimmed = value.trim().toLowerCase();
+  if (trimmed.startsWith("#")) {
+    return normalizeHex(trimmed);
+  }
+  if (NAMED_COLORS[trimmed]) {
+    return NAMED_COLORS[trimmed];
+  }
+  if (trimmed.startsWith("rgb")) {
+    return parseRgb(trimmed);
+  }
+  return value;
+}
+function normalizeHex(hex) {
+  let color = hex.slice(1);
+  if (color.length === 3) {
+    color = color.charAt(0) + color.charAt(0) + color.charAt(1) + color.charAt(1) + color.charAt(2) + color.charAt(2);
+  }
+  if (color.length === 4) {
+    color = color.charAt(0) + color.charAt(0) + color.charAt(1) + color.charAt(1) + color.charAt(2) + color.charAt(2);
+  }
+  if (color.length === 8) {
+    color = color.slice(0, 6);
+  }
+  if (!/^[0-9a-f]{6}$/.test(color)) {
+    return "#" + color;
+  }
+  return "#" + color;
+}
+function parseRgb(value) {
+  const match = value.match(
+    /rgba?\s*\(\s*(-?\d+)\s*[,\s]\s*(-?\d+)\s*[,\s]\s*(-?\d+)(?:\s*[,/]\s*[\d.]+)?\s*\)/
+  );
+  if (!match) {
+    return value;
+  }
+  const [, rStr, gStr, bStr] = match;
+  if (!rStr || !gStr || !bStr) return value;
+  const r = Math.max(0, Math.min(255, parseInt(rStr, 10)));
+  const g = Math.max(0, Math.min(255, parseInt(gStr, 10)));
+  const b = Math.max(0, Math.min(255, parseInt(bStr, 10)));
+  return "#" + toHex(r) + toHex(g) + toHex(b);
+}
+function toHex(n) {
+  const hex = n.toString(16);
+  return hex.length === 1 ? "0" + hex : hex;
+}
+function isValidHexColor(value) {
+  return /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.test(value);
+}
+function isValidColor(value) {
+  const trimmed = value.trim().toLowerCase();
+  if (/^#([0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(trimmed)) {
+    return true;
+  }
+  if (NAMED_COLORS[trimmed]) {
+    return true;
+  }
+  if (/^rgba?\s*\(\s*\d+\s*[,\s]\s*\d+\s*[,\s]\s*\d+(?:\s*[,/]\s*[\d.]+)?\s*\)$/.test(trimmed)) {
+    return true;
+  }
+  return false;
+}
+function getNamedColors() {
+  return Object.keys(NAMED_COLORS);
+}
+
+// src/schema/formats/inline/background.ts
+var backgroundFormat = {
+  name: "background",
+  scope: "inline",
+  normalize(value) {
+    return toHexColor(value);
+  },
+  validate(value) {
+    return typeof value === "string" && isValidColor(value);
+  }
+};
+
+// src/schema/formats/inline/bold.ts
+var boldFormat = {
+  name: "bold",
+  scope: "inline",
+  validate(value) {
+    return value === true;
+  }
+};
+
+// src/schema/formats/inline/code.ts
+var codeFormat = {
+  name: "code",
+  scope: "inline",
+  validate(value) {
+    return value === true;
+  }
+};
+
+// src/schema/formats/inline/color.ts
+var colorFormat = {
+  name: "color",
+  scope: "inline",
+  normalize(value) {
+    return toHexColor(value);
+  },
+  validate(value) {
+    return typeof value === "string" && isValidColor(value);
+  }
+};
+
+// src/schema/formats/inline/italic.ts
+var italicFormat = {
+  name: "italic",
+  scope: "inline",
+  validate(value) {
+    return value === true;
+  }
+};
+
+// src/schema/formats/inline/kbd.ts
+var kbdFormat = {
+  name: "kbd",
+  scope: "inline",
+  validate(value) {
+    return value === true;
+  }
+};
+
+// src/schema/formats/inline/link.ts
+var linkFormat = {
+  name: "link",
+  scope: "inline",
+  normalize(value) {
+    return value.trim();
+  },
+  validate(value) {
+    if (typeof value !== "string" || value.length === 0) {
+      return false;
+    }
+    const trimmed = value.trim();
+    if (trimmed.startsWith("/") || trimmed.startsWith("./") || trimmed.startsWith("../")) {
+      return true;
+    }
+    if (trimmed.startsWith("//")) {
+      return true;
+    }
+    if (trimmed.startsWith("mailto:") || trimmed.startsWith("tel:")) {
+      return true;
+    }
+    try {
+      const url = new URL(trimmed);
+      return url.protocol === "http:" || url.protocol === "https:";
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/schema/formats/inline/mark.ts
+var markFormat = {
+  name: "mark",
+  scope: "inline",
+  validate(value) {
+    return value === true;
+  }
+};
+
+// src/schema/formats/inline/strike.ts
+var strikeFormat = {
+  name: "strike",
+  scope: "inline",
+  validate(value) {
+    return value === true;
+  }
+};
+
+// src/schema/formats/inline/subscript.ts
+var subscriptFormat = {
+  name: "subscript",
+  scope: "inline",
+  validate(value) {
+    return value === true;
+  }
+};
+
+// src/schema/formats/inline/superscript.ts
+var superscriptFormat = {
+  name: "superscript",
+  scope: "inline",
+  validate(value) {
+    return value === true;
+  }
+};
+
+// src/schema/formats/inline/underline.ts
+var underlineFormat = {
+  name: "underline",
+  scope: "inline",
+  validate(value) {
+    return value === true;
+  }
+};
+
+// src/schema/formats/block/align.ts
+var VALID_ALIGN_TYPES = ["left", "center", "right", "justify"];
+var alignFormat = {
+  name: "align",
+  scope: "block",
+  normalize(value) {
+    return value.toLowerCase();
+  },
+  validate(value) {
+    return VALID_ALIGN_TYPES.includes(value);
+  }
+};
+
+// src/schema/formats/block/blockquote.ts
+var blockquoteFormat = {
+  name: "blockquote",
+  scope: "block",
+  validate(value) {
+    return value === true;
+  }
+};
+
+// src/schema/formats/block/code-block.ts
+var codeBlockFormat = {
+  name: "code-block",
+  scope: "block",
+  normalize(value) {
+    if (typeof value === "string") {
+      return value.toLowerCase().trim();
+    }
+    return value;
+  },
+  validate(value) {
+    if (value === true) {
+      return true;
+    }
+    if (typeof value === "string" && value.length > 0) {
+      return true;
+    }
+    return false;
+  }
+};
+
+// src/schema/formats/block/header.ts
+var headerFormat = {
+  name: "header",
+  scope: "block",
+  normalize(value) {
+    return Math.max(1, Math.min(6, Math.floor(value)));
+  },
+  validate(value) {
+    return Number.isInteger(value) && value >= 1 && value <= 6;
+  }
+};
+
+// src/schema/formats/block/header-id.ts
+var headerIdFormat = {
+  name: "header-id",
+  scope: "block",
+  normalize(value) {
+    return String(value).trim().toLowerCase();
+  },
+  validate(value) {
+    if (typeof value !== "string") return false;
+    const trimmed = value.trim();
+    return trimmed.length > 0 && !/\s/.test(trimmed);
+  }
+};
+
+// src/schema/formats/block/indent.ts
+var MAX_INDENT = 8;
+var indentFormat = {
+  name: "indent",
+  scope: "block",
+  normalize(value) {
+    return Math.max(0, Math.min(MAX_INDENT, Math.floor(value)));
+  },
+  validate(value) {
+    return Number.isInteger(value) && value >= 0 && value <= MAX_INDENT;
+  }
+};
+
+// src/schema/formats/block/list.ts
+var VALID_LIST_TYPES = ["ordered", "bullet", "checked", "unchecked"];
+var listFormat = {
+  name: "list",
+  scope: "block",
+  normalize(value) {
+    return value.toLowerCase();
+  },
+  validate(value) {
+    return VALID_LIST_TYPES.includes(value);
+  }
+};
+
+// src/schema/formats/block/table-row.ts
+var tableRowFormat = {
+  name: "table-row",
+  scope: "block",
+  validate(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0;
+  }
+};
+
+// src/schema/formats/block/table-col.ts
+var tableColFormat = {
+  name: "table-col",
+  scope: "block",
+  validate(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0;
+  }
+};
+
+// src/schema/formats/block/table-header.ts
+var tableHeaderFormat = {
+  name: "table-header",
+  scope: "block",
+  validate(value) {
+    return value === true;
+  }
+};
+
+// src/schema/formats/block/table-col-align.ts
+var VALID_ALIGNS = ["left", "center", "right"];
+var tableColAlignFormat = {
+  name: "table-col-align",
+  scope: "block",
+  normalize(value) {
+    return value.toLowerCase();
+  },
+  validate(value) {
+    return VALID_ALIGNS.includes(value);
+  }
+};
+
+// src/schema/formats/embed/block.ts
+var blockFormat = {
+  name: "block",
+  scope: "embed",
+  validate(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.type === "string" && value.type.length > 0;
+  }
+};
+
+// src/conversion/html/config.ts
+var INLINE_FORMAT_TAGS = {
+  link: "a",
+  bold: "strong",
+  italic: "em",
+  underline: "u",
+  strike: "s",
+  subscript: "sub",
+  superscript: "sup",
+  code: "code",
+  mark: "mark",
+  kbd: "kbd"
+};
+var INLINE_FORMAT_ORDER = [
+  "link",
+  "bold",
+  "italic",
+  "underline",
+  "strike",
+  "subscript",
+  "superscript",
+  "code",
+  "mark",
+  "kbd"
+];
+var INLINE_STYLE_FORMATS = {
+  color: "color",
+  background: "background-color"
+};
+var BLOCK_FORMAT_TAGS = {
+  header: (value) => `h${String(value)}`,
+  blockquote: "blockquote",
+  "code-block": "pre",
+  list: "li"
+  // Wrapped in ul/ol based on list type
+};
+var LIST_WRAPPER_TAGS = {
+  ordered: "ol",
+  bullet: "ul",
+  checked: "ul",
+  unchecked: "ul"
+};
+var EMBED_RENDERERS = {
+  image: (value, attrs) => {
+    const src = typeof value === "string" ? value : "";
+    const altVal = attrs?.alt;
+    const widthVal = attrs?.width;
+    const heightVal = attrs?.height;
+    const floatVal = attrs?.float;
+    const alt = altVal != null && (typeof altVal === "string" || typeof altVal === "number") ? ` alt="${escapeHtml(String(altVal))}"` : "";
+    const width = widthVal != null && (typeof widthVal === "string" || typeof widthVal === "number") ? ` width="${String(widthVal)}"` : "";
+    const height = heightVal != null && (typeof heightVal === "string" || typeof heightVal === "number") ? ` height="${String(heightVal)}"` : "";
+    const float = floatVal != null && typeof floatVal === "string" && floatVal !== "none" ? ` data-float="${escapeHtml(floatVal)}"` : "";
+    return `<img src="${escapeHtml(src)}"${alt}${width}${height}${float}>`;
+  },
+  video: (value, attrs) => {
+    const src = typeof value === "string" ? value : "";
+    const floatVal = attrs?.float;
+    const widthVal = attrs?.width;
+    const heightVal = attrs?.height;
+    const float = floatVal != null && typeof floatVal === "string" && floatVal !== "none" ? ` data-float="${escapeHtml(floatVal)}"` : "";
+    const styles = [];
+    if (widthVal != null && (typeof widthVal === "string" || typeof widthVal === "number")) {
+      const w = String(widthVal);
+      if (w && w !== "auto") styles.push(`width: ${/^\d+$/.test(w) ? w + "px" : w}`);
+    }
+    if (heightVal != null && (typeof heightVal === "string" || typeof heightVal === "number")) {
+      const h = String(heightVal);
+      if (h && h !== "auto") styles.push(`height: ${/^\d+$/.test(h) ? h + "px" : h}`);
+    }
+    const style = styles.length > 0 ? ` style="${styles.join("; ")}"` : "";
+    const embedSrc = toVideoEmbedUrl(src);
+    if (embedSrc) {
+      return `<iframe src="${escapeHtml(embedSrc)}" frameborder="0" allowfullscreen${float}${style}></iframe>`;
+    }
+    return `<video src="${escapeHtml(src)}" controls${float}${style}></video>`;
+  },
+  formula: (value) => {
+    const latex = typeof value === "string" ? value : "";
+    return `<span class="formula" data-formula="${escapeHtml(latex)}">${escapeHtml(latex)}</span>`;
+  },
+  diagram: (value) => {
+    const source = typeof value === "string" ? value : "";
+    return `<span class="diagram" data-diagram="${escapeHtml(source)}">${escapeHtml(source)}</span>`;
+  },
+  drawio: (value, attrs) => {
+    const src = typeof value === "string" ? value : "";
+    const altVal = attrs?.alt;
+    const alt = altVal != null && (typeof altVal === "string" || typeof altVal === "number") ? ` data-alt="${escapeHtml(String(altVal))}"` : "";
+    return `<span class="drawio" data-drawio-src="${escapeHtml(src)}"${alt}></span>`;
+  },
+  "footnote-ref": (value) => {
+    const id = typeof value === "string" ? value : String(value);
+    return `<sup class="footnote-ref"><a href="#fn-${escapeHtml(id)}" id="fnref-${escapeHtml(id)}">[${escapeHtml(id)}]</a></sup>`;
+  },
+  divider: () => "<hr>"
+};
+var TAG_TO_INLINE_FORMAT = {
+  strong: { format: "bold", value: true },
+  b: { format: "bold", value: true },
+  em: { format: "italic", value: true },
+  i: { format: "italic", value: true },
+  u: { format: "underline", value: true },
+  ins: { format: "underline", value: true },
+  s: { format: "strike", value: true },
+  strike: { format: "strike", value: true },
+  del: { format: "strike", value: true },
+  sub: { format: "subscript", value: true },
+  sup: { format: "superscript", value: true },
+  code: { format: "code", value: true },
+  mark: { format: "mark", value: true },
+  kbd: { format: "kbd", value: true }
+};
+var TAG_TO_BLOCK_FORMAT = {
+  h1: { format: "header", value: 1 },
+  h2: { format: "header", value: 2 },
+  h3: { format: "header", value: 3 },
+  h4: { format: "header", value: 4 },
+  h5: { format: "header", value: 5 },
+  h6: { format: "header", value: 6 },
+  blockquote: { format: "blockquote", value: true },
+  pre: { format: "code-block", value: true }
+};
+var CSS_ALIGN_TO_FORMAT = {
+  left: "left",
+  center: "center",
+  right: "right",
+  justify: "justify"
+};
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function unescapeHtml(text) {
+  return text.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#039;/g, "'").replace(/&amp;/g, "&");
+}
+function toVideoEmbedUrl(url) {
+  if (url.includes("youtube.com/embed") || url.includes("player.vimeo.com") || url.includes("dailymotion.com/embed") || url.includes("video_ext.php") || url.includes("rutube.ru/play/embed")) {
+    return url;
+  }
+  const ytMatch = url.match(/youtube\.com\/watch\?v=([\w-]+)/);
+  if (ytMatch) {
+    return `https://www.youtube.com/embed/${ytMatch[1]}`;
+  }
+  const ytShortMatch = url.match(/youtu\.be\/([\w-]+)/);
+  if (ytShortMatch) {
+    return `https://www.youtube.com/embed/${ytShortMatch[1]}`;
+  }
+  const rtMatch = url.match(/rutube\.ru\/video\/([\w]+)/);
+  if (rtMatch) {
+    return `https://rutube.ru/play/embed/${rtMatch[1]}`;
+  }
+  return null;
+}
+function fromVideoEmbedUrl(embedUrl) {
+  const ytMatch = embedUrl.match(/youtube\.com\/embed\/([\w-]+)/);
+  if (ytMatch) {
+    return `https://www.youtube.com/watch?v=${ytMatch[1]}`;
+  }
+  const rtMatch = embedUrl.match(/rutube\.ru\/play\/embed\/([\w]+)/);
+  if (rtMatch) {
+    return `https://rutube.ru/video/${rtMatch[1]}/`;
+  }
+  return embedUrl;
+}
+
+// src/schema/formats/embed/divider.ts
+var dividerFormat = {
+  name: "divider",
+  scope: "embed",
+  normalize(value) {
+    return !!value;
+  },
+  validate(value) {
+    return value === true;
+  },
+  render() {
+    return "<hr>";
+  },
+  match(element) {
+    if (element.tagName.toLowerCase() !== "hr") return null;
+    return { value: true };
+  }
+};
+
+// src/schema/formats/embed/footnote-ref.ts
+var footnoteRefFormat = {
+  name: "footnote-ref",
+  scope: "embed",
+  validate(value) {
+    if (typeof value !== "string") {
+      return false;
+    }
+    return value.trim().length > 0;
+  },
+  render(value) {
+    const id = typeof value === "string" ? value : String(value);
+    return `<sup class="footnote-ref"><a href="#fn-${escapeHtml(id)}" id="fnref-${escapeHtml(id)}">[${escapeHtml(id)}]</a></sup>`;
+  },
+  match(element) {
+    if (element.tagName.toLowerCase() !== "sup") return null;
+    const className = element.getAttribute("class") || "";
+    if (!className.includes("footnote-ref")) return null;
+    const children = element.childNodes;
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      if (child && isElement(child)) {
+        const href = child.getAttribute("href") || "";
+        const hrefMatch = href.match(/#fn-(.+)/);
+        if (hrefMatch?.[1]) {
+          return { value: hrefMatch[1] };
+        }
+      }
+    }
+    const id = element.getAttribute("id") || "";
+    const refMatch = id.match(/^fnref-(.+)/);
+    if (refMatch?.[1]) {
+      return { value: refMatch[1] };
+    }
+    return null;
+  }
+};
+
+// src/schema/formats/embed/formula.ts
+function isValidLatex(value) {
+  if (!value || value.trim().length === 0) {
+    return false;
+  }
+  let braceCount = 0;
+  for (const char of value) {
+    if (char === "{") braceCount++;
+    if (char === "}") braceCount--;
+    if (braceCount < 0) return false;
+  }
+  if (braceCount !== 0) return false;
+  let bracketCount = 0;
+  for (const char of value) {
+    if (char === "[") bracketCount++;
+    if (char === "]") bracketCount--;
+    if (bracketCount < 0) return false;
+  }
+  if (bracketCount !== 0) return false;
+  const invalidCommand = /\\(?![a-zA-Z]|\\|{|}|\[|\]|\s|,|;|!|\^|_)/;
+  if (invalidCommand.test(value)) {
+    return false;
+  }
+  return true;
+}
+var formulaFormat = {
+  name: "formula",
+  scope: "embed",
+  normalize(value) {
+    return value.trim();
+  },
+  validate(value) {
+    if (typeof value !== "string") {
+      return false;
+    }
+    return isValidLatex(value);
+  },
+  render(value) {
+    const latex = typeof value === "string" ? value : "";
+    return `<span class="formula" data-formula="${escapeHtml(latex)}">${escapeHtml(latex)}</span>`;
+  },
+  match(element) {
+    if (element.tagName.toLowerCase() !== "span") return null;
+    const className = element.getAttribute("class") || "";
+    if (!className.includes("formula")) return null;
+    const formula = element.getAttribute("data-formula");
+    if (!formula) return null;
+    return { value: formula };
+  }
+};
+
+// src/schema/formats/embed/image.ts
+var imageFormat = {
+  name: "image",
+  scope: "embed",
+  normalize(value) {
+    return value.trim();
+  },
+  validate(value) {
+    if (typeof value !== "string" || value.length === 0) {
+      return false;
+    }
+    const trimmed = value.trim();
+    if (trimmed.startsWith("data:image/")) {
+      return true;
+    }
+    if (trimmed.startsWith("/") || trimmed.startsWith("./") || trimmed.startsWith("../")) {
+      return true;
+    }
+    if (trimmed.startsWith("//")) {
+      return true;
+    }
+    try {
+      const url = new URL(trimmed);
+      return url.protocol === "http:" || url.protocol === "https:";
+    } catch {
+      return false;
+    }
+  },
+  render(value, attributes) {
+    const src = typeof value === "string" ? value : "";
+    const altVal = attributes?.alt;
+    const widthVal = attributes?.width;
+    const heightVal = attributes?.height;
+    const floatVal = attributes?.float;
+    const alt = altVal != null && (typeof altVal === "string" || typeof altVal === "number") ? ` alt="${escapeHtml(String(altVal))}"` : "";
+    const width = widthVal != null && (typeof widthVal === "string" || typeof widthVal === "number") ? ` width="${String(widthVal)}"` : "";
+    const height = heightVal != null && (typeof heightVal === "string" || typeof heightVal === "number") ? ` height="${String(heightVal)}"` : "";
+    const float = floatVal != null && typeof floatVal === "string" && floatVal !== "none" ? ` data-float="${escapeHtml(floatVal)}"` : "";
+    return `<img src="${escapeHtml(src)}"${alt}${width}${height}${float}>`;
+  },
+  match(element) {
+    if (element.tagName.toLowerCase() !== "img") return null;
+    const src = element.getAttribute("src");
+    if (!src) return null;
+    const attrs = {};
+    const alt = element.getAttribute("alt");
+    const width = element.getAttribute("width");
+    const height = element.getAttribute("height");
+    const float = element.getAttribute("data-float");
+    if (alt) attrs.alt = alt;
+    if (width) attrs.width = parseInt(width, 10);
+    if (height) attrs.height = parseInt(height, 10);
+    if (float) attrs.float = float;
+    if (Object.keys(attrs).length > 0) {
+      return { value: src, attributes: attrs };
+    }
+    return { value: src };
+  }
+};
+
+// src/schema/formats/embed/video.ts
+var videoFormat = {
+  name: "video",
+  scope: "embed",
+  normalize(value) {
+    return value.trim();
+  },
+  validate(value) {
+    if (typeof value !== "string" || value.length === 0) {
+      return false;
+    }
+    const trimmed = value.trim();
+    if (trimmed.startsWith("/") || trimmed.startsWith("./") || trimmed.startsWith("../")) {
+      return true;
+    }
+    if (trimmed.startsWith("//")) {
+      return true;
+    }
+    try {
+      const url = new URL(trimmed);
+      return url.protocol === "http:" || url.protocol === "https:";
+    } catch {
+      return false;
+    }
+  },
+  render(value, attributes) {
+    const src = typeof value === "string" ? value : "";
+    const floatVal = attributes?.float;
+    const widthVal = attributes?.width;
+    const heightVal = attributes?.height;
+    const float = floatVal != null && typeof floatVal === "string" && floatVal !== "none" ? ` data-float="${escapeHtml(floatVal)}"` : "";
+    const styles = [];
+    if (widthVal != null && (typeof widthVal === "string" || typeof widthVal === "number")) {
+      const w = String(widthVal);
+      if (w && w !== "auto") styles.push(`width: ${/^\d+$/.test(w) ? w + "px" : w}`);
+    }
+    if (heightVal != null && (typeof heightVal === "string" || typeof heightVal === "number")) {
+      const h = String(heightVal);
+      if (h && h !== "auto") styles.push(`height: ${/^\d+$/.test(h) ? h + "px" : h}`);
+    }
+    const style = styles.length > 0 ? ` style="${styles.join("; ")}"` : "";
+    const embedSrc = toVideoEmbedUrl(src);
+    if (embedSrc) {
+      return `<iframe src="${escapeHtml(embedSrc)}" frameborder="0" allowfullscreen${float}${style}></iframe>`;
+    }
+    return `<video src="${escapeHtml(src)}" controls${float}${style}></video>`;
+  },
+  match(element) {
+    const tagName = element.tagName.toLowerCase();
+    if (tagName !== "video" && tagName !== "iframe") return null;
+    const src = element.getAttribute("src");
+    if (!src) return null;
+    const attrs = {};
+    const float = element.getAttribute("data-float");
+    const styleAttr = element.getAttribute("style") || "";
+    if (float) attrs.float = float;
+    const widthMatch = styleAttr.match(/(?:^|;\s*)width:\s*([^;]+)/);
+    if (widthMatch?.[1]) attrs.width = widthMatch[1].trim().replace(/px$/, "");
+    const heightMatch = styleAttr.match(/(?:^|;\s*)height:\s*([^;]+)/);
+    if (heightMatch?.[1]) attrs.height = heightMatch[1].trim().replace(/px$/, "");
+    if (Object.keys(attrs).length > 0) {
+      return { value: fromVideoEmbedUrl(src), attributes: attrs };
+    }
+    return { value: fromVideoEmbedUrl(src) };
+  }
+};
+
+// src/schema/defaults.ts
+var defaultInlineFormats = [
+  boldFormat,
+  italicFormat,
+  underlineFormat,
+  strikeFormat,
+  subscriptFormat,
+  superscriptFormat,
+  codeFormat,
+  linkFormat,
+  colorFormat,
+  backgroundFormat,
+  markFormat,
+  kbdFormat
+];
+var defaultBlockFormats = [
+  headerFormat,
+  headerIdFormat,
+  blockquoteFormat,
+  codeBlockFormat,
+  listFormat,
+  alignFormat,
+  indentFormat,
+  tableRowFormat,
+  tableColFormat,
+  tableHeaderFormat,
+  tableColAlignFormat
+];
+var defaultEmbedFormats = [
+  imageFormat,
+  videoFormat,
+  formulaFormat,
+  dividerFormat,
+  blockFormat,
+  footnoteRefFormat
+];
+var defaultFormats = [
+  ...defaultInlineFormats,
+  ...defaultBlockFormats,
+  ...defaultEmbedFormats
+];
+function createDefaultRegistry() {
+  return new Registry().register(defaultFormats);
+}
+function createDefaultBlockHandlers() {
+  return new BlockHandlerRegistry().register(tableBlockHandler).register(footnotesBlockHandler).register(alertBlockHandler).register(columnsBlockHandler).register(boxBlockHandler);
+}
+
+// src/conversion/adapters/browser.ts
+var BrowserDOMAdapter = class {
+  /**
+   * Parse HTML string into a document fragment
+   *
+   * Uses a template element to parse arbitrary HTML safely.
+   */
+  parseHTML(html) {
+    if (!this.isAvailable()) {
+      throw new Error("BrowserDOMAdapter is not available in this environment");
+    }
+    const template = document.createElement("template");
+    template.innerHTML = html;
+    return template.content;
+  }
+  /**
+   * Serialize a node to HTML string
+   */
+  serializeHTML(node) {
+    if (!this.isAvailable()) {
+      throw new Error("BrowserDOMAdapter is not available in this environment");
+    }
+    if (node.nodeType === 11) {
+      const container = document.createElement("div");
+      const clone = node.cloneNode(true);
+      container.appendChild(clone);
+      return container.innerHTML;
+    }
+    if (node.nodeType === 1) {
+      return node.outerHTML;
+    }
+    if (node.nodeType === 3) {
+      return String(node.textContent ?? "");
+    }
+    return "";
+  }
+  /**
+   * Create a new document for building DOM structures
+   */
+  createDocument() {
+    if (!this.isAvailable()) {
+      throw new Error("BrowserDOMAdapter is not available in this environment");
+    }
+    return document;
+  }
+  /**
+   * Check if browser DOM APIs are available
+   */
+  isAvailable() {
+    return typeof document !== "undefined" && typeof document.createElement === "function";
+  }
+};
+var browserAdapter = new BrowserDOMAdapter();
+
+// src/conversion/adapters/node.ts
+var jsdomModule = null;
+var jsdomLoadError = null;
+async function loadJsdom() {
+  if (jsdomLoadError) {
+    throw jsdomLoadError;
+  }
+  if (jsdomModule) {
+    return jsdomModule;
+  }
+  try {
+    const mod = await import("jsdom");
+    jsdomModule = mod;
+    return jsdomModule;
+  } catch {
+    jsdomLoadError = new Error("jsdom is not installed. Install it with: pnpm add jsdom");
+    throw jsdomLoadError;
+  }
+}
+function isJsdomAvailable() {
+  if (typeof window !== "undefined") {
+    return false;
+  }
+  try {
+    if (jsdomModule) return true;
+    if (jsdomLoadError) return false;
+    __require.resolve("jsdom");
+    return true;
+  } catch {
+    return false;
+  }
+}
+var NodeDOMAdapter = class {
+  constructor() {
+    this.jsdom = null;
+  }
+  /**
+   * Parse HTML string into a document fragment
+   */
+  parseHTML(html) {
+    const dom = this.getOrCreateJsdom();
+    const template = dom.window.document.createElement("template");
+    template.innerHTML = html;
+    return template.content;
+  }
+  /**
+   * Serialize a node to HTML string
+   */
+  serializeHTML(node) {
+    const dom = this.getOrCreateJsdom();
+    if (node.nodeType === 11) {
+      const container = dom.window.document.createElement("div");
+      const clone = node.cloneNode(true);
+      container.appendChild(clone);
+      return container.innerHTML;
+    }
+    if (node.nodeType === 1) {
+      return node.outerHTML;
+    }
+    if (node.nodeType === 3) {
+      return String(node.textContent ?? "");
+    }
+    return "";
+  }
+  /**
+   * Create a new document for building DOM structures
+   */
+  createDocument() {
+    const dom = this.getOrCreateJsdom();
+    return dom.window.document;
+  }
+  /**
+   * Check if jsdom is available
+   */
+  isAvailable() {
+    return isJsdomAvailable();
+  }
+  /**
+   * Initialize the adapter with jsdom (async)
+   *
+   * Call this before using the adapter if you want to handle
+   * loading errors gracefully.
+   */
+  async initialize() {
+    const mod = await loadJsdom();
+    this.jsdom = new mod.JSDOM("<!DOCTYPE html><html><body></body></html>");
+  }
+  /**
+   * Get or create jsdom instance (sync, throws if not available)
+   */
+  getOrCreateJsdom() {
+    if (this.jsdom) {
+      return this.jsdom;
+    }
+    if (!isJsdomAvailable()) {
+      throw new Error("jsdom is not available. Install it with: pnpm add jsdom");
+    }
+    const mod = __require("jsdom");
+    this.jsdom = new mod.JSDOM("<!DOCTYPE html><html><body></body></html>");
+    return this.jsdom;
+  }
+};
+var nodeAdapter = new NodeDOMAdapter();
+
+// src/conversion/adapters/index.ts
+function getAdapter() {
+  if (browserAdapter.isAvailable()) {
+    return browserAdapter;
+  }
+  if (nodeAdapter.isAvailable()) {
+    return nodeAdapter;
+  }
+  throw new Error("No DOM adapter available. In Node.js, install jsdom: pnpm add jsdom");
+}
+function isAdapterAvailable() {
+  return browserAdapter.isAvailable() || nodeAdapter.isAvailable();
+}
+
+// src/conversion/html/delta-to-html.ts
+import { Delta as Delta7, isInsert as isInsert2, isEmbedInsert as isEmbedInsert2 } from "@scrider/delta";
+
+// src/conversion/utils/slugify.ts
+function slugify(text) {
+  return text.trim().toLowerCase().replace(/[^\p{L}\p{N}\s\-_]/gu, "").replace(/\s+/g, "-").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "");
+}
+function slugifyWithDedup(text, usedSlugs) {
+  const base = slugify(text);
+  const count = usedSlugs.get(base) ?? 0;
+  usedSlugs.set(base, count + 1);
+  if (count === 0) {
+    return base;
+  }
+  return `${base}-${count}`;
+}
+
+// src/conversion/html/delta-to-html.ts
+function deltaToHtml(delta, options = {}) {
+  const lines = splitIntoLines(delta);
+  const embedRenderers = { ...EMBED_RENDERERS, ...options.embedRenderers };
+  const pretty = options.pretty ?? false;
+  const hierarchicalNumbers = options.hierarchicalNumbers ?? false;
+  const blockHandlers = options.blockHandlers;
+  const anchorLinks = options.anchorLinks ?? false;
+  let html = "";
+  let listStack = [];
+  let counters = [];
+  const slugUsageMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line) continue;
+    if (isTableLine(line)) {
+      html += closeAllLists(listStack, pretty);
+      listStack = [];
+      counters = [];
+      const tableLines = collectTableLines(lines, i);
+      html += renderTable(tableLines, embedRenderers, pretty, blockHandlers, options);
+      i += tableLines.length - 1;
+      continue;
+    }
+    const { tag, isList, listType, indent, isCodeBlock } = getBlockInfo(line.attributes);
+    if (isCodeBlock) {
+      html += closeAllLists(listStack, pretty);
+      listStack = [];
+      counters = [];
+      const codeLines = collectCodeBlockLines(lines, i);
+      const language = getCodeBlockLanguage(line.attributes);
+      html += renderCodeBlock(codeLines, language, embedRenderers, pretty, blockHandlers, options);
+      i += codeLines.length - 1;
+      continue;
+    }
+    if (!isList && isBlockLevelEmbedLine(line)) {
+      html += closeAllLists(listStack, pretty);
+      listStack = [];
+      counters = [];
+      html += renderLineContent(line.ops, embedRenderers, blockHandlers, options);
+      if (pretty) html += "\n";
+      continue;
+    }
+    if (isList) {
+      html += handleListOpen(listStack, listType, indent, pretty);
+      if (hierarchicalNumbers && listType === "ordered") {
+        if (counters.length > indent + 1) {
+          counters = counters.slice(0, indent + 1);
+        }
+        while (counters.length < indent) {
+          counters.push(1);
+        }
+        if (counters.length === indent) {
+          counters.push(0);
+        }
+        counters[indent] = (counters[indent] || 0) + 1;
+      }
+    } else {
+      html += closeAllLists(listStack, pretty);
+      listStack = [];
+      counters = [];
+    }
+    const content = renderLineContent(line.ops, embedRenderers, blockHandlers, options);
+    if (isList) {
+      const listItemAttrs = getListItemAttributes(line.attributes);
+      const indentLevel = listStack.length;
+      let hierarchicalNumber;
+      if (hierarchicalNumbers && listType === "ordered") {
+        hierarchicalNumber = counters.slice(0, indent + 1).join(".");
+      }
+      html += renderListItem(content, listItemAttrs, pretty, indentLevel, hierarchicalNumber);
+    } else {
+      let headingId;
+      if (line.attributes?.header) {
+        const customId = line.attributes["header-id"];
+        if (typeof customId === "string" && customId.length > 0) {
+          headingId = customId;
+        } else if (anchorLinks) {
+          const plainText = extractPlainText(line.ops);
+          headingId = slugifyWithDedup(plainText, slugUsageMap);
+        }
+      }
+      html += renderBlock(content, tag, line.attributes, pretty, headingId);
+    }
+  }
+  html += closeAllLists(listStack, pretty);
+  if (options.wrapper) {
+    html = `<${options.wrapper}>${html}</${options.wrapper}>`;
+  }
+  return html;
+}
+function getIndent(level) {
+  return "  ".repeat(level);
+}
+function splitIntoLines(delta) {
+  const lines = [];
+  let currentOps = [];
+  for (const op of delta.ops) {
+    if (!isInsert2(op)) continue;
+    if (isEmbedInsert2(op)) {
+      currentOps.push(op);
+      continue;
+    }
+    const text = op.insert;
+    const parts = text.split("\n");
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      if (part === void 0) continue;
+      if (part.length > 0) {
+        currentOps.push({
+          insert: part,
+          ...op.attributes && { attributes: op.attributes }
+        });
+      }
+      if (i < parts.length - 1) {
+        lines.push({
+          ops: currentOps,
+          attributes: op.attributes
+          // Line attributes come from the \n op
+        });
+        currentOps = [];
+      }
+    }
+  }
+  if (currentOps.length > 0) {
+    lines.push({
+      ops: currentOps,
+      attributes: void 0
+    });
+  }
+  return lines;
+}
+var BLOCK_LEVEL_EMBEDS = /* @__PURE__ */ new Set(["divider", "block"]);
+function isBlockLevelEmbedLine(line) {
+  if (line.ops.length !== 1) return false;
+  const op = line.ops[0];
+  if (!op || !isEmbedInsert2(op)) return false;
+  const embed = op.insert;
+  const embedType = Object.keys(embed)[0];
+  if (!!embedType && BLOCK_LEVEL_EMBEDS.has(embedType)) return true;
+  const attrs = op.attributes;
+  if (attrs && typeof attrs.float === "string" && attrs.float !== "none") return true;
+  return false;
+}
+function isTableLine(line) {
+  return line.attributes != null && typeof line.attributes["table-row"] === "number" && typeof line.attributes["table-col"] === "number";
+}
+function collectTableLines(lines, startIndex) {
+  const result = [];
+  for (let i = startIndex; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line || !isTableLine(line)) break;
+    result.push(line);
+  }
+  return result;
+}
+function renderTable(tableLines, embedRenderers, pretty, blockHandlers, options) {
+  const rows = /* @__PURE__ */ new Map();
+  for (const line of tableLines) {
+    const attrs = line.attributes;
+    const rowIdx = attrs["table-row"];
+    const colIdx = attrs["table-col"];
+    if (!rows.has(rowIdx)) {
+      rows.set(rowIdx, { isHeader: !!attrs["table-header"], cells: /* @__PURE__ */ new Map() });
+    }
+    const row = rows.get(rowIdx);
+    if (attrs["table-header"]) row.isHeader = true;
+    row.cells.set(colIdx, {
+      ops: line.ops,
+      colAlign: typeof attrs["table-col-align"] === "string" ? attrs["table-col-align"] : void 0
+    });
+  }
+  const sortedRows = [...rows.entries()].sort((a, b) => a[0] - b[0]);
+  let maxCol = 0;
+  for (const [, row] of sortedRows) {
+    for (const colIdx of row.cells.keys()) {
+      if (colIdx > maxCol) maxCol = colIdx;
+    }
+  }
+  const headerRows = sortedRows.filter(([, r]) => r.isHeader);
+  const bodyRows = sortedRows.filter(([, r]) => !r.isHeader);
+  const indent = pretty ? "  " : "";
+  const nl = pretty ? "\n" : "";
+  let html = `<table>${nl}`;
+  if (headerRows.length > 0) {
+    html += `${indent}<thead>${nl}`;
+    for (const [, row] of headerRows) {
+      html += renderTableRow(
+        row.cells,
+        maxCol,
+        "th",
+        embedRenderers,
+        pretty,
+        2,
+        blockHandlers,
+        options
+      );
+    }
+    html += `${indent}</thead>${nl}`;
+  }
+  if (bodyRows.length > 0) {
+    html += `${indent}<tbody>${nl}`;
+    for (const [, row] of bodyRows) {
+      html += renderTableRow(
+        row.cells,
+        maxCol,
+        "td",
+        embedRenderers,
+        pretty,
+        2,
+        blockHandlers,
+        options
+      );
+    }
+    html += `${indent}</tbody>${nl}`;
+  }
+  html += `</table>`;
+  if (pretty) html += "\n";
+  return html;
+}
+function renderTableRow(cells, maxCol, cellTag, embedRenderers, pretty, depth, blockHandlers, options) {
+  const indent = pretty ? "  ".repeat(depth) : "";
+  const cellIndent = pretty ? "  ".repeat(depth + 1) : "";
+  const nl = pretty ? "\n" : "";
+  let html = `${indent}<tr>${nl}`;
+  for (let col = 0; col <= maxCol; col++) {
+    const cell = cells.get(col);
+    const content = cell ? renderLineContent(cell.ops, embedRenderers, blockHandlers, options) : "";
+    const alignStyle = cell?.colAlign && cell.colAlign !== "left" ? ` style="text-align: ${cell.colAlign}"` : "";
+    html += `${cellIndent}<${cellTag}${alignStyle}>${content}</${cellTag}>${nl}`;
+  }
+  html += `${indent}</tr>${nl}`;
+  return html;
+}
+function getBlockInfo(attributes) {
+  if (!attributes) {
+    return { tag: "p", isList: false, isCodeBlock: false, listType: void 0, indent: 0 };
+  }
+  const indent = typeof attributes.indent === "number" ? attributes.indent : 0;
+  if (attributes["code-block"]) {
+    return { tag: "pre", isList: false, isCodeBlock: true, listType: void 0, indent };
+  }
+  if (attributes.list) {
+    const listVal = attributes.list;
+    const listType = typeof listVal === "string" ? listVal : "bullet";
+    return { tag: "li", isList: true, isCodeBlock: false, listType, indent };
+  }
+  for (const [format, tagOrFn] of Object.entries(BLOCK_FORMAT_TAGS)) {
+    if (format in attributes && format !== "list" && format !== "code-block") {
+      const tag = typeof tagOrFn === "function" ? tagOrFn(attributes[format]) : tagOrFn;
+      return { tag, isList: false, isCodeBlock: false, listType: void 0, indent };
+    }
+  }
+  return { tag: "p", isList: false, isCodeBlock: false, listType: void 0, indent };
+}
+function collectCodeBlockLines(lines, startIndex) {
+  const codeLines = [];
+  const startLine = lines[startIndex];
+  if (!startLine) return codeLines;
+  const startLang = getCodeBlockLanguage(startLine.attributes);
+  for (let i = startIndex; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line || !line.attributes?.["code-block"]) break;
+    const lang = getCodeBlockLanguage(line.attributes);
+    if (i > startIndex && lang !== startLang) break;
+    codeLines.push(line);
+  }
+  return codeLines;
+}
+function getCodeBlockLanguage(attributes) {
+  if (!attributes) return void 0;
+  const codeBlock = attributes["code-block"];
+  if (typeof codeBlock === "string" && codeBlock !== "true") {
+    return codeBlock;
+  }
+  return void 0;
+}
+function renderCodeBlock(codeLines, language, embedRenderers, pretty, blockHandlers, options) {
+  const lineContents = codeLines.map(
+    (line) => renderLineContent(line.ops, embedRenderers, blockHandlers, options)
+  );
+  const code = lineContents.join("\n");
+  const langClass = language ? ` class="language-${escapeHtml(language)}"` : "";
+  const langAttr = language ? ` data-language="${escapeHtml(language)}"` : "";
+  const html = `<pre${langAttr}><code${langClass}>${code}
+</code></pre>`;
+  return pretty ? html + "\n" : html;
+}
+function handleListOpen(stack, listType, indent, pretty) {
+  let html = "";
+  const wrapperTag = LIST_WRAPPER_TAGS[listType] || "ul";
+  while (stack.length > 0) {
+    const last = stack[stack.length - 1];
+    if (!last || last.indent <= indent) break;
+    const closed = stack.pop();
+    if (closed) {
+      const closeTag = LIST_WRAPPER_TAGS[closed.type] || "ul";
+      if (pretty) html += getIndent(stack.length);
+      html += `</${closeTag}>`;
+      if (pretty) html += "\n";
+    }
+  }
+  const top = stack[stack.length - 1];
+  if (top && top.indent === indent && top.type !== listType) {
+    const closed = stack.pop();
+    if (closed) {
+      const closeTag = LIST_WRAPPER_TAGS[closed.type] || "ul";
+      if (pretty) html += getIndent(stack.length);
+      html += `</${closeTag}>`;
+      if (pretty) html += "\n";
+    }
+  }
+  while (true) {
+    const last = stack[stack.length - 1];
+    const currentIndent = last ? last.indent + 1 : 0;
+    if (currentIndent > indent) break;
+    if (pretty) html += getIndent(stack.length);
+    html += `<${wrapperTag}>`;
+    if (pretty) html += "\n";
+    stack.push({ type: listType, indent: currentIndent });
+    if (currentIndent >= indent) break;
+  }
+  const current = stack[stack.length - 1];
+  if (!current || current.indent < indent) {
+    if (pretty) html += getIndent(stack.length);
+    html += `<${wrapperTag}>`;
+    if (pretty) html += "\n";
+    stack.push({ type: listType, indent });
+  }
+  return html;
+}
+function closeAllLists(stack, pretty) {
+  let html = "";
+  while (stack.length > 0) {
+    const closed = stack.pop();
+    const closeTag = LIST_WRAPPER_TAGS[closed.type] || "ul";
+    if (pretty) html += getIndent(stack.length);
+    html += `</${closeTag}>`;
+    if (pretty) html += "\n";
+  }
+  return html;
+}
+function getListItemAttributes(attributes) {
+  if (!attributes) return "";
+  const listType = attributes.list;
+  if (listType === "checked") {
+    return ' data-checked="true"';
+  }
+  if (listType === "unchecked") {
+    return ' data-checked="false"';
+  }
+  return "";
+}
+function renderListItem(content, attrs, pretty, indentLevel, hierarchicalNumber) {
+  const indent = pretty ? getIndent(indentLevel) : "";
+  const innerContent = content || "<br>";
+  let fullAttrs = attrs;
+  if (hierarchicalNumber) {
+    fullAttrs += ` data-number="${hierarchicalNumber}"`;
+  }
+  const html = `${indent}<li${fullAttrs}>${innerContent}</li>`;
+  return pretty ? html + "\n" : html;
+}
+function renderBlock(content, tag, attributes, pretty, id) {
+  const idAttr = id ? ` id="${escapeHtml(id)}"` : "";
+  const styleAttr = getBlockStyleAttribute(attributes);
+  const innerContent = content || "<br>";
+  const html = `<${tag}${idAttr}${styleAttr}>${innerContent}</${tag}>`;
+  return pretty ? html + "\n" : html;
+}
+function getBlockStyleAttribute(attributes) {
+  if (!attributes) return "";
+  const styles = [];
+  const alignVal = attributes.align;
+  if (alignVal && typeof alignVal === "string" && alignVal !== "left") {
+    styles.push(`text-align: ${alignVal}`);
+  }
+  if (attributes.indent && typeof attributes.indent === "number") {
+    if (!attributes.list) {
+      styles.push(`margin-left: ${attributes.indent * 2}em`);
+    }
+  }
+  return styles.length > 0 ? ` style="${styles.join("; ")}"` : "";
+}
+function extractPlainText(ops) {
+  let text = "";
+  for (const op of ops) {
+    if (isInsert2(op) && typeof op.insert === "string") {
+      text += op.insert;
+    }
+  }
+  return text;
+}
+function renderLineContent(ops, embedRenderers, blockHandlers, options) {
+  let html = "";
+  for (const op of ops) {
+    if (!isInsert2(op)) continue;
+    if (isEmbedInsert2(op)) {
+      html += renderEmbed(
+        op.insert,
+        op.attributes,
+        embedRenderers,
+        blockHandlers,
+        options
+      );
+    } else {
+      html += renderInlineText(op.insert, op.attributes);
+    }
+  }
+  return html;
+}
+function renderInlineText(text, attributes) {
+  if (!text) return "";
+  let html = escapeHtml(text);
+  if (!attributes) return html;
+  const styles = [];
+  for (const [format, cssProperty] of Object.entries(INLINE_STYLE_FORMATS)) {
+    if (format in attributes) {
+      styles.push(`${cssProperty}: ${String(attributes[format])}`);
+    }
+  }
+  if (styles.length > 0) {
+    html = `<span style="${styles.join("; ")}">${html}</span>`;
+  }
+  for (let i = INLINE_FORMAT_ORDER.length - 1; i >= 0; i--) {
+    const format = INLINE_FORMAT_ORDER[i];
+    if (!format) continue;
+    if (!(format in attributes)) continue;
+    const tag = INLINE_FORMAT_TAGS[format];
+    if (!tag) continue;
+    if (format === "link") {
+      const href = escapeHtml(String(attributes.link));
+      html = `<a href="${href}">${html}</a>`;
+    } else {
+      html = `<${tag}>${html}</${tag}>`;
+    }
+  }
+  return html;
+}
+function renderEmbed(value, attributes, renderers, blockHandlers, options) {
+  const embedType = Object.keys(value)[0];
+  if (!embedType) return "";
+  if (embedType === "block" && blockHandlers) {
+    const blockData = value.block;
+    if (blockData && typeof blockData.type === "string") {
+      const handler = blockHandlers.get(blockData.type);
+      if (handler) {
+        if (handler.validate && !handler.validate(blockData)) {
+          return "";
+        }
+        const context = {
+          registry: null,
+          options: { pretty: options?.pretty ?? false },
+          renderDelta: (ops) => deltaToHtml(new Delta7(ops), options ?? {}),
+          ...attributes ? { opAttributes: attributes } : {}
+        };
+        return handler.toHtml(blockData, context);
+      }
+    }
+    return "";
+  }
+  const embedValue = value[embedType];
+  const registry = options?.registry;
+  if (registry) {
+    const format = registry.get(embedType);
+    if (format?.render) {
+      return format.render(embedValue, attributes);
+    }
+  }
+  const renderer = renderers[embedType];
+  if (renderer) {
+    return renderer(embedValue, attributes);
+  }
+  return `<span data-embed="${escapeHtml(embedType)}" data-value="${escapeHtml(String(embedValue))}"></span>`;
+}
+
+// src/conversion/html/html-to-delta.ts
+import { Delta as Delta8 } from "@scrider/delta";
+function htmlToDelta(html, options = {}) {
+  const adapter = options.adapter ?? getAdapter();
+  const normalizeWhitespace = options.normalizeWhitespace ?? true;
+  const tagHandlers = { ...DEFAULT_TAG_HANDLERS, ...options.tagHandlers };
+  const fragment = adapter.parseHTML(html);
+  const delta = new Delta8();
+  let currentAttributes = {};
+  let currentBlockAttributes = {};
+  let pendingText = "";
+  let atLineStart = true;
+  const context = {
+    delta,
+    get attributes() {
+      return { ...currentAttributes };
+    },
+    get blockAttributes() {
+      return { ...currentBlockAttributes };
+    },
+    pushText(text) {
+      if (normalizeWhitespace) {
+        text = normalizeText(text, pendingText, atLineStart);
+      }
+      if (text) {
+        pendingText += text;
+        atLineStart = false;
+      }
+    },
+    pushEmbed(embed, attrs) {
+      flushText();
+      const finalAttrs = { ...currentAttributes, ...attrs };
+      if (Object.keys(finalAttrs).length > 0) {
+        delta.insert(embed, finalAttrs);
+      } else {
+        delta.insert(embed);
+      }
+      atLineStart = false;
+    },
+    pushNewline() {
+      flushText();
+      const attrs = { ...currentBlockAttributes };
+      if (Object.keys(attrs).length > 0) {
+        delta.insert("\n", attrs);
+      } else {
+        delta.insert("\n");
+      }
+      currentBlockAttributes = {};
+      atLineStart = true;
+    }
+  };
+  function flushText() {
+    if (pendingText) {
+      const attrs = { ...currentAttributes };
+      if (Object.keys(attrs).length > 0) {
+        delta.insert(pendingText, attrs);
+      } else {
+        delta.insert(pendingText);
+      }
+      pendingText = "";
+    }
+  }
+  function processNode(node) {
+    if (node.nodeType === NODE_TYPE.TEXT_NODE) {
+      const text = node.textContent ?? "";
+      context.pushText(text);
+      return;
+    }
+    if (!isElement(node)) return;
+    const tagName = node.tagName.toLowerCase();
+    const handler = findTagHandler(tagHandlers, node, tagName);
+    if (handler) {
+      handler(node, context);
+      return;
+    }
+    const blockFormat2 = TAG_TO_BLOCK_FORMAT[tagName];
+    if (blockFormat2) {
+      processBlockElement(node, blockFormat2);
+      return;
+    }
+    if (tagName === "ul" || tagName === "ol") {
+      processListElement(node, tagName);
+      return;
+    }
+    const inlineFormat = TAG_TO_INLINE_FORMAT[tagName];
+    if (inlineFormat) {
+      processInlineElement(node, inlineFormat);
+      return;
+    }
+    if (tagName === "a") {
+      processLinkElement(node);
+      return;
+    }
+    if (tagName === "span") {
+      processSpanElement(node);
+      return;
+    }
+    if (tagName === "table") {
+      processTableElement(node);
+      return;
+    }
+    if (options.registry) {
+      const embedFormats = options.registry.getByScope("embed");
+      for (const format of embedFormats) {
+        if (format.match) {
+          const result = format.match(node);
+          if (result != null) {
+            context.pushEmbed({ [format.name]: result.value }, result.attributes);
+            return;
+          }
+        }
+      }
+    }
+    if (tagName === "img") {
+      processImageElement(node);
+      return;
+    }
+    if (tagName === "video" || tagName === "iframe") {
+      processVideoElement(node);
+      return;
+    }
+    if (tagName === "hr") {
+      context.pushEmbed({ divider: true });
+      context.pushNewline();
+      return;
+    }
+    if (tagName === "section" || tagName === "div") {
+      const className = node.getAttribute("class") || "";
+      if (className.includes("footnotes")) {
+        processFootnotesSection(node);
+        return;
+      }
+      if (className.includes("markdown-alert")) {
+        processAlertElement(node);
+        return;
+      }
+      if (/\bcolumns\b/.test(className)) {
+        processColumnsElement(node);
+        return;
+      }
+      if (className.includes("inline-box")) {
+        processBoxElement(node);
+        return;
+      }
+    }
+    if (tagName === "p" || tagName === "div") {
+      processDefaultBlock(node);
+      return;
+    }
+    if (tagName === "br") {
+      context.pushNewline();
+      return;
+    }
+    processChildren(node);
+  }
+  function processChildren(node) {
+    const children2 = node.childNodes;
+    for (let i = 0; i < children2.length; i++) {
+      const child = children2[i];
+      if (child) processNode(child);
+    }
+  }
+  function processBlockElement(element, format) {
+    if (format.format === "code-block") {
+      processCodeBlockElement(element);
+      return;
+    }
+    const prevBlockAttrs = { ...currentBlockAttributes };
+    currentBlockAttributes[format.format] = format.value;
+    const align = getAlignment(element);
+    if (align) {
+      currentBlockAttributes.align = align;
+    }
+    if (format.format === "header") {
+      const id = element.getAttribute("id");
+      if (id) {
+        const text = element.textContent || "";
+        const computedSlug = slugify(text);
+        if (id !== computedSlug) {
+          currentBlockAttributes["header-id"] = id;
+        }
+      }
+    }
+    processChildren(element);
+    context.pushNewline();
+    currentBlockAttributes = prevBlockAttrs;
+  }
+  function processCodeBlockElement(element) {
+    const prevBlockAttrs = { ...currentBlockAttributes };
+    let language;
+    const dataLang = element.getAttribute("data-language");
+    if (dataLang) {
+      language = dataLang;
+    }
+    const children2 = element.childNodes;
+    let codeElement = null;
+    for (let i = 0; i < children2.length; i++) {
+      const child = children2[i];
+      if (child && isElement(child) && child.tagName.toLowerCase() === "code") {
+        codeElement = child;
+        break;
+      }
+    }
+    if (codeElement && !language) {
+      const className = codeElement.getAttribute("class") || "";
+      const match = className.match(/language-(\S+)/);
+      if (match?.[1]) {
+        language = match[1];
+      }
+    }
+    const codeBlockValue = language || true;
+    currentBlockAttributes["code-block"] = codeBlockValue;
+    const sourceElement = codeElement || element;
+    const rawText = sourceElement.textContent ?? "";
+    const text = rawText.endsWith("\n") ? rawText.slice(0, -1) : rawText;
+    const codeLines = text.split("\n");
+    for (let i = 0; i < codeLines.length; i++) {
+      const line = codeLines[i];
+      if (line !== void 0 && line.length > 0) {
+        flushText();
+        pendingText = line;
+      }
+      flushText();
+      const attrs = { ...currentBlockAttributes };
+      if (Object.keys(attrs).length > 0) {
+        delta.insert("\n", attrs);
+      } else {
+        delta.insert("\n");
+      }
+      atLineStart = true;
+    }
+    currentBlockAttributes = prevBlockAttrs;
+  }
+  function processListElement(element, listTag, indent = 0) {
+    const children2 = element.childNodes;
+    for (let i = 0; i < children2.length; i++) {
+      const child = children2[i];
+      if (!child || !isElement(child)) continue;
+      const childTag = child.tagName.toLowerCase();
+      if (childTag === "li") {
+        processListItem(child, listTag, indent);
+      } else if (childTag === "ul" || childTag === "ol") {
+        processListElement(child, childTag, indent + 1);
+      }
+    }
+  }
+  function processListItem(element, listTag, indent) {
+    const prevBlockAttrs = { ...currentBlockAttributes };
+    let listType = listTag === "ol" ? "ordered" : "bullet";
+    const dataChecked = element.getAttribute("data-checked");
+    if (dataChecked === "true") {
+      listType = "checked";
+    } else if (dataChecked === "false") {
+      listType = "unchecked";
+    }
+    currentBlockAttributes.list = listType;
+    if (indent > 0) {
+      currentBlockAttributes.indent = indent;
+    }
+    const children2 = element.childNodes;
+    let hasNestedList = false;
+    const firstChild = children2[0];
+    const isBrOnlyListItem = children2.length === 1 && firstChild !== void 0 && isElement(firstChild) && firstChild.tagName.toLowerCase() === "br";
+    for (let i = 0; i < children2.length; i++) {
+      const child = children2[i];
+      if (!child) continue;
+      if (isElement(child)) {
+        const childTag = child.tagName.toLowerCase();
+        if (childTag === "ul" || childTag === "ol") {
+          if (!hasNestedList) {
+            context.pushNewline();
+            hasNestedList = true;
+          }
+          processNestedList(child, childTag, indent + 1);
+          continue;
+        }
+      }
+      if (!hasNestedList && !isBrOnlyListItem) {
+        processNode(child);
+      }
+    }
+    if (!hasNestedList) {
+      context.pushNewline();
+    }
+    currentBlockAttributes = prevBlockAttrs;
+  }
+  function processNestedList(element, listTag, indent) {
+    const children2 = element.childNodes;
+    for (let i = 0; i < children2.length; i++) {
+      const child = children2[i];
+      if (!child || !isElement(child)) continue;
+      const childTag = child.tagName.toLowerCase();
+      if (childTag === "li") {
+        processListItem(child, listTag, indent);
+      }
+    }
+  }
+  function processInlineElement(element, format) {
+    flushText();
+    const prevAttrs = { ...currentAttributes };
+    currentAttributes[format.format] = format.value;
+    processChildren(element);
+    flushText();
+    currentAttributes = prevAttrs;
+  }
+  function processLinkElement(element) {
+    const href = element.getAttribute("href");
+    if (!href) {
+      processChildren(element);
+      return;
+    }
+    flushText();
+    const prevAttrs = { ...currentAttributes };
+    currentAttributes.link = href;
+    processChildren(element);
+    flushText();
+    currentAttributes = prevAttrs;
+  }
+  function processSpanElement(element) {
+    flushText();
+    const prevAttrs = { ...currentAttributes };
+    const color = element.style?.color || element.style?.getPropertyValue?.("color");
+    if (color) {
+      currentAttributes.color = color;
+    }
+    const bg = element.style?.backgroundColor || element.style?.getPropertyValue?.("background-color");
+    if (bg) {
+      currentAttributes.background = bg;
+    }
+    processChildren(element);
+    flushText();
+    currentAttributes = prevAttrs;
+  }
+  function processImageElement(element) {
+    const src = element.getAttribute("src");
+    if (!src) return;
+    const attrs = {};
+    const alt = element.getAttribute("alt");
+    const width = element.getAttribute("width");
+    const height = element.getAttribute("height");
+    const float = element.getAttribute("data-float");
+    if (alt) attrs.alt = alt;
+    if (width) attrs.width = parseInt(width, 10);
+    if (height) attrs.height = parseInt(height, 10);
+    if (float) attrs.float = float;
+    context.pushEmbed({ image: src }, attrs);
+  }
+  function processVideoElement(element) {
+    const src = element.getAttribute("src");
+    if (!src) return;
+    const attrs = {};
+    const float = element.getAttribute("data-float");
+    const style = element.getAttribute("style") || "";
+    if (float) attrs.float = float;
+    const widthMatch = style.match(/(?:^|;\s*)width:\s*([^;]+)/);
+    if (widthMatch?.[1]) attrs.width = widthMatch[1].trim().replace(/px$/, "");
+    const heightMatch = style.match(/(?:^|;\s*)height:\s*([^;]+)/);
+    if (heightMatch?.[1]) attrs.height = heightMatch[1].trim().replace(/px$/, "");
+    const embedAttrs = Object.keys(attrs).length > 0 ? attrs : void 0;
+    context.pushEmbed({ video: fromVideoEmbedUrl(src) }, embedAttrs);
+  }
+  function processFootnotesSection(section) {
+    const footnotesHandler = options.blockHandlers?.get("footnotes");
+    if (footnotesHandler) {
+      const blockContext = {
+        registry: void 0,
+        // Registry not needed for fromHtml parsing
+        parseElement: (el) => {
+          const innerHtml = el.innerHTML ?? "";
+          if (!innerHtml) return [{ insert: "\n" }];
+          return htmlToDelta(innerHtml, options).ops;
+        }
+      };
+      const data = footnotesHandler.fromHtml(section, blockContext);
+      if (data) {
+        flushText();
+        delta.insert({ block: data });
+        delta.insert("\n");
+        atLineStart = true;
+        return;
+      }
+    }
+    processChildren(section);
+  }
+  function processAlertElement(element) {
+    const alertHandler = options.blockHandlers?.get("alert");
+    if (alertHandler) {
+      const blockContext = {
+        registry: void 0,
+        parseElement: (el) => {
+          const innerHtml = el.innerHTML ?? "";
+          if (!innerHtml) return [{ insert: "\n" }];
+          return htmlToDelta(innerHtml, options).ops;
+        }
+      };
+      const data = alertHandler.fromHtml(element, blockContext);
+      if (data) {
+        flushText();
+        delta.insert({ block: data });
+        delta.insert("\n");
+        atLineStart = true;
+        return;
+      }
+    }
+    processChildren(element);
+  }
+  function processColumnsElement(element) {
+    const columnsHandler = options.blockHandlers?.get("columns");
+    if (columnsHandler) {
+      const blockContext = {
+        registry: void 0,
+        parseElement: (el) => {
+          const innerHtml = el.innerHTML ?? "";
+          if (!innerHtml) return [{ insert: "\n" }];
+          return htmlToDelta(innerHtml, options).ops;
+        }
+      };
+      const data = columnsHandler.fromHtml(element, blockContext);
+      if (data) {
+        flushText();
+        delta.insert({ block: data });
+        delta.insert("\n");
+        atLineStart = true;
+        return;
+      }
+    }
+    processChildren(element);
+  }
+  function processBoxElement(element) {
+    const boxHandler = options.blockHandlers?.get("box");
+    if (boxHandler) {
+      const blockContext = {
+        registry: void 0,
+        parseElement: (el) => {
+          const innerHtml = el.innerHTML ?? "";
+          if (!innerHtml) return [{ insert: "\n" }];
+          return htmlToDelta(innerHtml, options).ops;
+        }
+      };
+      const data = boxHandler.fromHtml(element, blockContext);
+      if (data) {
+        flushText();
+        const opAttrs = {};
+        const dataFloat = element.getAttribute("data-float");
+        if (dataFloat) opAttrs.float = dataFloat;
+        const dataOverflow = element.getAttribute("data-overflow");
+        if (dataOverflow) opAttrs.overflow = dataOverflow;
+        const style = element.getAttribute("style") || "";
+        const widthMatch = style.match(/(?:^|;\s*)width:\s*([^;]+)/);
+        if (widthMatch?.[1]) opAttrs.width = widthMatch[1].trim();
+        const heightMatch = style.match(/(?:^|;\s*)height:\s*([^;]+)/);
+        if (heightMatch?.[1]) opAttrs.height = heightMatch[1].trim();
+        const hasAttrs = Object.keys(opAttrs).length > 0;
+        delta.insert({ block: data }, hasAttrs ? opAttrs : void 0);
+        delta.insert("\n");
+        atLineStart = true;
+        return;
+      }
+    }
+    processChildren(element);
+  }
+  function processTableElement(table) {
+    const tableHandler = options.blockHandlers?.get("table");
+    if (tableHandler) {
+      const blockContext = {
+        registry: void 0,
+        // Registry not needed for fromHtml parsing
+        parseElement: (el) => {
+          const innerHtml = el.innerHTML ?? "";
+          if (!innerHtml) return [{ insert: "\n" }];
+          return htmlToDelta(innerHtml, options).ops;
+        }
+      };
+      const data = tableHandler.fromHtml(table, blockContext);
+      if (data) {
+        flushText();
+        delta.insert({ block: data });
+        delta.insert("\n");
+        atLineStart = true;
+        return;
+      }
+    }
+    let rowIdx = 0;
+    const tableChildren = table.childNodes;
+    for (let i = 0; i < tableChildren.length; i++) {
+      const section = tableChildren[i];
+      if (!section || !isElement(section)) continue;
+      const sectionTag = section.tagName.toLowerCase();
+      if (sectionTag === "thead" || sectionTag === "tbody" || sectionTag === "tfoot") {
+        const isHeader = sectionTag === "thead";
+        const sectionChildren = section.childNodes;
+        for (let j = 0; j < sectionChildren.length; j++) {
+          const row = sectionChildren[j];
+          if (!row || !isElement(row) || row.tagName.toLowerCase() !== "tr") continue;
+          processTableRow(row, rowIdx, isHeader);
+          rowIdx++;
+        }
+      } else if (sectionTag === "tr") {
+        processTableRow(section, rowIdx, false);
+        rowIdx++;
+      }
+    }
+  }
+  function processTableRow(tr, rowIdx, isHeader) {
+    let colIdx = 0;
+    const cells = tr.childNodes;
+    for (let i = 0; i < cells.length; i++) {
+      const cell = cells[i];
+      if (!cell || !isElement(cell)) continue;
+      const cellTag = cell.tagName.toLowerCase();
+      if (cellTag !== "td" && cellTag !== "th") continue;
+      const cellIsHeader = isHeader || cellTag === "th";
+      const textAlign = cell.style?.textAlign || cell.style?.getPropertyValue?.("text-align");
+      const colAlign = textAlign && (textAlign === "left" || textAlign === "center" || textAlign === "right") ? textAlign : void 0;
+      const prevBlockAttrs = { ...currentBlockAttributes };
+      currentBlockAttributes["table-row"] = rowIdx;
+      currentBlockAttributes["table-col"] = colIdx;
+      if (cellIsHeader) {
+        currentBlockAttributes["table-header"] = true;
+      }
+      if (colAlign) {
+        currentBlockAttributes["table-col-align"] = colAlign;
+      }
+      processChildren(cell);
+      context.pushNewline();
+      currentBlockAttributes = prevBlockAttrs;
+      colIdx++;
+    }
+  }
+  function processDefaultBlock(element) {
+    const prevBlockAttrs = { ...currentBlockAttributes };
+    const align = getAlignment(element);
+    if (align) {
+      currentBlockAttributes.align = align;
+    }
+    const children2 = element.childNodes;
+    const firstChild = children2[0];
+    const isBrOnlyParagraph = children2.length === 1 && firstChild !== void 0 && isElement(firstChild) && firstChild.tagName.toLowerCase() === "br";
+    if (!isBrOnlyParagraph) {
+      processChildren(element);
+    }
+    context.pushNewline();
+    currentBlockAttributes = prevBlockAttrs;
+  }
+  function getAlignment(element) {
+    const textAlign = element.style?.textAlign || element.style?.getPropertyValue?.("text-align");
+    if (textAlign && CSS_ALIGN_TO_FORMAT[textAlign]) {
+      return CSS_ALIGN_TO_FORMAT[textAlign];
+    }
+    return null;
+  }
+  const children = fragment.childNodes;
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i];
+    if (child) processNode(child);
+  }
+  flushText();
+  if (delta.ops.length > 0) {
+    const lastOp = delta.ops[delta.ops.length - 1];
+    if (lastOp && "insert" in lastOp) {
+      const lastInsert = lastOp.insert;
+      if (typeof lastInsert === "string" && !lastInsert.endsWith("\n")) {
+        delta.insert("\n");
+      }
+    }
+  }
+  return delta;
+}
+function normalizeText(text, pendingText, atLineStart) {
+  text = text.replace(/[\t\n\r]+/g, " ");
+  text = text.replace(/ +/g, " ");
+  if (atLineStart && pendingText === "" && text.startsWith(" ")) {
+    text = text.slice(1);
+  }
+  return text;
+}
+function findTagHandler(handlers, element, tagName) {
+  const className = element.getAttribute("class");
+  if (className) {
+    const classes = className.split(/\s+/);
+    for (const cls of classes) {
+      const key = `${tagName}.${cls}`;
+      if (handlers[key]) {
+        return handlers[key];
+      }
+    }
+  }
+  if (handlers[tagName]) {
+    return handlers[tagName];
+  }
+  return null;
+}
+var DEFAULT_TAG_HANDLERS = {
+  // Formula span
+  "span.formula": (element, context) => {
+    const formula = element.getAttribute("data-formula");
+    if (formula) {
+      context.pushEmbed({ formula });
+    }
+  },
+  // Diagram (Mermaid) span — inline mode
+  "span.diagram": (element, context) => {
+    const diagram = element.getAttribute("data-diagram");
+    if (diagram) {
+      context.pushEmbed({ diagram });
+    }
+  },
+  // Draw.io diagram span — file reference
+  "span.drawio": (element, context) => {
+    const src = element.getAttribute("data-drawio-src");
+    if (src) {
+      const attrs = {};
+      const alt = element.getAttribute("data-alt");
+      if (alt) attrs.alt = alt;
+      context.pushEmbed({ drawio: src }, Object.keys(attrs).length > 0 ? attrs : void 0);
+    }
+  },
+  // Footnote reference: <sup class="footnote-ref"><a href="#fn-{id}">{label}</a></sup>
+  "sup.footnote-ref": (element, context) => {
+    const children = element.childNodes;
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      if (child && isElement(child) && child.tagName.toLowerCase() === "a") {
+        const href = child.getAttribute("href") || "";
+        const match = href.match(/#fn-(.+)/);
+        if (match?.[1]) {
+          context.pushEmbed({ "footnote-ref": match[1] });
+          return;
+        }
+      }
+    }
+    const id = element.getAttribute("id") || "";
+    const refMatch = id.match(/^fnref-(.+)/);
+    if (refMatch?.[1]) {
+      context.pushEmbed({ "footnote-ref": refMatch[1] });
+    }
+  }
+};
+
+// src/conversion/markdown/delta-to-markdown.ts
+import { Delta as Delta9, isInsert as isInsert3, isTextInsert as isTextInsert2, isEmbedInsert as isEmbedInsert3 } from "@scrider/delta";
+
+// src/conversion/markdown/config.ts
+var MARKDOWN_ESCAPE_CHARS = /[\\`*_[\]<>#]/g;
+function escapeMarkdown(text) {
+  return text.replace(MARKDOWN_ESCAPE_CHARS, "\\$&");
+}
+var INLINE_FORMAT_SYNTAX = {
+  bold: { prefix: "**", suffix: "**" },
+  italic: { prefix: "_", suffix: "_" },
+  underline: { prefix: "<u>", suffix: "</u>" },
+  strike: { prefix: "~~", suffix: "~~" },
+  subscript: { prefix: "<sub>", suffix: "</sub>" },
+  superscript: { prefix: "<sup>", suffix: "</sup>" },
+  code: { prefix: "`", suffix: "`" },
+  mark: { prefix: "<mark>", suffix: "</mark>" },
+  kbd: { prefix: "<kbd>", suffix: "</kbd>" }
+};
+var MD_INLINE_FORMAT_ORDER = [
+  "bold",
+  "italic",
+  "underline",
+  "strike",
+  "subscript",
+  "superscript",
+  "code",
+  "mark",
+  "kbd"
+];
+var BLOCK_FORMAT_PREFIX = {
+  header: (value) => {
+    const level = typeof value === "number" ? value : 1;
+    return "#".repeat(Math.min(Math.max(level, 1), 6)) + " ";
+  },
+  blockquote: "> ",
+  "code-block": ""
+  // Handled separately with fences
+};
+var LIST_TYPE_PREFIX = {
+  bullet: "- ",
+  ordered: (index) => `${index + 1}. `,
+  checked: "- [x] ",
+  unchecked: "- [ ] "
+};
+function getIndentPrefix(level) {
+  return "    ".repeat(level);
+}
+function renderImage(src, alt, _title) {
+  const altText = alt ?? "";
+  return `![${escapeMarkdown(altText)}](${src})`;
+}
+function renderLink(text, href, _title) {
+  return `[${text}](${href})`;
+}
+function renderCodeBlock2(code, language) {
+  const lang = language ?? "";
+  return `\`\`\`${lang}
+${code}
+\`\`\``;
+}
+
+// src/conversion/markdown/delta-to-markdown.ts
+function deltaToMarkdown(delta, options = {}) {
+  const {
+    strict = false,
+    preserveEmptyLines = false,
+    mathSyntax = "dollar",
+    mathBlock = true,
+    embedRenderers = {},
+    blockHandlers,
+    prettyHtml = false,
+    registry
+  } = options;
+  const useLatexDelimiters = mathSyntax === "latex";
+  const lines = splitIntoLines2(delta.ops);
+  let orderedListIndex = 0;
+  let lastListType = null;
+  let lastIndent = 0;
+  let lastWasBlockquote = false;
+  const result = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line) continue;
+    const attrs = line.attributes;
+    const isBlockquote = !!attrs.blockquote;
+    if (typeof attrs["table-row"] === "number" && typeof attrs["table-col"] === "number") {
+      const tableLines = collectTableLines2(lines, i);
+      result.push(renderMarkdownTable(tableLines, embedRenderers, useLatexDelimiters, registry));
+      result.push("");
+      i += tableLines.length - 1;
+      lastListType = null;
+      orderedListIndex = 0;
+      lastWasBlockquote = false;
+      continue;
+    }
+    if (attrs["code-block"]) {
+      if (lastWasBlockquote) {
+        result.push("");
+        lastWasBlockquote = false;
+      }
+      const codeLines = collectCodeBlock(lines, i);
+      const language = getCodeBlockLanguage2(attrs);
+      const code = codeLines.map(
+        (l) => renderLineContent2(l.ops, embedRenderers, true, false, blockHandlers, false, registry)
+      ).join("\n");
+      if (language === "math") {
+        if (mathBlock === false) {
+          result.push("");
+          result.push(`$${code}$`);
+          result.push("");
+        } else if (useLatexDelimiters) {
+          result.push(`\\[
+${code}
+\\]`);
+        } else {
+          result.push(renderCodeBlock2(code, language));
+        }
+      } else {
+        result.push(renderCodeBlock2(code, language));
+      }
+      i += codeLines.length - 1;
+      lastListType = null;
+      orderedListIndex = 0;
+      continue;
+    }
+    if (lastWasBlockquote && !isBlockquote) {
+      result.push("");
+    } else if (!lastWasBlockquote && isBlockquote && result.length > 0) {
+      const lastLine = result[result.length - 1];
+      if (lastLine !== void 0 && lastLine !== "") {
+        result.push("");
+      }
+    }
+    const listType = typeof attrs.list === "string" ? attrs.list : void 0;
+    const indent = typeof attrs.indent === "number" ? attrs.indent : 0;
+    if (listType) {
+      if (listType !== lastListType || indent !== lastIndent) {
+        orderedListIndex = 0;
+      }
+      if (listType === "ordered") {
+        orderedListIndex++;
+      }
+    } else {
+      lastListType = null;
+      orderedListIndex = 0;
+    }
+    const content = renderLineContent2(
+      line.ops,
+      embedRenderers,
+      false,
+      useLatexDelimiters,
+      blockHandlers,
+      prettyHtml,
+      registry
+    );
+    if (!content && !hasBlockFormat(attrs)) {
+      result.push(preserveEmptyLines ? "<br>" : "");
+      lastWasBlockquote = false;
+      continue;
+    }
+    const markdown = renderBlockFormat(content, attrs, orderedListIndex, strict);
+    result.push(markdown);
+    if (/^<img\s/.test(content) && !hasBlockFormat(attrs)) {
+      result.push("");
+    }
+    lastListType = listType ?? null;
+    lastIndent = indent;
+    lastWasBlockquote = isBlockquote;
+  }
+  return result.join("\n");
+}
+function hasBlockFormat(attrs) {
+  return !!(attrs.header || attrs.list || attrs.blockquote || attrs["code-block"] || attrs.align || attrs.indent);
+}
+function splitIntoLines2(ops) {
+  const lines = [];
+  let currentOps = [];
+  for (const op of ops) {
+    if (!isInsert3(op)) continue;
+    const opAttrs = op.attributes ?? {};
+    if (isTextInsert2(op)) {
+      const text = op.insert;
+      const parts = text.split("\n");
+      for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (part === void 0) continue;
+        if (part.length > 0) {
+          const newOp = { insert: part };
+          const inlineAttrs = {};
+          for (const [key, value] of Object.entries(opAttrs)) {
+            if (![
+              "header",
+              "blockquote",
+              "code-block",
+              "list",
+              "indent",
+              "align",
+              "direction",
+              "table-row",
+              "table-col",
+              "table-header",
+              "table-col-align"
+            ].includes(key)) {
+              inlineAttrs[key] = value;
+            }
+          }
+          if (Object.keys(inlineAttrs).length > 0) {
+            newOp.attributes = inlineAttrs;
+          }
+          currentOps.push(newOp);
+        }
+        if (i < parts.length - 1) {
+          lines.push({
+            ops: currentOps,
+            attributes: opAttrs
+            // Line attributes come from the \n op
+          });
+          currentOps = [];
+        }
+      }
+    } else {
+      currentOps.push(op);
+    }
+  }
+  if (currentOps.length > 0) {
+    lines.push({ ops: currentOps, attributes: {} });
+  }
+  return lines;
+}
+function collectCodeBlock(lines, startIndex) {
+  const codeLines = [];
+  const startLine = lines[startIndex];
+  if (!startLine) return codeLines;
+  const startLang = getCodeBlockLanguage2(startLine.attributes);
+  for (let i = startIndex; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line || !line.attributes["code-block"]) break;
+    const lang = getCodeBlockLanguage2(line.attributes);
+    if (i > startIndex && lang !== startLang) break;
+    codeLines.push(line);
+  }
+  return codeLines;
+}
+function collectTableLines2(lines, startIndex) {
+  const result = [];
+  for (let i = startIndex; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line || typeof line.attributes["table-row"] !== "number" || typeof line.attributes["table-col"] !== "number") {
+      break;
+    }
+    result.push(line);
+  }
+  return result;
+}
+function renderMarkdownTable(tableLines, embedRenderers, useLatexDelimiters = false, registry) {
+  const rows = /* @__PURE__ */ new Map();
+  for (const line of tableLines) {
+    const attrs = line.attributes;
+    const rowIdx = attrs["table-row"];
+    const colIdx = attrs["table-col"];
+    if (!rows.has(rowIdx)) {
+      rows.set(rowIdx, { isHeader: !!attrs["table-header"], cells: /* @__PURE__ */ new Map() });
+    }
+    const row = rows.get(rowIdx);
+    if (attrs["table-header"]) row.isHeader = true;
+    row.cells.set(colIdx, {
+      ops: line.ops,
+      colAlign: typeof attrs["table-col-align"] === "string" ? attrs["table-col-align"] : void 0
+    });
+  }
+  const sortedRows = [...rows.entries()].sort((a, b) => a[0] - b[0]);
+  let maxCol = 0;
+  for (const [, row] of sortedRows) {
+    for (const colIdx of row.cells.keys()) {
+      if (colIdx > maxCol) maxCol = colIdx;
+    }
+  }
+  const headerRows = sortedRows.filter(([, r]) => r.isHeader);
+  const bodyRows = sortedRows.filter(([, r]) => !r.isHeader);
+  const colAligns = [];
+  const alignSource = headerRows.length > 0 ? headerRows : bodyRows;
+  if (alignSource.length > 0) {
+    const firstRow = alignSource[0];
+    for (let col = 0; col <= maxCol; col++) {
+      const cell = firstRow[1].cells.get(col);
+      colAligns.push(cell?.colAlign);
+    }
+  }
+  const mdLines = [];
+  if (headerRows.length > 0) {
+    for (const [, row] of headerRows) {
+      mdLines.push(renderMdRow(row.cells, maxCol, embedRenderers, useLatexDelimiters, registry));
+    }
+    mdLines.push(renderMdSeparator(maxCol, colAligns));
+  } else {
+    const emptyRow = /* @__PURE__ */ new Map();
+    for (let col = 0; col <= maxCol; col++) {
+      emptyRow.set(col, { ops: [] });
+    }
+    mdLines.push(renderMdRow(emptyRow, maxCol, embedRenderers, useLatexDelimiters, registry));
+    mdLines.push(renderMdSeparator(maxCol, colAligns));
+  }
+  for (const [, row] of bodyRows) {
+    mdLines.push(renderMdRow(row.cells, maxCol, embedRenderers, useLatexDelimiters, registry));
+  }
+  return mdLines.join("\n");
+}
+function renderMdRow(cells, maxCol, embedRenderers, useLatexDelimiters = false, registry) {
+  const parts = [];
+  for (let col = 0; col <= maxCol; col++) {
+    const cell = cells.get(col);
+    const content = cell ? renderLineContent2(
+      cell.ops,
+      embedRenderers,
+      false,
+      useLatexDelimiters,
+      void 0,
+      false,
+      registry
+    ) : "";
+    parts.push(content.replace(/\|/g, "\\|"));
+  }
+  return "| " + parts.join(" | ") + " |";
+}
+function renderMdSeparator(maxCol, colAligns) {
+  const parts = [];
+  for (let col = 0; col <= maxCol; col++) {
+    const align = colAligns[col];
+    if (align === "center") {
+      parts.push(":---:");
+    } else if (align === "right") {
+      parts.push("---:");
+    } else if (align === "left") {
+      parts.push(":---");
+    } else {
+      parts.push("---");
+    }
+  }
+  return "| " + parts.join(" | ") + " |";
+}
+function getCodeBlockLanguage2(attributes) {
+  const codeBlock = attributes["code-block"];
+  if (typeof codeBlock === "string" && codeBlock !== "true") {
+    return codeBlock;
+  }
+  return void 0;
+}
+function renderLineContent2(ops, embedRenderers, inCodeBlock, useLatexDelimiters = false, blockHandlers, prettyHtml = false, registry) {
+  let result = "";
+  for (const op of ops) {
+    const attrs = op.attributes;
+    if (isTextInsert2(op)) {
+      const text = op.insert;
+      if (inCodeBlock) {
+        result += text;
+      } else {
+        result += renderInlineText2(text, attrs);
+      }
+    } else if (isEmbedInsert3(op)) {
+      const embed = op.insert;
+      result += renderEmbed2(
+        embed,
+        attrs,
+        embedRenderers,
+        useLatexDelimiters,
+        blockHandlers,
+        prettyHtml,
+        registry
+      );
+    }
+  }
+  return result;
+}
+function renderInlineText2(text, attributes) {
+  if (!attributes || Object.keys(attributes).length === 0) {
+    return escapeMarkdown(text);
+  }
+  const link = typeof attributes.link === "string" ? attributes.link : void 0;
+  let result = attributes.code ? text : escapeMarkdown(text);
+  for (let i = MD_INLINE_FORMAT_ORDER.length - 1; i >= 0; i--) {
+    const format = MD_INLINE_FORMAT_ORDER[i];
+    if (!format || !attributes[format]) continue;
+    const syntax = INLINE_FORMAT_SYNTAX[format];
+    if (syntax) {
+      result = `${syntax.prefix}${result}${syntax.suffix}`;
+    }
+  }
+  if (link) {
+    result = renderLink(result, link);
+  }
+  if (typeof attributes.color === "string") {
+    result = `<span style="color: ${attributes.color}">${result}</span>`;
+  }
+  if (typeof attributes.background === "string") {
+    result = `<span style="background-color: ${attributes.background}">${result}</span>`;
+  }
+  return result;
+}
+function renderEmbed2(embed, attributes, customRenderers, useLatexDelimiters = false, blockHandlers, prettyHtml = false, registry) {
+  const entries = Object.entries(embed);
+  if (entries.length === 0) return "";
+  const firstEntry = entries[0];
+  if (!firstEntry) return "";
+  const embedType = firstEntry[0];
+  const embedValue = firstEntry[1];
+  if (embedType === "block" && blockHandlers) {
+    const blockData = embedValue;
+    if (blockData && typeof blockData.type === "string") {
+      const handler = blockHandlers.get(blockData.type);
+      if (handler) {
+        const opAttrs = attributes ? { opAttributes: attributes } : {};
+        if (handler.toMarkdown) {
+          const mdContext = {
+            registry: void 0,
+            renderDelta: (ops) => deltaToMarkdown(new Delta9(ops), { blockHandlers }),
+            ...opAttrs
+          };
+          const md = handler.toMarkdown(blockData, mdContext);
+          if (md !== null) return md;
+        }
+        const htmlContext = {
+          registry: void 0,
+          ...prettyHtml ? { options: { pretty: true } } : {},
+          renderDelta: (ops) => deltaToHtml(new Delta9(ops), { blockHandlers, pretty: prettyHtml }),
+          ...opAttrs
+        };
+        return "\n" + handler.toHtml(blockData, htmlContext) + "\n";
+      }
+    }
+    return "";
+  }
+  const customRenderer = customRenderers[embedType];
+  if (customRenderer) {
+    return customRenderer(embedValue, attributes);
+  }
+  if (registry) {
+    const format = registry.get(embedType);
+    if (format) {
+      if (format.toMarkdown) {
+        const md = format.toMarkdown(embedValue, attributes);
+        if (md !== null) return md;
+      }
+      if (format.render) {
+        return format.render(embedValue, attributes);
+      }
+    }
+  }
+  if (embedType === "image") {
+    const src = typeof embedValue === "string" ? embedValue : "";
+    const alt = typeof attributes?.alt === "string" ? attributes.alt : void 0;
+    const hasFloat = attributes?.float != null && typeof attributes.float === "string" && attributes.float !== "none";
+    const hasWidth = attributes?.width != null;
+    const hasHeight = attributes?.height != null;
+    if (hasFloat || hasWidth || hasHeight) {
+      const altAttr = alt ? ` alt="${escapeHtml(alt)}"` : "";
+      const floatAttr = hasFloat ? ` data-float="${escapeHtml(String(attributes.float))}"` : "";
+      const widthAttr = hasWidth ? ` width="${escapeHtml(String(attributes.width))}"` : "";
+      const heightAttr = hasHeight ? ` height="${escapeHtml(String(attributes.height))}"` : "";
+      return `<img src="${escapeHtml(src)}"${altAttr}${floatAttr}${widthAttr}${heightAttr}>`;
+    }
+    return renderImage(src, alt);
+  }
+  if (embedType === "video") {
+    const src = typeof embedValue === "string" ? embedValue : "";
+    const hasFloat = attributes?.float != null && typeof attributes.float === "string" && attributes.float !== "none";
+    const hasWidth = attributes?.width != null;
+    const hasHeight = attributes?.height != null;
+    if (hasFloat || hasWidth || hasHeight) {
+      const floatAttr = hasFloat ? ` data-float="${escapeHtml(String(attributes.float))}"` : "";
+      const styles = [];
+      if (hasWidth) {
+        const w = typeof attributes.width === "string" || typeof attributes.width === "number" ? String(attributes.width) : "";
+        if (w && w !== "auto") styles.push(`width: ${/^\d+$/.test(w) ? w + "px" : w}`);
+      }
+      if (hasHeight) {
+        const h = typeof attributes.height === "string" || typeof attributes.height === "number" ? String(attributes.height) : "";
+        if (h && h !== "auto") styles.push(`height: ${/^\d+$/.test(h) ? h + "px" : h}`);
+      }
+      const styleAttr = styles.length > 0 ? ` style="${styles.join("; ")}"` : "";
+      const embedSrc = toVideoEmbedUrl(src);
+      if (embedSrc) {
+        return `<iframe src="${escapeHtml(embedSrc)}" frameborder="0" allowfullscreen${floatAttr}${styleAttr}></iframe>`;
+      }
+      return `<video src="${escapeHtml(src)}" controls${floatAttr}${styleAttr}></video>`;
+    }
+    return `![Video](${src})`;
+  }
+  if (embedType === "formula") {
+    const latex = typeof embedValue === "string" ? embedValue : "";
+    return useLatexDelimiters ? `\\(${latex}\\)` : `$${latex}$`;
+  }
+  if (embedType === "diagram") {
+    const source = typeof embedValue === "string" ? embedValue : "";
+    const lang = source.trimStart().startsWith("@startuml") ? "plantuml" : "mermaid";
+    return `
+\`\`\`${lang}
+${source}
+\`\`\`
+`;
+  }
+  if (embedType === "drawio") {
+    const src = typeof embedValue === "string" ? embedValue : "";
+    const alt = typeof attributes?.alt === "string" ? attributes.alt : void 0;
+    return renderImage(src, alt);
+  }
+  if (embedType === "footnote-ref") {
+    const id = typeof embedValue === "string" ? embedValue : String(embedValue);
+    return `[^${id}]`;
+  }
+  if (embedType === "divider") {
+    return "\n---\n";
+  }
+  return "";
+}
+function renderBlockFormat(content, attributes, orderedIndex, _strict) {
+  const indent = typeof attributes.indent === "number" ? attributes.indent : 0;
+  const indentPrefix = getIndentPrefix(indent);
+  const header = typeof attributes.header === "number" ? attributes.header : void 0;
+  if (header) {
+    const prefixFn = BLOCK_FORMAT_PREFIX.header;
+    if (typeof prefixFn === "function") {
+      let line = prefixFn(header) + content;
+      const headerId = attributes["header-id"];
+      if (typeof headerId === "string" && headerId.length > 0) {
+        line += ` {#${headerId}}`;
+      }
+      return line;
+    }
+  }
+  if (attributes.blockquote) {
+    return "> " + content;
+  }
+  const listType = typeof attributes.list === "string" ? attributes.list : void 0;
+  if (listType) {
+    const prefixDef = LIST_TYPE_PREFIX[listType];
+    let prefix;
+    if (typeof prefixDef === "function") {
+      prefix = prefixDef(orderedIndex - 1);
+    } else if (prefixDef) {
+      prefix = prefixDef;
+    } else {
+      prefix = "- ";
+    }
+    return indentPrefix + prefix + content;
+  }
+  return content;
+}
+
+// src/conversion/markdown/markdown-to-delta.ts
+import { Delta as Delta10 } from "@scrider/delta";
+var remarkParse = null;
+var remarkGfm = null;
+var remarkMath = null;
+var unified = null;
+function isRemarkAvailable() {
+  try {
+    __require.resolve("unified");
+    __require.resolve("remark-parse");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadRemark() {
+  if (unified) return;
+  try {
+    const [unifiedMod, remarkParseMod, remarkGfmMod] = await Promise.all([
+      import("unified"),
+      import("remark-parse"),
+      import("remark-gfm")
+    ]);
+    unified = unifiedMod.unified;
+    remarkParse = remarkParseMod.default;
+    remarkGfm = remarkGfmMod.default;
+  } catch {
+    throw new Error(
+      "remark is not installed. Install with: pnpm add unified remark-parse remark-gfm"
+    );
+  }
+  try {
+    const remarkMathMod = await import("remark-math");
+    remarkMath = remarkMathMod.default;
+  } catch {
+  }
+}
+function preprocessMarkdown(markdown, mathBlock) {
+  markdown = markdown.replace(/\\\((.+?)\\\)/g, (_match, content) => `$${content}$`);
+  markdown = markdown.replace(/\\\[([\s\S]+?)\\\]/g, (_match, content) => `$$${content}$$`);
+  if (mathBlock) {
+    markdown = markdown.replace(
+      /^\$([^$\n]+)\$\s*$/gm,
+      (_match, content) => `$$
+${content}
+$$`
+    );
+  }
+  return markdown.replace(/^<br\s*\/?>$/gim, "\n<!--empty-line-->\n");
+}
+async function markdownToDelta(markdown, options = {}) {
+  const {
+    gfm = true,
+    mathBlock = true,
+    mermaidBlock = true,
+    plantumlBlock = true,
+    nodeHandlers = {}
+  } = options;
+  markdown = preprocessMarkdown(markdown, mathBlock);
+  await loadRemark();
+  if (!unified || !remarkParse) {
+    throw new Error("Failed to load remark");
+  }
+  let processor = unified().use(remarkParse);
+  if (gfm && remarkGfm) {
+    processor = processor.use(remarkGfm);
+  }
+  if (remarkMath) {
+    processor = processor.use(remarkMath);
+  }
+  const tree = processor.parse(markdown);
+  return astToDelta(
+    tree,
+    nodeHandlers,
+    mathBlock,
+    mermaidBlock,
+    plantumlBlock,
+    options.blockHandlers
+  );
+}
+function markdownToDeltaSync(markdown, options = {}) {
+  const {
+    gfm = true,
+    mathBlock = true,
+    mermaidBlock = true,
+    plantumlBlock = true,
+    nodeHandlers = {}
+  } = options;
+  markdown = preprocessMarkdown(markdown, mathBlock);
+  if (!unified || !remarkParse) {
+    try {
+      const unifiedMod = __require("unified");
+      const remarkParseMod = __require("remark-parse");
+      const remarkGfmMod = __require("remark-gfm");
+      unified = unifiedMod.unified;
+      remarkParse = remarkParseMod.default;
+      remarkGfm = remarkGfmMod.default;
+    } catch {
+      throw new Error(
+        "remark is not installed. Install with: pnpm add unified remark-parse remark-gfm"
+      );
+    }
+    if (!remarkMath) {
+      try {
+        const remarkMathMod = __require("remark-math");
+        remarkMath = remarkMathMod.default;
+      } catch {
+      }
+    }
+  }
+  let processor = unified().use(remarkParse);
+  if (gfm && remarkGfm) {
+    processor = processor.use(remarkGfm);
+  }
+  if (remarkMath) {
+    processor = processor.use(remarkMath);
+  }
+  const tree = processor.parse(markdown);
+  return astToDelta(
+    tree,
+    nodeHandlers,
+    mathBlock,
+    mermaidBlock,
+    plantumlBlock,
+    options.blockHandlers
+  );
+}
+function astToDelta(tree, customHandlers, mathBlock, mermaidBlock, plantumlBlock, blockHandlers) {
+  const delta = new Delta10();
+  let currentInlineAttrs = {};
+  let pendingText = "";
+  const spanAttrStack = [];
+  const footnoteDefinitions = /* @__PURE__ */ new Map();
+  const context = {
+    delta,
+    pushText(text, attrs) {
+      if (attrs && Object.keys(attrs).length > 0) {
+        if (pendingText) {
+          if (Object.keys(currentInlineAttrs).length > 0) {
+            delta.insert(pendingText, currentInlineAttrs);
+          } else {
+            delta.insert(pendingText);
+          }
+          pendingText = "";
+        }
+        delta.insert(text, { ...currentInlineAttrs, ...attrs });
+      } else {
+        pendingText += text;
+      }
+    },
+    pushEmbed(embed, attrs) {
+      if (pendingText) {
+        if (Object.keys(currentInlineAttrs).length > 0) {
+          delta.insert(pendingText, currentInlineAttrs);
+        } else {
+          delta.insert(pendingText);
+        }
+        pendingText = "";
+      }
+      if (attrs && Object.keys(attrs).length > 0) {
+        delta.insert(embed, attrs);
+      } else {
+        delta.insert(embed);
+      }
+    },
+    pushNewline(attrs) {
+      if (pendingText) {
+        if (Object.keys(currentInlineAttrs).length > 0) {
+          delta.insert(pendingText, currentInlineAttrs);
+        } else {
+          delta.insert(pendingText);
+        }
+        pendingText = "";
+      }
+      if (attrs && Object.keys(attrs).length > 0) {
+        delta.insert("\n", attrs);
+      } else {
+        delta.insert("\n");
+      }
+    }
+  };
+  const HEADING_ID_RE = /\s*\{#([\w-]+)\}\s*$/;
+  function extractHeadingId(heading) {
+    const children = heading.children;
+    if (!children || children.length === 0) return null;
+    const lastChild = children[children.length - 1];
+    if (!lastChild || lastChild.type !== "text" || !lastChild.value) return null;
+    const match = lastChild.value.match(HEADING_ID_RE);
+    if (!match) return null;
+    lastChild.value = lastChild.value.replace(HEADING_ID_RE, "");
+    return match[1];
+  }
+  const ALERT_TYPE_RE = /^\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\]\s*$/i;
+  function extractAlertType(blockquote) {
+    const bqChildren = blockquote.children;
+    if (!bqChildren || bqChildren.length === 0) return null;
+    const firstChild = bqChildren[0];
+    if (!firstChild || firstChild.type !== "paragraph") return null;
+    const paraChildren = firstChild.children;
+    if (!paraChildren || paraChildren.length === 0) return null;
+    const firstInline = paraChildren[0];
+    if (!firstInline || firstInline.type !== "text" || !firstInline.value) return null;
+    const firstLine = firstInline.value.split("\n")[0] ?? "";
+    const match = ALERT_TYPE_RE.exec(firstLine.trim());
+    if (!match || !match[1]) return null;
+    return match[1].toLowerCase();
+  }
+  function processAlertBlockquote(blockquote, alertType) {
+    const children = [...blockquote.children || []];
+    const first = children[0];
+    if (first && first.type === "paragraph" && first.children) {
+      const firstPara = { ...first, children: [...first.children] };
+      const firstInline = firstPara.children[0];
+      if (firstInline && firstInline.type === "text" && firstInline.value) {
+        const lines = firstInline.value.split("\n");
+        lines.shift();
+        const remaining = lines.join("\n");
+        if (remaining.trim().length > 0) {
+          firstPara.children[0] = { ...firstInline, value: remaining };
+        } else {
+          firstPara.children.shift();
+        }
+        if (firstPara.children.length === 0) {
+          children.shift();
+        } else {
+          children[0] = firstPara;
+        }
+      }
+    }
+    const syntheticRoot = {
+      type: "root",
+      children
+    };
+    const contentDelta = astToDelta(
+      syntheticRoot,
+      customHandlers,
+      mathBlock,
+      mermaidBlock,
+      plantumlBlock,
+      blockHandlers
+    );
+    context.pushEmbed({
+      block: {
+        type: "alert",
+        alertType,
+        content: { ops: contentDelta.ops }
+      }
+    });
+    context.pushNewline();
+  }
+  function processNode(node, blockAttrs = {}) {
+    const customHandler = customHandlers[node.type];
+    if (customHandler) {
+      customHandler(node, context);
+      return;
+    }
+    switch (node.type) {
+      case "root":
+        processChildren(node, blockAttrs);
+        break;
+      case "paragraph":
+        processChildren(node, blockAttrs);
+        context.pushNewline(blockAttrs);
+        break;
+      case "heading": {
+        const headerId = extractHeadingId(node);
+        processChildren(node, {});
+        const headerAttrs = { header: node.depth ?? 1 };
+        if (headerId) {
+          headerAttrs["header-id"] = headerId;
+        }
+        context.pushNewline(headerAttrs);
+        break;
+      }
+      case "blockquote": {
+        const alertType = extractAlertType(node);
+        if (alertType) {
+          processAlertBlockquote(node, alertType);
+        } else {
+          processChildren(node, { blockquote: true });
+        }
+        break;
+      }
+      case "list":
+        processList(node);
+        break;
+      case "listItem":
+        break;
+      case "code":
+        processCodeBlock(node);
+        break;
+      case "table":
+        processTable(node);
+        break;
+      case "tableRow":
+      case "tableCell":
+        break;
+      case "thematicBreak":
+        context.pushEmbed({ divider: true });
+        context.pushNewline();
+        break;
+      case "text":
+        context.pushText(node.value ?? "");
+        break;
+      case "strong":
+        processInline(node, { bold: true });
+        break;
+      case "emphasis":
+        processInline(node, { italic: true });
+        break;
+      case "delete":
+        processInline(node, { strike: true });
+        break;
+      case "inlineCode":
+        context.pushText(node.value ?? "", { code: true });
+        break;
+      case "link":
+        processLink(node);
+        break;
+      case "image":
+        processImage(node);
+        break;
+      case "inlineMath":
+        context.pushEmbed({ formula: node.value ?? "" });
+        break;
+      case "math":
+        processMathBlock(node);
+        break;
+      case "footnoteReference":
+        context.pushEmbed({ "footnote-ref": node.identifier ?? "" });
+        break;
+      case "footnoteDefinition":
+        footnoteDefinitions.set(node.identifier ?? "", node);
+        break;
+      case "break":
+        context.pushNewline();
+        break;
+      case "html": {
+        const htmlContent = node.value ?? "";
+        if (isBlockLevelHtml(htmlContent)) {
+          processBlockHtml(htmlContent);
+        } else {
+          processInlineHtml(node);
+        }
+        break;
+      }
+      default:
+        if (node.children) {
+          processChildren(node, blockAttrs);
+        }
+    }
+  }
+  function processChildren(node, blockAttrs) {
+    if (!node.children) return;
+    for (const child of node.children) {
+      processNode(child, blockAttrs);
+    }
+  }
+  function processInline(node, attrs) {
+    const prevAttrs = { ...currentInlineAttrs };
+    if (pendingText) {
+      if (Object.keys(currentInlineAttrs).length > 0) {
+        delta.insert(pendingText, currentInlineAttrs);
+      } else {
+        delta.insert(pendingText);
+      }
+      pendingText = "";
+    }
+    currentInlineAttrs = { ...currentInlineAttrs, ...attrs };
+    if (node.children) {
+      for (const child of node.children) {
+        processNode(child);
+      }
+    }
+    if (pendingText) {
+      if (Object.keys(currentInlineAttrs).length > 0) {
+        delta.insert(pendingText, currentInlineAttrs);
+      } else {
+        delta.insert(pendingText);
+      }
+      pendingText = "";
+    }
+    currentInlineAttrs = prevAttrs;
+  }
+  function processLink(node) {
+    processInline(node, { link: node.url ?? "" });
+  }
+  function processImage(node) {
+    const url = node.url ?? "";
+    const alt = node.alt ?? "";
+    if (alt.toLowerCase() === "video") {
+      context.pushEmbed({ video: url });
+      return;
+    }
+    const attrs = {};
+    if (node.alt) attrs.alt = node.alt;
+    if (url.toLowerCase().endsWith(".drawio")) {
+      context.pushEmbed({ drawio: url }, Object.keys(attrs).length > 0 ? attrs : void 0);
+    } else {
+      context.pushEmbed({ image: url }, Object.keys(attrs).length > 0 ? attrs : void 0);
+    }
+  }
+  function processList(node, indent = 0) {
+    if (!node.children) return;
+    const ordered = node.ordered ?? false;
+    for (const item of node.children) {
+      if (item.type !== "listItem") continue;
+      let listType;
+      if (item.checked === true) {
+        listType = "checked";
+      } else if (item.checked === false) {
+        listType = "unchecked";
+      } else {
+        listType = ordered ? "ordered" : "bullet";
+      }
+      const blockAttrs = { list: listType };
+      if (indent > 0) {
+        blockAttrs.indent = indent;
+      }
+      if (item.children) {
+        for (const child of item.children) {
+          if (child.type === "list") {
+            processList(child, indent + 1);
+          } else if (child.type === "paragraph") {
+            processChildren(child, {});
+            context.pushNewline(blockAttrs);
+          } else {
+            processNode(child, blockAttrs);
+          }
+        }
+      }
+    }
+  }
+  function processCodeBlock(node) {
+    const code = node.value ?? "";
+    const lang = node.lang;
+    if (lang === "mermaid" && mermaidBlock === false) {
+      context.pushEmbed({ diagram: code });
+      context.pushNewline();
+      return;
+    }
+    if (lang === "plantuml" && plantumlBlock === false) {
+      context.pushEmbed({ diagram: code });
+      context.pushNewline();
+      return;
+    }
+    const lines = code.split("\n");
+    const codeBlockAttr = {
+      "code-block": lang ?? true
+    };
+    for (const line of lines) {
+      context.pushText(line);
+      context.pushNewline(codeBlockAttr);
+    }
+  }
+  function processMathBlock(node) {
+    const value = node.value ?? "";
+    if (mathBlock === false) {
+      context.pushEmbed({ formula: value });
+      context.pushNewline();
+    } else {
+      const lines = value.split("\n");
+      const mathBlockAttr = { "code-block": "math" };
+      for (const line of lines) {
+        context.pushText(line);
+        context.pushNewline(mathBlockAttr);
+      }
+    }
+  }
+  function processTable(node) {
+    if (!node.children) return;
+    const aligns = node.align || [];
+    for (let rowIdx = 0; rowIdx < node.children.length; rowIdx++) {
+      const rowNode = node.children[rowIdx];
+      if (!rowNode || rowNode.type !== "tableRow") continue;
+      const isHeader = rowIdx === 0;
+      if (!rowNode.children) continue;
+      for (let colIdx = 0; colIdx < rowNode.children.length; colIdx++) {
+        const cellNode = rowNode.children[colIdx];
+        if (!cellNode || cellNode.type !== "tableCell") continue;
+        const cellBlockAttrs = {
+          "table-row": rowIdx,
+          "table-col": colIdx
+        };
+        if (isHeader) {
+          cellBlockAttrs["table-header"] = true;
+        }
+        const colAlign = aligns[colIdx];
+        if (colAlign) {
+          cellBlockAttrs["table-col-align"] = colAlign;
+        }
+        if (cellNode.children) {
+          for (const child of cellNode.children) {
+            processNode(child);
+          }
+        }
+        context.pushNewline(cellBlockAttrs);
+      }
+    }
+  }
+  function isBlockLevelHtml(html) {
+    return /^\s*<(div|table|section|article|aside|nav|header|footer|figure|pre|hr|ol|ul|dl|details|iframe|video)\b/i.test(
+      html
+    );
+  }
+  function processBlockHtml(html) {
+    flushInlineText();
+    const blockDelta = htmlToDelta(html, blockHandlers ? { blockHandlers } : {});
+    for (const op of blockDelta.ops) {
+      delta.push(op);
+    }
+  }
+  function flushInlineText() {
+    if (pendingText) {
+      if (Object.keys(currentInlineAttrs).length > 0) {
+        delta.insert(pendingText, currentInlineAttrs);
+      } else {
+        delta.insert(pendingText);
+      }
+      pendingText = "";
+    }
+  }
+  function tagToInlineAttr(tag) {
+    switch (tag) {
+      case "u":
+      case "ins":
+        return ["underline", true];
+      case "sub":
+        return ["subscript", true];
+      case "sup":
+        return ["superscript", true];
+      case "mark":
+        return ["mark", true];
+      case "kbd":
+        return ["kbd", true];
+      case "b":
+      case "strong":
+        return ["bold", true];
+      case "i":
+      case "em":
+        return ["italic", true];
+      case "s":
+      case "del":
+      case "strike":
+        return ["strike", true];
+      default:
+        return null;
+    }
+  }
+  function processInlineHtml(node) {
+    const html = (node.value ?? "").trim();
+    const openTagMatch = html.match(/^<(u|ins|sub|sup|mark|kbd|b|strong|i|em|s|del|strike)>$/i);
+    if (openTagMatch) {
+      const tag = openTagMatch[1]?.toLowerCase() ?? "";
+      flushInlineText();
+      const attr = tagToInlineAttr(tag);
+      if (attr) {
+        currentInlineAttrs = { ...currentInlineAttrs, [attr[0]]: attr[1] };
+      }
+      return;
+    }
+    const closeTagMatch = html.match(/^<\/(u|ins|sub|sup|mark|kbd|b|strong|i|em|s|del|strike)>$/i);
+    if (closeTagMatch) {
+      const tag = closeTagMatch[1]?.toLowerCase() ?? "";
+      flushInlineText();
+      const attr = tagToInlineAttr(tag);
+      if (attr) {
+        const newAttrs = { ...currentInlineAttrs };
+        delete newAttrs[attr[0]];
+        currentInlineAttrs = newAttrs;
+      }
+      return;
+    }
+    const spanMatch = html.match(/^<span\s+style="([^"]*)">/i);
+    if (spanMatch) {
+      flushInlineText();
+      const style = spanMatch[1] ?? "";
+      const addedKeys = [];
+      const colorMatch = style.match(/(?:^|;)\s*color\s*:\s*([^;]+)/i);
+      if (colorMatch) {
+        currentInlineAttrs = { ...currentInlineAttrs, color: colorMatch[1].trim() };
+        addedKeys.push("color");
+      }
+      const bgMatch = style.match(/(?:^|;)\s*background(?:-color)?\s*:\s*([^;]+)/i);
+      if (bgMatch) {
+        currentInlineAttrs = { ...currentInlineAttrs, background: bgMatch[1].trim() };
+        addedKeys.push("background");
+      }
+      spanAttrStack.push(addedKeys);
+      return;
+    }
+    if (/^<\/span>$/i.test(html)) {
+      flushInlineText();
+      const keys = spanAttrStack.pop();
+      if (keys) {
+        const newAttrs = { ...currentInlineAttrs };
+        for (const key of keys) delete newAttrs[key];
+        currentInlineAttrs = newAttrs;
+      }
+      return;
+    }
+    const imgMatch = html.match(/^<img\s+([^>]*)\/?>$/i);
+    if (imgMatch) {
+      const attrStr = imgMatch[1] ?? "";
+      const srcMatch = attrStr.match(/src="([^"]*)"/);
+      if (srcMatch) {
+        flushInlineText();
+        const attrs = {};
+        const altMatch = attrStr.match(/alt="([^"]*)"/);
+        const floatMatch = attrStr.match(/data-float="([^"]*)"/);
+        const widthMatch = attrStr.match(/width="([^"]*)"/);
+        const heightMatch = attrStr.match(/height="([^"]*)"/);
+        if (altMatch?.[1]) attrs.alt = altMatch[1];
+        if (floatMatch?.[1]) attrs.float = floatMatch[1];
+        if (widthMatch?.[1]) attrs.width = parseInt(widthMatch[1], 10) || widthMatch[1];
+        if (heightMatch?.[1]) attrs.height = parseInt(heightMatch[1], 10) || heightMatch[1];
+        context.pushEmbed(
+          { image: srcMatch[1] },
+          Object.keys(attrs).length > 0 ? attrs : void 0
+        );
+        context.pushNewline();
+      }
+      return;
+    }
+    if (html.trim() === "<!--empty-line-->") {
+      context.pushNewline();
+      return;
+    }
+    if (/^<br\s*\/?>$/i.test(html)) {
+      context.pushNewline();
+      return;
+    }
+  }
+  processNode(tree);
+  if (footnoteDefinitions.size > 0) {
+    const notes = {};
+    for (const [id, defNode] of footnoteDefinitions) {
+      const syntheticRoot = {
+        type: "root",
+        children: defNode.children || []
+      };
+      const defDelta = astToDelta(
+        syntheticRoot,
+        customHandlers,
+        mathBlock,
+        mermaidBlock,
+        plantumlBlock,
+        blockHandlers
+      );
+      notes[id] = { ops: defDelta.ops };
+    }
+    context.pushEmbed({ block: { type: "footnotes", notes } });
+    context.pushNewline();
+  }
+  if (delta.ops.length > 0) {
+    const lastOp = delta.ops[delta.ops.length - 1];
+    if (lastOp && "insert" in lastOp) {
+      const lastInsert = lastOp.insert;
+      if (typeof lastInsert !== "string" || !lastInsert.endsWith("\n")) {
+        delta.insert("\n");
+      }
+    }
+  }
+  return delta;
+}
+export {
+  ALERT_TYPES,
+  BOX_FLOAT_VALUES,
+  BOX_OVERFLOW_VALUES,
+  BlockHandlerRegistry,
+  BrowserDOMAdapter,
+  NODE_TYPE,
+  NodeDOMAdapter,
+  Registry,
+  alertBlockHandler,
+  alignFormat,
+  backgroundFormat,
+  blockFormat,
+  blockquoteFormat,
+  boldFormat,
+  boxBlockHandler,
+  browserAdapter,
+  cloneDelta,
+  codeBlockFormat,
+  codeFormat,
+  colorFormat,
+  columnsBlockHandler,
+  createDefaultBlockHandlers,
+  createDefaultRegistry,
+  defaultBlockFormats,
+  defaultEmbedFormats,
+  defaultFormats,
+  defaultInlineFormats,
+  deltaToHtml,
+  deltaToMarkdown,
+  dividerFormat,
+  escapeHtml,
+  extractBoxOpAttributes,
+  footnoteRefFormat,
+  footnotesBlockHandler,
+  formulaFormat,
+  getAdapter,
+  getNamedColors,
+  headerFormat,
+  headerIdFormat,
+  htmlToDelta,
+  imageFormat,
+  indentFormat,
+  isAdapterAvailable,
+  isElement,
+  isRemarkAvailable,
+  isTextNode,
+  isValidColor,
+  isValidHexColor,
+  italicFormat,
+  kbdFormat,
+  linkFormat,
+  listFormat,
+  markFormat,
+  markdownToDelta,
+  markdownToDeltaSync,
+  nodeAdapter,
+  normalizeDelta,
+  sanitizeDelta,
+  slugify,
+  slugifyWithDedup,
+  strikeFormat,
+  subscriptFormat,
+  superscriptFormat,
+  tableBlockHandler,
+  tableColAlignFormat,
+  tableColFormat,
+  tableHeaderFormat,
+  tableRowFormat,
+  toHexColor,
+  underlineFormat,
+  unescapeHtml,
+  validateDelta,
+  videoFormat
+};
+//# sourceMappingURL=index.js.map