{"version":3,"sources":["../src/common/default-block-attributes.ts","../src/common/utils/group-consecutive.ts","../src/common/transformers/block-merger.ts","../src/common/transformers/code-block-grouper.ts","../src/common/utils/node-queries.ts","../src/common/transformers/list-grouper.ts","../src/common/transformers/table-grouper.ts"],"names":["getListType","getIndent","getTableRow"],"mappings":"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","file":"chunk-PQC32O34.cjs","sourcesContent":["import type { BlockAttributeHandler } from '../core/ast-types';\n\n/**\n * Default block attribute handlers for standard Quill delta attributes.\n *\n * Each handler maps a Quill attribute name to an AST block type\n * and any attributes to carry over to the node.\n */\nexport const DEFAULT_BLOCK_ATTRIBUTES: Record = {\n header: (value) => ({\n blockType: 'header',\n blockAttrs: { header: value },\n }),\n\n blockquote: () => ({\n blockType: 'blockquote',\n blockAttrs: {},\n }),\n\n 'code-block': (value) => ({\n blockType: 'code-block',\n blockAttrs: { 'code-block': value },\n }),\n\n list: (value) => ({\n blockType: 'list-item',\n blockAttrs: { list: value },\n }),\n\n table: (value) => ({\n blockType: 'table-cell',\n blockAttrs: { table: value },\n }),\n\n // Passthrough attributes — keep on the block without changing its type\n align: (value) => ({\n blockType: '',\n blockAttrs: { align: value },\n }),\n\n direction: (value) => ({\n blockType: '',\n blockAttrs: { direction: value },\n }),\n\n indent: (value) => ({\n blockType: '',\n blockAttrs: { indent: value },\n }),\n};\n","/**\n * Groups consecutive elements in an array that satisfy a predicate.\n *\n * Returns a new array where consecutive elements matching the predicate\n * are collected into sub-arrays, and non-matching elements are left as-is.\n *\n * Ported from quill-delta-to-html's `groupConsecutiveElementsWhile`.\n *\n * @example\n * ```ts\n * groupConsecutiveElementsWhile(\n * [1, 'a', 'b', 2, 'c'],\n * (curr, prev) => typeof curr === typeof prev\n * );\n * // => [1, ['a', 'b'], 2, 'c']\n * ```\n */\nexport function groupConsecutiveElementsWhile(\n arr: T[],\n predicate: (curr: T, prev: T) => boolean,\n): Array {\n const groups: T[][] = [];\n\n for (let i = 0; i < arr.length; i++) {\n const curr = arr[i]!;\n\n if (i > 0 && predicate(curr, arr[i - 1]!)) {\n groups[groups.length - 1]!.push(curr);\n } else {\n groups.push([curr]);\n }\n }\n\n return groups.map((g) => (g.length === 1 ? g[0]! : g));\n}\n","import type { TNode, Transformer } from '../../core/ast-types';\nimport { groupConsecutiveElementsWhile } from '../utils/group-consecutive';\n\n// ─── Config ─────────────────────────────────────────────────────────────────\n\n/**\n * Configuration for the blockMerger transformer.\n *\n * Each flag controls whether consecutive blocks of that type\n * should be merged into a single block (with `
`-equivalent\n * newline separators between their inline children).\n *\n * Defaults match quill-delta-to-html behavior:\n * - blockquote: merged\n * - header: merged\n * - code-block: merged\n * - paragraph: merged\n */\nexport interface BlockMergerConfig {\n /** Merge consecutive blockquotes. Default: `true` */\n multiLineBlockquote?: boolean;\n /** Merge consecutive same-level headers. Default: `true` */\n multiLineHeader?: boolean;\n /** Merge consecutive same-language code blocks. Default: `true` */\n multiLineCodeblock?: boolean;\n /** Merge consecutive paragraphs (same indent/align/direction). Default: `true` */\n multiLineParagraph?: boolean;\n}\n\nconst DEFAULT_CONFIG: Required = {\n multiLineBlockquote: true,\n multiLineHeader: true,\n multiLineCodeblock: true,\n multiLineParagraph: true,\n};\n\n// ─── Merge Logic ────────────────────────────────────────────────────────────\n\n/**\n * Returns a `line-break` node used as a separator between merged blocks.\n * Renderers handle this as `
` (HTML), `\\n` (markdown), etc.\n */\nfunction createLineBreakNode(): TNode {\n return {\n type: 'line-break',\n attributes: {},\n children: [],\n isInline: true,\n };\n}\n\n/**\n * Returns a text `\\n` node used as a separator inside `
` blocks\n * where a literal newline is the correct visual break.\n */\nfunction createNewlineTextNode(): TNode {\n  return {\n    type: 'text',\n    attributes: {},\n    children: [],\n    data: '\\n',\n    isInline: true,\n  };\n}\n\nfunction isMergeableType(type: string, cfg: Required): boolean {\n  switch (type) {\n    case 'blockquote':\n      return cfg.multiLineBlockquote;\n    case 'header':\n      return cfg.multiLineHeader;\n    case 'code-block':\n      return cfg.multiLineCodeblock;\n    case 'paragraph':\n      return cfg.multiLineParagraph;\n    default:\n      return false;\n  }\n}\n\nfunction haveSameBlockStyle(a: TNode, b: TNode): boolean {\n  if (a.type !== b.type) return false;\n\n  switch (a.type) {\n    case 'header':\n      return a.attributes.header === b.attributes.header;\n    case 'code-block':\n      return a.attributes['code-block'] === b.attributes['code-block'];\n    case 'paragraph':\n      return (\n        a.attributes.indent === b.attributes.indent &&\n        a.attributes.align === b.attributes.align &&\n        a.attributes.direction === b.attributes.direction\n      );\n    case 'blockquote':\n      return true;\n    default:\n      return false;\n  }\n}\n\nfunction mergeBlocks(blocks: TNode[]): TNode {\n  const first = blocks[0]!;\n  if (blocks.length === 1) return first;\n\n  // Code blocks live inside 
 where literal \\n is the correct separator.\n  // All other blocks use line-break nodes (rendered as 
 in HTML).\n  const separator = first.type === 'code-block' ? createNewlineTextNode : createLineBreakNode;\n\n  const mergedChildren: TNode[] = [];\n  for (let i = 0; i < blocks.length; i++) {\n    if (i > 0) {\n      mergedChildren.push(separator());\n    }\n    mergedChildren.push(...blocks[i]!.children);\n  }\n\n  return {\n    ...first,\n    children: mergedChildren,\n  };\n}\n\n// ─── Transformer ────────────────────────────────────────────────────────────\n\n/**\n * Creates a transformer that merges consecutive same-style blocks.\n *\n * For example, consecutive blockquotes become one blockquote with\n * newline separators between their content. Same for headers and code blocks.\n *\n * @param config - Controls which block types are merged\n *\n * @example\n * ```ts\n * const ast = applyTransformers(rawAst, [listGrouper, blockMerger()]);\n * ```\n *\n * @example\n * ```ts\n * // Disable paragraph merging\n * const ast = applyTransformers(rawAst, [blockMerger({ multiLineParagraph: false })]);\n * ```\n */\nexport function blockMerger(config?: BlockMergerConfig): Transformer {\n  const cfg: Required = { ...DEFAULT_CONFIG, ...config };\n\n  return (children: TNode[]): TNode[] => {\n    const grouped = groupConsecutiveElementsWhile(children, (curr, prev) => {\n      return (\n        isMergeableType(curr.type, cfg) &&\n        isMergeableType(prev.type, cfg) &&\n        haveSameBlockStyle(curr, prev)\n      );\n    });\n\n    return grouped.map((item) => {\n      if (Array.isArray(item)) {\n        return mergeBlocks(item);\n      }\n      return item;\n    });\n  };\n}\n","import type { TNode, Transformer } from '../../core/ast-types';\nimport { groupConsecutiveElementsWhile } from '../utils/group-consecutive';\n\n/**\n * Wraps adjacent `code-block` nodes into a `code-block-container` parent.\n *\n * Quill stores each code line as a separate block with a `code-block` attribute.\n * This transformer groups consecutive code-block nodes into a single\n * `code-block-container` node, mirroring Quill's editor DOM structure:\n *\n * ```html\n * 
\n *   
line 1
\n *   
line 2
\n * 
\n * ```\n *\n * @example\n * ```ts\n * const ast = new DeltaParser(delta).use(codeBlockGrouper).toAST();\n * ```\n */\nexport const codeBlockGrouper: Transformer = (children: TNode[]): TNode[] => {\n  return groupCodeBlocks(children);\n};\n\nfunction isCodeBlock(node: TNode): boolean {\n  return node.type === 'code-block';\n}\n\nfunction groupCodeBlocks(children: TNode[]): TNode[] {\n  const grouped = groupConsecutiveElementsWhile(children, (curr, prev) => {\n    return isCodeBlock(curr) && isCodeBlock(prev);\n  });\n\n  return grouped.map((item): TNode => {\n    if (!Array.isArray(item)) {\n      if (isCodeBlock(item)) {\n        return createContainer([item]);\n      }\n      return item;\n    }\n    return createContainer(item);\n  });\n}\n\nfunction createContainer(codeBlocks: TNode[]): TNode {\n  return {\n    type: 'code-block-container',\n    attributes: {},\n    children: codeBlocks,\n    isInline: false,\n  };\n}\n","import type { TNode } from '../../core/ast-types';\nimport {\n  getIndent as getIndentAttr,\n  getListType as getListTypeAttr,\n  getTableRow,\n} from '../../renderers/common/node-attributes';\n\n/**\n * Reusable query functions for inspecting TNode type and attributes.\n * Used by transformers to avoid duplicating attribute-access logic.\n *\n * Primitive attribute accessors delegate to the type-safe guards\n * in `renderers/common/node-attributes.ts`.\n */\n\nexport function isListItem(node: TNode): boolean {\n  return node.type === 'list-item';\n}\n\nexport function isTableCell(node: TNode): boolean {\n  return node.type === 'table-cell';\n}\n\nexport function getListType(node: TNode): string {\n  return getListTypeAttr(node);\n}\n\nexport function getIndent(node: TNode): number {\n  return getIndentAttr(node) ?? 0;\n}\n\nexport function getRowId(node: TNode): string | undefined {\n  return getTableRow(node);\n}\n\nexport function isSameListType(a: TNode, b: TNode): boolean {\n  const aList = getListType(a);\n  const bList = getListType(b);\n  if (!aList || !bList) return false;\n\n  // checked and unchecked are treated as the same list type\n  const isCheckList = (v: string) => v === 'checked' || v === 'unchecked';\n  if (isCheckList(aList) && isCheckList(bList)) return true;\n\n  return aList === bList;\n}\n\nexport function hasHigherIndent(a: TNode, b: TNode): boolean {\n  return getIndent(a) > getIndent(b);\n}\n\nexport function isSameRow(a: TNode, b: TNode): boolean {\n  return isTableCell(a) && isTableCell(b) && getRowId(a) === getRowId(b);\n}\n","import type { TNode, Transformer } from '../../core/ast-types';\nimport { groupConsecutiveElementsWhile } from '../utils/group-consecutive';\nimport {\n  getIndent,\n  getListType,\n  hasHigherIndent,\n  isListItem,\n  isSameListType,\n} from '../utils/node-queries';\n\n/**\n * Groups adjacent `list-item` nodes into `list` container nodes\n * and nests them correctly based on indentation levels.\n *\n * Ported from quill-delta-to-html's ListNester.\n *\n * Quill stores list items as flat blocks with `list` and optional `indent` attributes.\n * This transformer:\n * 1. Groups consecutive same-type, same-indent list items into flat list containers\n * 2. Merges consecutive list groups into sections\n * 3. Nests higher-indent groups under their parent items\n * 4. Merges consecutive root-level lists of the same type\n *\n * @example\n * ```ts\n * const ast = new DeltaParser(delta).use(listGrouper).toAST();\n * ```\n */\nexport const listGrouper: Transformer = (children: TNode[]): TNode[] => {\n  return nestLists(children);\n};\n\n// ─── Internal nesting structures ────────────────────────────────────────────\n// These intermediate types exist only during the nesting algorithm.\n// They are converted back to TNodes before the transformer returns.\n\n/** A list-item TNode paired with an optional nested sub-list. */\ninterface NestingItem {\n  node: TNode;\n  innerList: NestingGroup | null;\n}\n\n/** A group of NestingItems that will become a single `list` TNode. */\ninterface NestingGroup {\n  items: NestingItem[];\n}\n\nfunction isNestingGroup(item: unknown): item is NestingGroup {\n  return typeof item === 'object' && item !== null && 'items' in item;\n}\n\n// ─── Pipeline ───────────────────────────────────────────────────────────────\n\nfunction nestLists(children: TNode[]): TNode[] {\n  const withGroups = convertListItemsToNestingGroups(children);\n  const sections = groupConsecutiveNestingGroups(withGroups);\n\n  const nested = sections.flatMap((section) => {\n    if (!Array.isArray(section)) return [section];\n    return nestSection(section as NestingGroup[]);\n  });\n\n  const merged = mergeConsecutiveSameTypeLists(nested);\n\n  return merged.map((item) => (isNestingGroup(item) ? toListTNode(item) : item));\n}\n\n// ─── Step 1: Flat grouping ──────────────────────────────────────────────────\n\nfunction convertListItemsToNestingGroups(children: TNode[]): Array {\n  const grouped = groupConsecutiveElementsWhile(children, (curr, prev) => {\n    return (\n      isListItem(curr) &&\n      isListItem(prev) &&\n      isSameListType(curr, prev) &&\n      getIndent(curr) === getIndent(prev)\n    );\n  });\n\n  return grouped.map((item): TNode | NestingGroup => {\n    if (!Array.isArray(item)) {\n      if (isListItem(item)) {\n        return { items: [{ node: item, innerList: null }] };\n      }\n      return item;\n    }\n    return { items: item.map((n) => ({ node: n, innerList: null })) };\n  });\n}\n\n// ─── Step 2: Section grouping ───────────────────────────────────────────────\n\nfunction groupConsecutiveNestingGroups(\n  items: Array,\n): Array> {\n  return groupConsecutiveElementsWhile(items, (curr, prev) => {\n    return isNestingGroup(curr) && isNestingGroup(prev);\n  });\n}\n\n// ─── Step 3: Indent-based nesting ───────────────────────────────────────────\n\nfunction nestSection(sectionItems: NestingGroup[]): NestingGroup[] {\n  const byIndent = groupByIndent(sectionItems);\n\n  Object.keys(byIndent)\n    .map(Number)\n    .sort()\n    .reverse()\n    .forEach((indent) => {\n      byIndent[indent]!.forEach((group) => {\n        const idx = sectionItems.indexOf(group);\n        if (placeUnderParent(group, sectionItems.slice(0, idx))) {\n          sectionItems.splice(idx, 1);\n        }\n      });\n    });\n\n  return sectionItems;\n}\n\nfunction groupByIndent(items: NestingGroup[]): Record {\n  return items.reduce>((acc, group) => {\n    const indent = getIndent(group.items[0]!.node);\n    if (indent > 0) {\n      acc[indent] = acc[indent] || [];\n      acc[indent]!.push(group);\n    }\n    return acc;\n  }, {});\n}\n\nfunction placeUnderParent(target: NestingGroup, candidates: NestingGroup[]): boolean {\n  for (let i = candidates.length - 1; i >= 0; i--) {\n    const candidate = candidates[i]!;\n    if (hasHigherIndent(target.items[0]!.node, candidate.items[0]!.node)) {\n      const parent = candidate.items[candidate.items.length - 1]!;\n      if (parent.innerList) {\n        parent.innerList.items = parent.innerList.items.concat(target.items);\n      } else {\n        parent.innerList = target;\n      }\n      return true;\n    }\n  }\n  return false;\n}\n\n// ─── Step 4: Merge same-type root lists ─────────────────────────────────────\n\nfunction mergeConsecutiveSameTypeLists(\n  items: Array,\n): Array {\n  const grouped = groupConsecutiveElementsWhile(items, (curr, prev) => {\n    if (!isNestingGroup(curr) || !isNestingGroup(prev)) return false;\n    return isSameListType(curr.items[0]!.node, prev.items[0]!.node);\n  });\n\n  return grouped.map((v): TNode | NestingGroup => {\n    if (!Array.isArray(v)) return v;\n    const allItems = (v as NestingGroup[]).flatMap((g) => g.items);\n    return { items: allItems };\n  });\n}\n\n// ─── TNode conversion ───────────────────────────────────────────────────────\n\nfunction toListTNode(group: NestingGroup): TNode {\n  return {\n    type: 'list',\n    attributes: { list: getListType(group.items[0]!.node) },\n    children: group.items.map(toListItemTNode),\n    isInline: false,\n  };\n}\n\nfunction toListItemTNode(item: NestingItem): TNode {\n  const children = [...item.node.children];\n  if (item.innerList) {\n    children.push(toListTNode(item.innerList));\n  }\n  return { ...item.node, children };\n}\n","import type { TNode, Transformer } from '../../core/ast-types';\nimport { groupConsecutiveElementsWhile } from '../utils/group-consecutive';\nimport { isSameRow, isTableCell } from '../utils/node-queries';\n\n/**\n * Wraps adjacent table-cell nodes into proper table > row > cell structure.\n *\n * Ported from quill-delta-to-html's TableGrouper.\n *\n * Quill stores table cells as flat blocks with a `table` attribute\n * whose value is the row identifier (e.g. `'row-1'`).\n * This transformer:\n * 1. Detects consecutive `table-cell` nodes in root.children\n * 2. Groups cells sharing the same row id into `table-row` containers\n * 3. Wraps all rows in a `table` container node\n *\n * @example\n * ```ts\n * const ast = new DeltaParser(delta).use(tableGrouper).toAST();\n * ```\n */\nexport const tableGrouper: Transformer = (children: TNode[]): TNode[] => {\n  return groupTables(children);\n};\n\n// ─── Core grouping ──────────────────────────────────────────────────────────\n\nfunction groupTables(children: TNode[]): TNode[] {\n  const grouped = groupConsecutiveElementsWhile(children, (curr, prev) => {\n    return isTableCell(curr) && isTableCell(prev);\n  });\n\n  return grouped.map((item): TNode => {\n    if (!Array.isArray(item)) {\n      if (isTableCell(item)) {\n        return createTable([createRow([item])]);\n      }\n      return item;\n    }\n    return createTable(groupCellsIntoRows(item));\n  });\n}\n\nfunction groupCellsIntoRows(cells: TNode[]): TNode[] {\n  const grouped = groupConsecutiveElementsWhile(cells, isSameRow);\n\n  return grouped.map((item): TNode => {\n    return createRow(Array.isArray(item) ? item : [item]);\n  });\n}\n\n// ─── TNode factories ────────────────────────────────────────────────────────\n\nfunction createRow(cells: TNode[]): TNode {\n  return {\n    type: 'table-row',\n    attributes: {},\n    children: cells,\n    isInline: false,\n  };\n}\n\nfunction createTable(rows: TNode[]): TNode {\n  return {\n    type: 'table',\n    attributes: {},\n    children: rows,\n    isInline: false,\n  };\n}\n"]}