{"version":3,"sources":["../src/index.ts","../src/handlers/block.ts","../src/types.ts","../src/handlers/inline.ts","../src/md-to-delta.ts","../src/tree-walker.ts"],"sourcesContent":["export { createDefaultBlockHandlers } from './handlers/block';\nexport { createDefaultInlineHandlers } from './handlers/inline';\nexport { MarkdownToQuill } from './md-to-delta';\nexport type {\n  BlockHandler,\n  ConvertContext,\n  ConvertExtra,\n  InlineHandler,\n  Logger,\n  MarkdownToQuillOptions,\n  Op,\n} from './types';\nexport { blockHandler, inlineHandler } from './types';\n","import type { AlignType, Code, Heading, List, ListItem, Table, TableCell } from 'mdast';\nimport Delta from 'quill-delta';\nimport { type BlockHandler, blockHandler } from '../types';\n\nexport function createDefaultBlockHandlers(): Record<string, BlockHandler> {\n  return {\n    paragraph: (ctx, child) => {\n      const delta = ctx.converter.convertChildren(ctx.node, child, ctx.op, ctx.indent + 1);\n      if (!ctx.parent) {\n        delta.insert('\\n');\n      }\n      return delta;\n    },\n    code: blockHandler<Code>((_ctx, child) => {\n      const delta = new Delta();\n      const lines = child.value.split('\\n');\n      const codeBlock: string | boolean = child.lang || true;\n      for (const line of lines) {\n        if (line) {\n          delta.push({ insert: line });\n        }\n        delta.push({ insert: '\\n', attributes: { 'code-block': codeBlock } });\n      }\n      return delta;\n    }),\n    list: (ctx, child) => {\n      return ctx.converter.convertChildren(ctx.node, child, ctx.op, ctx.indent);\n    },\n    listItem: blockHandler<ListItem>((ctx, child) => {\n      const parent = ctx.node as List;\n      let delta = new Delta();\n      for (const item of child.children) {\n        delta = delta.concat(ctx.converter.convertChildren(parent, item, {}, ctx.indent + 1));\n        if (item.type !== 'list') {\n          let listAttribute: string;\n          if (parent.ordered) {\n            listAttribute = 'ordered';\n          } else if (child.checked) {\n            listAttribute = 'checked';\n          } else if (child.checked === false) {\n            listAttribute = 'unchecked';\n          } else {\n            listAttribute = 'bullet';\n          }\n          const attributes: { list: string; indent?: number } = { list: listAttribute };\n          if (ctx.indent) {\n            attributes.indent = ctx.indent;\n          }\n          delta.push({ insert: '\\n', attributes });\n        }\n      }\n      ctx.converter.log('list item', delta.ops);\n      return delta;\n    }),\n    table: blockHandler<Table>((ctx, child) => {\n      return ctx.converter.convertChildren(ctx.node, child, ctx.op, ctx.indent, {\n        align: child.align ?? undefined,\n      });\n    }),\n    tableRow: (ctx, child) => {\n      return ctx.converter.convertChildren(ctx.node, child, ctx.op, ctx.indent, {\n        ...ctx.extra,\n        id: ctx.converter.generateId(),\n      });\n    },\n    tableCell: blockHandler<TableCell>((ctx, child) => {\n      const align = ctx.extra?.align as (AlignType | null)[] | undefined;\n      const alignCell = align && align.length > ctx.idx ? align[ctx.idx] : null;\n      const tableId = (ctx.extra?.id as string) ?? '';\n      ctx.converter.log('align', alignCell, align, ctx.idx);\n      let delta = new Delta();\n      delta = delta.concat(ctx.converter.convertChildren(ctx.node, child, {}, 1));\n      const attributes: Record<string, unknown> = { table: tableId };\n      if (alignCell && alignCell !== 'left') {\n        attributes.align = alignCell;\n      }\n      delta.insert('\\n', attributes);\n      ctx.converter.log('table cell', delta.ops, alignCell);\n      return delta;\n    }),\n    heading: blockHandler<Heading>((ctx, child) => {\n      const delta = ctx.converter.convertChildren(ctx.node, child, ctx.op, ctx.indent + 1);\n      delta.push({\n        insert: '\\n',\n        attributes: { header: child.depth },\n      });\n      return delta;\n    }),\n    blockquote: (ctx, child) => {\n      const delta = ctx.converter.convertChildren(ctx.node, child, ctx.op, ctx.indent + 1);\n      delta.push({ insert: '\\n', attributes: { blockquote: true } });\n      return delta;\n    },\n    thematicBreak: () => {\n      const delta = new Delta();\n      delta.insert({ divider: true });\n      delta.insert('\\n');\n      return delta;\n    },\n  };\n}\n","import type { Nodes, Parents, RootContent } from 'mdast';\nimport type Delta from 'quill-delta';\n\nexport type Logger = (message: string, ...args: unknown[]) => void;\n\nexport type Op = Delta['ops'][number];\n\nexport type ConvertExtra = Record<string, unknown>;\n\nexport interface HandlerUtils {\n  convertChildren(parent: Parents | null, node: Nodes, op?: Op, indent?: number, extra?: ConvertExtra): Delta;\n  inlineFormat(parent: Parents, node: RootContent, op: Op, attributes: Record<string, unknown>): Delta | null;\n  embedFormat(op: Op, value: Record<string, unknown>, attributes?: Record<string, unknown> | null): Delta;\n  generateId(): string;\n  log: Logger;\n}\n\nexport interface ConvertContext {\n  parent: Parents | null;\n  node: Parents;\n  op: Op;\n  indent: number;\n  extra?: ConvertExtra;\n  idx: number;\n  converter: HandlerUtils;\n}\n\nexport type BlockHandler = (ctx: ConvertContext, child: RootContent) => Delta;\nexport type InlineHandler = (ctx: ConvertContext, child: RootContent) => Delta | null;\n\nexport function blockHandler<T extends RootContent>(fn: (ctx: ConvertContext, child: T) => Delta): BlockHandler {\n  return fn as BlockHandler;\n}\n\nexport function inlineHandler<T extends RootContent>(fn: (ctx: ConvertContext, child: T) => Delta | null): InlineHandler {\n  return fn as InlineHandler;\n}\n\nexport interface MarkdownToQuillOptions {\n  logger?: Logger;\n  tableIdGenerator?: () => string;\n  blockHandlers?: Record<string, BlockHandler>;\n  inlineHandlers?: Record<string, InlineHandler>;\n  blockTypes?: string[];\n  mdastExtensions?: object[];\n  micromarkExtensions?: object[];\n}\n","import type { Image, Link } from 'mdast';\nimport { type InlineHandler, inlineHandler } from '../types';\n\nexport function createDefaultInlineHandlers(): Record<string, InlineHandler> {\n  return {\n    strong: (ctx, child) => ctx.converter.inlineFormat(ctx.node, child, ctx.op, { bold: true }),\n    emphasis: (ctx, child) => ctx.converter.inlineFormat(ctx.node, child, ctx.op, { italic: true }),\n    delete: (ctx, child) => ctx.converter.inlineFormat(ctx.node, child, ctx.op, { strike: true }),\n    inlineCode: (ctx, child) => ctx.converter.inlineFormat(ctx.node, child, ctx.op, { code: true }),\n    link: inlineHandler<Link>((ctx, child) => ctx.converter.inlineFormat(ctx.node, child, ctx.op, { link: child.url })),\n    image: inlineHandler<Image>((ctx, child) => {\n      return ctx.converter.embedFormat(ctx.op, { image: child.url }, child.alt ? { alt: child.alt } : null);\n    }),\n  };\n}\n","import type { Root } from 'mdast';\nimport { fromMarkdown } from 'mdast-util-from-markdown';\nimport { gfmStrikethroughFromMarkdown } from 'mdast-util-gfm-strikethrough';\nimport { gfmTableFromMarkdown } from 'mdast-util-gfm-table';\nimport { gfmTaskListItemFromMarkdown } from 'mdast-util-gfm-task-list-item';\nimport { gfmStrikethrough } from 'micromark-extension-gfm-strikethrough';\nimport { gfmTable } from 'micromark-extension-gfm-table';\nimport { gfmTaskListItem } from 'micromark-extension-gfm-task-list-item';\nimport type Delta from 'quill-delta';\nimport { createDefaultBlockHandlers } from './handlers/block';\nimport { createDefaultInlineHandlers } from './handlers/inline';\nimport { TreeWalker } from './tree-walker';\nimport type { BlockHandler, InlineHandler, Logger, MarkdownToQuillOptions } from './types';\n\nconst DEFAULT_BLOCK_TYPES = ['paragraph', 'code', 'heading', 'blockquote', 'list', 'table'];\n\nfunction defaultIdGenerator(): string {\n  const id = Math.random().toString(36).slice(2, 6);\n  return `row-${id}`;\n}\n\nexport class MarkdownToQuill {\n  private readonly options: MarkdownToQuillOptions;\n  private readonly log: Logger;\n  private readonly blockTypes: Set<string>;\n  private readonly blockHandlers: Map<string, BlockHandler>;\n  private readonly inlineHandlers: Map<string, InlineHandler>;\n\n  constructor(options?: MarkdownToQuillOptions) {\n    this.options = options ?? {};\n    this.log = this.options.logger ?? (() => {});\n    this.blockTypes = new Set(options?.blockTypes ?? DEFAULT_BLOCK_TYPES);\n\n    this.blockHandlers = new Map(Object.entries(createDefaultBlockHandlers()));\n    this.inlineHandlers = new Map(Object.entries(createDefaultInlineHandlers()));\n\n    if (options?.blockHandlers) {\n      for (const [type, handler] of Object.entries(options.blockHandlers)) {\n        this.blockHandlers.set(type, handler);\n      }\n    }\n    if (options?.inlineHandlers) {\n      for (const [type, handler] of Object.entries(options.inlineHandlers)) {\n        this.inlineHandlers.set(type, handler);\n      }\n    }\n  }\n\n  convert(text: string): Delta {\n    const tree: Root = fromMarkdown(text, {\n      extensions: [gfmStrikethrough(), gfmTable(), gfmTaskListItem(), ...(this.options.micromarkExtensions ?? [])],\n      mdastExtensions: [\n        gfmStrikethroughFromMarkdown(),\n        gfmTableFromMarkdown(),\n        gfmTaskListItemFromMarkdown(),\n        ...(this.options.mdastExtensions ?? []),\n      ],\n    }) as Root;\n\n    const walker = new TreeWalker(\n      this.log,\n      this.blockTypes,\n      this.blockHandlers,\n      this.inlineHandlers,\n      this.options.tableIdGenerator ?? defaultIdGenerator,\n    );\n    return walker.run(tree);\n  }\n}\n","import type { Nodes, Parents, Root, RootContent } from 'mdast';\nimport Delta from 'quill-delta';\nimport type { BlockHandler, ConvertContext, ConvertExtra, HandlerUtils, InlineHandler, Logger, Op } from './types';\n\nexport class TreeWalker implements HandlerUtils {\n  readonly log: Logger;\n  private readonly blockTypes: Set<string>;\n  private readonly blockHandlers: Map<string, BlockHandler>;\n  private readonly inlineHandlers: Map<string, InlineHandler>;\n  private readonly idGenerator: () => string;\n\n  constructor(\n    log: Logger,\n    blockTypes: Set<string>,\n    blockHandlers: Map<string, BlockHandler>,\n    inlineHandlers: Map<string, InlineHandler>,\n    idGenerator: () => string,\n  ) {\n    this.log = log;\n    this.blockTypes = blockTypes;\n    this.blockHandlers = blockHandlers;\n    this.inlineHandlers = inlineHandlers;\n    this.idGenerator = idGenerator;\n  }\n\n  run(tree: Root): Delta {\n    this.log('tree', tree);\n    return this.convertChildren(null, tree, {});\n  }\n\n  convertChildren(parent: Parents | null, node: Nodes, op: Op = {}, indent = 0, extra?: ConvertExtra): Delta {\n    if (!('children' in node)) return new Delta();\n\n    const parentNode = node as Parents;\n    let delta = new Delta();\n    this.log('children:', parentNode.children, extra);\n\n    const children = parentNode.children as RootContent[];\n    let prevType: string | undefined;\n    for (let idx = 0; idx < children.length; idx++) {\n      const child = children[idx];\n      if (prevType && this.blockTypes.has(child.type) && this.blockTypes.has(prevType)) {\n        delta.insert('\\n');\n      }\n\n      const ctx: ConvertContext = {\n        parent,\n        node: parentNode,\n        op,\n        indent,\n        extra,\n        idx,\n        converter: this,\n      };\n\n      try {\n        const blockHandler = this.blockHandlers.get(child.type);\n\n        if (blockHandler) {\n          delta = delta.concat(blockHandler(ctx, child));\n        } else {\n          const inlineHandler = this.inlineHandlers.get(child.type);\n          if (inlineHandler) {\n            const d = inlineHandler(ctx, child);\n            if (d) {\n              delta = delta.concat(d);\n            }\n          } else {\n            const d = this.inlineFormat(parentNode, child, op, {});\n            if (d) {\n              delta = delta.concat(d);\n            }\n          }\n        }\n      } catch (error) {\n        const pos = child.position?.start;\n        const location = pos ? ` at line ${pos.line}, column ${pos.column}` : '';\n        throw new Error(`Failed to convert \"${child.type}\" node${location}`, {\n          cause: error,\n        });\n      }\n\n      prevType = child.type;\n    }\n    return delta;\n  }\n\n  generateId(): string {\n    return this.idGenerator();\n  }\n\n  inlineFormat(parent: Parents, node: RootContent, op: Op, attributes: Record<string, unknown>): Delta | null {\n    const text = 'value' in node && typeof node.value === 'string' ? node.value : null;\n    const newAttributes = { ...op.attributes, ...attributes };\n    op = { ...op };\n    if (text) {\n      op.insert = text;\n    }\n    if (Object.keys(newAttributes).length) {\n      op.attributes = newAttributes;\n    }\n    if ('children' in node) {\n      return this.convertChildren(parent, node as Parents, op);\n    }\n    return op.insert ? new Delta().push(op) : null;\n  }\n\n  embedFormat(op: Op, value: Record<string, unknown>, attrs?: Record<string, unknown> | null): Delta {\n    const attributes = attrs ? { ...op.attributes, ...attrs } : op.attributes;\n    return new Delta().insert(value, attributes);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACCA,yBAAkB;;;AC6BX,SAAS,aAAoC,IAA4D;AAC9G,SAAO;AACT;AAEO,SAAS,cAAqC,IAAoE;AACvH,SAAO;AACT;;;ADhCO,SAAS,6BAA2D;AACzE,SAAO;AAAA,IACL,WAAW,CAAC,KAAK,UAAU;AACzB,YAAM,QAAQ,IAAI,UAAU,gBAAgB,IAAI,MAAM,OAAO,IAAI,IAAI,IAAI,SAAS,CAAC;AACnF,UAAI,CAAC,IAAI,QAAQ;AACf,cAAM,OAAO,IAAI;AAAA,MACnB;AACA,aAAO;AAAA,IACT;AAAA,IACA,MAAM,aAAmB,CAAC,MAAM,UAAU;AACxC,YAAM,QAAQ,IAAI,mBAAAA,QAAM;AACxB,YAAM,QAAQ,MAAM,MAAM,MAAM,IAAI;AACpC,YAAM,YAA8B,MAAM,QAAQ;AAClD,iBAAW,QAAQ,OAAO;AACxB,YAAI,MAAM;AACR,gBAAM,KAAK,EAAE,QAAQ,KAAK,CAAC;AAAA,QAC7B;AACA,cAAM,KAAK,EAAE,QAAQ,MAAM,YAAY,EAAE,cAAc,UAAU,EAAE,CAAC;AAAA,MACtE;AACA,aAAO;AAAA,IACT,CAAC;AAAA,IACD,MAAM,CAAC,KAAK,UAAU;AACpB,aAAO,IAAI,UAAU,gBAAgB,IAAI,MAAM,OAAO,IAAI,IAAI,IAAI,MAAM;AAAA,IAC1E;AAAA,IACA,UAAU,aAAuB,CAAC,KAAK,UAAU;AAC/C,YAAM,SAAS,IAAI;AACnB,UAAI,QAAQ,IAAI,mBAAAA,QAAM;AACtB,iBAAW,QAAQ,MAAM,UAAU;AACjC,gBAAQ,MAAM,OAAO,IAAI,UAAU,gBAAgB,QAAQ,MAAM,CAAC,GAAG,IAAI,SAAS,CAAC,CAAC;AACpF,YAAI,KAAK,SAAS,QAAQ;AACxB,cAAI;AACJ,cAAI,OAAO,SAAS;AAClB,4BAAgB;AAAA,UAClB,WAAW,MAAM,SAAS;AACxB,4BAAgB;AAAA,UAClB,WAAW,MAAM,YAAY,OAAO;AAClC,4BAAgB;AAAA,UAClB,OAAO;AACL,4BAAgB;AAAA,UAClB;AACA,gBAAM,aAAgD,EAAE,MAAM,cAAc;AAC5E,cAAI,IAAI,QAAQ;AACd,uBAAW,SAAS,IAAI;AAAA,UAC1B;AACA,gBAAM,KAAK,EAAE,QAAQ,MAAM,WAAW,CAAC;AAAA,QACzC;AAAA,MACF;AACA,UAAI,UAAU,IAAI,aAAa,MAAM,GAAG;AACxC,aAAO;AAAA,IACT,CAAC;AAAA,IACD,OAAO,aAAoB,CAAC,KAAK,UAAU;AACzC,aAAO,IAAI,UAAU,gBAAgB,IAAI,MAAM,OAAO,IAAI,IAAI,IAAI,QAAQ;AAAA,QACxE,OAAO,MAAM,SAAS;AAAA,MACxB,CAAC;AAAA,IACH,CAAC;AAAA,IACD,UAAU,CAAC,KAAK,UAAU;AACxB,aAAO,IAAI,UAAU,gBAAgB,IAAI,MAAM,OAAO,IAAI,IAAI,IAAI,QAAQ;AAAA,QACxE,GAAG,IAAI;AAAA,QACP,IAAI,IAAI,UAAU,WAAW;AAAA,MAC/B,CAAC;AAAA,IACH;AAAA,IACA,WAAW,aAAwB,CAAC,KAAK,UAAU;AACjD,YAAM,QAAQ,IAAI,OAAO;AACzB,YAAM,YAAY,SAAS,MAAM,SAAS,IAAI,MAAM,MAAM,IAAI,GAAG,IAAI;AACrE,YAAM,UAAW,IAAI,OAAO,MAAiB;AAC7C,UAAI,UAAU,IAAI,SAAS,WAAW,OAAO,IAAI,GAAG;AACpD,UAAI,QAAQ,IAAI,mBAAAA,QAAM;AACtB,cAAQ,MAAM,OAAO,IAAI,UAAU,gBAAgB,IAAI,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;AAC1E,YAAM,aAAsC,EAAE,OAAO,QAAQ;AAC7D,UAAI,aAAa,cAAc,QAAQ;AACrC,mBAAW,QAAQ;AAAA,MACrB;AACA,YAAM,OAAO,MAAM,UAAU;AAC7B,UAAI,UAAU,IAAI,cAAc,MAAM,KAAK,SAAS;AACpD,aAAO;AAAA,IACT,CAAC;AAAA,IACD,SAAS,aAAsB,CAAC,KAAK,UAAU;AAC7C,YAAM,QAAQ,IAAI,UAAU,gBAAgB,IAAI,MAAM,OAAO,IAAI,IAAI,IAAI,SAAS,CAAC;AACnF,YAAM,KAAK;AAAA,QACT,QAAQ;AAAA,QACR,YAAY,EAAE,QAAQ,MAAM,MAAM;AAAA,MACpC,CAAC;AACD,aAAO;AAAA,IACT,CAAC;AAAA,IACD,YAAY,CAAC,KAAK,UAAU;AAC1B,YAAM,QAAQ,IAAI,UAAU,gBAAgB,IAAI,MAAM,OAAO,IAAI,IAAI,IAAI,SAAS,CAAC;AACnF,YAAM,KAAK,EAAE,QAAQ,MAAM,YAAY,EAAE,YAAY,KAAK,EAAE,CAAC;AAC7D,aAAO;AAAA,IACT;AAAA,IACA,eAAe,MAAM;AACnB,YAAM,QAAQ,IAAI,mBAAAA,QAAM;AACxB,YAAM,OAAO,EAAE,SAAS,KAAK,CAAC;AAC9B,YAAM,OAAO,IAAI;AACjB,aAAO;AAAA,IACT;AAAA,EACF;AACF;;;AEjGO,SAAS,8BAA6D;AAC3E,SAAO;AAAA,IACL,QAAQ,CAAC,KAAK,UAAU,IAAI,UAAU,aAAa,IAAI,MAAM,OAAO,IAAI,IAAI,EAAE,MAAM,KAAK,CAAC;AAAA,IAC1F,UAAU,CAAC,KAAK,UAAU,IAAI,UAAU,aAAa,IAAI,MAAM,OAAO,IAAI,IAAI,EAAE,QAAQ,KAAK,CAAC;AAAA,IAC9F,QAAQ,CAAC,KAAK,UAAU,IAAI,UAAU,aAAa,IAAI,MAAM,OAAO,IAAI,IAAI,EAAE,QAAQ,KAAK,CAAC;AAAA,IAC5F,YAAY,CAAC,KAAK,UAAU,IAAI,UAAU,aAAa,IAAI,MAAM,OAAO,IAAI,IAAI,EAAE,MAAM,KAAK,CAAC;AAAA,IAC9F,MAAM,cAAoB,CAAC,KAAK,UAAU,IAAI,UAAU,aAAa,IAAI,MAAM,OAAO,IAAI,IAAI,EAAE,MAAM,MAAM,IAAI,CAAC,CAAC;AAAA,IAClH,OAAO,cAAqB,CAAC,KAAK,UAAU;AAC1C,aAAO,IAAI,UAAU,YAAY,IAAI,IAAI,EAAE,OAAO,MAAM,IAAI,GAAG,MAAM,MAAM,EAAE,KAAK,MAAM,IAAI,IAAI,IAAI;AAAA,IACtG,CAAC;AAAA,EACH;AACF;;;ACbA,sCAA6B;AAC7B,0CAA6C;AAC7C,kCAAqC;AACrC,2CAA4C;AAC5C,mDAAiC;AACjC,2CAAyB;AACzB,oDAAgC;;;ACNhC,IAAAC,sBAAkB;AAGX,IAAM,aAAN,MAAyC;AAAA,EACrC;AAAA,EACQ;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAEjB,YACE,KACA,YACA,eACA,gBACA,aACA;AACA,SAAK,MAAM;AACX,SAAK,aAAa;AAClB,SAAK,gBAAgB;AACrB,SAAK,iBAAiB;AACtB,SAAK,cAAc;AAAA,EACrB;AAAA,EAEA,IAAI,MAAmB;AACrB,SAAK,IAAI,QAAQ,IAAI;AACrB,WAAO,KAAK,gBAAgB,MAAM,MAAM,CAAC,CAAC;AAAA,EAC5C;AAAA,EAEA,gBAAgB,QAAwB,MAAa,KAAS,CAAC,GAAG,SAAS,GAAG,OAA6B;AACzG,QAAI,EAAE,cAAc,MAAO,QAAO,IAAI,oBAAAC,QAAM;AAE5C,UAAM,aAAa;AACnB,QAAI,QAAQ,IAAI,oBAAAA,QAAM;AACtB,SAAK,IAAI,aAAa,WAAW,UAAU,KAAK;AAEhD,UAAM,WAAW,WAAW;AAC5B,QAAI;AACJ,aAAS,MAAM,GAAG,MAAM,SAAS,QAAQ,OAAO;AAC9C,YAAM,QAAQ,SAAS,GAAG;AAC1B,UAAI,YAAY,KAAK,WAAW,IAAI,MAAM,IAAI,KAAK,KAAK,WAAW,IAAI,QAAQ,GAAG;AAChF,cAAM,OAAO,IAAI;AAAA,MACnB;AAEA,YAAM,MAAsB;AAAA,QAC1B;AAAA,QACA,MAAM;AAAA,QACN;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA,WAAW;AAAA,MACb;AAEA,UAAI;AACF,cAAMC,gBAAe,KAAK,cAAc,IAAI,MAAM,IAAI;AAEtD,YAAIA,eAAc;AAChB,kBAAQ,MAAM,OAAOA,cAAa,KAAK,KAAK,CAAC;AAAA,QAC/C,OAAO;AACL,gBAAMC,iBAAgB,KAAK,eAAe,IAAI,MAAM,IAAI;AACxD,cAAIA,gBAAe;AACjB,kBAAM,IAAIA,eAAc,KAAK,KAAK;AAClC,gBAAI,GAAG;AACL,sBAAQ,MAAM,OAAO,CAAC;AAAA,YACxB;AAAA,UACF,OAAO;AACL,kBAAM,IAAI,KAAK,aAAa,YAAY,OAAO,IAAI,CAAC,CAAC;AACrD,gBAAI,GAAG;AACL,sBAAQ,MAAM,OAAO,CAAC;AAAA,YACxB;AAAA,UACF;AAAA,QACF;AAAA,MACF,SAAS,OAAO;AACd,cAAM,MAAM,MAAM,UAAU;AAC5B,cAAM,WAAW,MAAM,YAAY,IAAI,IAAI,YAAY,IAAI,MAAM,KAAK;AACtE,cAAM,IAAI,MAAM,sBAAsB,MAAM,IAAI,SAAS,QAAQ,IAAI;AAAA,UACnE,OAAO;AAAA,QACT,CAAC;AAAA,MACH;AAEA,iBAAW,MAAM;AAAA,IACnB;AACA,WAAO;AAAA,EACT;AAAA,EAEA,aAAqB;AACnB,WAAO,KAAK,YAAY;AAAA,EAC1B;AAAA,EAEA,aAAa,QAAiB,MAAmB,IAAQ,YAAmD;AAC1G,UAAM,OAAO,WAAW,QAAQ,OAAO,KAAK,UAAU,WAAW,KAAK,QAAQ;AAC9E,UAAM,gBAAgB,EAAE,GAAG,GAAG,YAAY,GAAG,WAAW;AACxD,SAAK,EAAE,GAAG,GAAG;AACb,QAAI,MAAM;AACR,SAAG,SAAS;AAAA,IACd;AACA,QAAI,OAAO,KAAK,aAAa,EAAE,QAAQ;AACrC,SAAG,aAAa;AAAA,IAClB;AACA,QAAI,cAAc,MAAM;AACtB,aAAO,KAAK,gBAAgB,QAAQ,MAAiB,EAAE;AAAA,IACzD;AACA,WAAO,GAAG,SAAS,IAAI,oBAAAF,QAAM,EAAE,KAAK,EAAE,IAAI;AAAA,EAC5C;AAAA,EAEA,YAAY,IAAQ,OAAgC,OAA+C;AACjG,UAAM,aAAa,QAAQ,EAAE,GAAG,GAAG,YAAY,GAAG,MAAM,IAAI,GAAG;AAC/D,WAAO,IAAI,oBAAAA,QAAM,EAAE,OAAO,OAAO,UAAU;AAAA,EAC7C;AACF;;;ADjGA,IAAM,sBAAsB,CAAC,aAAa,QAAQ,WAAW,cAAc,QAAQ,OAAO;AAE1F,SAAS,qBAA6B;AACpC,QAAM,KAAK,KAAK,OAAO,EAAE,SAAS,EAAE,EAAE,MAAM,GAAG,CAAC;AAChD,SAAO,OAAO,EAAE;AAClB;AAEO,IAAM,kBAAN,MAAsB;AAAA,EACV;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAEjB,YAAY,SAAkC;AAC5C,SAAK,UAAU,WAAW,CAAC;AAC3B,SAAK,MAAM,KAAK,QAAQ,WAAW,MAAM;AAAA,IAAC;AAC1C,SAAK,aAAa,IAAI,IAAI,SAAS,cAAc,mBAAmB;AAEpE,SAAK,gBAAgB,IAAI,IAAI,OAAO,QAAQ,2BAA2B,CAAC,CAAC;AACzE,SAAK,iBAAiB,IAAI,IAAI,OAAO,QAAQ,4BAA4B,CAAC,CAAC;AAE3E,QAAI,SAAS,eAAe;AAC1B,iBAAW,CAAC,MAAM,OAAO,KAAK,OAAO,QAAQ,QAAQ,aAAa,GAAG;AACnE,aAAK,cAAc,IAAI,MAAM,OAAO;AAAA,MACtC;AAAA,IACF;AACA,QAAI,SAAS,gBAAgB;AAC3B,iBAAW,CAAC,MAAM,OAAO,KAAK,OAAO,QAAQ,QAAQ,cAAc,GAAG;AACpE,aAAK,eAAe,IAAI,MAAM,OAAO;AAAA,MACvC;AAAA,IACF;AAAA,EACF;AAAA,EAEA,QAAQ,MAAqB;AAC3B,UAAM,WAAa,8CAAa,MAAM;AAAA,MACpC,YAAY,KAAC,+DAAiB,OAAG,+CAAS,OAAG,+DAAgB,GAAG,GAAI,KAAK,QAAQ,uBAAuB,CAAC,CAAE;AAAA,MAC3G,iBAAiB;AAAA,YACf,kEAA6B;AAAA,YAC7B,kDAAqB;AAAA,YACrB,kEAA4B;AAAA,QAC5B,GAAI,KAAK,QAAQ,mBAAmB,CAAC;AAAA,MACvC;AAAA,IACF,CAAC;AAED,UAAM,SAAS,IAAI;AAAA,MACjB,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK,QAAQ,oBAAoB;AAAA,IACnC;AACA,WAAO,OAAO,IAAI,IAAI;AAAA,EACxB;AACF;","names":["Delta","import_quill_delta","Delta","blockHandler","inlineHandler"]}