@prosekit/extensions 0.16.0-beta.0 → 0.16.0

package/dist/image.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image.js","names":[],"sources":["../src/image/image-commands/insert-image.ts","../src/image/image-commands/upload-image.ts","../src/image/image-commands.ts","../src/image/image-spec.ts","../src/image/image-upload-handler.ts","../src/image/image.ts"],"sourcesContent":["import { insertNode } from '@prosekit/core'\nimport type { Command } from '@prosekit/pm/state'\n\nimport type { ImageAttrs } from '../image-spec.ts'\n\n/**\n * Returns a command that inserts an image node with the given attributes at the\n * current selection position.\n *\n * @public\n */\nexport function insertImage(attrs?: ImageAttrs): Command {\n  return insertNode({ type: 'image', attrs })\n}\n","import { insertNode, ProseKitError } from '@prosekit/core'\nimport type { Command, EditorState, Transaction } from '@prosekit/pm/state'\nimport type { EditorView } from '@prosekit/pm/view'\n\nimport { UploadTask, type Uploader } from '../../file/index.ts'\nimport type { ImageAttrs } from '../image-spec.ts'\n\n/**\n * Options for {@link uploadImage}.\n *\n * @public\n */\nexport interface UploadImageOptions {\n  /**\n   * The uploader used to upload the file. It should return a promise that\n   * resolves to the URL of the uploaded image.\n   */\n  uploader: Uploader<string>\n  /**\n   * The file that will be uploaded.\n   */\n  file: File\n  /**\n   * The position where the image should be inserted. If not provided, the\n   * image is inserted at the current selection.\n   */\n  pos?: number\n  /**\n   * If the image should replace the existing image at the given position. This\n   * is only used if `pos` is provided.\n   *\n   * @default false\n   */\n  replace?: boolean\n  /**\n   * A handler to be called when an error occurs during the upload.\n   */\n  onError?: ImageUploadErrorHandler\n}\n\n/**\n * Options for the {@link ImageUploadErrorHandler} callback.\n *\n * @public\n */\nexport interface ImageUploadErrorHandlerOptions {\n  /**\n   * The file that was uploaded.\n   */\n  file: File\n  /**\n   * The error that occurred during the upload.\n   */\n  error: unknown\n  /**\n   * The upload task that was used to upload the file.\n   */\n  uploadTask: UploadTask<string>\n}\n\n/**\n * A handler to be called when an error occurs during the upload.\n *\n * @public\n */\nexport type ImageUploadErrorHandler = (options: ImageUploadErrorHandlerOptions) => void\n\n/**\n * Returns a command that uploads an image file and inserts an image node with a\n * temporary URL which is replaced once the upload completes.\n *\n * @param options\n *\n * @public\n */\nexport function uploadImage({\n  uploader,\n  file,\n  pos,\n  replace = false,\n  onError,\n}: UploadImageOptions): Command {\n  return (state, dispatch, view) => {\n    const uploadTask = new UploadTask({ file, uploader })\n    const objectURL = uploadTask.objectURL\n\n    uploadTask.finished\n      .then((resultURL) => {\n        if (view && view.isDestroyed) {\n          return\n        } else if (typeof resultURL !== 'string') {\n          const error = new ProseKitError(\n            `Unexpected upload result. Expected a string but got ${typeof resultURL}`,\n          )\n          onError?.({ file, error, uploadTask })\n        } else if (!view) {\n          const error = new ProseKitError(\n            'View must be available to replace the image URL',\n          )\n          onError?.({ file, error, uploadTask })\n        } else {\n          replaceImageURL(view, objectURL, resultURL)\n          UploadTask.delete(objectURL)\n        }\n      })\n      .catch((error) => {\n        onError?.({ file, error, uploadTask })\n      })\n\n    if (replace && pos != null) {\n      if (replaceExistingImageURL(state, pos, objectURL, dispatch)) {\n        return true\n      }\n    }\n\n    const attrs: ImageAttrs = { src: objectURL }\n    return insertNode({ type: 'image', attrs, pos })(state, dispatch, view)\n  }\n}\n\nfunction replaceExistingImageURL(\n  state: EditorState,\n  pos: number,\n  imageURL: string,\n  dispatch?: (tr: Transaction) => void,\n): boolean {\n  const node = state.doc.nodeAt(pos)\n  if (!node || node.type.name !== 'image') {\n    return false\n  }\n  const attrs = node.attrs as ImageAttrs\n  if (attrs.src === imageURL) {\n    return true\n  }\n  if (dispatch) {\n    const tr = state.tr\n    tr.setNodeAttribute(pos, 'src', imageURL)\n    dispatch(tr)\n  }\n  return true\n}\n\n/**\n * Replaces the temporary image URL with the final uploaded URL.\n *\n * @internal\n */\nexport function replaceImageURL(\n  view: EditorView,\n  oldURL: string,\n  newURL: string,\n): void {\n  const positions: number[] = []\n  view.state.doc.descendants((node, pos) => {\n    if (node.type.name === 'image') {\n      const attrs = node.attrs as ImageAttrs\n      if (attrs.src === oldURL) {\n        positions.push(pos)\n      }\n    }\n  })\n\n  if (positions.length === 0) {\n    return\n  }\n\n  const tr = view.state.tr\n  for (const pos of positions) {\n    tr.setNodeAttribute(pos, 'src', newURL)\n  }\n  view.dispatch(tr)\n}\n","import { defineCommands, type Extension } from '@prosekit/core'\n\nimport { insertImage } from './image-commands/insert-image.ts'\nimport { uploadImage, type UploadImageOptions } from './image-commands/upload-image.ts'\nimport type { ImageAttrs } from './image-spec.ts'\n\n/**\n * @internal\n */\nexport type ImageCommandsExtension = Extension<{\n  Commands: {\n    insertImage: [attrs?: ImageAttrs]\n    uploadImage: [options: UploadImageOptions]\n  }\n}>\n\n/**\n * @internal\n */\nexport function defineImageCommands(): ImageCommandsExtension {\n  return defineCommands({\n    insertImage,\n    uploadImage,\n  })\n}\n","import { defineNodeSpec, type Extension } from '@prosekit/core'\n\n/**\n * @public\n */\nexport interface ImageAttrs {\n  src?: string | null\n  width?: number | null\n  height?: number | null\n}\n\n/**\n * @internal\n */\nexport type ImageSpecExtension = Extension<{\n  Nodes: {\n    image: ImageAttrs\n  }\n}>\n\n/**\n * @internal\n */\nexport function defineImageSpec(): ImageSpecExtension {\n  return defineNodeSpec({\n    name: 'image',\n    attrs: {\n      src: { default: null, validate: 'string|null' },\n      width: { default: null, validate: 'number|null' },\n      height: { default: null, validate: 'number|null' },\n    },\n    group: 'block',\n    defining: true,\n    draggable: true,\n    parseDOM: [\n      {\n        tag: 'img[src]',\n        getAttrs: (element): ImageAttrs => {\n          if (typeof element === 'string') {\n            return { src: null }\n          }\n\n          const src = element.getAttribute('src') || null\n\n          let width: number | null = null\n          let height: number | null = null\n\n          const rect = element.getBoundingClientRect()\n          if (rect.width > 0 && rect.height > 0) {\n            width = rect.width\n            height = rect.height\n          } else if (\n            element instanceof HTMLImageElement\n            && element.naturalWidth > 0\n            && element.naturalHeight > 0\n          ) {\n            width = element.naturalWidth\n            height = element.naturalHeight\n          }\n          return { src, width, height }\n        },\n      },\n    ],\n    toDOM(node) {\n      const attrs = node.attrs as ImageAttrs\n      return ['img', attrs]\n    },\n  })\n}\n","import { union, type PlainExtension } from '@prosekit/core'\n\nimport {\n  defineFileDropHandler,\n  defineFilePasteHandler,\n  type FileDropHandler,\n  type FileDropHandlerOptions,\n  type FilePasteHandler,\n  type FilePasteHandlerOptions,\n  type Uploader,\n} from '../file/index.ts'\n\nimport { uploadImage, type ImageUploadErrorHandler } from './image-commands/upload-image.ts'\n\n/**\n * A predicate to determine if the pasted file should be uploaded and inserted as an image.\n */\nexport type ImageCanPastePredicate = (options: FilePasteHandlerOptions) => boolean\n\n/**\n * A predicate to determine if the dropped file should be uploaded and inserted as an image.\n */\nexport type ImageCanDropPredicate = (options: FileDropHandlerOptions) => boolean\n\n/**\n * A handler to be called when an error occurs during the upload.\n */\nexport interface ImageUploadHandlerOptions {\n  /**\n   * The uploader used to upload the file. It should return a promise that\n   * resolves to the URL of the uploaded image.\n   */\n  uploader: Uploader<string>\n  /**\n   * A predicate to determine if the pasted file should be uploaded and inserted as an image.\n   * If not provided, it defaults to only allowing paste of files with a content type starting with `image/`.\n   */\n  canPaste?: ImageCanPastePredicate\n  /**\n   * A predicate to determine if the dropped file should be uploaded and inserted as an image.\n   * If not provided, it defaults to only allowing drop of files with a content type starting with `image/`.\n   */\n  canDrop?: ImageCanDropPredicate\n  /**\n   * A handler to be called when an error occurs during the upload.\n   * If not provided, it defaults to logging the error to the console.\n   */\n  onError?: ImageUploadErrorHandler\n}\n\nfunction defaultCanUpload({ file }: { file: File }): boolean {\n  // Only handle image files by default\n  return file.type.startsWith('image/')\n}\n\nconst defaultOnError: ImageUploadErrorHandler = ({ error }) => {\n  console.error('[prosekit] Failed to upload image:', error)\n}\n\n/**\n * Returns an extension that handles image file uploads when pasting or dropping\n * images into the editor.\n *\n * @param options\n */\nexport function defineImageUploadHandler({\n  uploader,\n  canPaste = defaultCanUpload,\n  canDrop = defaultCanUpload,\n  onError = defaultOnError,\n}: ImageUploadHandlerOptions): PlainExtension {\n  const handlePaste: FilePasteHandler = (options) => {\n    if (!canPaste(options)) return false\n    const { view, file } = options\n    const command = uploadImage({ uploader, file, onError })\n    return command(view.state, view.dispatch, view)\n  }\n\n  const handleDrop: FileDropHandler = (options) => {\n    if (!canDrop(options)) return false\n    const { view, file, pos } = options\n    const command = uploadImage({ uploader, file, onError, pos })\n    return command(view.state, view.dispatch, view)\n  }\n\n  return union(\n    defineFilePasteHandler(handlePaste),\n    defineFileDropHandler(handleDrop),\n  )\n}\n","import { union, type Union } from '@prosekit/core'\n\nimport { defineImageCommands, type ImageCommandsExtension } from './image-commands.ts'\nimport { defineImageSpec, type ImageSpecExtension } from './image-spec.ts'\n\n/**\n * @internal\n */\nexport type ImageExtension = Union<[ImageSpecExtension, ImageCommandsExtension]>\n\n/**\n * @public\n */\nexport function defineImage(): ImageExtension {\n  return union(defineImageSpec(), defineImageCommands())\n}\n"],"mappings":"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"}

package/dist/index.d.ts

@@ -1,7 +1,5 @@
 import { PlainExtension } from "@prosekit/core";
 import { EditorView } from "@prosekit/pm/view";
-
-//#region src/file/file-drop-handler.d.ts
 interface FileDropHandlerOptions {
   /**
    * The editor view.
@@ -28,8 +26,6 @@ interface FileDropHandlerOptions {
  */
 type FileDropHandler = (options: FileDropHandlerOptions) => boolean | void;
 declare function defineFileDropHandler(handler: FileDropHandler): PlainExtension;
-//#endregion
-//#region src/file/file-paste-handler.d.ts
 interface FilePasteHandlerOptions {
   /**
    * The editor view.
@@ -52,8 +48,6 @@ interface FilePasteHandlerOptions {
  */
 type FilePasteHandler = (options: FilePasteHandlerOptions) => boolean | void;
 declare function defineFilePasteHandler(handler: FilePasteHandler): PlainExtension;
-//#endregion
-//#region src/file/file-upload.d.ts
 /**
  * An interface representing the upload progress.
  */
@@ -129,6 +123,5 @@ declare class UploadTask<Result> {
    */
   static delete(objectURL: string): void;
 }
-//#endregion
 export { FilePasteHandler as a, FileDropHandler as c, UploaderOptions as i, FileDropHandlerOptions as l, UploadTask as n, FilePasteHandlerOptions as o, Uploader as r, defineFilePasteHandler as s, UploadProgress as t, defineFileDropHandler as u };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/file/file-drop-handler.ts","../src/file/file-paste-handler.ts","../src/file/file-upload.ts"],"mappings":";;;;UAYiB,sBAAA;;AAAjB;;EAIE,IAAA,EAAM,UAAA;EAAA;;;EAKN,KAAA,EAAO,SAAA;EAKG;;;EAAV,IAAA,EAAM,IAAA;EALC;;;EAUP,GAAA;AAAA;;AASF;;;;;KAAY,eAAA,IACV,OAAA,EAAS,sBAAA;AAAA,iBAGK,qBAAA,CACd,OAAA,EAAS,eAAA,GACR,cAAA;;;UClCc,uBAAA;;ADAjB;;ECIE,IAAA,EAAM,UAAA;EDAA;;;ECKN,KAAA,EAAO,cAAA;EDKG;;;ECAV,IAAA,EAAM,IAAA;AAAA;;;;;;ADcR;KCLY,gBAAA,IACV,OAAA,EAAS,uBAAA;AAAA,iBAGK,sBAAA,CACd,OAAA,EAAS,gBAAA,GACR,cAAA;;;;;;UCpCc,cAAA;EAGf,MAAA;EAGA,KAAA;AAAA;AAAA,UAGe,eAAA;EFOR;;;EEHP,IAAA,EAAM,IAAA;EFFN;;;EEOA,UAAA,GAAa,QAAA,EAAU,cAAA;AAAA;;;;;KAOb,QAAA,YAAoB,OAAA,EAAS,eAAA,KAAoB,OAAA,CAAQ,MAAA;;;;cAKxD,UAAA;EFSG;;;;;EAAA,SEHL,SAAA;EFKR;;;EAAA,UEAS,IAAA;;;ADlCZ;YCuCY,MAAA,EAAQ,MAAA;;;;YAKR,KAAA,EAAO,KAAA;ED9BP;;;EAAA,SCmCD,QAAA,EAAU,OAAA,CAAQ,MAAA;EAAA,QAEnB,WAAA;ED1CD;;;;;AAcT;;ICoCgB,IAAA;IAAM;EAAA;IAAc,IAAA,EAAM,IAAA;IAAM,QAAA,EAAU,QAAA,CAAS,MAAA;EAAA;EDhCnD;;;ECgEP,iBAAA,CACL,QAAA,GAAW,QAAA,EAAU,cAAA,YACpB,YAAA;EDjEM;;;EAAA,OC6EF,GAAA,kBAAA,CACL,SAAA,WACC,UAAA,CAAW,MAAA;ED9EC;;;EAAA,OCqFR,MAAA,CAAO,SAAA;AAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/file/file-drop-handler.ts","../src/file/file-paste-handler.ts","../src/file/file-upload.ts"],"mappings":";;UAYiB,sBAAA;EAAA;;;EAIf,IAAA,EAAM,UAAA;EAKC;;;EAAP,KAAA,EAAO,SAAA;EALP;;;EAUA,IAAA,EAAM,IAAA;EAAN;;;EAKA,GAAA;AAAA;AASF;;;;;AAIA;AAJA,KAAY,eAAA,IACV,OAAA,EAAS,sBAAA;AAAA,iBAGK,qBAAA,CACd,OAAA,EAAS,eAAA,GACR,cAAA;AAAA,UClCc,uBAAA;EDAA;;;ECIf,IAAA,EAAM,UAAA;EDKC;;;ECAP,KAAA,EAAO,cAAA;EDLP;;;ECUA,IAAA,EAAM,IAAA;AAAA;;;;;ADcR;;KCLY,gBAAA,IACV,OAAA,EAAS,uBAAA;AAAA,iBAGK,sBAAA,CACd,OAAA,EAAS,gBAAA,GACR,cAAA;;;;UCpCc,cAAA;EAGf,MAAA;EAGA,KAAA;AAAA;AAAA,UAGe,eAAA;EFYT;;;EERN,IAAA,EAAM,IAAA;EFFA;;;EEON,UAAA,GAAa,QAAA,EAAU,cAAA;AAAA;;;;AFiBzB;KEVY,QAAA,YAAoB,OAAA,EAAS,eAAA,KAAoB,OAAA,CAAQ,MAAA;;;;cAKxD,UAAA;EFSwB;;;;;EAAA,SEH1B,SAAA;EFKM;;;EAAA,UEAL,IAAA;EDlC4B;;;EAAA,UCuC5B,MAAA,EAAQ,MAAA;EDzBZ;;;EAAA,UC8BI,KAAA,EAAO,KAAA;EDxCX;;;EAAA,SC6CG,QAAA,EAAU,OAAA,CAAQ,MAAA;EAAA,QAEnB,WAAA;EDrCE;;AASZ;;;;;ICoCgB,IAAA;IAAM;EAAA;IAAc,IAAA,EAAM,IAAA;IAAM,QAAA,EAAU,QAAA,CAAS,MAAA;EAAA;ED9BlD;;;EC8DR,iBAAA,CACL,QAAA,GAAW,QAAA,EAAU,cAAA,YACpB,YAAA;EDhEY;;;EAAA,OC4ER,GAAA,kBAAA,CACL,SAAA,WACC,UAAA,CAAW,MAAA;EAlHe;;;EAAA,OAyHtB,MAAA,CAAO,SAAA;AAAA"}

package/dist/{prosekit-extensions-input-rule.d.ts → input-rule.d.ts}

@@ -1,8 +1,6 @@
 import { PlainExtension } from "@prosekit/core";
 import { InputRule } from "@prosekit/pm/inputrules";
 import { Attrs, MarkType, NodeType, ProseMirrorNode } from "@prosekit/pm/model";
-
-//#region src/input-rule/index.d.ts
 /**
  * Defines an input rule extension.
  *
@@ -124,6 +122,5 @@ declare function defineWrappingInputRule({
    */
   join?: (match: RegExpMatchArray, node: ProseMirrorNode) => boolean;
 }): PlainExtension;
-//#endregion
 export { MarkInputRuleOptions, createMarkInputRule, defineInputRule, defineMarkInputRule, defineTextBlockInputRule, defineWrappingInputRule };
-//# sourceMappingURL=prosekit-extensions-input-rule.d.ts.map
+//# sourceMappingURL=input-rule.d.ts.map

package/dist/input-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-rule.d.ts","names":[],"sources":["../src/input-rule/index.ts"],"mappings":";;;;AAsBA;;;;;;iBAAgB,eAAA,CAAgB,IAAA,EAAM,SAAA,GAAY,cAAA;;;AASlD;;;UAAiB,oBAAA;EAWA;;;;;EALf,KAAA,EAAO,MAAA;EAAP;;;EAKA,IAAA,WAAe,QAAA;EAKf;;;EAAA,KAAA,GAAQ,KAAA,YAAiB,KAAA,EAAO,gBAAA,KAAqB,KAAA;EAAA;;;;AAavD;EANE,UAAA;AAAA;;;;iBAMc,mBAAA,CAAA;EACd,KAAA;EACA,IAAA;EACA,KAAA;EACA;AAAA,GACC,oBAAA,GAAuB,SAAA;;;;;;;iBAqDV,mBAAA,CACd,OAAA,EAAS,oBAAA,GACR,cAAA;;;;;;;;;;AAFH;iBAgBgB,wBAAA,CAAA;EACd,KAAA;EACA,IAAA;EACA;AAAA;;;;;;EAOA,KAAA,EAAO,MAAA;EAxBQ;AAcjB;;EAeE,IAAA,WAAe,QAAA;EAdf;;;EAmBA,KAAA,GAAQ,KAAA,YAAiB,KAAA,EAAO,gBAAA,KAAqB,KAAA;AAAA,IACnD,cAAA;;;;;;;;;;;iBAiBY,uBAAA,CAAA;EACd,KAAA;EACA,IAAA;EACA,KAAA;EACA;AAAA;EAvCA;;;;;EA8CA,KAAA,EAAO,MAAA;EA7BC;;;EAkCR,IAAA,WAAe,QAAA;EAjCb;;;EAsCF,KAAA,GAAQ,KAAA,YAAiB,KAAA,EAAO,gBAAA,KAAqB,KAAA;EArBhB;;;;;;;;EA+BrC,IAAA,IAAQ,KAAA,EAAO,gBAAA,EAAkB,IAAA,EAAM,eAAA;AAAA,IACrC,cAAA"}

package/dist/{prosekit-extensions-input-rule.js → input-rule.js}

@@ -1,6 +1,5 @@
 import { defineFacet, defineFacetPayload, getMarkType, getNodeType, isMarkAbsent, maybeRun, pluginFacet } from "@prosekit/core";
 import { InputRule, inputRules, textblockTypeInputRule, wrappingInputRule } from "@prosekit/pm/inputrules";
-//#region src/input-rule/index.ts
 /**
 * Defines an input rule extension.
 *
@@ -83,7 +82,6 @@ const inputRuleFacet = defineFacet({
 	},
 	parent: pluginFacet
 });
-//#endregion
 export { createMarkInputRule, defineInputRule, defineMarkInputRule, defineTextBlockInputRule, defineWrappingInputRule };
 
-//# sourceMappingURL=prosekit-extensions-input-rule.js.map
+//# sourceMappingURL=input-rule.js.map

package/dist/input-rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-rule.js","names":[],"sources":["../src/input-rule/index.ts"],"sourcesContent":["import {\n  defineFacet,\n  defineFacetPayload,\n  getMarkType,\n  getNodeType,\n  isMarkAbsent,\n  maybeRun,\n  pluginFacet,\n  type PlainExtension,\n  type PluginPayload,\n} from '@prosekit/core'\nimport { InputRule, inputRules, textblockTypeInputRule, wrappingInputRule } from '@prosekit/pm/inputrules'\nimport type { Attrs, MarkType, NodeType, ProseMirrorNode, Schema } from '@prosekit/pm/model'\nimport type { Plugin } from '@prosekit/pm/state'\n\n/**\n * Defines an input rule extension.\n *\n * @param rule - The ProseMirror input rule to add.\n *\n * @public\n */\nexport function defineInputRule(rule: InputRule): PlainExtension {\n  return defineInputRuleFacetPayload(() => rule)\n}\n\n/**\n * Options for {@link defineMarkInputRule}.\n *\n * @public\n */\nexport interface MarkInputRuleOptions {\n  /**\n   * The regular expression to match against, which should end with `$` and has\n   * exactly one capture group. All other matched text outside the capture group\n   * will be deleted.\n   */\n  regex: RegExp\n\n  /**\n   * The type of mark to set.\n   */\n  type: string | MarkType\n\n  /**\n   * Attributes to set on the mark.\n   */\n  attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null)\n\n  /**\n   * Whether this rule should fire inside marks marked as [code](https://prosemirror.net/docs/ref/#model.MarkSpec.code).\n   *\n   * @default `false`\n   */\n  inCodeMark?: boolean\n}\n\n/**\n * @internal\n */\nexport function createMarkInputRule({\n  regex,\n  type,\n  attrs = null,\n  inCodeMark = false,\n}: MarkInputRuleOptions): InputRule {\n  const rule = new InputRule(regex, (state, match, start, end) => {\n    const { tr, schema } = state\n    const [fullText, markText] = match\n\n    if (!markText) {\n      return null\n    }\n\n    const markStart = start + fullText.indexOf(markText)\n    const markEnd = markStart + markText.length\n\n    if (!(start <= markStart && markStart < markEnd && markEnd <= end)) {\n      // Incorrect regex.\n      return null\n    }\n\n    const markType = getMarkType(schema, type)\n    const mark = markType.create(maybeRun(attrs, match))\n\n    if (!isMarkAbsent(tr.doc, markStart, markEnd, markType, attrs)) {\n      // The mark is already active.\n      return null\n    }\n\n    const initialStoredMarks = tr.storedMarks ?? []\n\n    tr.addMark(markStart, markEnd, mark)\n\n    if (markEnd < end) {\n      tr.delete(markEnd, end)\n    }\n    if (start < markStart) {\n      tr.delete(start, markStart)\n    }\n\n    // Make sure not to reactivate any marks which had previously been\n    // deactivated. By keeping track of the initial stored marks we are able to\n    // discard any unintended consequences of deleting text and adding it again.\n    tr.setStoredMarks(initialStoredMarks)\n\n    return tr\n  }, { inCodeMark })\n\n  return rule\n}\n\n/**\n * Defines an input rule for automatically adding inline marks when a given\n * pattern is typed.\n *\n * @public\n */\nexport function defineMarkInputRule(\n  options: MarkInputRuleOptions,\n): PlainExtension {\n  return defineInputRule(createMarkInputRule(options))\n}\n\n/**\n * Defines an input rule that changes the type of a textblock when the matched\n * text is typed into it.\n *\n * See also [textblockTypeInputRule](https://prosemirror.net/docs/ref/#inputrules.textblockTypeInputRule)\n *\n * @param options\n *\n * @public\n */\nexport function defineTextBlockInputRule({\n  regex,\n  type,\n  attrs,\n}: {\n  /**\n   * The regular expression to match against, which should end with `$`. It\n   * usually also starts with `^` to that it is only matched at the start of a\n   * textblock.\n   */\n  regex: RegExp\n\n  /**\n   * The node type to replace the matched text with.\n   */\n  type: string | NodeType\n\n  /**\n   * Attributes to set on the node.\n   */\n  attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null)\n}): PlainExtension {\n  return defineInputRuleFacetPayload(({ schema }): InputRule => {\n    const nodeType = getNodeType(schema, type)\n    return textblockTypeInputRule(regex, nodeType, attrs)\n  })\n}\n\n/**\n * Defines an input rule for automatically wrapping a textblock when a given\n * string is typed.\n *\n * See also [wrappingInputRule](https://prosemirror.net/docs/ref/#inputrules.wrappingInputRule)\n *\n * @param options\n *\n * @public\n */\nexport function defineWrappingInputRule({\n  regex,\n  type,\n  attrs,\n  join,\n}: {\n  /**\n   * The regular expression to match against, which should end with `$`. It\n   * usually also starts with `^` to that it is only matched at the start of a\n   * textblock.\n   */\n  regex: RegExp\n\n  /**\n   * The type of node to wrap in.\n   */\n  type: string | NodeType\n\n  /**\n   * Attributes to set on the node.\n   */\n  attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null)\n\n  /**\n   * By default, if there's a node with the same type above the newly wrapped\n   * node, the rule will try to\n   * [join](https://prosemirror.net/docs/ref/#transform.Transform.join) those\n   * two nodes. You can pass a join predicate, which takes a regular expression\n   * match and the node before the wrapped node, and can return a boolean to\n   * indicate whether a join should happen.\n   */\n  join?: (match: RegExpMatchArray, node: ProseMirrorNode) => boolean\n}): PlainExtension {\n  return defineInputRuleFacetPayload(({ schema }): InputRule => {\n    const nodeType = getNodeType(schema, type)\n    return wrappingInputRule(regex, nodeType, attrs, join)\n  })\n}\n\nfunction defineInputRuleFacetPayload(input: InputRulePayload): PlainExtension {\n  return defineFacetPayload(inputRuleFacet, [input]) as PlainExtension\n}\n\ntype InputRulePayload = (context: { schema: Schema }) => InputRule\n\nconst inputRuleFacet = defineFacet<InputRulePayload, PluginPayload>({\n  reducer: (inputs: InputRulePayload[]): PluginPayload => {\n    return (context): Plugin[] => {\n      const rules: InputRule[] = inputs.flatMap((callback) => callback(context))\n      return [inputRules({ rules })]\n    }\n  },\n  parent: pluginFacet,\n})\n"],"mappings":";;;;;;;;;AAsBA,SAAgB,gBAAgB,MAAiC;AAC/D,QAAO,kCAAkC,KAAK;;;;;AAqChD,SAAgB,oBAAoB,EAClC,OACA,MACA,QAAQ,MACR,aAAa,SACqB;AA4ClC,QAAO,IA3CU,UAAU,QAAQ,OAAO,OAAO,OAAO,QAAQ;EAC9D,MAAM,EAAE,IAAI,WAAW;EACvB,MAAM,CAAC,UAAU,YAAY;AAE7B,MAAI,CAAC,SACH,QAAO;EAGT,MAAM,YAAY,QAAQ,SAAS,QAAQ,SAAS;EACpD,MAAM,UAAU,YAAY,SAAS;AAErC,MAAI,EAAE,SAAS,aAAa,YAAY,WAAW,WAAW,KAE5D,QAAO;EAGT,MAAM,WAAW,YAAY,QAAQ,KAAK;EAC1C,MAAM,OAAO,SAAS,OAAO,SAAS,OAAO,MAAM,CAAC;AAEpD,MAAI,CAAC,aAAa,GAAG,KAAK,WAAW,SAAS,UAAU,MAAM,CAE5D,QAAO;EAGT,MAAM,qBAAqB,GAAG,eAAe,EAAE;AAE/C,KAAG,QAAQ,WAAW,SAAS,KAAK;AAEpC,MAAI,UAAU,IACZ,IAAG,OAAO,SAAS,IAAI;AAEzB,MAAI,QAAQ,UACV,IAAG,OAAO,OAAO,UAAU;AAM7B,KAAG,eAAe,mBAAmB;AAErC,SAAO;IACN,EAAE,YAAY,CAEN;;;;;;;;AASb,SAAgB,oBACd,SACgB;AAChB,QAAO,gBAAgB,oBAAoB,QAAQ,CAAC;;;;;;;;;;;;AAatD,SAAgB,yBAAyB,EACvC,OACA,MACA,SAkBiB;AACjB,QAAO,6BAA6B,EAAE,aAAwB;AAE5D,SAAO,uBAAuB,OADb,YAAY,QAAQ,KACQ,EAAE,MAAM;GACrD;;;;;;;;;;;;AAaJ,SAAgB,wBAAwB,EACtC,OACA,MACA,OACA,QA4BiB;AACjB,QAAO,6BAA6B,EAAE,aAAwB;AAE5D,SAAO,kBAAkB,OADR,YAAY,QAAQ,KACG,EAAE,OAAO,KAAK;GACtD;;AAGJ,SAAS,4BAA4B,OAAyC;AAC5E,QAAO,mBAAmB,gBAAgB,CAAC,MAAM,CAAC;;AAKpD,MAAM,iBAAiB,YAA6C;CAClE,UAAU,WAA8C;AACtD,UAAQ,YAAsB;AAE5B,UAAO,CAAC,WAAW,EAAE,OADM,OAAO,SAAS,aAAa,SAAS,QAAQ,CAC/C,EAAE,CAAC,CAAC;;;CAGlC,QAAQ;CACT,CAAC"}

package/dist/{prosekit-extensions-italic.d.ts → italic.d.ts}

@@ -1,7 +1,5 @@
 import { Extension, PlainExtension, Union } from "@prosekit/core";
 import { Attrs } from "@prosekit/pm/model";
-
-//#region src/italic/italic-commands.d.ts
 /**
  * @internal
  */
@@ -14,20 +12,14 @@ type ItalicCommandsExtension = Extension<{
  * @internal
  */
 declare function defineItalicCommands(): ItalicCommandsExtension;
-//#endregion
-//#region src/italic/italic-input-rule.d.ts
 /**
  * @internal
  */
 declare function defineItalicInputRule(): PlainExtension;
-//#endregion
-//#region src/italic/italic-keymap.d.ts
 /**
  * @internal
  */
 declare function defineItalicKeymap(): PlainExtension;
-//#endregion
-//#region src/italic/italic-spec.d.ts
 /**
  * @internal
  */
@@ -40,8 +32,6 @@ type ItalicSpecExtension = Extension<{
  * @internal
  */
 declare function defineItalicSpec(): ItalicSpecExtension;
-//#endregion
-//#region src/italic/italic.d.ts
 /**
  * @internal
  */
@@ -50,6 +40,5 @@ type ItalicExtension = Union<[ItalicSpecExtension, ItalicCommandsExtension]>;
  * @public
  */
 declare function defineItalic(): ItalicExtension;
-//#endregion
 export { type ItalicCommandsExtension, type ItalicExtension, type ItalicSpecExtension, defineItalic, defineItalicCommands, defineItalicInputRule, defineItalicKeymap, defineItalicSpec };
-//# sourceMappingURL=prosekit-extensions-italic.d.ts.map
+//# sourceMappingURL=italic.d.ts.map

package/dist/italic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"italic.d.ts","names":[],"sources":["../src/italic/italic-commands.ts","../src/italic/italic-input-rule.ts","../src/italic/italic-keymap.ts","../src/italic/italic-spec.ts","../src/italic/italic.ts"],"mappings":";;;;AAKA;KAAY,uBAAA,GAA0B,SAAA;EACpC,QAAA;IACE,YAAA;EAAA;AAAA;;;;iBAOY,oBAAA,CAAA,GAAwB,uBAAA;;;AATxC;iBCEgB,qBAAA,CAAA,GAAyB,cAAA;;;ADFzC;iBEAgB,kBAAA,CAAA,GAAsB,cAAA;;AFAtC;;KGCY,mBAAA,GAAsB,SAAA;EAChC,KAAA;IACE,MAAA,EAAQ,KAAA;EAAA;AAAA;;;AHMZ;iBGCgB,gBAAA,CAAA,GAAoB,mBAAA;AHVpC;;;AAAA,KIKY,eAAA,GAAkB,KAAA,EAC3B,mBAAA,EAAqB,uBAAA;;;AJGxB;iBIGgB,YAAA,CAAA,GAAgB,eAAA"}

package/dist/{prosekit-extensions-italic.js → italic.js}

@@ -1,14 +1,11 @@
-import { defineMarkInputRule } from "./prosekit-extensions-input-rule.js";
+import { defineMarkInputRule } from "./input-rule.js";
 import { canUseRegexLookbehind, defineCommands, defineKeymap, defineMarkSpec, toggleMark, union } from "@prosekit/core";
-//#region src/italic/italic-commands.ts
 /**
 * @internal
 */
 function defineItalicCommands() {
 	return defineCommands({ toggleItalic: () => toggleMark({ type: "italic" }) });
 }
-//#endregion
-//#region src/italic/italic-input-rule.ts
 /**
 * @internal
 */
@@ -18,16 +15,12 @@ function defineItalicInputRule() {
 		type: "italic"
 	});
 }
-//#endregion
-//#region src/italic/italic-keymap.ts
 /**
 * @internal
 */
 function defineItalicKeymap() {
 	return defineKeymap({ "Mod-i": toggleMark({ type: "italic" }) });
 }
-//#endregion
-//#region src/italic/italic-spec.ts
 /**
 * @internal
 */
@@ -48,15 +41,12 @@ function defineItalicSpec() {
 		}
 	});
 }
