@prosekit/extensions 0.11.2 → 0.11.4

package/dist/{drop-indicator-B8P652g2.js → drop-indicator-dB9rZn8e.js}

@@ -61,8 +61,9 @@ function buildGetTarget(view, onDrag) {
 			const p2Distance = pointLineDistance(point, line2);
 			return p1Distance - p2Distance || pos1 - pos2;
 		};
-		const targets = getTargets();
+		let targets = getTargets();
 		targets.sort(compare);
+		targets = targets.slice(0, 8);
 		const target = targets.find((target$1) => onDrag({
 			view,
 			pos: target$1[0],

package/dist/paste-rule-Cca3n5TA.js

@@ -0,0 +1,173 @@
+import { defineFacet, defineFacetPayload, getMarkType, pluginFacet } from "@prosekit/core";
+import { PluginKey, ProseMirrorPlugin } from "@prosekit/pm/state";
+import { Fragment, Slice } from "@prosekit/pm/model";
+
+//#region src/paste-rule/paste-rule-plugin.ts
+/**
+* @internal
+*/
+const pasteRuleFacet = defineFacet({
+	reduce: () => {
+		let handlers = [];
+		let isPlainText = false;
+		const transformPasted = (slice, view) => {
+			for (const handler of handlers) slice = handler({
+				slice,
+				view,
+				plain: isPlainText
+			});
+			return slice;
+		};
+		const plugin = new ProseMirrorPlugin({
+			key: new PluginKey("prosekit-paste-rule"),
+			props: {
+				transformPasted,
+				transformPastedText: (text, plain) => {
+					isPlainText = plain;
+					return text;
+				},
+				transformPastedHTML(html) {
+					isPlainText = false;
+					return html;
+				}
+			}
+		});
+		return (inputs) => {
+			handlers = [...inputs].reverse();
+			return plugin;
+		};
+	},
+	singleton: true,
+	parent: pluginFacet
+});
+/**
+* @internal
+*/
+function definePasteRulePlugin(payload) {
+	return defineFacetPayload(pasteRuleFacet, [payload]);
+}
+
+//#endregion
+//#region src/paste-rule/paste-rule.ts
+/**
+* Defines a paste rule. This rule allows you to modify pasted or dragged
+* content before it is inserted into the document.
+*
+* @param options
+*
+* @public
+*/
+function definePasteRule({ handler }) {
+	return definePasteRulePlugin(handler);
+}
+
+//#endregion
+//#region src/paste-rule/split-text-by-regex.ts
+/**
+* Splits text into chunks based on regex matches, preserving both matched and unmatched segments.
+* Returns an array of tuples where each tuple contains a text segment and either the match data
+* (for matched segments) or undefined (for unmatched segments).
+*/
+function splitTextByRegex(text, regex) {
+	regex.lastIndex = 0;
+	const chunks = [];
+	let lastIndex = 0;
+	let match;
+	let matched = false;
+	while (match = regex.exec(text)) {
+		const start = match.index;
+		const end = regex.lastIndex;
+		if (start > lastIndex) chunks.push([text.slice(lastIndex, start), void 0]);
+		chunks.push([text.slice(start, end), match]);
+		matched = true;
+		if (lastIndex === end) return;
+		lastIndex = end;
+	}
+	if (matched && lastIndex < text.length) chunks.push([text.slice(lastIndex), void 0]);
+	regex.lastIndex = 0;
+	return matched ? chunks : void 0;
+}
+
+//#endregion
+//#region src/paste-rule/mark-paste-rule.ts
+/**
+* Defines a paste rule that applies marks based on regex patterns.
+*
+* @public
+*/
+function defineMarkPasteRule(options) {
+	return definePasteRule({ handler: ({ slice, view, plain }) => {
+		if (plain) return slice;
+		const markType = getMarkType(view.state.schema, options.type);
+		return replaceMarkInSlice({
+			markType,
+			regex: options.regex,
+			getAttrs: options.getAttrs,
+			shouldSkip: options.shouldSkip
+		}, slice);
+	} });
+}
+function replaceMarkInSlice(options, slice) {
+	const newFragment = replaceMarkInFragment(options, slice.content);
+	if (!newFragment) return slice;
+	return new Slice(newFragment, slice.openStart, slice.openEnd);
+}
+function replaceMarkInFragment(options, fragment) {
+	let changed = false;
+	let children = [];
+	for (const child of fragment.content) {
+		const newChild = replaceMarkInNode(options, child);
+		if (newChild) changed = true;
+		children.push(newChild || child);
+	}
+	if (changed) return Fragment.from(children);
+}
+function replaceMarkInNode(options, node) {
+	if (node.type.spec.code) return;
+	if (node.type.isInline) return;
+	if (node.type.isTextblock) return replaceMarkInTextblockNode(options, node);
+	const newChildren = replaceMarkInFragment(options, node.content);
+	if (!newChildren) return;
+	return node.copy(newChildren);
+}
+function replaceMarkInTextblockNode(options, node) {
+	const newChildren = [];
+	let changed = false;
+	for (const inlineNode of node.content.content) {
+		const newInlineNodes = replaceMarkInInlineNode(options, inlineNode);
+		if (newInlineNodes) {
+			changed = true;
+			newChildren.push(...newInlineNodes);
+		} else newChildren.push(inlineNode);
+	}
+	if (changed) return node.copy(Fragment.from(newChildren));
+}
+function replaceMarkInInlineNode(options, node) {
+	const text = node.text;
+	if (!text) return;
+	const { markType, shouldSkip } = options;
+	if (shouldSkip) {
+		if (shouldSkip(node)) return;
+	} else {
+		if (node.marks.some((mark) => mark.type === markType)) return;
+		if (node.marks.some((mark) => mark.type.spec.code)) return;
+	}
+	const chunks = splitTextByRegex(text, options.regex);
+	if (!chunks) return;
+	const schema = node.type.schema;
+	const nodes = [];
+	for (const [text$1, match] of chunks) {
+		if (!text$1) continue;
+		if (match) {
+			const attrs = options.getAttrs?.(match) ?? null;
+			if (attrs !== false) {
+				const mark = markType.create(attrs);
+				nodes.push(schema.text(text$1, [...node.marks, mark]));
+			} else nodes.push(schema.text(text$1, node.marks));
+		} else nodes.push(schema.text(text$1, node.marks));
+	}
+	return nodes;
+}
+
+//#endregion
+export { defineMarkPasteRule, definePasteRule };

package/dist/prosekit-extensions-code-block.d.ts

@@ -1,4 +1,4 @@
-import { ShikiHighlighterOptions } from "./shiki-highlighter-chunk-D7gKY7Kr.js";
+import { ShikiHighlighterOptions } from "./shiki-highlighter-chunk-DSPM0T27.js";
 import { Extension, PlainExtension, Union } from "@prosekit/core";
 import { Parser } from "prosemirror-highlight";
 import { BundledLanguage as ShikiBundledLanguage, BundledLanguageInfo as ShikiBundledLanguageInfo, BundledTheme as ShikiBundledTheme, BundledThemeInfo as ShikiBundledThemeInfo, SpecialLanguage, bundledLanguagesInfo as shikiBundledLanguagesInfo, bundledThemesInfo as shikiBundledThemesInfo } from "shiki";

package/dist/prosekit-extensions-drop-indicator.js

@@ -1,3 +1,3 @@
-import { defineDropIndicator } from "./drop-indicator-B8P652g2.js";
+import { defineDropIndicator } from "./drop-indicator-dB9rZn8e.js";
 
 export { defineDropIndicator };

package/dist/prosekit-extensions-link.d.ts

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

package/dist/prosekit-extensions-link.js

@@ -1,6 +1,7 @@
 import { defineInputRule } from "./input-rule-Gji4N7Oe.js";
 import { defineEnterRule } from "./enter-rule-RdhEA900.js";
 import { defineMarkRule } from "./mark-rule-D7zaa32n.js";
+import { defineMarkPasteRule } from "./paste-rule-Cca3n5TA.js";
 import { addMark, defineCommands, defineMarkSpec, expandMark, removeMark, toggleMark, union } from "@prosekit/core";
 import { InputRule } from "@prosekit/pm/inputrules";
 
@@ -17,6 +18,22 @@ 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
+*/
+function defineLinkPasteRule() {
+	return defineMarkPasteRule({
+		type: "link",
+		regex: LINK_MARK_RE,
+		getAttrs: (match) => {
+			if (match[1]) return { href: match[1] };
+			return false;
+		}
+	});
+}
+
 //#endregion
 //#region src/link/index.ts
 /**
@@ -121,8 +138,8 @@ function defineLinkMarkRule() {
 * @public
 */
 function defineLink() {
-	return union(defineLinkSpec(), defineLinkCommands(), defineLinkInputRule(), defineLinkEnterRule());
+	return union(defineLinkSpec(), defineLinkCommands(), defineLinkInputRule(), defineLinkEnterRule(), defineLinkPasteRule());
 }
 
 //#endregion
-export { defineLink, defineLinkCommands, defineLinkEnterRule, defineLinkInputRule, defineLinkMarkRule, defineLinkSpec };
+export { defineLink, defineLinkCommands, defineLinkEnterRule, defineLinkInputRule, defineLinkMarkRule, defineLinkPasteRule, defineLinkSpec };

package/dist/prosekit-extensions-list.js

@@ -1,5 +1,5 @@
 import { defineInputRule } from "./input-rule-Gji4N7Oe.js";
-import { defineDropIndicator } from "./drop-indicator-B8P652g2.js";
+import { defineDropIndicator } from "./drop-indicator-dB9rZn8e.js";
 import { defineClipboardSerializer, defineCommands, defineKeymap, defineNodeSpec, definePlugin, insertNode, union } from "@prosekit/core";
 import { Plugin } from "@prosekit/pm/state";
 import { chainCommands, deleteSelection } from "@prosekit/pm/commands";

package/dist/prosekit-extensions-paste-rule.d.ts

@@ -0,0 +1,93 @@
+import { PlainExtension } from "@prosekit/core";
+import { EditorView } from "@prosekit/pm/view";
+import { Attrs, MarkType, ProseMirrorNode, Slice } from "@prosekit/pm/model";
+
+//#region src/paste-rule/mark-paste-rule.d.ts
+
+/**
+ * The options for {@link defineMarkPasteRule}.
+ *
+ * @public
+ */
+interface MarkPasteRuleOptions {
+  /**
+   * The regular expression to match against. It must have a `g` flag to match
+   * all instances of the mark.
+   */
+  regex: RegExp;
+  /**
+   * The mark type to apply to the matched text.
+   */
+  type: string | MarkType;
+  /**
+   * A function used to compute attributes to set on the mark created by this
+   * rule. When it returns `false`, the rule won't match. When it returns `null`
+   * or `undefined`, that is interpreted as an empty/default set of attributes.
+   * @default null
+   */
+  getAttrs?: (match: RegExpExecArray) => Attrs | null | undefined | false;
+  /**
+   * Optional function to determine if a text node should be skipped.
+   * Default behavior: skip code nodes and nodes that already have the target mark.
+   */
+  shouldSkip?: (node: ProseMirrorNode) => boolean;
+}
+/**
+ * Defines a paste rule that applies marks based on regex patterns.
+ *
+ * @public
+ */
+declare function defineMarkPasteRule(options: MarkPasteRuleOptions): PlainExtension;
+//#endregion
+//#region src/paste-rule/paste-rule.d.ts
+/**
+ * @public
+ *
+ * Options for {@link PasteRuleHandler}.
+ */
+interface PasteRuleHandlerOptions {
+  /**
+   * The slice to be pasted.
+   */
+  slice: Slice;
+  /**
+   * The editor view.
+   */
+  view: EditorView;
+  /**
+   * Whether the pasted content is treated as plain text. This is true when the
+   * `Shift` key is held when pasting.
+   */
+  plain: boolean;
+}
+/**
+ * @public
+ *
+ * Can be used to transform pasted or dragged-and-dropped content before it is
+ * applied to the document.
+ */
+type PasteRuleHandler = (options: PasteRuleHandlerOptions) => Slice;
+/**
+ * Options for {@link definePasteRule}.
+ *
+ * @public
+ */
+interface PasteRuleOptions {
+  /**
+   * A function to be called when a paste rule is triggered.
+   */
+  handler: PasteRuleHandler;
+}
+/**
+ * Defines a paste rule. This rule allows you to modify pasted or dragged
+ * content before it is inserted into the document.
+ *
+ * @param options
+ *
+ * @public
+ */
+declare function definePasteRule({
+  handler
+}: PasteRuleOptions): PlainExtension;
+//#endregion
+export { type MarkPasteRuleOptions, type PasteRuleHandler, type PasteRuleHandlerOptions, type PasteRuleOptions, defineMarkPasteRule, definePasteRule };

package/dist/prosekit-extensions-paste-rule.js

@@ -0,0 +1,3 @@
+import { defineMarkPasteRule, definePasteRule } from "./paste-rule-Cca3n5TA.js";
+
+export { defineMarkPasteRule, definePasteRule };

package/dist/prosekit-extensions-placeholder.js

@@ -1,4 +1,5 @@
-import { findTable } from "./table-3rDWFyBH.js";
+import "./drop-indicator-dB9rZn8e.js";
+import { findTable } from "./table-CPI9ZxbK.js";
 import { definePlugin, isInCodeBlock, maybeRun } from "@prosekit/core";
 import { Plugin, PluginKey } from "@prosekit/pm/state";
 import { Decoration, DecorationSet } from "@prosekit/pm/view";

package/dist/prosekit-extensions-table.d.ts

@@ -268,6 +268,15 @@ type TableExtension = Union<[TableSpecExtension, TableRowSpecExtension, TableCel
  */
 declare function defineTable(): TableExtension;
 //#endregion
+//#region src/table/table-drop-indicator.d.ts
+/**
+ * Hides the drop indicator when dragging a table column or row by using the
+ * table handle.
+ *
+ * @internal
+ */
+declare function defineTableDropIndicator(): PlainExtension;
+//#endregion
 //#region src/table/table-plugins.d.ts
 /**
  * @public
@@ -296,4 +305,4 @@ declare function findTable($pos: ResolvedPos): FindParentNodeResult | undefined;
  */
 
 //#endregion
-export { type InsertTableOptions, type MoveTableColumnOptions, type MoveTableRowOptions, type SelectTableCellOptions, type SelectTableColumnOptions, type SelectTableOptions, type SelectTableRowOptions, type TableCellSpecExtension, type TableCommandsExtension, type TableExtension, type TableHeaderCellSpecExtension, type TableRowSpecExtension, type TableSpecExtension, defineTable, defineTableCellSpec, defineTableCommands, defineTableHeaderCellSpec, defineTablePlugins, defineTableRowSpec, defineTableSpec, exitTable, findTable, insertTable, isCellSelection, moveTableColumn, moveTableRow, selectTable, selectTableCell, selectTableColumn, selectTableRow };
+export { type InsertTableOptions, type MoveTableColumnOptions, type MoveTableRowOptions, type SelectTableCellOptions, type SelectTableColumnOptions, type SelectTableOptions, type SelectTableRowOptions, type TableCellSpecExtension, type TableCommandsExtension, type TableExtension, type TableHeaderCellSpecExtension, type TableRowSpecExtension, type TableSpecExtension, defineTable, defineTableCellSpec, defineTableCommands, defineTableDropIndicator, defineTableHeaderCellSpec, defineTablePlugins, defineTableRowSpec, defineTableSpec, exitTable, findTable, insertTable, isCellSelection, moveTableColumn, moveTableRow, selectTable, selectTableCell, selectTableColumn, selectTableRow };

package/dist/prosekit-extensions-table.js

@@ -1,3 +1,4 @@
-import { defineTable, defineTableCellSpec, defineTableCommands, defineTableHeaderCellSpec, defineTablePlugins, defineTableRowSpec, defineTableSpec, exitTable, findTable, insertTable, isCellSelection, moveTableColumn, moveTableRow, selectTable, selectTableCell, selectTableColumn, selectTableRow } from "./table-3rDWFyBH.js";
+import "./drop-indicator-dB9rZn8e.js";
+import { defineTable, defineTableCellSpec, defineTableCommands, defineTableDropIndicator, defineTableHeaderCellSpec, defineTablePlugins, defineTableRowSpec, defineTableSpec, exitTable, findTable, insertTable, isCellSelection, moveTableColumn, moveTableRow, selectTable, selectTableCell, selectTableColumn, selectTableRow } from "./table-CPI9ZxbK.js";
 
-export { defineTable, defineTableCellSpec, defineTableCommands, defineTableHeaderCellSpec, defineTablePlugins, defineTableRowSpec, defineTableSpec, exitTable, findTable, insertTable, isCellSelection, moveTableColumn, moveTableRow, selectTable, selectTableCell, selectTableColumn, selectTableRow };
+export { defineTable, defineTableCellSpec, defineTableCommands, defineTableDropIndicator, defineTableHeaderCellSpec, defineTablePlugins, defineTableRowSpec, defineTableSpec, exitTable, findTable, insertTable, isCellSelection, moveTableColumn, moveTableRow, selectTable, selectTableCell, selectTableColumn, selectTableRow };

package/dist/shiki-highlighter-chunk.d.ts

@@ -1,2 +1,2 @@
-import { HighlighterOptions, HighlighterResult, ShikiHighlighterOptions, createOrGetHighlighter } from "./shiki-highlighter-chunk-D7gKY7Kr.js";
+import { HighlighterOptions, HighlighterResult, ShikiHighlighterOptions, createOrGetHighlighter } from "./shiki-highlighter-chunk-DSPM0T27.js";
 export { HighlighterOptions, HighlighterResult, ShikiHighlighterOptions, createOrGetHighlighter };

package/dist/{table-3rDWFyBH.js → table-CPI9ZxbK.js}

@@ -1,3 +1,4 @@
+import { defineDropIndicator } from "./drop-indicator-dB9rZn8e.js";
 import { defaultBlockAt, defineCommands, defineNodeSpec, definePlugin, findParentNode, getNodeType, insertNode, union } from "@prosekit/core";
 import { TextSelection } from "@prosekit/pm/state";
 import { CellSelection, TableMap, addColumnAfter, addColumnBefore, addRowAfter, addRowBefore, cellAround, cellNear, columnResizing, deleteCellSelection, deleteColumn, deleteRow, deleteTable, inSameTable, mergeCells, splitCell, tableEditing, tableNodes } from "prosemirror-tables";
@@ -661,6 +662,31 @@ function defineTableCommands() {
 	});
 }
 
+//#endregion
+//#region src/table/table-drop-indicator.ts
+/**
+* Hides the drop indicator when dragging a table column or row by using the
+* table handle.
+*
+* @internal
+*/
+function defineTableDropIndicator() {
+	return defineDropIndicator({ onDrag });
+}
+const matchMap = /* @__PURE__ */ new WeakMap();
+const onDrag = ({ event }) => {
+	const dataTransfer = event.dataTransfer;
+	if (!dataTransfer) return true;
+	let match;
+	if (matchMap.has(dataTransfer)) match = matchMap.get(dataTransfer);
+	else {
+		const types = dataTransfer.types;
+		match = types.includes("application/x-prosekit-table-handle-drag");
+		matchMap.set(dataTransfer, match);
+	}
+	return !match;
+};
+
 //#endregion
 //#region src/table/table-plugins.ts
 /**
@@ -727,8 +753,8 @@ function defineTableHeaderCellSpec() {
 * @public
 */
 function defineTable() {
-	return union(defineTableSpec(), defineTableRowSpec(), defineTableCellSpec(), defineTableHeaderCellSpec(), defineTablePlugins(), defineTableCommands());
+	return union(defineTableSpec(), defineTableRowSpec(), defineTableCellSpec(), defineTableHeaderCellSpec(), defineTablePlugins(), defineTableCommands(), defineTableDropIndicator());
 }
 
 //#endregion
-export { defineTable, defineTableCellSpec, defineTableCommands, defineTableHeaderCellSpec, defineTablePlugins, defineTableRowSpec, defineTableSpec, exitTable, findTable, insertTable, isCellSelection, moveTableColumn, moveTableRow, selectTable, selectTableCell, selectTableColumn, selectTableRow };
+export { defineTable, defineTableCellSpec, defineTableCommands, defineTableDropIndicator, defineTableHeaderCellSpec, defineTablePlugins, defineTableRowSpec, defineTableSpec, exitTable, findTable, insertTable, isCellSelection, moveTableColumn, moveTableRow, selectTable, selectTableCell, selectTableColumn, selectTableRow };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/extensions",
   "type": "module",
-  "version": "0.11.2",
+  "version": "0.11.4",
   "private": false,
   "description": "A collection of common extensions for ProseKit",
   "author": {
@@ -142,6 +142,10 @@
       "types": "./dist/prosekit-extensions-paragraph.d.ts",
       "default": "./dist/prosekit-extensions-paragraph.js"
     },
+    "./paste-rule": {
+      "types": "./dist/prosekit-extensions-paste-rule.d.ts",
+      "default": "./dist/prosekit-extensions-paste-rule.js"
+    },
     "./placeholder": {
       "types": "./dist/prosekit-extensions-placeholder.d.ts",
       "default": "./dist/prosekit-extensions-placeholder.js"
@@ -210,7 +214,7 @@
     "prosemirror-highlight": "^0.13.0",
     "prosemirror-search": "^1.1.0",
     "prosemirror-tables": "^1.7.1",
-    "shiki": "^3.9.1",
+    "shiki": "^3.9.2",
     "@prosekit/core": "^0.8.3",
     "@prosekit/pm": "^0.1.11"
   },
@@ -239,16 +243,16 @@
     "@vitest/browser": "^3.2.4",
     "diffable-html": "^6.0.1",
     "just-pick": "^4.2.0",
-    "loro-crdt": "^1.5.9",
+    "loro-crdt": "^1.5.10",
     "loro-prosemirror": "^0.2.3",
     "rehype-parse": "^9.0.1",
     "rehype-remark": "^10.0.1",
     "remark-html": "^16.0.1",
     "remark-parse": "^11.0.0",
     "remark-stringify": "^11.0.0",
-    "tsdown": "^0.13.2",
+    "tsdown": "^0.13.4",
     "type-fest": "^4.41.0",
-    "typescript": "~5.8.3",
+    "typescript": "~5.9.2",
     "unified": "^11.0.5",
     "vitest": "^3.2.4",
     "y-prosemirror": "^1.3.7",
@@ -292,6 +296,7 @@
       "prosekit-extensions-mention": "./src/mention/index.ts",
       "prosekit-extensions-mod-click-prevention": "./src/mod-click-prevention/index.ts",
       "prosekit-extensions-paragraph": "./src/paragraph/index.ts",
+      "prosekit-extensions-paste-rule": "./src/paste-rule/index.ts",
       "prosekit-extensions-placeholder": "./src/placeholder/index.ts",
       "placeholder/style": "./src/placeholder/style.css",
       "prosekit-extensions-readonly": "./src/readonly/index.ts",
@@ -394,6 +399,9 @@
       "paragraph": [
         "./dist/prosekit-extensions-paragraph.d.ts"
       ],
+      "paste-rule": [
+        "./dist/prosekit-extensions-paste-rule.d.ts"
+      ],
       "placeholder": [
         "./dist/prosekit-extensions-placeholder.d.ts"
       ],