{
  "version": 3,
  "sources": ["../src/index.ts", "../src/selection.ts", "../src/helpers.ts", "../src/transforms.ts", "../src/node.ts"],
  "sourcesContent": ["export {\n  findParentNode,\n  findParentNodeClosestToPos,\n  findParentDomRef,\n  hasParentNode,\n  findParentNodeOfType,\n  findParentNodeOfTypeClosestToPos,\n  hasParentNodeOfType,\n  findParentDomRefOfType,\n  findSelectedNodeOfType,\n  findPositionOfNodeBefore,\n  findDomRefAtPos,\n} from './selection';\nexport {\n  flatten,\n  findChildren,\n  findTextNodes,\n  findInlineNodes,\n  findBlockNodes,\n  findChildrenByAttr,\n  findChildrenByType,\n  findChildrenByMark,\n  contains,\n} from './node';\nexport {\n  removeParentNodeOfType,\n  replaceParentNodeOfType,\n  removeSelectedNode,\n  replaceSelectedNode,\n  setTextSelection,\n  safeInsert,\n  setParentNodeMarkup,\n  selectParentNodeOfType,\n  removeNodeBefore,\n} from './transforms';\nexport { isNodeSelection, canInsert } from './helpers';\nexport type {\n  DomAtPos,\n  NodeTypeParam,\n  Predicate,\n  NodeWithPos,\n  ContentNodeWithPos,\n} from './types';\n", "import type { Node as PMNode, ResolvedPos } from 'prosemirror-model';\nimport { Selection } from 'prosemirror-state';\nimport type {\n  FindPredicate,\n  FindResult,\n  DomAtPos,\n  NodeTypeParam,\n} from './types';\nimport { equalNodeType, isNodeSelection } from './helpers';\n\n// Iterates over parent nodes, returning the closest node and its start position `predicate` returns truthy for. `start` points to the start position of the node, `pos` points directly before the node.\n//\n// ```javascript\n// const predicate = node => node.type === schema.nodes.blockquote;\n// const parent = findParentNode(predicate)(selection);\n// ```\nexport const findParentNode =\n  (predicate: FindPredicate) =>\n  (\n    { $from, $to }: Selection,\n    validateSameParent: boolean = false\n  ): FindResult => {\n    // Check if parent are different\n    if (validateSameParent && !$from.sameParent($to)) {\n      // If they are, I need to find a common parent\n      let depth = Math.min($from.depth, $to.depth);\n      while (depth >= 0) {\n        const fromNode = $from.node(depth);\n        const toNode = $to.node(depth);\n        if (toNode === fromNode) {\n          // The have the same parent\n          if (predicate(fromNode)) {\n            // Check the predicate\n            return {\n              // Return the resolved pos\n              pos: depth > 0 ? $from.before(depth) : 0,\n              start: $from.start(depth),\n              depth: depth,\n              node: fromNode,\n            };\n          }\n        }\n        depth = depth - 1; // Keep looking\n      }\n      return;\n    }\n\n    return findParentNodeClosestToPos($from, predicate);\n  };\n\n// Iterates over parent nodes starting from the given `$pos`, returning the closest node and its start position `predicate` returns truthy for. `start` points to the start position of the node, `pos` points directly before the node.\n//\n// ```javascript\n// const predicate = node => node.type === schema.nodes.blockquote;\n// const parent = findParentNodeClosestToPos(state.doc.resolve(5), predicate);\n// ```\nexport const findParentNodeClosestToPos = (\n  $pos: ResolvedPos,\n  predicate: FindPredicate\n): FindResult => {\n  for (let i = $pos.depth; i > 0; i--) {\n    const node = $pos.node(i);\n    if (predicate(node)) {\n      return {\n        pos: i > 0 ? $pos.before(i) : 0,\n        start: $pos.start(i),\n        depth: i,\n        node,\n      };\n    }\n  }\n};\n\n// Iterates over parent nodes, returning DOM reference of the closest node `predicate` returns truthy for.\n//\n// ```javascript\n// const domAtPos = view.domAtPos.bind(view);\n// const predicate = node => node.type === schema.nodes.table;\n// const parent = findParentDomRef(predicate, domAtPos)(selection); // <table>\n// ```\nexport const findParentDomRef =\n  (predicate: FindPredicate, domAtPos: DomAtPos) =>\n  (selection: Selection): Node | undefined => {\n    const parent = findParentNode(predicate)(selection);\n    if (parent) {\n      return findDomRefAtPos(parent.pos, domAtPos);\n    }\n  };\n\n// Checks if there's a parent node `predicate` returns truthy for.\n//\n// ```javascript\n// if (hasParentNode(node => node.type === schema.nodes.table)(selection)) {\n//   // ....\n// }\n// ```\nexport const hasParentNode =\n  (predicate: FindPredicate) =>\n  (selection: Selection): boolean => {\n    return !!findParentNode(predicate)(selection);\n  };\n\n// Iterates over parent nodes, returning closest node of a given `nodeType`. `start` points to the start position of the node, `pos` points directly before the node.\n//\n// ```javascript\n// const parent = findParentNodeOfType(schema.nodes.paragraph)(selection);\n// ```\nexport const findParentNodeOfType =\n  (nodeType: NodeTypeParam) =>\n  (selection: Selection): FindResult => {\n    return findParentNode((node) => equalNodeType(nodeType, node))(selection);\n  };\n\n// Iterates over parent nodes starting from the given `$pos`, returning closest node of a given `nodeType`. `start` points to the start position of the node, `pos` points directly before the node.\n//\n// ```javascript\n// const parent = findParentNodeOfTypeClosestToPos(state.doc.resolve(10), schema.nodes.paragraph);\n// ```\nexport const findParentNodeOfTypeClosestToPos = (\n  $pos: ResolvedPos,\n  nodeType: NodeTypeParam\n): FindResult => {\n  return findParentNodeClosestToPos($pos, (node: PMNode) =>\n    equalNodeType(nodeType, node)\n  );\n};\n\n// Checks if there's a parent node of a given `nodeType`.\n//\n// ```javascript\n// if (hasParentNodeOfType(schema.nodes.table)(selection)) {\n//   // ....\n// }\n// ```\nexport const hasParentNodeOfType =\n  (nodeType: NodeTypeParam) =>\n  (selection: Selection): boolean => {\n    return hasParentNode((node) => equalNodeType(nodeType, node))(selection);\n  };\n\n// Iterates over parent nodes, returning DOM reference of the closest node of a given `nodeType`.\n//\n// ```javascript\n// const domAtPos = view.domAtPos.bind(view);\n// const parent = findParentDomRefOfType(schema.nodes.codeBlock, domAtPos)(selection); // <pre>\n// ```\nexport const findParentDomRefOfType =\n  (nodeType: NodeTypeParam, domAtPos: DomAtPos) =>\n  (selection: Selection): Node | undefined => {\n    return findParentDomRef(\n      (node) => equalNodeType(nodeType, node),\n      domAtPos\n    )(selection);\n  };\n\n// Returns a node of a given `nodeType` if it is selected. `start` points to the start position of the node, `pos` points directly before the node.\n//\n// ```javascript\n// const { extension, inlineExtension, bodiedExtension } = schema.nodes;\n// const selectedNode = findSelectedNodeOfType([\n//   extension,\n//   inlineExtension,\n//   bodiedExtension,\n// ])(selection);\n// ```\nexport const findSelectedNodeOfType =\n  (nodeType: NodeTypeParam) =>\n  (selection: Selection): FindResult => {\n    if (isNodeSelection(selection)) {\n      const { node, $from } = selection;\n      if (equalNodeType(nodeType, node)) {\n        return {\n          node,\n          start: $from.start(),\n          pos: $from.pos,\n          depth: $from.depth,\n        };\n      }\n    }\n  };\n\n// Returns position of the previous node.\n//\n// ```javascript\n// const pos = findPositionOfNodeBefore(tr.selection);\n// ```\nexport const findPositionOfNodeBefore = (\n  selection: Selection\n): number | undefined => {\n  const { nodeBefore } = selection.$from;\n  const maybeSelection = Selection.findFrom(selection.$from, -1);\n  if (maybeSelection && nodeBefore) {\n    // leaf node\n    const parent = findParentNodeOfType(nodeBefore.type)(maybeSelection);\n    if (parent) {\n      return parent.pos;\n    }\n    return maybeSelection.$from.pos;\n  }\n};\n\n// Returns DOM reference of a node at a given `position`. If the node type is of type `TEXT_NODE` it will return the reference of the parent node.\n//\n// ```javascript\n// const domAtPos = view.domAtPos.bind(view);\n// const ref = findDomRefAtPos($from.pos, domAtPos);\n// ```\nexport const findDomRefAtPos = (position: number, domAtPos: DomAtPos): Node => {\n  const dom = domAtPos(position);\n  const node = dom.node.childNodes[dom.offset];\n\n  if (dom.node.nodeType === Node.TEXT_NODE && dom.node.parentNode) {\n    return dom.node.parentNode;\n  }\n\n  if (!node || node.nodeType === Node.TEXT_NODE) {\n    return dom.node;\n  }\n\n  return node;\n};\n", "import { Selection, NodeSelection, type Transaction } from 'prosemirror-state';\nimport { Fragment, Node as PMNode, type ResolvedPos } from 'prosemirror-model';\nimport { setTextSelection } from './transforms';\nimport type { NodeTypeParam, Content } from './types';\n\n// Checks if current selection is a `NodeSelection`.\n//\n// ```javascript\n// if (isNodeSelection(tr.selection)) {\n//   // ...\n// }\n// ```\nexport const isNodeSelection = (\n  selection: Selection\n): selection is NodeSelection => {\n  return selection instanceof NodeSelection;\n};\n\n// Checks if the type a given `node` equals to a given `nodeType`.\nexport const equalNodeType = (\n  nodeType: NodeTypeParam,\n  node: PMNode\n): boolean => {\n  return (\n    (Array.isArray(nodeType) && nodeType.indexOf(node.type) > -1) ||\n    node.type === nodeType\n  );\n};\n\n// Creates a new transaction object from a given transaction\nexport const cloneTr = (tr: Transaction): Transaction => {\n  return Object.assign(Object.create(tr), tr).setTime(Date.now());\n};\n\n// Returns a `replace` transaction that replaces a node at a given position with the given `content`.\n// It will return the original transaction if replacing is not possible.\n// `position` should point at the position immediately before the node.\nexport const replaceNodeAtPos =\n  (position: number, content: Content) =>\n  (tr: Transaction): Transaction => {\n    const node = tr.doc.nodeAt(position);\n    const $pos = tr.doc.resolve(position);\n    if (!node) {\n      return tr;\n    }\n\n    if (canReplace($pos, content)) {\n      tr = tr.replaceWith(position, position + node.nodeSize, content);\n      const start = tr.selection.$from.pos - 1;\n      // put cursor inside of the inserted node\n      tr = setTextSelection(Math.max(start, 0), -1)(tr);\n      // move cursor to the start of the node\n      tr = setTextSelection(tr.selection.$from.start())(tr);\n      return cloneTr(tr);\n    }\n    return tr;\n  };\n\n// Checks if replacing a node at a given `$pos` inside of the `doc` node with the given `content` is possible.\nexport const canReplace = ($pos: ResolvedPos, content: Content): boolean => {\n  const node = $pos.node($pos.depth);\n  return (\n    node &&\n    node.type.validContent(\n      content instanceof Fragment ? content : Fragment.from(content)\n    )\n  );\n};\n\n// Returns a `delete` transaction that removes a node at a given position with the given `node`.\n// `position` should point at the position immediately before the node.\nexport const removeNodeAtPos =\n  (position: number) =>\n  (tr: Transaction): Transaction => {\n    const node = tr.doc.nodeAt(position);\n    if (!node) {\n      return tr;\n    }\n\n    return cloneTr(tr.delete(position, position + node.nodeSize));\n  };\n\n// Checks if a given `content` can be inserted at the given `$pos`\n//\n// ```javascript\n// const { selection: { $from } } = state;\n// const node = state.schema.nodes.atom.createChecked();\n// if (canInsert($from, node)) {\n//   // ...\n// }\n// ```\nexport const canInsert = ($pos: ResolvedPos, content: Content): boolean => {\n  const index = $pos.index();\n\n  if (content instanceof Fragment) {\n    return $pos.parent.canReplace(index, index, content);\n  } else if (content instanceof PMNode) {\n    return $pos.parent.canReplaceWith(index, index, content.type);\n  }\n  return false;\n};\n\n// Checks if a given `node` is an empty paragraph\nexport const isEmptyParagraph = (node: PMNode): boolean => {\n  return !node || (node.type.name === 'paragraph' && node.nodeSize === 2);\n};\n\nexport const checkInvalidMovements = (\n  originIndex: number,\n  targetIndex: number,\n  targets: number[],\n  type: unknown\n): boolean => {\n  const direction = originIndex > targetIndex ? -1 : 1;\n  const errorMessage = `Target position is invalid, you can't move the ${type} ${originIndex} to ${targetIndex}, the target can't be split. You could use tryToFit option.`;\n\n  if (direction === 1) {\n    if (targets.slice(0, targets.length - 1).indexOf(targetIndex) !== -1) {\n      throw new Error(errorMessage);\n    }\n  } else {\n    if (targets.slice(1).indexOf(targetIndex) !== -1) {\n      throw new Error(errorMessage);\n    }\n  }\n\n  return true;\n};\n", "import { NodeSelection, Selection, type Transaction } from 'prosemirror-state';\nimport {\n  Fragment,\n  Node as PMNode,\n  type NodeType,\n  Mark,\n} from 'prosemirror-model';\nimport { findParentNodeOfType, findPositionOfNodeBefore } from './selection';\nimport {\n  cloneTr,\n  isNodeSelection,\n  replaceNodeAtPos,\n  removeNodeAtPos,\n  canInsert,\n  isEmptyParagraph,\n} from './helpers';\nimport type { Attrs, NodeTypeParam, Content } from './types';\n\n// Returns a new transaction that removes a node of a given `nodeType`. It will return an original transaction if parent node hasn't been found.\n//\n// ```javascript\n// dispatch(\n//   removeParentNodeOfType(schema.nodes.table)(tr)\n// );\n// ```\nexport const removeParentNodeOfType =\n  (nodeType: NodeTypeParam) =>\n  (tr: Transaction): Transaction => {\n    const parent = findParentNodeOfType(nodeType)(tr.selection);\n    if (parent) {\n      return removeNodeAtPos(parent.pos)(tr);\n    }\n    return tr;\n  };\n\n// Returns a new transaction that replaces parent node of a given `nodeType` with the given `content`. It will return an original transaction if either parent node hasn't been found or replacing is not possible.\n//\n// ```javascript\n// const node = schema.nodes.paragraph.createChecked({}, schema.text('new'));\n//\n// dispatch(\n//  replaceParentNodeOfType(schema.nodes.table, node)(tr)\n// );\n// ```\nexport const replaceParentNodeOfType =\n  (nodeType: NodeTypeParam, content: Content) =>\n  (tr: Transaction): Transaction => {\n    if (!Array.isArray(nodeType)) {\n      nodeType = [nodeType];\n    }\n    for (let i = 0, count = nodeType.length; i < count; i++) {\n      const parent = findParentNodeOfType(nodeType[i])(tr.selection);\n      if (parent) {\n        const newTr = replaceNodeAtPos(parent.pos, content)(tr);\n        if (newTr !== tr) {\n          return newTr;\n        }\n      }\n    }\n    return tr;\n  };\n\n// Returns a new transaction that removes selected node. It will return an original transaction if current selection is not a `NodeSelection`.\n//\n// ```javascript\n// dispatch(\n//   removeSelectedNode(tr)\n// );\n// ```\nexport const removeSelectedNode = (tr: Transaction): Transaction => {\n  if (isNodeSelection(tr.selection)) {\n    const from = tr.selection.$from.pos;\n    const to = tr.selection.$to.pos;\n    return cloneTr(tr.delete(from, to));\n  }\n  return tr;\n};\n\n// Returns a new transaction that replaces selected node with a given `node`, keeping NodeSelection on the new `node`.\n// It will return the original transaction if either current selection is not a NodeSelection or replacing is not possible.\n//\n// ```javascript\n// const node = schema.nodes.paragraph.createChecked({}, schema.text('new'));\n// dispatch(\n//   replaceSelectedNode(node)(tr)\n// );\n// ```\nexport const replaceSelectedNode =\n  (content: Content) =>\n  (tr: Transaction): Transaction => {\n    if (isNodeSelection(tr.selection)) {\n      const { $from, $to } = tr.selection;\n      if (\n        (content instanceof Fragment &&\n          $from.parent.canReplace(\n            $from.index(),\n            $from.indexAfter(),\n            content\n          )) ||\n        (content instanceof PMNode &&\n          $from.parent.canReplaceWith(\n            $from.index(),\n            $from.indexAfter(),\n            content.type\n          ))\n      ) {\n        return cloneTr(\n          tr\n            .replaceWith($from.pos, $to.pos, content)\n            // restore node selection\n            .setSelection(new NodeSelection(tr.doc.resolve($from.pos)))\n        );\n      }\n    }\n    return tr;\n  };\n\n// Returns a new transaction that tries to find a valid cursor selection starting at the given `position`\n// and searching back if `dir` is negative, and forward if positive.\n// If a valid cursor position hasn't been found, it will return the original transaction.\n//\n// ```javascript\n// dispatch(\n//   setTextSelection(5)(tr)\n// );\n// ```\nexport const setTextSelection =\n  (position: number, dir = 1) =>\n  (tr: Transaction): Transaction => {\n    const nextSelection = Selection.findFrom(\n      tr.doc.resolve(position),\n      dir,\n      true\n    );\n    if (nextSelection) {\n      return tr.setSelection(nextSelection);\n    }\n    return tr;\n  };\n\nconst isSelectableNode = (node: Content): node is PMNode =>\n  Boolean(node instanceof PMNode && node.type && node.type.spec.selectable);\nconst shouldSelectNode = (node: Content): boolean =>\n  isSelectableNode(node) && node.type.isLeaf;\n\nconst setSelection = (\n  node: Content,\n  pos: number,\n  tr: Transaction\n): Transaction => {\n  if (shouldSelectNode(node)) {\n    return tr.setSelection(new NodeSelection(tr.doc.resolve(pos)));\n  }\n  return setTextSelection(pos)(tr);\n};\n\n// Returns a new transaction that inserts a given `content` at the current cursor position, or at a given `position`, if it is allowed by schema. If schema restricts such nesting, it will try to find an appropriate place for a given node in the document, looping through parent nodes up until the root document node.\n// If `tryToReplace` is true and current selection is a NodeSelection, it will replace selected node with inserted content if its allowed by schema.\n// If cursor is inside of an empty paragraph, it will try to replace that paragraph with the given content. If insertion is successful and inserted node has content, it will set cursor inside of that content.\n// It will return an original transaction if the place for insertion hasn't been found.\n//\n// ```javascript\n// const node = schema.nodes.extension.createChecked({});\n// dispatch(\n//   safeInsert(node)(tr)\n// );\n// ```\nexport const safeInsert =\n  (content: Content, position?: number, tryToReplace?: boolean) =>\n  (tr: Transaction): Transaction => {\n    const hasPosition = typeof position === 'number';\n    const { $from } = tr.selection;\n    const $insertPos = hasPosition\n      ? tr.doc.resolve(position)\n      : isNodeSelection(tr.selection)\n      ? tr.doc.resolve($from.pos + 1)\n      : $from;\n    const { parent } = $insertPos;\n\n    // try to replace selected node\n    if (isNodeSelection(tr.selection) && tryToReplace) {\n      const oldTr = tr;\n      tr = replaceSelectedNode(content)(tr);\n      if (oldTr !== tr) {\n        return tr;\n      }\n    }\n\n    // try to replace an empty paragraph\n    if (isEmptyParagraph(parent)) {\n      const oldTr = tr;\n      tr = replaceParentNodeOfType(parent.type, content)(tr);\n      if (oldTr !== tr) {\n        const pos = isSelectableNode(content)\n          ? // for selectable node, selection position would be the position of the replaced parent\n            $insertPos.before($insertPos.depth)\n          : $insertPos.pos;\n        return setSelection(content, pos, tr);\n      }\n    }\n\n    // given node is allowed at the current cursor position\n    if (canInsert($insertPos, content)) {\n      tr.insert($insertPos.pos, content);\n      const pos = hasPosition\n        ? $insertPos.pos\n        : isSelectableNode(content)\n        ? // for atom nodes selection position after insertion is the previous pos\n          tr.selection.$anchor.pos - 1\n        : tr.selection.$anchor.pos;\n      return cloneTr(setSelection(content, pos, tr));\n    }\n\n    // looking for a place in the doc where the node is allowed\n    for (let i = $insertPos.depth; i > 0; i--) {\n      const pos = $insertPos.after(i);\n      const $pos = tr.doc.resolve(pos);\n      if (canInsert($pos, content)) {\n        tr.insert(pos, content);\n        return cloneTr(setSelection(content, pos, tr));\n      }\n    }\n    return tr;\n  };\n\n// Returns a transaction that changes the type, attributes, and/or marks of the parent node of a given `nodeType`.\n//\n// ```javascript\n// const node = schema.nodes.extension.createChecked({});\n// dispatch(\n//   setParentNodeMarkup(schema.nodes.panel, null, { panelType })(tr);\n// );\n// ```\nexport const setParentNodeMarkup =\n  (\n    nodeType: NodeTypeParam,\n    type: NodeType | null,\n    attrs?: Attrs | null,\n    marks?: Array<Mark> | ReadonlyArray<Mark>\n  ) =>\n  (tr: Transaction): Transaction => {\n    const parent = findParentNodeOfType(nodeType)(tr.selection);\n    if (parent) {\n      return cloneTr(\n        tr.setNodeMarkup(\n          parent.pos,\n          type,\n          Object.assign({}, parent.node.attrs, attrs),\n          marks\n        )\n      );\n    }\n    return tr;\n  };\n\n// Returns a new transaction that sets a `NodeSelection` on a parent node of a `given nodeType`.\n//\n// ```javascript\n// dispatch(\n//   selectParentNodeOfType([tableCell, tableHeader])(state.tr)\n// );\n// ```\nexport const selectParentNodeOfType =\n  (nodeType: NodeTypeParam) =>\n  (tr: Transaction): Transaction => {\n    if (!isNodeSelection(tr.selection)) {\n      const parent = findParentNodeOfType(nodeType)(tr.selection);\n      if (parent) {\n        return cloneTr(\n          tr.setSelection(NodeSelection.create(tr.doc, parent.pos))\n        );\n      }\n    }\n    return tr;\n  };\n\n// Returns a new transaction that deletes previous node.\n//\n// ```javascript\n// dispatch(\n//   removeNodeBefore(state.tr)\n// );\n// ```\nexport const removeNodeBefore = (tr: Transaction): Transaction => {\n  const position = findPositionOfNodeBefore(tr.selection);\n  if (typeof position === 'number') {\n    return removeNodeAtPos(position)(tr);\n  }\n  return tr;\n};\n", "import { type Node as PMNode, MarkType, NodeType } from 'prosemirror-model';\nimport type { Attrs } from './types';\n\ntype FindChildrenAttrsPredicate = (attrs: Attrs) => boolean;\ntype FindNodesResult = Array<{ node: PMNode; pos: number }>;\ntype FindChildrenPredicate = (node: PMNode) => boolean;\n\n// Flattens descendants of a given `node`. It doesn't descend into a node when descend argument is `false` (defaults to `true`).\n//\n// ```javascript\n// const children = flatten(node);\n// ```\nexport const flatten = (\n  node: PMNode,\n  descend: boolean = true\n): FindNodesResult => {\n  if (!node) {\n    throw new Error('Invalid \"node\" parameter');\n  }\n  const result: FindNodesResult = [];\n  node.descendants((child, pos) => {\n    result.push({ node: child, pos });\n    if (!descend) {\n      return false;\n    }\n  });\n  return result;\n};\n\n// Iterates over descendants of a given `node`, returning child nodes predicate returns truthy for. It doesn't descend into a node when descend argument is `false` (defaults to `true`).\n//\n// ```javascript\n// const textNodes = findChildren(node, child => child.isText, false);\n// ```\nexport const findChildren = (\n  node: PMNode,\n  predicate: FindChildrenPredicate,\n  descend: boolean = true\n): FindNodesResult => {\n  if (!node) {\n    throw new Error('Invalid \"node\" parameter');\n  } else if (!predicate) {\n    throw new Error('Invalid \"predicate\" parameter');\n  }\n  return flatten(node, descend).filter((child) => predicate(child.node));\n};\n\n// Returns text nodes of a given `node`. It doesn't descend into a node when descend argument is `false` (defaults to `true`).\n//\n// ```javascript\n// const textNodes = findTextNodes(node);\n// ```\nexport const findTextNodes = (\n  node: PMNode,\n  descend: boolean = true\n): FindNodesResult => {\n  return findChildren(node, (child) => child.isText, descend);\n};\n\n// Returns inline nodes of a given `node`. It doesn't descend into a node when descend argument is `false` (defaults to `true`).\n//\n// ```javascript\n// const inlineNodes = findInlineNodes(node);\n// ```\nexport const findInlineNodes = (\n  node: PMNode,\n  descend: boolean = true\n): FindNodesResult => {\n  return findChildren(node, (child) => child.isInline, descend);\n};\n\n// Returns block descendants of a given `node`. It doesn't descend into a node when descend argument is `false` (defaults to `true`).\n//\n// ```javascript\n// const blockNodes = findBlockNodes(node);\n// ```\nexport const findBlockNodes = (\n  node: PMNode,\n  descend: boolean = true\n): FindNodesResult => {\n  return findChildren(node, (child) => child.isBlock, descend);\n};\n\n// Iterates over descendants of a given `node`, returning child nodes predicate returns truthy for. It doesn't descend into a node when descend argument is `false` (defaults to `true`).\n//\n// ```javascript\n// const mergedCells = findChildrenByAttr(table, attrs => attrs.colspan === 2);\n// ```\nexport const findChildrenByAttr = (\n  node: PMNode,\n  predicate: FindChildrenAttrsPredicate,\n  descend: boolean = true\n): FindNodesResult => {\n  return findChildren(node, (child) => !!predicate(child.attrs), descend);\n};\n\n// Iterates over descendants of a given `node`, returning child nodes of a given nodeType. It doesn't descend into a node when descend argument is `false` (defaults to `true`).\n//\n// ```javascript\n// const cells = findChildrenByType(table, schema.nodes.tableCell);\n// ```\nexport const findChildrenByType = (\n  node: PMNode,\n  nodeType: NodeType,\n  descend: boolean = true\n): FindNodesResult => {\n  return findChildren(node, (child) => child.type === nodeType, descend);\n};\n\n// Iterates over descendants of a given `node`, returning child nodes that have a mark of a given markType. It doesn't descend into a `node` when descend argument is `false` (defaults to `true`).\n//\n// ```javascript\n// const nodes = findChildrenByMark(state.doc, schema.marks.strong);\n// ```\nexport const findChildrenByMark = (\n  node: PMNode,\n  markType: MarkType,\n  descend: boolean = true\n): FindNodesResult => {\n  return findChildren(\n    node,\n    (child) => Boolean(markType.isInSet(child.marks)),\n    descend\n  );\n};\n\n// Returns `true` if a given node contains nodes of a given `nodeType`\n//\n// ```javascript\n// if (contains(panel, schema.nodes.listItem)) {\n//   // ...\n// }\n// ```\nexport const contains = (node: PMNode, nodeType: NodeType): boolean => {\n  return !!findChildrenByType(node, nodeType).length;\n};\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACCA,IAAAA,4BAA0B;;;ACD1B,IAAAC,4BAA2D;AAC3D,IAAAC,4BAA2D;;;ACD3D,+BAA2D;AAC3D,+BAKO;AAmBA,IAAM,yBACX,CAAC,aACD,CAAC,OAAiC;AAChC,QAAM,SAAS,qBAAqB,QAAQ,EAAE,GAAG,SAAS;AAC1D,MAAI,QAAQ;AACV,WAAO,gBAAgB,OAAO,GAAG,EAAE,EAAE;AAAA,EACvC;AACA,SAAO;AACT;AAWK,IAAM,0BACX,CAAC,UAAyB,YAC1B,CAAC,OAAiC;AAChC,MAAI,CAAC,MAAM,QAAQ,QAAQ,GAAG;AAC5B,eAAW,CAAC,QAAQ;AAAA,EACtB;AACA,WAAS,IAAI,GAAG,QAAQ,SAAS,QAAQ,IAAI,OAAO,KAAK;AACvD,UAAM,SAAS,qBAAqB,SAAS,CAAC,CAAC,EAAE,GAAG,SAAS;AAC7D,QAAI,QAAQ;AACV,YAAM,QAAQ,iBAAiB,OAAO,KAAK,OAAO,EAAE,EAAE;AACtD,UAAI,UAAU,IAAI;AAChB,eAAO;AAAA,MACT;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;AASK,IAAM,qBAAqB,CAAC,OAAiC;AAClE,MAAI,gBAAgB,GAAG,SAAS,GAAG;AACjC,UAAM,OAAO,GAAG,UAAU,MAAM;AAChC,UAAM,KAAK,GAAG,UAAU,IAAI;AAC5B,WAAO,QAAQ,GAAG,OAAO,MAAM,EAAE,CAAC;AAAA,EACpC;AACA,SAAO;AACT;AAWO,IAAM,sBACX,CAAC,YACD,CAAC,OAAiC;AAChC,MAAI,gBAAgB,GAAG,SAAS,GAAG;AACjC,UAAM,EAAE,OAAO,IAAI,IAAI,GAAG;AAC1B,QACG,mBAAmB,qCAClB,MAAM,OAAO;AAAA,MACX,MAAM,MAAM;AAAA,MACZ,MAAM,WAAW;AAAA,MACjB;AAAA,IACF,KACD,mBAAmB,yBAAAC,QAClB,MAAM,OAAO;AAAA,MACX,MAAM,MAAM;AAAA,MACZ,MAAM,WAAW;AAAA,MACjB,QAAQ;AAAA,IACV,GACF;AACA,aAAO;AAAA,QACL,GACG,YAAY,MAAM,KAAK,IAAI,KAAK,OAAO,EAEvC,aAAa,IAAI,uCAAc,GAAG,IAAI,QAAQ,MAAM,GAAG,CAAC,CAAC;AAAA,MAC9D;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;AAWK,IAAM,mBACX,CAAC,UAAkB,MAAM,MACzB,CAAC,OAAiC;AAChC,QAAM,gBAAgB,mCAAU;AAAA,IAC9B,GAAG,IAAI,QAAQ,QAAQ;AAAA,IACvB;AAAA,IACA;AAAA,EACF;AACA,MAAI,eAAe;AACjB,WAAO,GAAG,aAAa,aAAa;AAAA,EACtC;AACA,SAAO;AACT;AAEF,IAAM,mBAAmB,CAAC,SACxB,QAAQ,gBAAgB,yBAAAA,QAAU,KAAK,QAAQ,KAAK,KAAK,KAAK,UAAU;AAC1E,IAAM,mBAAmB,CAAC,SACxB,iBAAiB,IAAI,KAAK,KAAK,KAAK;AAEtC,IAAM,eAAe,CACnB,MACA,KACA,OACgB;AAChB,MAAI,iBAAiB,IAAI,GAAG;AAC1B,WAAO,GAAG,aAAa,IAAI,uCAAc,GAAG,IAAI,QAAQ,GAAG,CAAC,CAAC;AAAA,EAC/D;AACA,SAAO,iBAAiB,GAAG,EAAE,EAAE;AACjC;AAaO,IAAM,aACX,CAAC,SAAkB,UAAmB,iBACtC,CAAC,OAAiC;AAChC,QAAM,cAAc,OAAO,aAAa;AACxC,QAAM,EAAE,MAAM,IAAI,GAAG;AACrB,QAAM,aAAa,cACf,GAAG,IAAI,QAAQ,QAAQ,IACvB,gBAAgB,GAAG,SAAS,IAC5B,GAAG,IAAI,QAAQ,MAAM,MAAM,CAAC,IAC5B;AACJ,QAAM,EAAE,OAAO,IAAI;AAGnB,MAAI,gBAAgB,GAAG,SAAS,KAAK,cAAc;AACjD,UAAM,QAAQ;AACd,SAAK,oBAAoB,OAAO,EAAE,EAAE;AACpC,QAAI,UAAU,IAAI;AAChB,aAAO;AAAA,IACT;AAAA,EACF;AAGA,MAAI,iBAAiB,MAAM,GAAG;AAC5B,UAAM,QAAQ;AACd,SAAK,wBAAwB,OAAO,MAAM,OAAO,EAAE,EAAE;AACrD,QAAI,UAAU,IAAI;AAChB,YAAM,MAAM,iBAAiB,OAAO;AAAA;AAAA,QAEhC,WAAW,OAAO,WAAW,KAAK;AAAA,UAClC,WAAW;AACf,aAAO,aAAa,SAAS,KAAK,EAAE;AAAA,IACtC;AAAA,EACF;AAGA,MAAI,UAAU,YAAY,OAAO,GAAG;AAClC,OAAG,OAAO,WAAW,KAAK,OAAO;AACjC,UAAM,MAAM,cACR,WAAW,MACX,iBAAiB,OAAO;AAAA;AAAA,MAExB,GAAG,UAAU,QAAQ,MAAM;AAAA,QAC3B,GAAG,UAAU,QAAQ;AACzB,WAAO,QAAQ,aAAa,SAAS,KAAK,EAAE,CAAC;AAAA,EAC/C;AAGA,WAAS,IAAI,WAAW,OAAO,IAAI,GAAG,KAAK;AACzC,UAAM,MAAM,WAAW,MAAM,CAAC;AAC9B,UAAM,OAAO,GAAG,IAAI,QAAQ,GAAG;AAC/B,QAAI,UAAU,MAAM,OAAO,GAAG;AAC5B,SAAG,OAAO,KAAK,OAAO;AACtB,aAAO,QAAQ,aAAa,SAAS,KAAK,EAAE,CAAC;AAAA,IAC/C;AAAA,EACF;AACA,SAAO;AACT;AAUK,IAAM,sBACX,CACE,UACA,MACA,OACA,UAEF,CAAC,OAAiC;AAChC,QAAM,SAAS,qBAAqB,QAAQ,EAAE,GAAG,SAAS;AAC1D,MAAI,QAAQ;AACV,WAAO;AAAA,MACL,GAAG;AAAA,QACD,OAAO;AAAA,QACP;AAAA,QACA,OAAO,OAAO,CAAC,GAAG,OAAO,KAAK,OAAO,KAAK;AAAA,QAC1C;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;AASK,IAAM,yBACX,CAAC,aACD,CAAC,OAAiC;AAChC,MAAI,CAAC,gBAAgB,GAAG,SAAS,GAAG;AAClC,UAAM,SAAS,qBAAqB,QAAQ,EAAE,GAAG,SAAS;AAC1D,QAAI,QAAQ;AACV,aAAO;AAAA,QACL,GAAG,aAAa,uCAAc,OAAO,GAAG,KAAK,OAAO,GAAG,CAAC;AAAA,MAC1D;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;AASK,IAAM,mBAAmB,CAAC,OAAiC;AAChE,QAAM,WAAW,yBAAyB,GAAG,SAAS;AACtD,MAAI,OAAO,aAAa,UAAU;AAChC,WAAO,gBAAgB,QAAQ,EAAE,EAAE;AAAA,EACrC;AACA,SAAO;AACT;;;ADrRO,IAAM,kBAAkB,CAC7B,cAC+B;AAC/B,SAAO,qBAAqB;AAC9B;AAGO,IAAM,gBAAgB,CAC3B,UACA,SACY;AACZ,SACG,MAAM,QAAQ,QAAQ,KAAK,SAAS,QAAQ,KAAK,IAAI,IAAI,MAC1D,KAAK,SAAS;AAElB;AAGO,IAAM,UAAU,CAAC,OAAiC;AACvD,SAAO,OAAO,OAAO,OAAO,OAAO,EAAE,GAAG,EAAE,EAAE,QAAQ,KAAK,IAAI,CAAC;AAChE;AAKO,IAAM,mBACX,CAAC,UAAkB,YACnB,CAAC,OAAiC;AAChC,QAAM,OAAO,GAAG,IAAI,OAAO,QAAQ;AACnC,QAAM,OAAO,GAAG,IAAI,QAAQ,QAAQ;AACpC,MAAI,CAAC,MAAM;AACT,WAAO;AAAA,EACT;AAEA,MAAI,WAAW,MAAM,OAAO,GAAG;AAC7B,SAAK,GAAG,YAAY,UAAU,WAAW,KAAK,UAAU,OAAO;AAC/D,UAAM,QAAQ,GAAG,UAAU,MAAM,MAAM;AAEvC,SAAK,iBAAiB,KAAK,IAAI,OAAO,CAAC,GAAG,EAAE,EAAE,EAAE;AAEhD,SAAK,iBAAiB,GAAG,UAAU,MAAM,MAAM,CAAC,EAAE,EAAE;AACpD,WAAO,QAAQ,EAAE;AAAA,EACnB;AACA,SAAO;AACT;AAGK,IAAM,aAAa,CAAC,MAAmB,YAA8B;AAC1E,QAAM,OAAO,KAAK,KAAK,KAAK,KAAK;AACjC,SACE,QACA,KAAK,KAAK;AAAA,IACR,mBAAmB,qCAAW,UAAU,mCAAS,KAAK,OAAO;AAAA,EAC/D;AAEJ;AAIO,IAAM,kBACX,CAAC,aACD,CAAC,OAAiC;AAChC,QAAM,OAAO,GAAG,IAAI,OAAO,QAAQ;AACnC,MAAI,CAAC,MAAM;AACT,WAAO;AAAA,EACT;AAEA,SAAO,QAAQ,GAAG,OAAO,UAAU,WAAW,KAAK,QAAQ,CAAC;AAC9D;AAWK,IAAM,YAAY,CAAC,MAAmB,YAA8B;AACzE,QAAM,QAAQ,KAAK,MAAM;AAEzB,MAAI,mBAAmB,oCAAU;AAC/B,WAAO,KAAK,OAAO,WAAW,OAAO,OAAO,OAAO;AAAA,EACrD,WAAW,mBAAmB,0BAAAC,MAAQ;AACpC,WAAO,KAAK,OAAO,eAAe,OAAO,OAAO,QAAQ,IAAI;AAAA,EAC9D;AACA,SAAO;AACT;AAGO,IAAM,mBAAmB,CAAC,SAA0B;AACzD,SAAO,CAAC,QAAS,KAAK,KAAK,SAAS,eAAe,KAAK,aAAa;AACvE;;;ADzFO,IAAM,iBACX,CAAC,cACD,CACE,EAAE,OAAO,IAAI,GACb,qBAA8B,UACf;AAEf,MAAI,sBAAsB,CAAC,MAAM,WAAW,GAAG,GAAG;AAEhD,QAAI,QAAQ,KAAK,IAAI,MAAM,OAAO,IAAI,KAAK;AAC3C,WAAO,SAAS,GAAG;AACjB,YAAM,WAAW,MAAM,KAAK,KAAK;AACjC,YAAM,SAAS,IAAI,KAAK,KAAK;AAC7B,UAAI,WAAW,UAAU;AAEvB,YAAI,UAAU,QAAQ,GAAG;AAEvB,iBAAO;AAAA;AAAA,YAEL,KAAK,QAAQ,IAAI,MAAM,OAAO,KAAK,IAAI;AAAA,YACvC,OAAO,MAAM,MAAM,KAAK;AAAA,YACxB;AAAA,YACA,MAAM;AAAA,UACR;AAAA,QACF;AAAA,MACF;AACA,cAAQ,QAAQ;AAAA,IAClB;AACA;AAAA,EACF;AAEA,SAAO,2BAA2B,OAAO,SAAS;AACpD;AAQK,IAAM,6BAA6B,CACxC,MACA,cACe;AACf,WAAS,IAAI,KAAK,OAAO,IAAI,GAAG,KAAK;AACnC,UAAM,OAAO,KAAK,KAAK,CAAC;AACxB,QAAI,UAAU,IAAI,GAAG;AACnB,aAAO;AAAA,QACL,KAAK,IAAI,IAAI,KAAK,OAAO,CAAC,IAAI;AAAA,QAC9B,OAAO,KAAK,MAAM,CAAC;AAAA,QACnB,OAAO;AAAA,QACP;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AASO,IAAM,mBACX,CAAC,WAA0B,aAC3B,CAAC,cAA2C;AAC1C,QAAM,SAAS,eAAe,SAAS,EAAE,SAAS;AAClD,MAAI,QAAQ;AACV,WAAO,gBAAgB,OAAO,KAAK,QAAQ;AAAA,EAC7C;AACF;AASK,IAAM,gBACX,CAAC,cACD,CAAC,cAAkC;AACjC,SAAO,CAAC,CAAC,eAAe,SAAS,EAAE,SAAS;AAC9C;AAOK,IAAM,uBACX,CAAC,aACD,CAAC,cAAqC;AACpC,SAAO,eAAe,CAAC,SAAS,cAAc,UAAU,IAAI,CAAC,EAAE,SAAS;AAC1E;AAOK,IAAM,mCAAmC,CAC9C,MACA,aACe;AACf,SAAO;AAAA,IAA2B;AAAA,IAAM,CAAC,SACvC,cAAc,UAAU,IAAI;AAAA,EAC9B;AACF;AASO,IAAM,sBACX,CAAC,aACD,CAAC,cAAkC;AACjC,SAAO,cAAc,CAAC,SAAS,cAAc,UAAU,IAAI,CAAC,EAAE,SAAS;AACzE;AAQK,IAAM,yBACX,CAAC,UAAyB,aAC1B,CAAC,cAA2C;AAC1C,SAAO;AAAA,IACL,CAAC,SAAS,cAAc,UAAU,IAAI;AAAA,IACtC;AAAA,EACF,EAAE,SAAS;AACb;AAYK,IAAM,yBACX,CAAC,aACD,CAAC,cAAqC;AACpC,MAAI,gBAAgB,SAAS,GAAG;AAC9B,UAAM,EAAE,MAAM,MAAM,IAAI;AACxB,QAAI,cAAc,UAAU,IAAI,GAAG;AACjC,aAAO;AAAA,QACL;AAAA,QACA,OAAO,MAAM,MAAM;AAAA,QACnB,KAAK,MAAM;AAAA,QACX,OAAO,MAAM;AAAA,MACf;AAAA,IACF;AAAA,EACF;AACF;AAOK,IAAM,2BAA2B,CACtC,cACuB;AACvB,QAAM,EAAE,WAAW,IAAI,UAAU;AACjC,QAAM,iBAAiB,oCAAU,SAAS,UAAU,OAAO,EAAE;AAC7D,MAAI,kBAAkB,YAAY;AAEhC,UAAM,SAAS,qBAAqB,WAAW,IAAI,EAAE,cAAc;AACnE,QAAI,QAAQ;AACV,aAAO,OAAO;AAAA,IAChB;AACA,WAAO,eAAe,MAAM;AAAA,EAC9B;AACF;AAQO,IAAM,kBAAkB,CAAC,UAAkB,aAA6B;AAC7E,QAAM,MAAM,SAAS,QAAQ;AAC7B,QAAM,OAAO,IAAI,KAAK,WAAW,IAAI,MAAM;AAE3C,MAAI,IAAI,KAAK,aAAa,KAAK,aAAa,IAAI,KAAK,YAAY;AAC/D,WAAO,IAAI,KAAK;AAAA,EAClB;AAEA,MAAI,CAAC,QAAQ,KAAK,aAAa,KAAK,WAAW;AAC7C,WAAO,IAAI;AAAA,EACb;AAEA,SAAO;AACT;;;AGhNO,IAAM,UAAU,CACrB,MACA,UAAmB,SACC;AACpB,MAAI,CAAC,MAAM;AACT,UAAM,IAAI,MAAM,0BAA0B;AAAA,EAC5C;AACA,QAAM,SAA0B,CAAC;AACjC,OAAK,YAAY,CAAC,OAAO,QAAQ;AAC/B,WAAO,KAAK,EAAE,MAAM,OAAO,IAAI,CAAC;AAChC,QAAI,CAAC,SAAS;AACZ,aAAO;AAAA,IACT;AAAA,EACF,CAAC;AACD,SAAO;AACT;AAOO,IAAM,eAAe,CAC1B,MACA,WACA,UAAmB,SACC;AACpB,MAAI,CAAC,MAAM;AACT,UAAM,IAAI,MAAM,0BAA0B;AAAA,EAC5C,WAAW,CAAC,WAAW;AACrB,UAAM,IAAI,MAAM,+BAA+B;AAAA,EACjD;AACA,SAAO,QAAQ,MAAM,OAAO,EAAE,OAAO,CAAC,UAAU,UAAU,MAAM,IAAI,CAAC;AACvE;AAOO,IAAM,gBAAgB,CAC3B,MACA,UAAmB,SACC;AACpB,SAAO,aAAa,MAAM,CAAC,UAAU,MAAM,QAAQ,OAAO;AAC5D;AAOO,IAAM,kBAAkB,CAC7B,MACA,UAAmB,SACC;AACpB,SAAO,aAAa,MAAM,CAAC,UAAU,MAAM,UAAU,OAAO;AAC9D;AAOO,IAAM,iBAAiB,CAC5B,MACA,UAAmB,SACC;AACpB,SAAO,aAAa,MAAM,CAAC,UAAU,MAAM,SAAS,OAAO;AAC7D;AAOO,IAAM,qBAAqB,CAChC,MACA,WACA,UAAmB,SACC;AACpB,SAAO,aAAa,MAAM,CAAC,UAAU,CAAC,CAAC,UAAU,MAAM,KAAK,GAAG,OAAO;AACxE;AAOO,IAAM,qBAAqB,CAChC,MACA,UACA,UAAmB,SACC;AACpB,SAAO,aAAa,MAAM,CAAC,UAAU,MAAM,SAAS,UAAU,OAAO;AACvE;AAOO,IAAM,qBAAqB,CAChC,MACA,UACA,UAAmB,SACC;AACpB,SAAO;AAAA,IACL;AAAA,IACA,CAAC,UAAU,QAAQ,SAAS,QAAQ,MAAM,KAAK,CAAC;AAAA,IAChD;AAAA,EACF;AACF;AASO,IAAM,WAAW,CAAC,MAAc,aAAgC;AACrE,SAAO,CAAC,CAAC,mBAAmB,MAAM,QAAQ,EAAE;AAC9C;",
  "names": ["import_prosemirror_state", "import_prosemirror_state", "import_prosemirror_model", "PMNode", "PMNode"]
}