-//#endregion
-//#region src/italic/italic.ts
 /**
 * @public
 */
 function defineItalic() {
 	return union(defineItalicSpec(), defineItalicCommands(), defineItalicKeymap(), defineItalicInputRule());
 }
-//#endregion
 export { defineItalic, defineItalicCommands, defineItalicInputRule, defineItalicKeymap, defineItalicSpec };
 
-//# sourceMappingURL=prosekit-extensions-italic.js.map
+//# sourceMappingURL=italic.js.map

package/dist/italic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"italic.js","names":[],"sources":["../src/italic/italic-commands.ts","../src/italic/italic-input-rule.ts","../src/italic/italic-keymap.ts","../src/italic/italic-spec.ts","../src/italic/italic.ts"],"sourcesContent":["import { defineCommands, toggleMark, type Extension } from '@prosekit/core'\n\n/**\n * @internal\n */\nexport type ItalicCommandsExtension = Extension<{\n  Commands: {\n    toggleItalic: []\n  }\n}>\n\n/**\n * @internal\n */\nexport function defineItalicCommands(): ItalicCommandsExtension {\n  return defineCommands({\n    toggleItalic: () => toggleMark({ type: 'italic' }),\n  })\n}\n","import { canUseRegexLookbehind, type PlainExtension } from '@prosekit/core'\n\nimport { defineMarkInputRule } from '../input-rule/index.ts'\n\n/**\n * @internal\n */\nexport function defineItalicInputRule(): PlainExtension {\n  return defineMarkInputRule({\n    regex: canUseRegexLookbehind()\n      ? /(?<=\\s|^)\\*([^\\s*]|[^\\s*][^*]*[^\\s*])\\*$/\n      : /\\*([^\\s*]|[^\\s*][^*]*[^\\s*])\\*$/,\n    type: 'italic',\n  })\n}\n","import { defineKeymap, toggleMark, type PlainExtension } from '@prosekit/core'\n\n/**\n * @internal\n */\nexport function defineItalicKeymap(): PlainExtension {\n  return defineKeymap({\n    'Mod-i': toggleMark({ type: 'italic' }),\n  })\n}\n","import { defineMarkSpec, type Extension } from '@prosekit/core'\nimport type { Attrs } from '@prosekit/pm/model'\n\n/**\n * @internal\n */\nexport type ItalicSpecExtension = Extension<{\n  Marks: {\n    italic: Attrs\n  }\n}>\n\n/**\n * @internal\n */\nexport function defineItalicSpec(): ItalicSpecExtension {\n  return defineMarkSpec({\n    name: 'italic',\n    parseDOM: [\n      { tag: 'i' },\n      { tag: 'em' },\n      { style: 'font-style=italic' },\n      {\n        style: 'font-style=normal',\n        clearMark: (m) => m.type.name === 'italic',\n      },\n    ],\n    toDOM() {\n      return ['em', 0]\n    },\n  })\n}\n","import { union, type Union } from '@prosekit/core'\n\nimport { defineItalicCommands, type ItalicCommandsExtension } from './italic-commands.ts'\nimport { defineItalicInputRule } from './italic-input-rule.ts'\nimport { defineItalicKeymap } from './italic-keymap.ts'\nimport { defineItalicSpec, type ItalicSpecExtension } from './italic-spec.ts'\n\n/**\n * @internal\n */\nexport type ItalicExtension = Union<\n  [ItalicSpecExtension, ItalicCommandsExtension]\n>\n\n/**\n * @public\n */\nexport function defineItalic(): ItalicExtension {\n  return union(\n    defineItalicSpec(),\n    defineItalicCommands(),\n    defineItalicKeymap(),\n    defineItalicInputRule(),\n  )\n}\n"],"mappings":";;;;;AAcA,SAAgB,uBAAgD;AAC9D,QAAO,eAAe,EACpB,oBAAoB,WAAW,EAAE,MAAM,UAAU,CAAC,EACnD,CAAC;;;;;ACVJ,SAAgB,wBAAwC;AACtD,QAAO,oBAAoB;EACzB,OAAO,uBAAuB,GAC1B,6CACA;EACJ,MAAM;EACP,CAAC;;;;;ACRJ,SAAgB,qBAAqC;AACnD,QAAO,aAAa,EAClB,SAAS,WAAW,EAAE,MAAM,UAAU,CAAC,EACxC,CAAC;;;;;ACOJ,SAAgB,mBAAwC;AACtD,QAAO,eAAe;EACpB,MAAM;EACN,UAAU;GACR,EAAE,KAAK,KAAK;GACZ,EAAE,KAAK,MAAM;GACb,EAAE,OAAO,qBAAqB;GAC9B;IACE,OAAO;IACP,YAAY,MAAM,EAAE,KAAK,SAAS;IACnC;GACF;EACD,QAAQ;AACN,UAAO,CAAC,MAAM,EAAE;;EAEnB,CAAC;;;;;ACbJ,SAAgB,eAAgC;AAC9C,QAAO,MACL,kBAAkB,EAClB,sBAAsB,EACtB,oBAAoB,EACpB,uBAAuB,CACxB"}

