@123usmanhaider321/ui 0.1.8 → 1.0.2

package/dist/node_modules/@tiptap/extension-list/dist/index.js

@@ -1,1039 +0,0 @@
-import { Node as Node3, wrappingInputRule, mergeAttributes, renderNestedMarkdownContent, Extension, isNodeActive, isAtStartOfNode, isAtEndOfNode, getNodeType, getNodeAtPosition, getRenderedAttributes, parseIndentedBlocks } from "../../core/dist/index.js";
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var ListItemName = "listItem";
-var TextStyleName = "textStyle";
-var bulletListInputRegex = /^\s*([-+*])\s$/;
-var BulletList = Node3.create({
-  name: "bulletList",
-  addOptions() {
-    return {
-      itemTypeName: "listItem",
-      HTMLAttributes: {},
-      keepMarks: false,
-      keepAttributes: false
-    };
-  },
-  group: "block list",
-  content() {
-    return `${this.options.itemTypeName}+`;
-  },
-  parseHTML() {
-    return [{ tag: "ul" }];
-  },
-  renderHTML({ HTMLAttributes }) {
-    return ["ul", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
-  },
-  markdownTokenName: "list",
-  parseMarkdown: (token, helpers) => {
-    if (token.type !== "list" || token.ordered) {
-      return [];
-    }
-    return {
-      type: "bulletList",
-      content: token.items ? helpers.parseChildren(token.items) : []
-    };
-  },
-  renderMarkdown: (node, h) => {
-    if (!node.content) {
-      return "";
-    }
-    return h.renderChildren(node.content, "\n");
-  },
-  markdownOptions: {
-    indentsContent: true
-  },
-  addCommands() {
-    return {
-      toggleBulletList: () => ({ commands, chain }) => {
-        if (this.options.keepAttributes) {
-          return chain().toggleList(this.name, this.options.itemTypeName, this.options.keepMarks).updateAttributes(ListItemName, this.editor.getAttributes(TextStyleName)).run();
-        }
-        return commands.toggleList(this.name, this.options.itemTypeName, this.options.keepMarks);
-      }
-    };
-  },
-  addKeyboardShortcuts() {
-    return {
-      "Mod-Shift-8": () => this.editor.commands.toggleBulletList()
-    };
-  },
-  addInputRules() {
-    let inputRule = wrappingInputRule({
-      find: bulletListInputRegex,
-      type: this.type
-    });
-    if (this.options.keepMarks || this.options.keepAttributes) {
-      inputRule = wrappingInputRule({
-        find: bulletListInputRegex,
-        type: this.type,
-        keepMarks: this.options.keepMarks,
-        keepAttributes: this.options.keepAttributes,
-        getAttributes: () => {
-          return this.editor.getAttributes(TextStyleName);
-        },
-        editor: this.editor
-      });
-    }
-    return [inputRule];
-  }
-});
-var ListItem = Node3.create({
-  name: "listItem",
-  addOptions() {
-    return {
-      HTMLAttributes: {},
-      bulletListTypeName: "bulletList",
-      orderedListTypeName: "orderedList"
-    };
-  },
-  content: "paragraph block*",
-  defining: true,
-  parseHTML() {
-    return [
-      {
-        tag: "li"
-      }
-    ];
-  },
-  renderHTML({ HTMLAttributes }) {
-    return ["li", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
-  },
-  markdownTokenName: "list_item",
-  parseMarkdown: (token, helpers) => {
-    var _a;
-    if (token.type !== "list_item") {
-      return [];
-    }
-    const parseBlockChildren = (_a = helpers.parseBlockChildren) != null ? _a : helpers.parseChildren;
-    let content = [];
-    if (token.tokens && token.tokens.length > 0) {
-      const hasParagraphTokens = token.tokens.some((t) => t.type === "paragraph");
-      if (hasParagraphTokens) {
-        content = parseBlockChildren(token.tokens);
-      } else {
-        const firstToken = token.tokens[0];
-        if (firstToken && firstToken.type === "text" && firstToken.tokens && firstToken.tokens.length > 0) {
-          const inlineContent = helpers.parseInline(firstToken.tokens);
-          content = [
-            {
-              type: "paragraph",
-              content: inlineContent
-            }
-          ];
-          if (token.tokens.length > 1) {
-            const remainingTokens = token.tokens.slice(1);
-            const additionalContent = parseBlockChildren(remainingTokens);
-            content.push(...additionalContent);
-          }
-        } else {
-          content = parseBlockChildren(token.tokens);
-        }
-      }
-    }
-    if (content.length === 0) {
-      content = [
-        {
-          type: "paragraph",
-          content: []
-        }
-      ];
-    }
-    return {
-      type: "listItem",
-      content
-    };
-  },
-  renderMarkdown: (node, h, ctx) => {
-    return renderNestedMarkdownContent(
-      node,
-      h,
-      (context) => {
-        var _a, _b;
-        if (context.parentType === "bulletList") {
-          return "- ";
-        }
-        if (context.parentType === "orderedList") {
-          const start = ((_b = (_a = context.meta) == null ? void 0 : _a.parentAttrs) == null ? void 0 : _b.start) || 1;
-          return `${start + context.index}. `;
-        }
-        return "- ";
-      },
-      ctx
-    );
-  },
-  addKeyboardShortcuts() {
-    return {
-      Enter: () => this.editor.commands.splitListItem(this.name),
-      Tab: () => this.editor.commands.sinkListItem(this.name),
-      "Shift-Tab": () => this.editor.commands.liftListItem(this.name)
-    };
-  }
-});
-var listHelpers_exports = {};
-__export(listHelpers_exports, {
-  findListItemPos: () => findListItemPos,
-  getNextListDepth: () => getNextListDepth,
-  handleBackspace: () => handleBackspace,
-  handleDelete: () => handleDelete,
-  hasListBefore: () => hasListBefore,
-  hasListItemAfter: () => hasListItemAfter,
-  hasListItemBefore: () => hasListItemBefore,
-  listItemHasSubList: () => listItemHasSubList,
-  nextListIsDeeper: () => nextListIsDeeper,
-  nextListIsHigher: () => nextListIsHigher
-});
-var findListItemPos = (typeOrName, state) => {
-  const { $from } = state.selection;
-  const nodeType = getNodeType(typeOrName, state.schema);
-  let currentNode = null;
-  let currentDepth = $from.depth;
-  let currentPos = $from.pos;
-  let targetDepth = null;
-  while (currentDepth > 0 && targetDepth === null) {
-    currentNode = $from.node(currentDepth);
-    if (currentNode.type === nodeType) {
-      targetDepth = currentDepth;
-    } else {
-      currentDepth -= 1;
-      currentPos -= 1;
-    }
-  }
-  if (targetDepth === null) {
-    return null;
-  }
-  return { $pos: state.doc.resolve(currentPos), depth: targetDepth };
-};
-var getNextListDepth = (typeOrName, state) => {
-  const listItemPos = findListItemPos(typeOrName, state);
-  if (!listItemPos) {
-    return false;
-  }
-  const [, depth] = getNodeAtPosition(state, typeOrName, listItemPos.$pos.pos + 4);
-  return depth;
-};
-var hasListBefore = (editorState, name, parentListTypes) => {
-  const { $anchor } = editorState.selection;
-  const previousNodePos = Math.max(0, $anchor.pos - 2);
-  const previousNode = editorState.doc.resolve(previousNodePos).node();
-  if (!previousNode || !parentListTypes.includes(previousNode.type.name)) {
-    return false;
-  }
-  return true;
-};
-var hasListItemBefore = (typeOrName, state) => {
-  var _a;
-  const { $anchor } = state.selection;
-  const $targetPos = state.doc.resolve($anchor.pos - 2);
-  if ($targetPos.index() === 0) {
-    return false;
-  }
-  if (((_a = $targetPos.nodeBefore) == null ? void 0 : _a.type.name) !== typeOrName) {
-    return false;
-  }
-  return true;
-};
-var listItemHasSubList = (typeOrName, state, node) => {
-  if (!node) {
-    return false;
-  }
-  const nodeType = getNodeType(typeOrName, state.schema);
-  let hasSubList = false;
-  node.descendants((child) => {
-    if (child.type === nodeType) {
-      hasSubList = true;
-    }
-  });
-  return hasSubList;
-};
-var handleBackspace = (editor, name, parentListTypes) => {
-  if (editor.commands.undoInputRule()) {
-    return true;
-  }
-  if (editor.state.selection.from !== editor.state.selection.to) {
-    return false;
-  }
-  if (!isNodeActive(editor.state, name) && hasListBefore(editor.state, name, parentListTypes)) {
-    const { $anchor } = editor.state.selection;
-    const $listPos = editor.state.doc.resolve($anchor.before() - 1);
-    const listDescendants = [];
-    $listPos.node().descendants((node, pos) => {
-      if (node.type.name === name) {
-        listDescendants.push({ node, pos });
-      }
-    });
-    const lastItem = listDescendants.at(-1);
-    if (!lastItem) {
-      return false;
-    }
-    const $lastItemPos = editor.state.doc.resolve($listPos.start() + lastItem.pos + 1);
-    return editor.chain().cut({ from: $anchor.start() - 1, to: $anchor.end() + 1 }, $lastItemPos.end()).joinForward().run();
-  }
-  if (!isNodeActive(editor.state, name)) {
-    return false;
-  }
-  if (!isAtStartOfNode(editor.state)) {
-    return false;
-  }
-  const listItemPos = findListItemPos(name, editor.state);
-  if (!listItemPos) {
-    return false;
-  }
-  const $prev = editor.state.doc.resolve(listItemPos.$pos.pos - 2);
-  const prevNode = $prev.node(listItemPos.depth);
-  const previousListItemHasSubList = listItemHasSubList(name, editor.state, prevNode);
-  if (hasListItemBefore(name, editor.state) && !previousListItemHasSubList) {
-    return editor.commands.joinItemBackward();
-  }
-  return editor.chain().liftListItem(name).run();
-};
-var nextListIsDeeper = (typeOrName, state) => {
-  const listDepth = getNextListDepth(typeOrName, state);
-  const listItemPos = findListItemPos(typeOrName, state);
-  if (!listItemPos || !listDepth) {
-    return false;
-  }
-  if (listDepth > listItemPos.depth) {
-    return true;
-  }
-  return false;
-};
-var nextListIsHigher = (typeOrName, state) => {
-  const listDepth = getNextListDepth(typeOrName, state);
-  const listItemPos = findListItemPos(typeOrName, state);
-  if (!listItemPos || !listDepth) {
-    return false;
-  }
-  if (listDepth < listItemPos.depth) {
-    return true;
-  }
-  return false;
-};
-var handleDelete = (editor, name) => {
-  if (!isNodeActive(editor.state, name)) {
-    return false;
-  }
-  if (!isAtEndOfNode(editor.state, name)) {
-    return false;
-  }
-  const { selection } = editor.state;
-  const { $from, $to } = selection;
-  if (!selection.empty && $from.sameParent($to)) {
-    return false;
-  }
-  if (nextListIsDeeper(name, editor.state)) {
-    return editor.chain().focus(editor.state.selection.from + 4).lift(name).joinBackward().run();
-  }
-  if (nextListIsHigher(name, editor.state)) {
-    return editor.chain().joinForward().joinBackward().run();
-  }
-  return editor.commands.joinItemForward();
-};
-var hasListItemAfter = (typeOrName, state) => {
-  var _a;
-  const { $anchor } = state.selection;
-  const $targetPos = state.doc.resolve($anchor.pos - $anchor.parentOffset - 2);
-  if ($targetPos.index() === $targetPos.parent.childCount - 1) {
-    return false;
-  }
-  if (((_a = $targetPos.nodeAfter) == null ? void 0 : _a.type.name) !== typeOrName) {
-    return false;
-  }
-  return true;
-};
-var ListKeymap = Extension.create({
-  name: "listKeymap",
-  addOptions() {
-    return {
-      listTypes: [
-        {
-          itemName: "listItem",
-          wrapperNames: ["bulletList", "orderedList"]
-        },
-        {
-          itemName: "taskItem",
-          wrapperNames: ["taskList"]
-        }
-      ]
-    };
-  },
-  addKeyboardShortcuts() {
-    return {
-      Delete: ({ editor }) => {
-        let handled = false;
-        this.options.listTypes.forEach(({ itemName }) => {
-          if (editor.state.schema.nodes[itemName] === void 0) {
-            return;
-          }
-          if (handleDelete(editor, itemName)) {
-            handled = true;
-          }
-        });
-        return handled;
-      },
-      "Mod-Delete": ({ editor }) => {
-        let handled = false;
-        this.options.listTypes.forEach(({ itemName }) => {
-          if (editor.state.schema.nodes[itemName] === void 0) {
-            return;
-          }
-          if (handleDelete(editor, itemName)) {
-            handled = true;
-          }
-        });
-        return handled;
-      },
-      Backspace: ({ editor }) => {
-        let handled = false;
-        this.options.listTypes.forEach(({ itemName, wrapperNames }) => {
-          if (editor.state.schema.nodes[itemName] === void 0) {
-            return;
-          }
-          if (handleBackspace(editor, itemName, wrapperNames)) {
-            handled = true;
-          }
-        });
-        return handled;
-      },
-      "Mod-Backspace": ({ editor }) => {
-        let handled = false;
-        this.options.listTypes.forEach(({ itemName, wrapperNames }) => {
-          if (editor.state.schema.nodes[itemName] === void 0) {
-            return;
-          }
-          if (handleBackspace(editor, itemName, wrapperNames)) {
-            handled = true;
-          }
-        });
-        return handled;
-      }
-    };
-  }
-});
-var ORDERED_LIST_ITEM_REGEX = /^(\s*)(\d+)\.\s+(.*)$/;
-var INDENTED_LINE_REGEX = /^\s/;
-function collectOrderedListItems(lines) {
-  const listItems = [];
-  let currentLineIndex = 0;
-  let consumed = 0;
-  while (currentLineIndex < lines.length) {
-    const line = lines[currentLineIndex];
-    const match = line.match(ORDERED_LIST_ITEM_REGEX);
-    if (!match) {
-      break;
-    }
-    const [, indent, number, content] = match;
-    const indentLevel = indent.length;
-    let itemContent = content;
-    let nextLineIndex = currentLineIndex + 1;
-    const itemLines = [line];
-    while (nextLineIndex < lines.length) {
-      const nextLine = lines[nextLineIndex];
-      const nextMatch = nextLine.match(ORDERED_LIST_ITEM_REGEX);
-      if (nextMatch) {
-        break;
-      }
-      if (nextLine.trim() === "") {
-        itemLines.push(nextLine);
-        itemContent += "\n";
-        nextLineIndex += 1;
-      } else if (nextLine.match(INDENTED_LINE_REGEX)) {
-        itemLines.push(nextLine);
-        itemContent += `
-${nextLine.slice(indentLevel + 2)}`;
-        nextLineIndex += 1;
-      } else {
-        break;
-      }
-    }
-    listItems.push({
-      indent: indentLevel,
-      number: parseInt(number, 10),
-      content: itemContent.trim(),
-      raw: itemLines.join("\n")
-    });
-    consumed = nextLineIndex;
-    currentLineIndex = nextLineIndex;
-  }
-  return [listItems, consumed];
-}
-function buildNestedStructure(items, baseIndent, lexer) {
-  var _a;
-  const result = [];
-  let currentIndex = 0;
-  while (currentIndex < items.length) {
-    const item = items[currentIndex];
-    if (item.indent === baseIndent) {
-      const contentLines = item.content.split("\n");
-      const mainText = ((_a = contentLines[0]) == null ? void 0 : _a.trim()) || "";
-      const tokens = [];
-      if (mainText) {
-        tokens.push({
-          type: "paragraph",
-          raw: mainText,
-          tokens: lexer.inlineTokens(mainText)
-        });
-      }
-      const additionalContent = contentLines.slice(1).join("\n").trim();
-      if (additionalContent) {
-        const blockTokens = lexer.blockTokens(additionalContent);
-        tokens.push(...blockTokens);
-      }
-      let lookAheadIndex = currentIndex + 1;
-      const nestedItems = [];
-      while (lookAheadIndex < items.length && items[lookAheadIndex].indent > baseIndent) {
-        nestedItems.push(items[lookAheadIndex]);
-        lookAheadIndex += 1;
-      }
-      if (nestedItems.length > 0) {
-        const nextIndent = Math.min(...nestedItems.map((nestedItem) => nestedItem.indent));
-        const nestedListItems = buildNestedStructure(nestedItems, nextIndent, lexer);
-        tokens.push({
-          type: "list",
-          ordered: true,
-          start: nestedItems[0].number,
-          items: nestedListItems,
-          raw: nestedItems.map((nestedItem) => nestedItem.raw).join("\n")
-        });
-      }
-      result.push({
-        type: "list_item",
-        raw: item.raw,
-        tokens
-      });
-      currentIndex = lookAheadIndex;
-    } else {
-      currentIndex += 1;
-    }
-  }
-  return result;
-}
-function parseListItems(items, helpers) {
-  return items.map((item) => {
-    if (item.type !== "list_item") {
-      return helpers.parseChildren([item])[0];
-    }
-    const content = [];
-    if (item.tokens && item.tokens.length > 0) {
-      item.tokens.forEach((itemToken) => {
-        if (itemToken.type === "paragraph" || itemToken.type === "list" || itemToken.type === "blockquote" || itemToken.type === "code") {
-          content.push(...helpers.parseChildren([itemToken]));
-        } else if (itemToken.type === "text" && itemToken.tokens) {
-          const inlineContent = helpers.parseChildren([itemToken]);
-          content.push({
-            type: "paragraph",
-            content: inlineContent
-          });
-        } else {
-          const parsed = helpers.parseChildren([itemToken]);
-          if (parsed.length > 0) {
-            content.push(...parsed);
-          }
-        }
-      });
-    }
-    return {
-      type: "listItem",
-      content
-    };
-  });
-}
-var ListItemName2 = "listItem";
-var TextStyleName2 = "textStyle";
-var orderedListInputRegex = /^(\d+)\.\s$/;
-var OrderedList = Node3.create({
-  name: "orderedList",
-  addOptions() {
-    return {
-      itemTypeName: "listItem",
-      HTMLAttributes: {},
-      keepMarks: false,
-      keepAttributes: false
-    };
-  },
-  group: "block list",
-  content() {
-    return `${this.options.itemTypeName}+`;
-  },
-  addAttributes() {
-    return {
-      start: {
-        default: 1,
-        parseHTML: (element) => {
-          return element.hasAttribute("start") ? parseInt(element.getAttribute("start") || "", 10) : 1;
-        }
-      },
-      type: {
-        default: null,
-        parseHTML: (element) => element.getAttribute("type")
-      }
-    };
-  },
-  parseHTML() {
-    return [
-      {
-        tag: "ol"
-      }
-    ];
-  },
-  renderHTML({ HTMLAttributes }) {
-    const { start, ...attributesWithoutStart } = HTMLAttributes;
-    return start === 1 ? ["ol", mergeAttributes(this.options.HTMLAttributes, attributesWithoutStart), 0] : ["ol", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
-  },
-  markdownTokenName: "list",
-  parseMarkdown: (token, helpers) => {
-    if (token.type !== "list" || !token.ordered) {
-      return [];
-    }
-    const startValue = token.start || 1;
-    const content = token.items ? parseListItems(token.items, helpers) : [];
-    if (startValue !== 1) {
-      return {
-        type: "orderedList",
-        attrs: { start: startValue },
-        content
-      };
-    }
-    return {
-      type: "orderedList",
-      content
-    };
-  },
-  renderMarkdown: (node, h) => {
-    if (!node.content) {
-      return "";
-    }
-    return h.renderChildren(node.content, "\n");
-  },
-  markdownTokenizer: {
-    name: "orderedList",
-    level: "block",
-    start: (src) => {
-      const match = src.match(/^(\s*)(\d+)\.\s+/);
-      const index = match == null ? void 0 : match.index;
-      return index !== void 0 ? index : -1;
-    },
-    tokenize: (src, _tokens, lexer) => {
-      var _a;
-      const lines = src.split("\n");
-      const [listItems, consumed] = collectOrderedListItems(lines);
-      if (listItems.length === 0) {
-        return void 0;
-      }
-      const items = buildNestedStructure(listItems, 0, lexer);
-      if (items.length === 0) {
-        return void 0;
-      }
-      const startValue = ((_a = listItems[0]) == null ? void 0 : _a.number) || 1;
-      return {
-        type: "list",
-        ordered: true,
-        start: startValue,
-        items,
-        raw: lines.slice(0, consumed).join("\n")
-      };
-    }
-  },
-  markdownOptions: {
-    indentsContent: true
-  },
-  addCommands() {
-    return {
-      toggleOrderedList: () => ({ commands, chain }) => {
-        if (this.options.keepAttributes) {
-          return chain().toggleList(this.name, this.options.itemTypeName, this.options.keepMarks).updateAttributes(ListItemName2, this.editor.getAttributes(TextStyleName2)).run();
-        }
-        return commands.toggleList(this.name, this.options.itemTypeName, this.options.keepMarks);
-      }
-    };
-  },
-  addKeyboardShortcuts() {
-    return {
-      "Mod-Shift-7": () => this.editor.commands.toggleOrderedList()
-    };
-  },
-  addInputRules() {
-    let inputRule = wrappingInputRule({
-      find: orderedListInputRegex,
-      type: this.type,
-      getAttributes: (match) => ({ start: +match[1] }),
-      joinPredicate: (match, node) => node.childCount + node.attrs.start === +match[1]
-    });
-    if (this.options.keepMarks || this.options.keepAttributes) {
-      inputRule = wrappingInputRule({
-        find: orderedListInputRegex,
-        type: this.type,
-        keepMarks: this.options.keepMarks,
-        keepAttributes: this.options.keepAttributes,
-        getAttributes: (match) => ({ start: +match[1], ...this.editor.getAttributes(TextStyleName2) }),
-        joinPredicate: (match, node) => node.childCount + node.attrs.start === +match[1],
-        editor: this.editor
-      });
-    }
-    return [inputRule];
-  }
-});
-var inputRegex = /^\s*(\[([( |x])?\])\s$/;
-var TaskItem = Node3.create({
-  name: "taskItem",
-  addOptions() {
-    return {
-      nested: false,
-      HTMLAttributes: {},
-      taskListTypeName: "taskList",
-      a11y: void 0
-    };
-  },
-  content() {
-    return this.options.nested ? "paragraph block*" : "paragraph+";
-  },
-  defining: true,
-  addAttributes() {
-    return {
-      checked: {
-        default: false,
-        keepOnSplit: false,
-        parseHTML: (element) => {
-          const dataChecked = element.getAttribute("data-checked");
-          return dataChecked === "" || dataChecked === "true";
-        },
-        renderHTML: (attributes) => ({
-          "data-checked": attributes.checked
-        })
-      }
-    };
-  },
-  parseHTML() {
-    return [
-      {
-        tag: `li[data-type="${this.name}"]`,
-        priority: 51
-      }
-    ];
-  },
-  renderHTML({ node, HTMLAttributes }) {
-    return [
-      "li",
-      mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, {
-        "data-type": this.name
-      }),
-      [
-        "label",
-        [
-          "input",
-          {
-            type: "checkbox",
-            checked: node.attrs.checked ? "checked" : null
-          }
-        ],
-        ["span"]
-      ],
-      ["div", 0]
-    ];
-  },
-  parseMarkdown: (token, h) => {
-    const content = [];
-    if (token.tokens && token.tokens.length > 0) {
-      content.push(h.createNode("paragraph", {}, h.parseInline(token.tokens)));
-    } else if (token.text) {
-      content.push(h.createNode("paragraph", {}, [h.createNode("text", { text: token.text })]));
-    } else {
-      content.push(h.createNode("paragraph", {}, []));
-    }
-    if (token.nestedTokens && token.nestedTokens.length > 0) {
-      const nestedContent = h.parseChildren(token.nestedTokens);
-      content.push(...nestedContent);
-    }
-    return h.createNode("taskItem", { checked: token.checked || false }, content);
-  },
-  renderMarkdown: (node, h) => {
-    var _a;
-    const checkedChar = ((_a = node.attrs) == null ? void 0 : _a.checked) ? "x" : " ";
-    const prefix = `- [${checkedChar}] `;
-    return renderNestedMarkdownContent(node, h, prefix);
-  },
-  addKeyboardShortcuts() {
-    const shortcuts = {
-      Enter: () => this.editor.commands.splitListItem(this.name),
-      "Shift-Tab": () => this.editor.commands.liftListItem(this.name)
-    };
-    if (!this.options.nested) {
-      return shortcuts;
-    }
-    return {
-      ...shortcuts,
-      Tab: () => this.editor.commands.sinkListItem(this.name)
-    };
-  },
-  addNodeView() {
-    return ({ node, HTMLAttributes, getPos, editor }) => {
-      const listItem = document.createElement("li");
-      const checkboxWrapper = document.createElement("label");
-      const checkboxStyler = document.createElement("span");
-      const checkbox = document.createElement("input");
-      const content = document.createElement("div");
-      const updateA11Y = (currentNode) => {
-        var _a, _b;
-        checkbox.ariaLabel = ((_b = (_a = this.options.a11y) == null ? void 0 : _a.checkboxLabel) == null ? void 0 : _b.call(_a, currentNode, checkbox.checked)) || `Task item checkbox for ${currentNode.textContent || "empty task item"}`;
-      };
-      updateA11Y(node);
-      checkboxWrapper.contentEditable = "false";
-      checkbox.type = "checkbox";
-      checkbox.addEventListener("mousedown", (event) => event.preventDefault());
-      checkbox.addEventListener("change", (event) => {
-        if (!editor.isEditable && !this.options.onReadOnlyChecked) {
-          checkbox.checked = !checkbox.checked;
-          return;
-        }
-        const { checked } = event.target;
-        if (editor.isEditable && typeof getPos === "function") {
-          editor.chain().focus(void 0, { scrollIntoView: false }).command(({ tr }) => {
-            const position = getPos();
-            if (typeof position !== "number") {
-              return false;
-            }
-            const currentNode = tr.doc.nodeAt(position);
-            tr.setNodeMarkup(position, void 0, {
-              ...currentNode == null ? void 0 : currentNode.attrs,
-              checked
-            });
-            return true;
-          }).run();
-        }
-        if (!editor.isEditable && this.options.onReadOnlyChecked) {
-          if (!this.options.onReadOnlyChecked(node, checked)) {
-            checkbox.checked = !checkbox.checked;
-          }
-        }
-      });
-      Object.entries(this.options.HTMLAttributes).forEach(([key, value]) => {
-        listItem.setAttribute(key, value);
-      });
-      listItem.dataset.checked = node.attrs.checked;
-      checkbox.checked = node.attrs.checked;
-      checkboxWrapper.append(checkbox, checkboxStyler);
-      listItem.append(checkboxWrapper, content);
-      Object.entries(HTMLAttributes).forEach(([key, value]) => {
-        listItem.setAttribute(key, value);
-      });
-      let prevRenderedAttributeKeys = new Set(Object.keys(HTMLAttributes));
-      return {
-        dom: listItem,
-        contentDOM: content,
-        update: (updatedNode) => {
-          if (updatedNode.type !== this.type) {
-            return false;
-          }
-          listItem.dataset.checked = updatedNode.attrs.checked;
-          checkbox.checked = updatedNode.attrs.checked;
-          updateA11Y(updatedNode);
-          const extensionAttributes = editor.extensionManager.attributes;
-          const newHTMLAttributes = getRenderedAttributes(updatedNode, extensionAttributes);
-          const newKeys = new Set(Object.keys(newHTMLAttributes));
-          const staticAttrs = this.options.HTMLAttributes;
-          prevRenderedAttributeKeys.forEach((key) => {
-            if (!newKeys.has(key)) {
-              if (key in staticAttrs) {
-                listItem.setAttribute(key, staticAttrs[key]);
-              } else {
-                listItem.removeAttribute(key);
-              }
-            }
-          });
-          Object.entries(newHTMLAttributes).forEach(([key, value]) => {
-            if (value === null || value === void 0) {
-              if (key in staticAttrs) {
-                listItem.setAttribute(key, staticAttrs[key]);
-              } else {
-                listItem.removeAttribute(key);
-              }
-            } else {
-              listItem.setAttribute(key, value);
-            }
-          });
-          prevRenderedAttributeKeys = newKeys;
-          return true;
-        }
-      };
-    };
-  },
-  addInputRules() {
-    return [
-      wrappingInputRule({
-        find: inputRegex,
-        type: this.type,
-        getAttributes: (match) => ({
-          checked: match[match.length - 1] === "x"
-        })
-      })
-    ];
-  }
-});
-var TaskList = Node3.create({
-  name: "taskList",
-  addOptions() {
-    return {
-      itemTypeName: "taskItem",
-      HTMLAttributes: {}
-    };
-  },
-  group: "block list",
-  content() {
-    return `${this.options.itemTypeName}+`;
-  },
-  parseHTML() {
-    return [
-      {
-        tag: `ul[data-type="${this.name}"]`,
-        priority: 51
-      }
-    ];
-  },
-  renderHTML({ HTMLAttributes }) {
-    return ["ul", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, { "data-type": this.name }), 0];
-  },
-  parseMarkdown: (token, h) => {
-    return h.createNode("taskList", {}, h.parseChildren(token.items || []));
-  },
-  renderMarkdown: (node, h) => {
-    if (!node.content) {
-      return "";
-    }
-    return h.renderChildren(node.content, "\n");
-  },
-  markdownTokenizer: {
-    name: "taskList",
-    level: "block",
-    start(src) {
-      var _a;
-      const index = (_a = src.match(/^\s*[-+*]\s+\[([ xX])\]\s+/)) == null ? void 0 : _a.index;
-      return index !== void 0 ? index : -1;
-    },
-    tokenize(src, tokens, lexer) {
-      const parseTaskListContent = (content) => {
-        const nestedResult = parseIndentedBlocks(
-          content,
-          {
-            itemPattern: /^(\s*)([-+*])\s+\[([ xX])\]\s+(.*)$/,
-            extractItemData: (match) => ({
-              indentLevel: match[1].length,
-              mainContent: match[4],
-              checked: match[3].toLowerCase() === "x"
-            }),
-            createToken: (data, nestedTokens) => ({
-              type: "taskItem",
-              raw: "",
-              mainContent: data.mainContent,
-              indentLevel: data.indentLevel,
-              checked: data.checked,
-              text: data.mainContent,
-              tokens: lexer.inlineTokens(data.mainContent),
-              nestedTokens
-            }),
-            // Allow recursive nesting
-            customNestedParser: parseTaskListContent
-          },
-          lexer
-        );
-        if (nestedResult) {
-          return [
-            {
-              type: "taskList",
-              raw: nestedResult.raw,
-              items: nestedResult.items
-            }
-          ];
-        }
-        return lexer.blockTokens(content);
-      };
-      const result = parseIndentedBlocks(
-        src,
-        {
-          itemPattern: /^(\s*)([-+*])\s+\[([ xX])\]\s+(.*)$/,
-          extractItemData: (match) => ({
-            indentLevel: match[1].length,
-            mainContent: match[4],
-            checked: match[3].toLowerCase() === "x"
-          }),
-          createToken: (data, nestedTokens) => ({
-            type: "taskItem",
-            raw: "",
-            mainContent: data.mainContent,
-            indentLevel: data.indentLevel,
-            checked: data.checked,
-            text: data.mainContent,
-            tokens: lexer.inlineTokens(data.mainContent),
-            nestedTokens
-          }),
-          // Use the recursive parser for nested content
-          customNestedParser: parseTaskListContent
-        },
-        lexer
-      );
-      if (!result) {
-        return void 0;
-      }
-      return {
-        type: "taskList",
-        raw: result.raw,
-        items: result.items
-      };
-    }
-  },
-  markdownOptions: {
-    indentsContent: true
-  },
-  addCommands() {
-    return {
-      toggleTaskList: () => ({ commands }) => {
-        return commands.toggleList(this.name, this.options.itemTypeName);
-      }
-    };
-  },
-  addKeyboardShortcuts() {
-    return {
-      "Mod-Shift-9": () => this.editor.commands.toggleTaskList()
-    };
-  }
-});
-Extension.create({
-  name: "listKit",
-  addExtensions() {
-    const extensions = [];
-    if (this.options.bulletList !== false) {
-      extensions.push(BulletList.configure(this.options.bulletList));
-    }
-    if (this.options.listItem !== false) {
-      extensions.push(ListItem.configure(this.options.listItem));
-    }
-    if (this.options.listKeymap !== false) {
-      extensions.push(ListKeymap.configure(this.options.listKeymap));
-    }
-    if (this.options.orderedList !== false) {
-      extensions.push(OrderedList.configure(this.options.orderedList));
-    }
-    if (this.options.taskItem !== false) {
-      extensions.push(TaskItem.configure(this.options.taskItem));
-    }
-    if (this.options.taskList !== false) {
-      extensions.push(TaskList.configure(this.options.taskList));
-    }
-    return extensions;
-  }
-});
-export {
-  BulletList,
-  ListItem,
-  ListKeymap,
-  OrderedList,
-  TaskItem,
-  TaskList,
-  bulletListInputRegex,
-  inputRegex,
-  listHelpers_exports as listHelpers,
-  orderedListInputRegex
-};
-//# sourceMappingURL=index.js.map