package/dist/{prosekit-extensions-link.d.ts → link.d.ts}

@@ -1,12 +1,8 @@
 import { Extension, PlainExtension, Union } from "@prosekit/core";
-
-//#region src/link/link-paste-rule.d.ts
 /**
  * @internal
  */
 declare function defineLinkPasteRule(): PlainExtension;
-//#endregion
-//#region src/link/link-types.d.ts
 /**
  * @public
  */
@@ -15,8 +11,6 @@ interface LinkAttrs {
   target?: string | null;
   rel?: string | null;
 }
-//#endregion
-//#region src/link/index.d.ts
 /**
  * @internal
  */
@@ -67,6 +61,5 @@ type LinkExtension = Union<[LinkSpecExtension, LinkCommandsExtension]>;
  * @public
  */
 declare function defineLink(): LinkExtension;
-//#endregion
 export { type LinkAttrs, LinkCommandsExtension, LinkExtension, LinkSpecExtension, defineLink, defineLinkCommands, defineLinkEnterRule, defineLinkInputRule, defineLinkMarkRule, defineLinkPasteRule, defineLinkSpec };
-//# sourceMappingURL=prosekit-extensions-link.d.ts.map
+//# sourceMappingURL=link.d.ts.map

package/dist/link.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"link.d.ts","names":[],"sources":["../src/link/link-paste-rule.ts","../src/link/link-types.ts","../src/link/index.ts"],"mappings":";;AAUA;;iBAAgB,mBAAA,CAAA,GAAuB,cAAA;;;AAAvC;UCPiB,SAAA;EACf,IAAA;EACA,MAAA;EACA,GAAA;AAAA;;;;KCsBU,iBAAA,GAAoB,SAAA;EAC9B,KAAA;IACE,IAAA,EAAM,SAAA;EAAA;AAAA;;;;iBAOM,cAAA,CAAA,GAAkB,iBAAA;;AATlC;;KAwCY,qBAAA,GAAwB,SAAA;EAClC,QAAA;IACE,OAAA,GAAU,KAAA,EAAO,SAAA;IACjB,UAAA;IACA,UAAA,GAAa,KAAA,EAAO,SAAA;IACpB,UAAA;EAAA;AAAA;AAAA,iBAIY,kBAAA,CAAA,GAAsB,qBAAA;;;;;AATtC;iBAuBgB,mBAAA,CAAA,GAAuB,cAAA;;;;;;iBAiBvB,mBAAA,CAAA,GAAuB,cAAA;;;;;;iBAmBvB,kBAAA,CAAA,GAAsB,cAAA;;;;KAW1B,aAAA,GAAgB,KAAA,EAAO,iBAAA,EAAmB,qBAAA;;;AA7DtD;iBAkEgB,UAAA,CAAA,GAAc,aAAA"}

package/dist/{prosekit-extensions-link.js → link.js}

@@ -1,10 +1,9 @@
-import { defineInputRule } from "./prosekit-extensions-input-rule.js";
-import { defineEnterRule } from "./prosekit-extensions-enter-rule.js";
-import { t as defineMarkRule } from "./mark-rule.js";
-import { t as defineMarkPasteRule } from "./paste-rule.js";
+import { defineInputRule } from "./input-rule.js";
+import { defineEnterRule } from "./enter-rule.js";
+import { t as defineMarkRule } from "./mark-rule2.js";
+import { t as defineMarkPasteRule } from "./paste-rule2.js";
 import { addMark, defineCommands, defineMarkSpec, expandMark, removeMark, toggleMark, union } from "@prosekit/core";
 import { InputRule } from "@prosekit/pm/inputrules";
-//#region src/link/link-regex.ts
 const TLD_RE_PATTERN = "a(?:a(?:a|rp)|b(?:arth|b(?:ott|vie)?|c|le|ogado|udhabi)|c(?:ademy|c(?:enture|ountants?)|o|tor)?|d(?:s|ult)?|e(?:g|ro|tna)?|f(?:l|rica)?|g(?:akhan|ency)?|i(?:g|r(?:bus|force|tel))?|kdn|l(?:faromeo|i(?:baba|pay)|l(?:finanz|state|y)|s(?:ace|tom))?|m(?:azon|e(?:rican(?:express|family)|x)|fam|ica|sterdam)?|n(?:alytics|droid|quan|z)|ol?|p(?:artments|p(?:le)?)|q(?:uarelle)?|r(?:a(?:b|mco)|chi|my|pa|te?)?|s(?:da|ia|sociates)?|t(?:hleta|torney)?|u(?:ction|di(?:ble|o)?|spost|t(?:hor|os?))?|vianca|ws?|xa?|z(?:ure)?)|b(?:a(?:by|idu|n(?:a(?:mex|narepublic)|d|k)|r(?:c(?:elona|lay(?:card|s))|efoot|gains)?|s(?:eball|ketball)|uhaus|yern)?|b(?:c|t|va)?|c[gn]|d|e(?:a(?:ts|uty)|er|ntley|rlin|st(?:buy)?|t)?|f|g|h(?:arti)?|i(?:ble|d|ke|ngo?|o|z)?|j|l(?:ack(?:friday)?|o(?:ckbuster|g|omberg)|ue)|m[sw]?|n(?:pparibas)?|o(?:ats|ehringer|fa|m|nd|o(?:k(?:ing)?)?|s(?:ch|t(?:ik|on))|t|utique|x)?|r(?:adesco|idgestone|o(?:adway|ker|ther)|ussels)?|s|t|u(?:ild(?:ers)?|siness|y|zz)|v|w|y|zh?)|c(?:a(?:b|fe|l(?:l|vinklein)?|m(?:era|p)?|non|p(?:etown|ital(?:one)?)|r(?:avan|ds|e(?:ers?)?|s)?|s(?:a|e|h|ino)|t(?:ering|holic)?)?|b(?:a|n|re|s)|c|d|e(?:nter|o|rn)|f[ad]?|g|h(?:a(?:n(?:el|nel)|rity|se|t)|eap|intai|r(?:istmas|ome)|urch)?|i(?:priani|rcle|sco|t(?:adel|ic?|y(?:eats)?))?|k|l(?:aims|eaning|i(?:ck|ni(?:c|que))|o(?:thing|ud)|ub(?:med)?)?|m|n|o(?:ach|des|ffee|l(?:lege|ogne)|m(?:cast|m(?:bank|unity)|p(?:a(?:ny|re)|uter)|sec)?|n(?:dos|s(?:truction|ulting)|t(?:act|ractors))|o(?:king(?:channel)?|l|p)|rsica|u(?:ntry|pons?|rses))?|pa|r(?:edit(?:card|union)?|icket|own|s|uises?)?|u(?:isinella)?|v|w|x|y(?:mru|ou)?|z)|d(?:a(?:bur|d|nce|t(?:a|e|ing|sun)|y)|clk|ds|e(?:al(?:er|s)?|gree|l(?:ivery|l|oitte|ta)|mocrat|nt(?:al|ist)|si(?:gn)?|v)?|hl|i(?:amonds|et|gital|rect(?:ory)?|s(?:co(?:unt|ver)|h)|y)|j|k|m|np|o(?:c(?:s|tor)|g|mains|t|wnload)?|rive|tv|u(?:bai|nlop|pont|rban)|v(?:ag|r)|z)|e(?:a(?:rth|t)|co?|d(?:eka|u(?:cation)?)|e|g|m(?:ail|erck)|n(?:ergy|gineer(?:ing)?|terprises)|pson|quipment|r(?:icsson|ni)?|s(?:q|tate)?|t(?:isalat)?|u(?:rovision|s)?|vents|x(?:change|p(?:ert|osed|ress)|traspace))|f(?:a(?:ge|i(?:l|rwinds|th)|mily|ns?|rm(?:ers)?|s(?:hion|t))|e(?:dex|edback|rr(?:ari|ero))|i(?:at|d(?:elity|o)|lm|na(?:l|nc(?:e|ial))|r(?:e(?:stone)?|mdale)|sh(?:ing)?|t(?:ness)?)?|j|k|l(?:i(?:ckr|ghts|r)|o(?:rist|wers)|y)|m|o(?:o(?:d(?:network)?|tball)?|r(?:d|ex|sale|um)|undation|x)?|r(?:e(?:e|senius)|l|o(?:gans|nt(?:door|ier)))?|tr|u(?:jitsu|nd?|rniture|tbol)|yi)|g(?:a(?:l(?:l(?:ery|o|up))?|mes?|p|rden|y)?|b(?:iz)?|dn?|e(?:a|nt(?:ing)?|orge)?|f|g(?:ee)?|h|i(?:fts?|v(?:es|ing))?|l(?:ass|e|ob(?:al|o))?|m(?:ail|bh|o|x)?|n|o(?:daddy|l(?:d(?:point)?|f)|o(?:dyear|g(?:le)?)?|p|t|v)|p|q|r(?:a(?:inger|phics|tis)|een|ipe|o(?:cery|up))?|s|t|u(?:ardian|cci|ge|i(?:de|tars)|ru)?|w|y)|h(?:a(?:ir|mburg|ngout|us)|bo|dfc(?:bank)?|e(?:alth(?:care)?|l(?:p|sinki)|r(?:e|mes))|gtv|i(?:phop|samitsu|tachi|v)|kt?|m|n|o(?:ckey|l(?:dings|iday)|me(?:depot|goods|s(?:ense)?)|nda|rse|s(?:pital|t(?:ing)?)|t(?:el(?:es|s)|mail)?|use|w)|r|sbc|t|u(?:ghes)?|y(?:att|undai))|i(?:bm|c(?:bc|e|u)|d|e(?:ee)?|fm|kano|l|m(?:amat|db|mo(?:bilien)?)?|n(?:c|dustries|f(?:initi|o)|g|k|s(?:titute|ur(?:ance|e))|t(?:ernational|uit)?|vestments)?|o|piranga|q|r(?:ish)?|s(?:maili|t(?:anbul)?)?|t(?:au|v)?)|j(?:a(?:guar|va)|cb|e(?:ep|tzt|welry)?|io|ll|mp?|nj|o(?:b(?:s|urg)|t|y)?|p(?:morgan|rs)?|u(?:egos|niper))|k(?:aufen|ddi|e(?:rry(?:hotels|logistics|properties))?|fh|g|h|i(?:a|ds|m|nd(?:er|le)|tchen|wi)?|m|n|o(?:eln|matsu|sher)|p(?:mg|n)?|r(?:d|ed)?|uokgroup|w|y(?:oto)?|z)|l(?:a(?:caixa|m(?:borghini|er)|n(?:c(?:aster|ia)|d(?:rover)?|xess)|salle|t(?:ino|robe)?|w(?:yer)?)?|b|c|ds|e(?:ase|clerc|frak|g(?:al|o)|xus)|gbt|i(?:dl|fe(?:insurance|style)?|ghting|ke|lly|m(?:ited|o)|n(?:coln|de|k)|psy|v(?:e|ing))?|k|l[cp]|o(?:ans?|c(?:ker|us)|l|ndon|tt[eo]|ve)|pl(?:financial)?|r|s|t(?:da?)?|u(?:ndbeck|x(?:e|ury))?|v|y)|m(?:a(?:cys|drid|i(?:f|son)|keup|n(?:agement|go)?|p|r(?:ket(?:ing|s)?|riott|shalls)|serati|ttel)?|ba|c(?:kinsey)?|d|e(?:d(?:ia)?|et|lbourne|m(?:e|orial)|nu?|rckmsd)?|g|h|i(?:ami|crosoft|l|n[it]|t(?:subishi)?)|k|l[bs]?|ma?|n|o(?:bi(?:le)?|da|e|i|m|n(?:ash|ey|ster)|r(?:mon|tgage)|scow|to(?:rcycles)?|v(?:ie)?)?|p|q|r|sd?|t[nr]?|u(?:s(?:eum|ic)|tual)?|v|w|x|y|z)|n(?:a(?:b|goya|me|tura|vy)?|ba|c|e(?:c|t(?:bank|flix|work)?|ustar|ws?|x(?:t(?:direct)?|us))?|fl?|go?|hk|i(?:co|k(?:e|on)|nja|ssa[ny])?|l|o(?:kia|rt(?:hwesternmutual|on)|w(?:ruz|tv)?)?|p|r[aw]?|tt|u|yc|z)|o(?:b(?:i|server)|ffice|kinawa|l(?:ayan(?:group)?|dnavy|lo)|m(?:ega)?|n(?:e|g|l(?:ine)?)|oo|pen|r(?:a(?:cle|nge)|g(?:anic)?|igins)|saka|t(?:suka|t)|vh)|p(?:a(?:ge|nasonic|r(?:is|s|t(?:ners|s|y))|ssagens|y)?|ccw|et?|f(?:izer)?|g|h(?:armacy|d|ilips|o(?:ne|to(?:graphy|s)?)|ysio)?|i(?:c(?:s|t(?:et|ures))|d|n[gk]?|oneer|zza)|k|l(?:a(?:ce|y(?:station)?)|u(?:mbing|s))?|m|nc?|o(?:hl|ker|litie|rn|st)|r(?:a(?:merica|xi)|ess|ime|o(?:d(?:uctions)?|f|gressive|mo|pert(?:ies|y)|tection)?|u(?:dential)?)?|s|t|ub|wc?|y)|q(?:a|pon|ue(?:bec|st))|r(?:a(?:cing|dio)|e(?:a(?:d|l(?:estate|t(?:or|y)))|cipes|d(?:stone|umbrella)?|hab|i(?:sen?|t)|liance|n(?:t(?:als)?)?|p(?:air|ort|ublican)|st(?:aurant)?|views?|xroth)?|i(?:c(?:h(?:ardli)?|oh)|l|o|p)|o(?:c(?:her|ks)|deo|gers|om)?|s(?:vp)?|u(?:gby|hr|n)?|we?|yukyu)|s(?:a(?:arland|fe(?:ty)?|kura|l(?:e|on)|ms(?:club|ung)|n(?:dvik(?:coromant)?|ofi)|p|rl|s|ve|xo)?|b[is]?|c(?:a|b|h(?:aeffler|midt|o(?:larships|ol)|ule|warz)|ience|ot)?|d|e(?:a(?:rch|t)|cur(?:e|ity)|ek|lect|ner|rvices|ven|w|xy?)?|fr|g|h(?:a(?:ngrila|rp|w)|ell|i(?:a|ksha)|o(?:es|p(?:ping)?|uji|w(?:time)?))?|i(?:lk|n(?:a|gles)|te)?|j|k(?:in?|y(?:pe)?)?|l(?:ing)?|m(?:art|ile)?|n(?:cf)?|o(?:c(?:cer|ial)|ft(?:bank|ware)|hu|l(?:ar|utions)|n[gy]|y)?|p(?:a(?:ce)?|o(?:rt|t))|rl?|s|t(?:a(?:da|ples|r|te(?:bank|farm))|c(?:group)?|o(?:ckholm|r(?:age|e))|ream|ud(?:io|y)|yle)?|u(?:cks|pp(?:l(?:ies|y)|ort)|r(?:f|gery)|zuki)?|v|w(?:atch|iss)|x|y(?:dney|stems)?|z)|t(?:a(?:b|ipei|lk|obao|rget|t(?:a(?:motors|r)|too)|xi?)|ci?|dk?|e(?:am|ch(?:nology)?|l|masek|nnis|va)|f|g|h(?:d|eat(?:er|re))?|i(?:aa|ckets|enda|ffany|ps|r(?:es|ol))|j(?:maxx|x)?|k(?:maxx)?|l|m(?:all)?|n|o(?:day|kyo|ols|p|ray|shiba|tal|urs|wn|y(?:ota|s))?|r(?:a(?:d(?:e|ing)|ining|vel(?:channel|ers(?:insurance)?)?)|ust|v)?|t|u(?:be|i|nes|shu)|vs?|w|z)|u(?:a|b(?:ank|s)|g|k|n(?:i(?:com|versity)|o)|ol|ps|s|y|z)|v(?:a(?:cations|n(?:a|guard))?|c|e(?:gas|ntures|r(?:isign|sicherung)|t)?|g|i(?:ajes|deo|g|king|llas|n|p|rgin|s(?:a|ion)|v[ao])?|laanderen|n|o(?:dka|l(?:kswagen|vo)|t(?:e|ing|o)|yage)|u(?:elos)?)|w(?:a(?:l(?:es|mart|ter)|ng(?:gou)?|tch(?:es)?)|e(?:ather(?:channel)?|b(?:cam|er|site)|d(?:ding)?|i(?:bo|r))|f|hoswho|i(?:en|ki|lliamhill|n(?:dows|e|ners)?)|me|o(?:lterskluwer|odside|r(?:ks?|ld)|w)|s|t[cf])|x(?:box|erox|finity|i(?:huan|n)|xx|yz)|y(?:a(?:chts|hoo|maxun|ndex)|e|o(?:dobashi|ga|kohama|u(?:tube)?)|t|un)|z(?:a(?:ppos|ra)?|ero|ip|m|one|uerich|w)";
 const PUNCTUATION_CHAR_PATTERN = "\\.\\,\\;\\!\\?";
 const STOP_CHAR_PATTERN = "[" + PUNCTUATION_CHAR_PATTERN + "]";
@@ -16,8 +15,6 @@ const LINK_MARK_PATTERN = LINK_RE_BASE_PATTERN + "(?=[\\.\\,\\;\\!\\?]|\\s|$)";
 const LINK_ENTER_RE = new RegExp(LINK_ENTER_PATTERN, "gi");
 const LINK_INPUT_RE = new RegExp(LINK_INPUT_PATTERN, "gi");
 const LINK_MARK_RE = new RegExp(LINK_MARK_PATTERN, "gi");
-//#endregion
-//#region src/link/link-paste-rule.ts
 /**
 * @internal
 */
@@ -31,8 +28,6 @@ function defineLinkPasteRule() {
 		}
 	});
 }
-//#endregion
-//#region src/link/index.ts
 /**
 * @internal
 */
@@ -137,7 +132,6 @@ function defineLinkMarkRule() {
 function defineLink() {
 	return union(defineLinkSpec(), defineLinkCommands(), defineLinkInputRule(), defineLinkEnterRule(), defineLinkPasteRule());
 }
-//#endregion
 export { defineLink, defineLinkCommands, defineLinkEnterRule, defineLinkInputRule, defineLinkMarkRule, defineLinkPasteRule, defineLinkSpec };
 
-//# sourceMappingURL=prosekit-extensions-link.js.map
+//# sourceMappingURL=link.js.map

package/dist/link.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"link.js","names":[],"sources":["../src/link/link-regex.ts","../src/link/link-paste-rule.ts","../src/link/index.ts"],"sourcesContent":["/* eslint-disable unicorn/prefer-string-raw -- Don't use String.raw here for better bundler minification */\n\n// All valid alpha TLDs.\n// Data source: https://data.iana.org/TLD/tlds-alpha-by-domain.txt\nconst TLD_RE_PATTERN =\n  'a(?:a(?:a|rp)|b(?:arth|b(?:ott|vie)?|c|le|ogado|udhabi)|c(?:ademy|c(?:enture|ountants?)|o|tor)?|d(?:s|ult)?|e(?:g|ro|tna)?|f(?:l|rica)?|g(?:akhan|ency)?|i(?:g|r(?:bus|force|tel))?|kdn|l(?:faromeo|i(?:baba|pay)|l(?:finanz|state|y)|s(?:ace|tom))?|m(?:azon|e(?:rican(?:express|family)|x)|fam|ica|sterdam)?|n(?:alytics|droid|quan|z)|ol?|p(?:artments|p(?:le)?)|q(?:uarelle)?|r(?:a(?:b|mco)|chi|my|pa|te?)?|s(?:da|ia|sociates)?|t(?:hleta|torney)?|u(?:ction|di(?:ble|o)?|spost|t(?:hor|os?))?|vianca|ws?|xa?|z(?:ure)?)|b(?:a(?:by|idu|n(?:a(?:mex|narepublic)|d|k)|r(?:c(?:elona|lay(?:card|s))|efoot|gains)?|s(?:eball|ketball)|uhaus|yern)?|b(?:c|t|va)?|c[gn]|d|e(?:a(?:ts|uty)|er|ntley|rlin|st(?:buy)?|t)?|f|g|h(?:arti)?|i(?:ble|d|ke|ngo?|o|z)?|j|l(?:ack(?:friday)?|o(?:ckbuster|g|omberg)|ue)|m[sw]?|n(?:pparibas)?|o(?:ats|ehringer|fa|m|nd|o(?:k(?:ing)?)?|s(?:ch|t(?:ik|on))|t|utique|x)?|r(?:adesco|idgestone|o(?:adway|ker|ther)|ussels)?|s|t|u(?:ild(?:ers)?|siness|y|zz)|v|w|y|zh?)|c(?:a(?:b|fe|l(?:l|vinklein)?|m(?:era|p)?|non|p(?:etown|ital(?:one)?)|r(?:avan|ds|e(?:ers?)?|s)?|s(?:a|e|h|ino)|t(?:ering|holic)?)?|b(?:a|n|re|s)|c|d|e(?:nter|o|rn)|f[ad]?|g|h(?:a(?:n(?:el|nel)|rity|se|t)|eap|intai|r(?:istmas|ome)|urch)?|i(?:priani|rcle|sco|t(?:adel|ic?|y(?:eats)?))?|k|l(?:aims|eaning|i(?:ck|ni(?:c|que))|o(?:thing|ud)|ub(?:med)?)?|m|n|o(?:ach|des|ffee|l(?:lege|ogne)|m(?:cast|m(?:bank|unity)|p(?:a(?:ny|re)|uter)|sec)?|n(?:dos|s(?:truction|ulting)|t(?:act|ractors))|o(?:king(?:channel)?|l|p)|rsica|u(?:ntry|pons?|rses))?|pa|r(?:edit(?:card|union)?|icket|own|s|uises?)?|u(?:isinella)?|v|w|x|y(?:mru|ou)?|z)|d(?:a(?:bur|d|nce|t(?:a|e|ing|sun)|y)|clk|ds|e(?:al(?:er|s)?|gree|l(?:ivery|l|oitte|ta)|mocrat|nt(?:al|ist)|si(?:gn)?|v)?|hl|i(?:amonds|et|gital|rect(?:ory)?|s(?:co(?:unt|ver)|h)|y)|j|k|m|np|o(?:c(?:s|tor)|g|mains|t|wnload)?|rive|tv|u(?:bai|nlop|pont|rban)|v(?:ag|r)|z)|e(?:a(?:rth|t)|co?|d(?:eka|u(?:cation)?)|e|g|m(?:ail|erck)|n(?:ergy|gineer(?:ing)?|terprises)|pson|quipment|r(?:icsson|ni)?|s(?:q|tate)?|t(?:isalat)?|u(?:rovision|s)?|vents|x(?:change|p(?:ert|osed|ress)|traspace))|f(?:a(?:ge|i(?:l|rwinds|th)|mily|ns?|rm(?:ers)?|s(?:hion|t))|e(?:dex|edback|rr(?:ari|ero))|i(?:at|d(?:elity|o)|lm|na(?:l|nc(?:e|ial))|r(?:e(?:stone)?|mdale)|sh(?:ing)?|t(?:ness)?)?|j|k|l(?:i(?:ckr|ghts|r)|o(?:rist|wers)|y)|m|o(?:o(?:d(?:network)?|tball)?|r(?:d|ex|sale|um)|undation|x)?|r(?:e(?:e|senius)|l|o(?:gans|nt(?:door|ier)))?|tr|u(?:jitsu|nd?|rniture|tbol)|yi)|g(?:a(?:l(?:l(?:ery|o|up))?|mes?|p|rden|y)?|b(?:iz)?|dn?|e(?:a|nt(?:ing)?|orge)?|f|g(?:ee)?|h|i(?:fts?|v(?:es|ing))?|l(?:ass|e|ob(?:al|o))?|m(?:ail|bh|o|x)?|n|o(?:daddy|l(?:d(?:point)?|f)|o(?:dyear|g(?:le)?)?|p|t|v)|p|q|r(?:a(?:inger|phics|tis)|een|ipe|o(?:cery|up))?|s|t|u(?:ardian|cci|ge|i(?:de|tars)|ru)?|w|y)|h(?:a(?:ir|mburg|ngout|us)|bo|dfc(?:bank)?|e(?:alth(?:care)?|l(?:p|sinki)|r(?:e|mes))|gtv|i(?:phop|samitsu|tachi|v)|kt?|m|n|o(?:ckey|l(?:dings|iday)|me(?:depot|goods|s(?:ense)?)|nda|rse|s(?:pital|t(?:ing)?)|t(?:el(?:es|s)|mail)?|use|w)|r|sbc|t|u(?:ghes)?|y(?:att|undai))|i(?:bm|c(?:bc|e|u)|d|e(?:ee)?|fm|kano|l|m(?:amat|db|mo(?:bilien)?)?|n(?:c|dustries|f(?:initi|o)|g|k|s(?:titute|ur(?:ance|e))|t(?:ernational|uit)?|vestments)?|o|piranga|q|r(?:ish)?|s(?:maili|t(?:anbul)?)?|t(?:au|v)?)|j(?:a(?:guar|va)|cb|e(?:ep|tzt|welry)?|io|ll|mp?|nj|o(?:b(?:s|urg)|t|y)?|p(?:morgan|rs)?|u(?:egos|niper))|k(?:aufen|ddi|e(?:rry(?:hotels|logistics|properties))?|fh|g|h|i(?:a|ds|m|nd(?:er|le)|tchen|wi)?|m|n|o(?:eln|matsu|sher)|p(?:mg|n)?|r(?:d|ed)?|uokgroup|w|y(?:oto)?|z)|l(?:a(?:caixa|m(?:borghini|er)|n(?:c(?:aster|ia)|d(?:rover)?|xess)|salle|t(?:ino|robe)?|w(?:yer)?)?|b|c|ds|e(?:ase|clerc|frak|g(?:al|o)|xus)|gbt|i(?:dl|fe(?:insurance|style)?|ghting|ke|lly|m(?:ited|o)|n(?:coln|de|k)|psy|v(?:e|ing))?|k|l[cp]|o(?:ans?|c(?:ker|us)|l|ndon|tt[eo]|ve)|pl(?:financial)?|r|s|t(?:da?)?|u(?:ndbeck|x(?:e|ury))?|v|y)|m(?:a(?:cys|drid|i(?:f|son)|keup|n(?:agement|go)?|p|r(?:ket(?:ing|s)?|riott|shalls)|serati|ttel)?|ba|c(?:kinsey)?|d|e(?:d(?:ia)?|et|lbourne|m(?:e|orial)|nu?|rckmsd)?|g|h|i(?:ami|crosoft|l|n[it]|t(?:subishi)?)|k|l[bs]?|ma?|n|o(?:bi(?:le)?|da|e|i|m|n(?:ash|ey|ster)|r(?:mon|tgage)|scow|to(?:rcycles)?|v(?:ie)?)?|p|q|r|sd?|t[nr]?|u(?:s(?:eum|ic)|tual)?|v|w|x|y|z)|n(?:a(?:b|goya|me|tura|vy)?|ba|c|e(?:c|t(?:bank|flix|work)?|ustar|ws?|x(?:t(?:direct)?|us))?|fl?|go?|hk|i(?:co|k(?:e|on)|nja|ssa[ny])?|l|o(?:kia|rt(?:hwesternmutual|on)|w(?:ruz|tv)?)?|p|r[aw]?|tt|u|yc|z)|o(?:b(?:i|server)|ffice|kinawa|l(?:ayan(?:group)?|dnavy|lo)|m(?:ega)?|n(?:e|g|l(?:ine)?)|oo|pen|r(?:a(?:cle|nge)|g(?:anic)?|igins)|saka|t(?:suka|t)|vh)|p(?:a(?:ge|nasonic|r(?:is|s|t(?:ners|s|y))|ssagens|y)?|ccw|et?|f(?:izer)?|g|h(?:armacy|d|ilips|o(?:ne|to(?:graphy|s)?)|ysio)?|i(?:c(?:s|t(?:et|ures))|d|n[gk]?|oneer|zza)|k|l(?:a(?:ce|y(?:station)?)|u(?:mbing|s))?|m|nc?|o(?:hl|ker|litie|rn|st)|r(?:a(?:merica|xi)|ess|ime|o(?:d(?:uctions)?|f|gressive|mo|pert(?:ies|y)|tection)?|u(?:dential)?)?|s|t|ub|wc?|y)|q(?:a|pon|ue(?:bec|st))|r(?:a(?:cing|dio)|e(?:a(?:d|l(?:estate|t(?:or|y)))|cipes|d(?:stone|umbrella)?|hab|i(?:sen?|t)|liance|n(?:t(?:als)?)?|p(?:air|ort|ublican)|st(?:aurant)?|views?|xroth)?|i(?:c(?:h(?:ardli)?|oh)|l|o|p)|o(?:c(?:her|ks)|deo|gers|om)?|s(?:vp)?|u(?:gby|hr|n)?|we?|yukyu)|s(?:a(?:arland|fe(?:ty)?|kura|l(?:e|on)|ms(?:club|ung)|n(?:dvik(?:coromant)?|ofi)|p|rl|s|ve|xo)?|b[is]?|c(?:a|b|h(?:aeffler|midt|o(?:larships|ol)|ule|warz)|ience|ot)?|d|e(?:a(?:rch|t)|cur(?:e|ity)|ek|lect|ner|rvices|ven|w|xy?)?|fr|g|h(?:a(?:ngrila|rp|w)|ell|i(?:a|ksha)|o(?:es|p(?:ping)?|uji|w(?:time)?))?|i(?:lk|n(?:a|gles)|te)?|j|k(?:in?|y(?:pe)?)?|l(?:ing)?|m(?:art|ile)?|n(?:cf)?|o(?:c(?:cer|ial)|ft(?:bank|ware)|hu|l(?:ar|utions)|n[gy]|y)?|p(?:a(?:ce)?|o(?:rt|t))|rl?|s|t(?:a(?:da|ples|r|te(?:bank|farm))|c(?:group)?|o(?:ckholm|r(?:age|e))|ream|ud(?:io|y)|yle)?|u(?:cks|pp(?:l(?:ies|y)|ort)|r(?:f|gery)|zuki)?|v|w(?:atch|iss)|x|y(?:dney|stems)?|z)|t(?:a(?:b|ipei|lk|obao|rget|t(?:a(?:motors|r)|too)|xi?)|ci?|dk?|e(?:am|ch(?:nology)?|l|masek|nnis|va)|f|g|h(?:d|eat(?:er|re))?|i(?:aa|ckets|enda|ffany|ps|r(?:es|ol))|j(?:maxx|x)?|k(?:maxx)?|l|m(?:all)?|n|o(?:day|kyo|ols|p|ray|shiba|tal|urs|wn|y(?:ota|s))?|r(?:a(?:d(?:e|ing)|ining|vel(?:channel|ers(?:insurance)?)?)|ust|v)?|t|u(?:be|i|nes|shu)|vs?|w|z)|u(?:a|b(?:ank|s)|g|k|n(?:i(?:com|versity)|o)|ol|ps|s|y|z)|v(?:a(?:cations|n(?:a|guard))?|c|e(?:gas|ntures|r(?:isign|sicherung)|t)?|g|i(?:ajes|deo|g|king|llas|n|p|rgin|s(?:a|ion)|v[ao])?|laanderen|n|o(?:dka|l(?:kswagen|vo)|t(?:e|ing|o)|yage)|u(?:elos)?)|w(?:a(?:l(?:es|mart|ter)|ng(?:gou)?|tch(?:es)?)|e(?:ather(?:channel)?|b(?:cam|er|site)|d(?:ding)?|i(?:bo|r))|f|hoswho|i(?:en|ki|lliamhill|n(?:dows|e|ners)?)|me|o(?:lterskluwer|odside|r(?:ks?|ld)|w)|s|t[cf])|x(?:box|erox|finity|i(?:huan|n)|xx|yz)|y(?:a(?:chts|hoo|maxun|ndex)|e|o(?:dobashi|ga|kohama|u(?:tube)?)|t|un)|z(?:a(?:ppos|ra)?|ero|ip|m|one|uerich|w)'\n\n// Some common punctuations that can be used to stop a link\nconst PUNCTUATION_CHAR_PATTERN = '\\\\.\\\\,\\\\;\\\\!\\\\?'\n\nconst STOP_CHAR_PATTERN = '[' + PUNCTUATION_CHAR_PATTERN + ']'\n\nconst END_CHAR_PATTERN = '[^' + '\\\\s' + PUNCTUATION_CHAR_PATTERN + ']'\n\n// dprint-ignore\nconst LINK_RE_BASE_PATTERN = (\n    // start of the link group\n    '(' + \n        '(?:' +\n            // protocol identifier (optional)\n            // short syntax // is allowed\n            '(?:(?:https?:)?\\\\/\\\\/)?' +\n\n            // host & domain names.\n            '(?:' +\n                '(?:' +\n                    '[a-z0-9\\\\u00a1-\\\\uffff]' +\n                    '[a-z0-9\\\\u00a1-\\\\uffff_-]{0,62}' +\n                ')?' +\n                '[a-z0-9\\\\u00a1-\\\\uffff]\\\\.' +\n            ')+' +\n\n            // TLD identifier name, must not end with dot\n            '(?:' +\n                TLD_RE_PATTERN +\n            ')' +\n        ')' +\n\n        // port number (optional)\n        '(?::\\\\d{2,5})?' +\n\n        // sub path (optional)\n        '(?:/' +\n            '(?:' + \n                '\\\\S*' +\n                END_CHAR_PATTERN +\n            ')?' +\n        ')?' +\n\n        // query string (optional)\n        '(?:\\\\?' + \n            '(?:' + \n                '\\\\S*' +\n                END_CHAR_PATTERN +\n            ')' +\n        ')?' +\n\n        // fragment (optional)\n        '(?:\\\\#' + \n            '(?:' + \n                '\\\\S*' +\n                END_CHAR_PATTERN +\n            ')?' +\n        ')?' +\n\n    // end of the link group\n    ')'\n)\n\n// dprint-ignore\nconst LINK_ENTER_PATTERN = LINK_RE_BASE_PATTERN + STOP_CHAR_PATTERN + '?' + '$'\n// dprint-ignore\nconst LINK_INPUT_PATTERN = LINK_RE_BASE_PATTERN + STOP_CHAR_PATTERN + '?' + '\\\\s$'\n// dprint-ignore\nconst LINK_MARK_PATTERN = LINK_RE_BASE_PATTERN + '(?=' + STOP_CHAR_PATTERN + '|\\\\s|$)'\n\nexport const LINK_ENTER_RE: RegExp = new RegExp(LINK_ENTER_PATTERN, 'gi')\nexport const LINK_INPUT_RE: RegExp = new RegExp(LINK_INPUT_PATTERN, 'gi')\nexport const LINK_MARK_RE: RegExp = new RegExp(LINK_MARK_PATTERN, 'gi')\n","import type { PlainExtension } from '@prosekit/core'\n\nimport { defineMarkPasteRule } from '../paste-rule/index.ts'\n\nimport { LINK_MARK_RE } from './link-regex.ts'\nimport type { LinkAttrs } from './link-types.ts'\n\n/**\n * @internal\n */\nexport function defineLinkPasteRule(): PlainExtension {\n  return defineMarkPasteRule({\n    type: 'link',\n    regex: LINK_MARK_RE,\n    getAttrs: (match: RegExpExecArray): LinkAttrs | false => {\n      if (match[1]) {\n        return { href: match[1] } satisfies LinkAttrs\n      }\n      return false\n    },\n  })\n}\n","import {\n  addMark,\n  defineCommands,\n  defineMarkSpec,\n  expandMark,\n  removeMark,\n  toggleMark,\n  union,\n  type Extension,\n  type PlainExtension,\n  type Union,\n} from '@prosekit/core'\nimport { InputRule } from '@prosekit/pm/inputrules'\n\nimport { defineEnterRule } from '../enter-rule/index.ts'\nimport { defineInputRule } from '../input-rule/index.ts'\nimport { defineMarkRule } from '../mark-rule/index.ts'\n\nimport { defineLinkPasteRule } from './link-paste-rule.ts'\nimport { LINK_ENTER_RE, LINK_INPUT_RE, LINK_MARK_RE } from './link-regex.ts'\nimport type { LinkAttrs } from './link-types.ts'\n\nexport { defineLinkPasteRule }\nexport type { LinkAttrs }\n\n/**\n * @internal\n */\nexport type LinkSpecExtension = Extension<{\n  Marks: {\n    link: LinkAttrs\n  }\n}>\n\n/**\n * @internal\n */\nexport function defineLinkSpec(): LinkSpecExtension {\n  return defineMarkSpec<'link', LinkAttrs>({\n    name: 'link',\n    inclusive: false,\n    attrs: {\n      href: { validate: 'string' },\n      target: { default: null, validate: 'string|null' },\n      rel: { default: null, validate: 'string|null' },\n    },\n    parseDOM: [\n      {\n        tag: 'a[href]',\n        getAttrs: (dom: HTMLElement) => {\n          return {\n            href: dom.getAttribute('href') || '',\n            target: dom.getAttribute('target') || null,\n            rel: dom.getAttribute('rel') || null,\n          }\n        },\n      },\n    ],\n    toDOM(node) {\n      const { href, target, rel } = node.attrs as LinkAttrs\n      return ['a', { href, target, rel }, 0]\n    },\n  })\n}\n\n/**\n * @internal\n */\nexport type LinkCommandsExtension = Extension<{\n  Commands: {\n    addLink: [attrs: LinkAttrs]\n    removeLink: []\n    toggleLink: [attrs: LinkAttrs]\n    expandLink: []\n  }\n}>\n\nexport function defineLinkCommands(): LinkCommandsExtension {\n  return defineCommands({\n    addLink: (attrs: LinkAttrs) => addMark({ type: 'link', attrs }),\n    removeLink: () => removeMark({ type: 'link' }),\n    toggleLink: (attrs: LinkAttrs) => toggleMark({ type: 'link', attrs }),\n    expandLink: () => expandMark({ type: 'link' }),\n  })\n}\n\n/**\n * Apply link marks after pressing Space.\n *\n * @internal\n */\nexport function defineLinkInputRule(): PlainExtension {\n  return defineInputRule(\n    new InputRule(LINK_INPUT_RE, (state, match, from) => {\n      const href = match[1]\n      if (!href) return null\n\n      const mark = state.schema.marks.link.create({ href })\n      return state.tr.addMark(from, from + href.length, mark).insertText(' ')\n    }),\n  )\n}\n\n/**\n * Apply link marks after typing Enter.\n *\n * @internal\n */\nexport function defineLinkEnterRule(): PlainExtension {\n  return defineEnterRule({\n    regex: LINK_ENTER_RE,\n    handler: ({ state, from, match }) => {\n      const href = match[1]\n      if (!href) return null\n\n      const mark = state.schema.marks.link.create({ href })\n      const tr = state.tr.addMark(from, from + href.length, mark)\n      return tr.docChanged ? tr : null\n    },\n  })\n}\n\n/**\n * Apply and remove link marks to the text during typing.\n *\n * @internal\n */\nexport function defineLinkMarkRule(): PlainExtension {\n  return defineMarkRule({\n    regex: LINK_MARK_RE,\n    type: 'link',\n    attrs: (match) => ({ href: match[1] }),\n  })\n}\n\n/**\n * @internal\n */\nexport type LinkExtension = Union<[LinkSpecExtension, LinkCommandsExtension]>\n\n/**\n * @public\n */\nexport function defineLink(): LinkExtension {\n  return union(\n    defineLinkSpec(),\n    defineLinkCommands(),\n    defineLinkInputRule(),\n    defineLinkEnterRule(),\n    defineLinkPasteRule(),\n  )\n}\n"],"mappings":";;;;;;AAIA,MAAM,iBACJ;AAGF,MAAM,2BAA2B;AAEjC,MAAM,oBAAoB,MAAM,2BAA2B;AAElC,KAAe;AAGxC,MAAM,uBAEF,6HAiBY,iBACJ;AAmCZ,MAAM,qBAAqB,uBAAuB,oBAAoB;AAEtE,MAAM,qBAAqB,uBAAuB,oBAAoB;AAEtE,MAAM,oBAAoB,uBAAuB;AAEjD,MAAa,gBAAwB,IAAI,OAAO,oBAAoB,KAAK;AACzE,MAAa,gBAAwB,IAAI,OAAO,oBAAoB,KAAK;AACzE,MAAa,eAAuB,IAAI,OAAO,mBAAmB,KAAK;;;;ACpEvE,SAAgB,sBAAsC;AACpD,QAAO,oBAAoB;EACzB,MAAM;EACN,OAAO;EACP,WAAW,UAA8C;AACvD,OAAI,MAAM,GACR,QAAO,EAAE,MAAM,MAAM,IAAI;AAE3B,UAAO;;EAEV,CAAC;;;;;ACiBJ,SAAgB,iBAAoC;AAClD,QAAO,eAAkC;EACvC,MAAM;EACN,WAAW;EACX,OAAO;GACL,MAAM,EAAE,UAAU,UAAU;GAC5B,QAAQ;IAAE,SAAS;IAAM,UAAU;IAAe;GAClD,KAAK;IAAE,SAAS;IAAM,UAAU;IAAe;GAChD;EACD,UAAU,CACR;GACE,KAAK;GACL,WAAW,QAAqB;AAC9B,WAAO;KACL,MAAM,IAAI,aAAa,OAAO,IAAI;KAClC,QAAQ,IAAI,aAAa,SAAS,IAAI;KACtC,KAAK,IAAI,aAAa,MAAM,IAAI;KACjC;;GAEJ,CACF;EACD,MAAM,MAAM;GACV,MAAM,EAAE,MAAM,QAAQ,QAAQ,KAAK;AACnC,UAAO;IAAC;IAAK;KAAE;KAAM;KAAQ;KAAK;IAAE;IAAE;;EAEzC,CAAC;;AAeJ,SAAgB,qBAA4C;AAC1D,QAAO,eAAe;EACpB,UAAU,UAAqB,QAAQ;GAAE,MAAM;GAAQ;GAAO,CAAC;EAC/D,kBAAkB,WAAW,EAAE,MAAM,QAAQ,CAAC;EAC9C,aAAa,UAAqB,WAAW;GAAE,MAAM;GAAQ;GAAO,CAAC;EACrE,kBAAkB,WAAW,EAAE,MAAM,QAAQ,CAAC;EAC/C,CAAC;;;;;;;AAQJ,SAAgB,sBAAsC;AACpD,QAAO,gBACL,IAAI,UAAU,gBAAgB,OAAO,OAAO,SAAS;EACnD,MAAM,OAAO,MAAM;AACnB,MAAI,CAAC,KAAM,QAAO;EAElB,MAAM,OAAO,MAAM,OAAO,MAAM,KAAK,OAAO,EAAE,MAAM,CAAC;AACrD,SAAO,MAAM,GAAG,QAAQ,MAAM,OAAO,KAAK,QAAQ,KAAK,CAAC,WAAW,IAAI;GACvE,CACH;;;;;;;AAQH,SAAgB,sBAAsC;AACpD,QAAO,gBAAgB;EACrB,OAAO;EACP,UAAU,EAAE,OAAO,MAAM,YAAY;GACnC,MAAM,OAAO,MAAM;AACnB,OAAI,CAAC,KAAM,QAAO;GAElB,MAAM,OAAO,MAAM,OAAO,MAAM,KAAK,OAAO,EAAE,MAAM,CAAC;GACrD,MAAM,KAAK,MAAM,GAAG,QAAQ,MAAM,OAAO,KAAK,QAAQ,KAAK;AAC3D,UAAO,GAAG,aAAa,KAAK;;EAE/B,CAAC;;;;;;;AAQJ,SAAgB,qBAAqC;AACnD,QAAO,eAAe;EACpB,OAAO;EACP,MAAM;EACN,QAAQ,WAAW,EAAE,MAAM,MAAM,IAAI;EACtC,CAAC;;;;;AAWJ,SAAgB,aAA4B;AAC1C,QAAO,MACL,gBAAgB,EAChB,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,CACtB"}

package/dist/{prosekit-extensions-list.d.ts → list.d.ts}

@@ -1,7 +1,5 @@
 import { Extension, PlainExtension, Union } from "@prosekit/core";
 import { DedentListOptions, DedentListOptions as DedentListOptions$1, IndentListOptions, IndentListOptions as IndentListOptions$1, ListAttributes, ListDOMSerializer, ToggleCollapsedOptions, ToggleCollapsedOptions as ToggleCollapsedOptions$1, UnwrapListOptions, UnwrapListOptions as UnwrapListOptions$1, WrapInListGetAttrs } from "prosemirror-flat-list";
-
-//#region src/list/list-commands.d.ts
 /**
  * @internal
  */
@@ -24,34 +22,24 @@ type ListCommandsExtension = Extension<{
  * @internal
  */
 declare function defineListCommands(): ListCommandsExtension;
-//#endregion
-//#region src/list/list-input-rules.d.ts
 /**
  * @internal
  */
 declare function defineListInputRules(): Extension;
-//#endregion
-//#region src/list/list-keymap.d.ts
 /**
  * Returns a extension that adds key bindings for list.
  *
  * @internal
  */
 declare function defineListKeymap(): PlainExtension;
-//#endregion
-//#region src/list/list-plugins.d.ts
 /**
  * @internal
  */
 declare function defineListPlugins(): PlainExtension;
-//#endregion
-//#region src/list/list-serializer.d.ts
 /**
  * @internal
  */
 declare function defineListSerializer(): PlainExtension;
-//#endregion
-//#region src/list/list-types.d.ts
 /**
  * The attributes of a list node.
  *
@@ -75,8 +63,6 @@ interface ListAttrs {
    */
   collapsed?: boolean;
 }
-//#endregion
-//#region src/list/list-spec.d.ts
 /**
  * @internal
  */
@@ -89,8 +75,6 @@ type ListSpecExtension = Extension<{
  * @internal
  */
 declare function defineListSpec(): ListSpecExtension;
-//#endregion
-//#region src/list/list.d.ts
 /**
  * @internal
  */
@@ -99,6 +83,5 @@ type ListExtension = Union<[ListSpecExtension, ListCommandsExtension]>;
  * @public
  */
 declare function defineList(): ListExtension;
-//#endregion
 export { type DedentListOptions, type IndentListOptions, type ListAttrs, type ListCommandsExtension, ListDOMSerializer, type ListExtension, type ListSpecExtension, type ToggleCollapsedOptions, type UnwrapListOptions, type WrapInListGetAttrs, defineList, defineListCommands, defineListInputRules, defineListKeymap, defineListPlugins, defineListSerializer, defineListSpec };
-//# sourceMappingURL=prosekit-extensions-list.d.ts.map
+//# sourceMappingURL=list.d.ts.map

package/dist/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","names":[],"sources":["../src/list/list-commands.ts","../src/list/list-input-rules.ts","../src/list/list-keymap.ts","../src/list/list-plugins.ts","../src/list/list-serializer.ts","../src/list/list-types.ts","../src/list/list-spec.ts","../src/list/list.ts"],"mappings":";;;AAyBA;;KAAY,qBAAA,GAAwB,SAAA;EAClC,QAAA;IACE,UAAA,GAAa,OAAA,GAAU,mBAAA;IACvB,UAAA,GAAa,OAAA,GAAU,mBAAA;IACvB,QAAA,GAAW,SAAA;IACX,SAAA;IACA,eAAA,GAAkB,OAAA,GAAU,wBAAA;IAC5B,UAAA,GAAa,OAAA,GAAU,mBAAA;IACvB,UAAA,GAAa,KAAA,GAAQ,cAAA;IACrB,UAAA,GAAa,KAAA,GAAQ,cAAA;IACrB,UAAA,GAAa,KAAA,GAAQ,cAAA;EAAA;AAAA;;;;;;iBAST,kBAAA,CAAA,GAAsB,qBAAA;;;AAnBtC;iBCjBgB,oBAAA,CAAA,GAAwB,SAAA;;;ADiBxC;;;iBEcgB,gBAAA,CAAA,GAAoB,cAAA;;;AFdpC;iBGIgB,iBAAA,CAAA,GAAqB,cAAA;;;AHJrC;iBIlBgB,oBAAA,CAAA,GAAwB,cAAA;;;;AJkBxC;;UKpBiB,SAAA;ELsBU;;;EKlBzB,IAAA;ELwBuB;;;EKpBvB,KAAA;ELY2C;;;EKR3C,OAAA;ELUE;;;EKNF,SAAA;AAAA;;ALIF;;KMhBY,iBAAA,GAAoB,SAAA;EAC9B,KAAA;IACE,IAAA,EAAM,SAAA;EAAA;AAAA;;;;iBA4BM,cAAA,CAAA,GAAkB,iBAAA;ANdlC;;;AAAA,KOZY,aAAA,GAAgB,KAAA,EAAO,iBAAA,EAAmB,qBAAA;;;;iBAKtC,UAAA,CAAA,GAAc,aAAA"}

package/dist/{prosekit-extensions-list.js → list.js}

@@ -1,11 +1,10 @@
-import { defineInputRule } from "./prosekit-extensions-input-rule.js";
-import { t as defineDropIndicator } from "./drop-indicator.js";
+import { defineInputRule } from "./input-rule.js";
+import { t as defineDropIndicator } from "./drop-indicator2.js";
 import { Plugin } from "@prosekit/pm/state";
 import { defineClipboardSerializer, defineCommands, defineKeymap, defineNodeSpec, definePlugin, insertNode, union } from "@prosekit/core";
 import { chainCommands, deleteSelection } from "@prosekit/pm/commands";
 import { isElementLike } from "@ocavue/utils";
 import { ListDOMSerializer, createDedentListCommand, createIndentListCommand, createListEventPlugin, createListRenderingPlugin, createListSpec, createMoveListCommand, createSafariInputMethodWorkaroundPlugin, createSplitListCommand, createToggleCollapsedCommand, createToggleListCommand, createUnwrapListCommand, createWrapInListCommand, deleteCommand, enterCommand, findCheckboxInListItem, joinCollapsedListBackward, joinListElements, joinListUp, listInputRules, listToDOM, protectCollapsed, unwrapListSlice } from "prosemirror-flat-list";
-//#region src/list/list-commands.ts
 function insertList(attrs) {
 	return insertNode({
 		type: "list",
@@ -30,16 +29,12 @@ function defineListCommands() {
 		insertList
 	});
 }
-//#endregion
-//#region src/list/list-input-rules.ts
 /**
 * @internal
 */
 function defineListInputRules() {
 	return union(listInputRules.map(defineInputRule));
 }
-//#endregion
-//#region src/list/list-keymap.ts
 const backspaceCommand = chainCommands(protectCollapsed, deleteSelection, joinListUp, joinCollapsedListBackward);
 const dedentListCommand = createDedentListCommand();
 const indentListCommand = createIndentListCommand();
@@ -60,8 +55,6 @@ const listKeymap = {
 function defineListKeymap() {
 	return defineKeymap(listKeymap);
 }
-//#endregion
-//#region src/list/list-plugins.ts
 function createListClipboardPlugin() {
 	return new Plugin({ props: { transformCopied: unwrapListSlice } });
 }
@@ -79,8 +72,6 @@ function createListPlugins() {
 function defineListPlugins() {
 	return definePlugin(createListPlugins);
 }
-//#endregion
-//#region src/list/list-serializer.ts
 /**
 * @internal
 */
@@ -140,8 +131,6 @@ function normalizeTaskList(node) {
 	node.replaceChildren(...content.children);
 	textBlock.prepend(checkbox);
 }
-//#endregion
-//#region src/list/list-spec.ts
 function getMarkers(node) {
 	const attrs = node.attrs;
 	switch (attrs.kind) {
@@ -167,8 +156,6 @@ function defineListSpec() {
 		name: "list"
 	});
 }
-//#endregion
-//#region src/list/list-drop-indicator.ts
 /**
 * Configures drop indicator to avoid unexpected drop point.
 *
@@ -190,15 +177,12 @@ const onDrag = ({ view, pos }) => {
 	}
 	return true;
 };
-//#endregion
-//#region src/list/list.ts
 /**
 * @public
 */
 function defineList() {
 	return union(defineListSpec(), defineListPlugins(), defineListKeymap(), defineListInputRules(), defineListCommands(), defineListSerializer(), defineListDropIndicator());
 }
-//#endregion
 export { ListDOMSerializer, defineList, defineListCommands, defineListInputRules, defineListKeymap, defineListPlugins, defineListSerializer, defineListSpec };
 
-//# sourceMappingURL=prosekit-extensions-list.js.map
+//# sourceMappingURL=list.js.map

package/dist/list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.js","names":[],"sources":["../src/list/list-commands.ts","../src/list/list-input-rules.ts","../src/list/list-keymap.ts","../src/list/list-plugins.ts","../src/list/list-serializer.ts","../src/list/list-spec.ts","../src/list/list-drop-indicator.ts","../src/list/list.ts"],"sourcesContent":["import { defineCommands, insertNode, type Extension } from '@prosekit/core'\nimport type { Command } from '@prosekit/pm/state'\nimport {\n  createDedentListCommand as dedentList,\n  createIndentListCommand as indentList,\n  createMoveListCommand as moveList,\n  createSplitListCommand as splitList,\n  createToggleCollapsedCommand as toggleCollapsed,\n  createToggleListCommand as toggleList,\n  createUnwrapListCommand as unwrapList,\n  createWrapInListCommand as wrapInList,\n  type DedentListOptions,\n  type IndentListOptions,\n  type ListAttributes,\n  type ToggleCollapsedOptions,\n  type UnwrapListOptions,\n} from 'prosemirror-flat-list'\n\nfunction insertList(attrs?: ListAttributes): Command {\n  return insertNode({ type: 'list', attrs })\n}\n\n/**\n * @internal\n */\nexport type ListCommandsExtension = Extension<{\n  Commands: {\n    dedentList: [options?: DedentListOptions]\n    indentList: [options?: IndentListOptions]\n    moveList: [direction: 'up' | 'down']\n    splitList: []\n    toggleCollapsed: [options?: ToggleCollapsedOptions]\n    unwrapList: [options?: UnwrapListOptions]\n    toggleList: [attrs?: ListAttributes]\n    wrapInList: [attrs?: ListAttributes]\n    insertList: [attrs?: ListAttributes]\n  }\n}>\n\n/**\n * Defines list commands.\n *\n * @internal\n */\nexport function defineListCommands(): ListCommandsExtension {\n  return defineCommands({\n    dedentList,\n    indentList,\n    moveList,\n    splitList,\n    toggleCollapsed,\n    unwrapList,\n    toggleList,\n    wrapInList,\n    insertList,\n  })\n}\n","import { union, type Extension } from '@prosekit/core'\nimport { listInputRules } from 'prosemirror-flat-list'\n\nimport { defineInputRule } from '../input-rule/index.ts'\n\n/**\n * @internal\n */\nexport function defineListInputRules(): Extension {\n  return union(listInputRules.map(defineInputRule))\n}\n","import { defineKeymap, type PlainExtension } from '@prosekit/core'\nimport { chainCommands, deleteSelection } from '@prosekit/pm/commands'\nimport {\n  createDedentListCommand,\n  createIndentListCommand,\n  deleteCommand,\n  enterCommand,\n  joinCollapsedListBackward,\n  joinListUp,\n  protectCollapsed,\n} from 'prosemirror-flat-list'\n\n// This is different from the one exported by prosemirror-flat-list, because\n// some commands are moved to `defineBaseKeymap` in `prosekit/core`.\nconst backspaceCommand = chainCommands(\n  protectCollapsed,\n  deleteSelection,\n  joinListUp,\n  joinCollapsedListBackward,\n)\n\nconst dedentListCommand = createDedentListCommand()\nconst indentListCommand = createIndentListCommand()\n\nconst listKeymap = {\n  'Enter': enterCommand,\n  'Backspace': backspaceCommand,\n  'Delete': deleteCommand,\n  'Mod-]': indentListCommand,\n  'Mod-[': dedentListCommand,\n  'Tab': indentListCommand,\n  'Shift-Tab': dedentListCommand,\n}\n\n/**\n * Returns a extension that adds key bindings for list.\n *\n * @internal\n */\nexport function defineListKeymap(): PlainExtension {\n  return defineKeymap(listKeymap)\n}\n","import { definePlugin, type PlainExtension } from '@prosekit/core'\nimport { Plugin } from '@prosekit/pm/state'\nimport {\n  createListEventPlugin,\n  createListRenderingPlugin,\n  createSafariInputMethodWorkaroundPlugin,\n  unwrapListSlice,\n} from 'prosemirror-flat-list'\n\nfunction createListClipboardPlugin(): Plugin {\n  return new Plugin({\n    props: {\n      transformCopied: unwrapListSlice,\n    },\n  })\n}\n\nfunction createListPlugins(): Plugin[] {\n  return [\n    createListEventPlugin(),\n    createListRenderingPlugin(),\n    createListClipboardPlugin(),\n    createSafariInputMethodWorkaroundPlugin(),\n  ]\n}\n\n/**\n * @internal\n */\nexport function defineListPlugins(): PlainExtension {\n  return definePlugin(createListPlugins)\n}\n","import { isElementLike } from '@ocavue/utils'\nimport { defineClipboardSerializer, type PlainExtension } from '@prosekit/core'\nimport { findCheckboxInListItem, joinListElements, listToDOM } from 'prosemirror-flat-list'\n\n/**\n * @internal\n */\nexport function defineListSerializer(): PlainExtension {\n  return defineClipboardSerializer({\n    serializeFragmentWrapper: (fn) => {\n      return (...args) => {\n        const dom = fn(...args)\n        return normalizeElementTree(joinListElements(dom))\n      }\n    },\n    serializeNodeWrapper: (fn) => {\n      return (...args) => {\n        const dom = fn(...args)\n        return isElementLike(dom)\n          ? normalizeElementTree(joinListElements(dom))\n          : dom\n      }\n    },\n    nodesFromSchemaWrapper: (fn) => {\n      return (...args) => {\n        const nodes = fn(...args)\n        return {\n          ...nodes,\n          list: (node) => listToDOM({ node, nativeList: true }),\n        }\n      }\n    },\n  })\n}\n\nfunction normalizeElementTree<T extends Element | DocumentFragment>(\n  node: T,\n): T {\n  if (isElementLike(node)) {\n    normalizeTaskList(node)\n  }\n\n  for (const child of node.children) {\n    normalizeElementTree(child)\n  }\n\n  return node\n}\n\n/**\n * Modifies the DOM tree for task lists to ensure that the output HTML can be\n * parsed by rehype-remark.\n */\nfunction normalizeTaskList(node: Element): void {\n  if (\n    !node.classList.contains('prosemirror-flat-list')\n    || node.getAttribute('data-list-kind') !== 'task'\n    || node.children.length !== 2\n  ) {\n    return\n  }\n\n  const marker = node.children.item(0)\n  if (!marker || !marker.classList.contains('list-marker')) {\n    return\n  }\n\n  const checkbox = findCheckboxInListItem(marker)\n  if (!checkbox) {\n    return\n  }\n\n  const content = node.children.item(1)\n  if (!content || !content.classList.contains('list-content')) {\n    return\n  }\n\n  const textBlock = content.children.item(0)\n  if (!textBlock || !['P', 'H1', 'H2', 'H3', 'H4', 'H5', 'H6'].includes(textBlock.tagName)) {\n    return\n  }\n\n  node.replaceChildren(...content.children)\n  textBlock.prepend(checkbox)\n}\n","import { defineNodeSpec, type Extension } from '@prosekit/core'\nimport type { DOMOutputSpec, ProseMirrorNode } from '@prosekit/pm/model'\nimport { createListSpec, listToDOM, type ListAttributes } from 'prosemirror-flat-list'\n\nimport type { ListAttrs } from './list-types.ts'\n\n/**\n * @internal\n */\nexport type ListSpecExtension = Extension<{\n  Nodes: {\n    list: ListAttrs\n  }\n}>\n\nfunction getMarkers(node: ProseMirrorNode): DOMOutputSpec[] {\n  const attrs = node.attrs as ListAttributes\n  switch (attrs.kind) {\n    case 'task':\n      // Use a `label` element here so that the area around the checkbox is also checkable.\n      return [\n        [\n          'label',\n          [\n            'input',\n            { type: 'checkbox', checked: attrs.checked ? '' : undefined },\n          ],\n        ],\n      ]\n    default:\n      // Always return an empty array so that the marker element is rendered. This\n      // is required to make the drop indicator locate the correct position.\n      return []\n  }\n}\n\n/**\n * @internal\n */\nexport function defineListSpec(): ListSpecExtension {\n  const spec = createListSpec()\n\n  return defineNodeSpec<'list', ListAttrs>({\n    ...spec,\n    toDOM: (node) => {\n      return listToDOM({ node, getMarkers })\n    },\n    name: 'list',\n  })\n}\n","import type { PlainExtension } from '@prosekit/core'\n\nimport type { DragEventHandler } from '../drop-indicator/index.ts'\nimport { defineDropIndicator } from '../drop-indicator/index.ts'\n\n/**\n * Configures drop indicator to avoid unexpected drop point.\n *\n * We don't want to drag a list node and drop it as the first\n * child of another list node.\n *\n * @internal\n */\nexport function defineListDropIndicator(): PlainExtension {\n  return defineDropIndicator({\n    onDrag,\n  })\n}\n\nconst onDrag: DragEventHandler = ({ view, pos }): boolean => {\n  const slice = view.dragging?.slice\n  if (\n    slice\n    && slice.openStart === 0\n    && slice.openEnd === 0\n    && slice.content.childCount === 1\n  ) {\n    const node = slice.content.child(0)\n    if (node.type.name === 'list') {\n      const $pos = view.state.doc.resolve(pos)\n      if ($pos.parent.type.name === 'list' && $pos.index() === 0) {\n        return false\n      }\n    }\n  }\n  return true\n}\n","import { union, type Union } from '@prosekit/core'\n\nimport { defineListCommands, type ListCommandsExtension } from './list-commands.ts'\nimport { defineListDropIndicator } from './list-drop-indicator.ts'\nimport { defineListInputRules } from './list-input-rules.ts'\nimport { defineListKeymap } from './list-keymap.ts'\nimport { defineListPlugins } from './list-plugins.ts'\nimport { defineListSerializer } from './list-serializer.ts'\nimport { defineListSpec, type ListSpecExtension } from './list-spec.ts'\n\n/**\n * @internal\n */\nexport type ListExtension = Union<[ListSpecExtension, ListCommandsExtension]>\n\n/**\n * @public\n */\nexport function defineList(): ListExtension {\n  return union(\n    defineListSpec(),\n    defineListPlugins(),\n    defineListKeymap(),\n    defineListInputRules(),\n    defineListCommands(),\n    defineListSerializer(),\n    defineListDropIndicator(),\n  )\n}\n"],"mappings":"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"}

package/dist/{prosekit-extensions-loro.d.ts → loro.d.ts}

@@ -1,7 +1,5 @@
 import { Extension, PlainExtension, Union } from "@prosekit/core";
 import { CursorAwareness, CursorEphemeralStore, CursorPluginOptions, LoroDocType, LoroSyncPluginProps, LoroSyncPluginProps as LoroSyncPluginProps$1, LoroUndoPluginProps, LoroUndoPluginProps as LoroUndoPluginProps$1 } from "loro-prosemirror";
-
-//#region src/loro/loro-commands.d.ts
 /**
  * @internal
  */
@@ -12,24 +10,14 @@ type LoroCommandsExtension = Extension<{
   };
 }>;
 declare function defineLoroCommands(): LoroCommandsExtension;
-//#endregion
-//#region src/loro/loro-cursor-plugin.d.ts
 interface LoroCursorOptions extends CursorPluginOptions {
   awareness?: CursorAwareness;
   presence?: CursorEphemeralStore;
 }
 declare function defineLoroCursorPlugin(options: LoroCursorOptions): PlainExtension;
-//#endregion
-//#region src/loro/loro-keymap.d.ts
 declare function defineLoroKeymap(): PlainExtension;
-//#endregion
-//#region src/loro/loro-sync-plugin.d.ts
 declare function defineLoroSyncPlugin(options: LoroSyncPluginProps$1): PlainExtension;
-//#endregion
-//#region src/loro/loro-undo-plugin.d.ts
 declare function defineLoroUndoPlugin(options: LoroUndoPluginProps$1): PlainExtension;
-//#endregion
-//#region src/loro/loro.d.ts
 interface LoroOptions {
   /**
    * The Loro instance handles the state of shared data.
@@ -64,6 +52,5 @@ type LoroExtension = Union<[LoroCommandsExtension, PlainExtension]>;
  * @public
  */
 declare function defineLoro(options: LoroOptions): LoroExtension;
-//#endregion
 export { type LoroCursorOptions, type LoroExtension, type LoroOptions, type LoroSyncPluginProps, type LoroUndoPluginProps, defineLoro, defineLoroCommands, defineLoroCursorPlugin, defineLoroKeymap, defineLoroSyncPlugin, defineLoroUndoPlugin };
-//# sourceMappingURL=prosekit-extensions-loro.d.ts.map
+//# sourceMappingURL=loro.d.ts.map

package/dist/loro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loro.d.ts","names":[],"sources":["../src/loro/loro-commands.ts","../src/loro/loro-cursor-plugin.ts","../src/loro/loro-keymap.ts","../src/loro/loro-sync-plugin.ts","../src/loro/loro-undo-plugin.ts","../src/loro/loro.ts"],"mappings":";;;;AAWA;KAAY,qBAAA,GAAwB,SAAA;EAClC,QAAA;IACE,IAAA;IACA,IAAA;EAAA;AAAA;AAAA,iBAIY,kBAAA,CAAA,GAAsB,qBAAA;AAAA,UCbrB,iBAAA,SAA0B,mBAAA;EACzC,SAAA,GAAY,eAAA;EACZ,QAAA,GAAW,oBAAA;AAAA;AAAA,iBAGG,sBAAA,CACd,OAAA,EAAS,iBAAA,GACR,cAAA;AAAA,iBCAa,gBAAA,CAAA,GAAoB,cAAA;AAAA,iBCTpB,oBAAA,CACd,OAAA,EAAS,qBAAA,GACR,cAAA;AAAA,iBCFa,oBAAA,CAAqB,OAAA,EAAS,qBAAA,GAAsB,cAAA;AAAA,UCcnD,WAAA;ELNgB;;;EKU/B,GAAA,EAAK,WAAA;ELTL;;;EKcA,SAAA,GAAY,eAAA;ELZN;AAIR;;EKaE,QAAA,GAAW,oBAAA;ELbyB;;;EKkBpC,IAAA,GAAO,IAAA,CAAK,qBAAA;EJ/BqB;;;EIoCjC,IAAA,GAAO,IAAA,CAAK,qBAAA;EJpC6B;;;EIyCzC,MAAA,GAAS,mBAAA;AAAA;;;;KAMC,aAAA,GAAgB,KAAA,EAAO,qBAAA,EAAuB,cAAA;;AJ1C1D;;iBI+CgB,UAAA,CAAW,OAAA,EAAS,WAAA,GAAc,aAAA"}