@quadrats/common 0.7.3 → 0.7.7

package/blockquote/createBlockquote.js

@@ -1,4 +1,4 @@
-import { unwrapNodesByTypes, wrapNodesWithUnhangRange, isNodesTypeIn } from '@quadrats/core';
+import { isNodesTypeIn, wrapNodesWithUnhangRange, unwrapNodesByTypes } from '@quadrats/core';
 import { BLOCKQUOTE_TYPE } from './constants.js';
 
 function createBlockquote({ type = BLOCKQUOTE_TYPE } = {}) {

package/bold/createBold.d.ts

@@ -1,2 +1,2 @@
 import { Editor } from '@quadrats/core';
-export declare function createBold<E extends Editor = Editor>(variant?: string): ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark<E>;
+export declare function createBold<E extends Editor = Editor>(variant?: string): ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions) => import("@quadrats/common/toggle-mark").ToggleMark<E>;

package/embed/createEmbed.js

@@ -1,14 +1,20 @@
-import { Element, Transforms, normalizeVoidElementChildren, PARAGRAPH_TYPE } from '@quadrats/core';
+import { PARAGRAPH_TYPE, Element, Transforms, normalizeVoidElementChildren, isAboveBlockEmpty } from '@quadrats/core';
 import { EMBED_TYPE } from './constants.js';
 import { serializeEmbedCode } from './serializeEmbedCode.js';
 
 function createEmbed(options) {
     const { type = EMBED_TYPE, strategies } = options;
     const insertEmbed = (editor, providers, embedCode, defaultNode = PARAGRAPH_TYPE) => {
+        var _a;
         const result = serializeEmbedCode(embedCode, strategies, providers);
         if (result) {
             const [provider, data] = result;
             const embedElement = Object.assign(Object.assign({}, data), { type, provider, children: [{ text: '' }] });
+            if (isAboveBlockEmpty(editor)) {
+                Transforms.removeNodes(editor, {
+                    at: (_a = editor.selection) === null || _a === void 0 ? void 0 : _a.anchor,
+                });
+            }
             Transforms.insertNodes(editor, [
                 embedElement,
                 typeof defaultNode === 'string'

package/embed/index.cjs.js

@@ -25,10 +25,16 @@ function deserializeEmbedElementToData(element, strategies) {
 function createEmbed(options) {
     const { type = EMBED_TYPE, strategies } = options;
     const insertEmbed = (editor, providers, embedCode, defaultNode = core.PARAGRAPH_TYPE) => {
+        var _a;
         const result = serializeEmbedCode(embedCode, strategies, providers);
         if (result) {
             const [provider, data] = result;
             const embedElement = Object.assign(Object.assign({}, data), { type, provider, children: [{ text: '' }] });
+            if (core.isAboveBlockEmpty(editor)) {
+                core.Transforms.removeNodes(editor, {
+                    at: (_a = editor.selection) === null || _a === void 0 ? void 0 : _a.anchor,
+                });
+            }
             core.Transforms.insertNodes(editor, [
                 embedElement,
                 typeof defaultNode === 'string'

package/embed/strategies/twitter/index.cjs.js

@@ -1,7 +1,7 @@
 'use strict';
 
 function getTwitterTweetDataFromUrl(url) {
-    const result = /^https:\/\/twitter.com\/[\w]*\/status\/([\w-]*)/i.exec(url);
+    const result = /^https:\/\/x.com\/[\w]*\/status\/([\w-]*)/i.exec(url);
     if (result) {
         const [, tweetId] = result;
         return {

package/embed/strategies/twitter/index.js

@@ -1,5 +1,5 @@
 function getTwitterTweetDataFromUrl(url) {
-    const result = /^https:\/\/twitter.com\/[\w]*\/status\/([\w-]*)/i.exec(url);
+    const result = /^https:\/\/x.com\/[\w]*\/status\/([\w-]*)/i.exec(url);
     if (result) {
         const [, tweetId] = result;
         return {

package/file-uploader/createFileUploader.d.ts

@@ -1,6 +1,8 @@
 import { Editor } from '@quadrats/core';
-import { FileUploader } from './typings';
+import { FileUploader, FileUploaderElement } from './typings';
 export interface CreateFileUploaderOptions {
     type?: string;
 }
+export declare const createFileUploaderElementByType: (type: string) => FileUploader<Editor>['createFileUploaderElement'];
+export declare function insertFileUploaderElement(editor: Editor, fileUploaderElement: FileUploaderElement | undefined): void;
 export declare function createFileUploader(options?: CreateFileUploaderOptions): FileUploader<Editor>;

package/file-uploader/createFileUploader.js

@@ -1,60 +1,76 @@
 import { __awaiter } from './_virtual/_tslib.js';
 import { readFileAsDataURL } from '@quadrats/utils';
-import { HistoryEditor, Transforms, isAboveBlockEmpty, createParagraphElement } from '@quadrats/core';
+import { isAboveBlockEmpty, Transforms, createParagraphElement, HistoryEditor } from '@quadrats/core';
 import { FILE_UPLOADER_TYPE } from './constants.js';
 import { getFilesFromInput } from './getFilesFromInput.js';
 
-function createFileUploader(options = {}) {
-    const { type = FILE_UPLOADER_TYPE } = options;
-    const createFileUploaderElement = (editor, file, options) => __awaiter(this, void 0, void 0, function* () {
-        const { createElement, getBody, getHeaders, getUrl, uploader, } = options;
-        const [mime] = file.type.split('/');
-        const createByMime = createElement[mime];
-        if (!createByMime) {
-            return;
-        }
-        const { dataURL: createElementByDataURL, response: createElementByResponse } = createByMime;
-        const headers = yield (getHeaders === null || getHeaders === void 0 ? void 0 : getHeaders(file));
-        const xhr = uploader || new XMLHttpRequest();
-        const dataURL = yield readFileAsDataURL(file);
-        let sent = false;
-        const fileUploaderElement = {
-            type,
-            register: (getPath, onProgress) => {
-                xhr.onload = () => {
-                    if (xhr.status < 400) {
-                        const path = getPath();
-                        if (path) {
-                            HistoryEditor.withoutSaving(editor, () => {
-                                Transforms.removeNodes(editor, { at: path });
-                                Transforms.insertNodes(editor, createElementByResponse(xhr.response), { at: path });
-                            });
-                        }
-                    }
-                    else {
-                        throw xhr.response;
+const createFileUploaderElementByType = type => (editor, file, options) => __awaiter(void 0, void 0, void 0, function* () {
+    const { createElement, getBody, getHeaders, getUrl, uploader, } = options;
+    const [mime] = file.type.split('/');
+    const createByMime = createElement[mime];
+    if (!createByMime) {
+        return;
+    }
+    const { dataURL: createElementByDataURL, response: createElementByResponse } = createByMime;
+    const headers = yield (getHeaders === null || getHeaders === void 0 ? void 0 : getHeaders(file));
+    const xhr = uploader || new XMLHttpRequest();
+    const dataURL = yield readFileAsDataURL(file);
+    let sent = false;
+    const fileUploaderElement = {
+        type,
+        register: (getPath, onProgress) => {
+            xhr.onload = () => {
+                if (xhr.status < 400) {
+                    const path = getPath();
+                    if (path) {
+                        HistoryEditor.withoutSaving(editor, () => {
+                            Transforms.removeNodes(editor, { at: path });
+                            Transforms.insertNodes(editor, createElementByResponse(xhr.response), { at: path });
+                        });
                     }
-                };
-                xhr.upload.onprogress = ({ loaded, total }) => onProgress((loaded * 100) / total);
-                if (!sent) {
-                    sent = true;
-                    xhr.send(getBody(file));
                 }
-                return () => {
-                    xhr.onload = null;
-                    xhr.upload.onprogress = null;
-                };
-            },
-            children: [createElementByDataURL(dataURL)],
-        };
-        xhr.open('POST', getUrl(file));
-        if (headers) {
-            for (const headerName in headers) {
-                xhr.setRequestHeader(headerName, headers[headerName]);
+                else {
+                    throw xhr.response;
+                }
+            };
+            xhr.upload.onprogress = ({ loaded, total }) => onProgress((loaded * 100) / total);
+            if (!sent) {
+                sent = true;
+                xhr.send(getBody(file));
             }
+            return () => {
+                xhr.onload = null;
+                xhr.upload.onprogress = null;
+            };
+        },
+        children: [createElementByDataURL(dataURL)],
+    };
+    xhr.open('POST', getUrl(file));
+    if (headers) {
+        for (const headerName in headers) {
+            xhr.setRequestHeader(headerName, headers[headerName]);
         }
-        return fileUploaderElement;
-    });
+    }
+    return fileUploaderElement;
+});
+function insertFileUploaderElement(editor, fileUploaderElement) {
+    var _a, _b, _c;
+    if (fileUploaderElement) {
+        // Clear empty node
+        if (isAboveBlockEmpty(editor)) {
+            Transforms.removeNodes(editor, {
+                at: (_a = editor.selection) === null || _a === void 0 ? void 0 : _a.anchor,
+            });
+        }
+        Transforms.insertNodes(editor, [fileUploaderElement, createParagraphElement()], {
+            at: ((_b = editor.selection) === null || _b === void 0 ? void 0 : _b.anchor.path.length) ? [((_c = editor.selection) === null || _c === void 0 ? void 0 : _c.anchor.path[0]) + 1] : undefined,
+        });
+        Transforms.move(editor);
+    }
+}
+function createFileUploader(options = {}) {
+    const { type = FILE_UPLOADER_TYPE } = options;
+    const createFileUploaderElement = createFileUploaderElementByType(type);
     const upload = (editor, options) => __awaiter(this, void 0, void 0, function* () {
         const { accept, multiple } = options;
         const files = yield getFilesFromInput({ accept, multiple });
@@ -64,19 +80,7 @@ function createFileUploader(options = {}) {
         files.reduce((prev, file) => __awaiter(this, void 0, void 0, function* () {
             yield prev;
             return createFileUploaderElement(editor, file, options).then((fileUploaderElement) => {
-                var _a, _b, _c;
-                if (fileUploaderElement) {
-                    // Clear empty node
-                    if (isAboveBlockEmpty(editor)) {
-                        Transforms.removeNodes(editor, {
-                            at: (_a = editor.selection) === null || _a === void 0 ? void 0 : _a.anchor,
-                        });
-                    }
-                    Transforms.insertNodes(editor, [fileUploaderElement, createParagraphElement()], {
-                        at: ((_b = editor.selection) === null || _b === void 0 ? void 0 : _b.anchor.path.length) ? [((_c = editor.selection) === null || _c === void 0 ? void 0 : _c.anchor.path[0]) + 1] : undefined,
-                    });
-                    Transforms.move(editor);
-                }
+                insertFileUploaderElement(editor, fileUploaderElement);
             });
         }), Promise.resolve());
     });
@@ -90,4 +94,4 @@ function createFileUploader(options = {}) {
     };
 }
 
-export { createFileUploader };
+export { createFileUploader, createFileUploaderElementByType, insertFileUploaderElement };

package/file-uploader/index.cjs.js

@@ -63,57 +63,73 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-function createFileUploader(options = {}) {
-    const { type = FILE_UPLOADER_TYPE } = options;
-    const createFileUploaderElement = (editor, file, options) => __awaiter(this, void 0, void 0, function* () {
-        const { createElement, getBody, getHeaders, getUrl, uploader, } = options;
-        const [mime] = file.type.split('/');
-        const createByMime = createElement[mime];
-        if (!createByMime) {
-            return;
-        }
-        const { dataURL: createElementByDataURL, response: createElementByResponse } = createByMime;
-        const headers = yield (getHeaders === null || getHeaders === void 0 ? void 0 : getHeaders(file));
-        const xhr = uploader || new XMLHttpRequest();
-        const dataURL = yield utils.readFileAsDataURL(file);
-        let sent = false;
-        const fileUploaderElement = {
-            type,
-            register: (getPath, onProgress) => {
-                xhr.onload = () => {
-                    if (xhr.status < 400) {
-                        const path = getPath();
-                        if (path) {
-                            core.HistoryEditor.withoutSaving(editor, () => {
-                                core.Transforms.removeNodes(editor, { at: path });
-                                core.Transforms.insertNodes(editor, createElementByResponse(xhr.response), { at: path });
-                            });
-                        }
-                    }
-                    else {
-                        throw xhr.response;
+const createFileUploaderElementByType = type => (editor, file, options) => __awaiter(void 0, void 0, void 0, function* () {
+    const { createElement, getBody, getHeaders, getUrl, uploader, } = options;
+    const [mime] = file.type.split('/');
+    const createByMime = createElement[mime];
+    if (!createByMime) {
+        return;
+    }
+    const { dataURL: createElementByDataURL, response: createElementByResponse } = createByMime;
+    const headers = yield (getHeaders === null || getHeaders === void 0 ? void 0 : getHeaders(file));
+    const xhr = uploader || new XMLHttpRequest();
+    const dataURL = yield utils.readFileAsDataURL(file);
+    let sent = false;
+    const fileUploaderElement = {
+        type,
+        register: (getPath, onProgress) => {
+            xhr.onload = () => {
+                if (xhr.status < 400) {
+                    const path = getPath();
+                    if (path) {
+                        core.HistoryEditor.withoutSaving(editor, () => {
+                            core.Transforms.removeNodes(editor, { at: path });
+                            core.Transforms.insertNodes(editor, createElementByResponse(xhr.response), { at: path });
+                        });
                     }
-                };
-                xhr.upload.onprogress = ({ loaded, total }) => onProgress((loaded * 100) / total);
-                if (!sent) {
-                    sent = true;
-                    xhr.send(getBody(file));
                 }
-                return () => {
-                    xhr.onload = null;
-                    xhr.upload.onprogress = null;
-                };
-            },
-            children: [createElementByDataURL(dataURL)],
-        };
-        xhr.open('POST', getUrl(file));
-        if (headers) {
-            for (const headerName in headers) {
-                xhr.setRequestHeader(headerName, headers[headerName]);
+                else {
+                    throw xhr.response;
+                }
+            };
+            xhr.upload.onprogress = ({ loaded, total }) => onProgress((loaded * 100) / total);
+            if (!sent) {
+                sent = true;
+                xhr.send(getBody(file));
             }
+            return () => {
+                xhr.onload = null;
+                xhr.upload.onprogress = null;
+            };
+        },
+        children: [createElementByDataURL(dataURL)],
+    };
+    xhr.open('POST', getUrl(file));
+    if (headers) {
+        for (const headerName in headers) {
+            xhr.setRequestHeader(headerName, headers[headerName]);
         }
-        return fileUploaderElement;
-    });
+    }
+    return fileUploaderElement;
+});
+function insertFileUploaderElement(editor, fileUploaderElement) {
+    var _a, _b, _c;
+    if (fileUploaderElement) {
+        // Clear empty node
+        if (core.isAboveBlockEmpty(editor)) {
+            core.Transforms.removeNodes(editor, {
+                at: (_a = editor.selection) === null || _a === void 0 ? void 0 : _a.anchor,
+            });
+        }
+        core.Transforms.insertNodes(editor, [fileUploaderElement, core.createParagraphElement()], {
+            at: ((_b = editor.selection) === null || _b === void 0 ? void 0 : _b.anchor.path.length) ? [((_c = editor.selection) === null || _c === void 0 ? void 0 : _c.anchor.path[0]) + 1] : undefined,
+        });
+        core.Transforms.move(editor);
+    }
+}
+function createFileUploader(options = {}) {
+    const { type = FILE_UPLOADER_TYPE } = options;
+    const createFileUploaderElement = createFileUploaderElementByType(type);
     const upload = (editor, options) => __awaiter(this, void 0, void 0, function* () {
         const { accept, multiple } = options;
         const files = yield getFilesFromInput({ accept, multiple });
@@ -123,19 +139,7 @@ function createFileUploader(options = {}) {
         files.reduce((prev, file) => __awaiter(this, void 0, void 0, function* () {
             yield prev;
             return createFileUploaderElement(editor, file, options).then((fileUploaderElement) => {
-                var _a, _b, _c;
-                if (fileUploaderElement) {
-                    // Clear empty node
-                    if (core.isAboveBlockEmpty(editor)) {
-                        core.Transforms.removeNodes(editor, {
-                            at: (_a = editor.selection) === null || _a === void 0 ? void 0 : _a.anchor,
-                        });
-                    }
-                    core.Transforms.insertNodes(editor, [fileUploaderElement, core.createParagraphElement()], {
-                        at: ((_b = editor.selection) === null || _b === void 0 ? void 0 : _b.anchor.path.length) ? [((_c = editor.selection) === null || _c === void 0 ? void 0 : _c.anchor.path[0]) + 1] : undefined,
-                    });
-                    core.Transforms.move(editor);
-                }
+                insertFileUploaderElement(editor, fileUploaderElement);
             });
         }), Promise.resolve());
     });
@@ -151,4 +155,6 @@ function createFileUploader(options = {}) {
 
 exports.FILE_UPLOADER_TYPE = FILE_UPLOADER_TYPE;
 exports.createFileUploader = createFileUploader;
+exports.createFileUploaderElementByType = createFileUploaderElementByType;
 exports.getFilesFromInput = getFilesFromInput;
+exports.insertFileUploaderElement = insertFileUploaderElement;

package/file-uploader/index.d.ts

@@ -1,4 +1,4 @@
 export * from './typings';
 export * from './constants';
 export { GetFilesFromInputOptions, getFilesFromInput } from './getFilesFromInput';
-export { CreateFileUploaderOptions, createFileUploader } from './createFileUploader';
+export { CreateFileUploaderOptions, createFileUploaderElementByType, insertFileUploaderElement, createFileUploader, } from './createFileUploader';

package/file-uploader/index.js

@@ -1,3 +1,3 @@
 export { FILE_UPLOADER_TYPE } from './constants.js';
 export { getFilesFromInput } from './getFilesFromInput.js';
-export { createFileUploader } from './createFileUploader.js';
+export { createFileUploader, createFileUploaderElementByType, insertFileUploaderElement } from './createFileUploader.js';

package/footnote/createFootnote.js

@@ -1,4 +1,4 @@
-import { isNodesTypeIn, getNodes, Transforms, unwrapNodesByTypes, wrapNodesWithUnhangRange } from '@quadrats/core';
+import { isNodesTypeIn, Transforms, wrapNodesWithUnhangRange, unwrapNodesByTypes, getNodes } from '@quadrats/core';
 import { FOOTNOTE_TYPE } from './constants.js';
 
 /* eslint-disable max-len */

package/heading/constants.d.ts

@@ -1,3 +1,3 @@
 import { HeadingLevel } from './typings';
 export declare const HEADING_TYPE = "heading";
-export declare const HEADING_LEVELS: readonly HeadingLevel[];
+export declare const HEADING_LEVELS: ReadonlyArray<HeadingLevel>;

package/heading/createHeading.js

@@ -1,5 +1,5 @@
-import { Element, Transforms, PARAGRAPH_TYPE, normalizeOnlyInlineOrTextInChildren, getNodes } from '@quadrats/core';
-import { HEADING_TYPE, HEADING_LEVELS } from './constants.js';
+import { PARAGRAPH_TYPE, getNodes, Element, Transforms, normalizeOnlyInlineOrTextInChildren } from '@quadrats/core';
+import { HEADING_LEVELS, HEADING_TYPE } from './constants.js';
 
 function createHeading({ type = HEADING_TYPE, enabledLevels = HEADING_LEVELS, } = {}) {
     const getHeadingNodes = (editor, level, options = {}) => getNodes(editor, Object.assign(Object.assign({}, options), { match: node => node.type === type && node.level === level }));

package/highlight/createHighlight.d.ts

@@ -1,2 +1,2 @@
 import { Editor } from '@quadrats/core';
-export declare function createHighlight<E extends Editor = Editor>(variant?: string): ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark<E>;
+export declare function createHighlight<E extends Editor = Editor>(variant?: string): ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions) => import("@quadrats/common/toggle-mark").ToggleMark<E>;

package/image/createImage.js

@@ -1,5 +1,5 @@
 import { isImageUrl } from '@quadrats/utils';
-import { Editor, Transforms, createParagraphElement, Element, normalizeVoidElementChildren, normalizeOnlyInlineOrTextInChildren, getAboveByTypes, isNodesTypeIn, Range } from '@quadrats/core';
+import { Range, isNodesTypeIn, getAboveByTypes, Editor, Transforms, createParagraphElement, Element, normalizeVoidElementChildren, normalizeOnlyInlineOrTextInChildren } from '@quadrats/core';
 import { IMAGE_TYPES } from './constants.js';
 
 function resolveSizeSteps(steps) {

package/input-block/createInputBlock.js

@@ -1,4 +1,4 @@
-import { Editor, Path, Transforms } from '@quadrats/core';
+import { Path, Editor, Transforms } from '@quadrats/core';
 import { INPUT_BLOCK_TYPE } from './constants.js';
 
 function createInputBlock(options = {}) {

package/italic/createItalic.d.ts

@@ -1,2 +1,2 @@
 import { Editor } from '@quadrats/core';
-export declare function createItalic<E extends Editor = Editor>(variant?: string): ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark<E>;
+export declare function createItalic<E extends Editor = Editor>(variant?: string): ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions) => import("@quadrats/common/toggle-mark").ToggleMark<E>;

package/link/createLink.js

@@ -1,5 +1,5 @@
 import { isUrl } from '@quadrats/utils';
-import { Range, Editor, Element, Transforms, Text, getRangeBeforeFromAboveBlockStart, getRangeBefore, isNodesTypeIn, unwrapNodesByTypes, wrapNodesWithUnhangRange, getAboveByTypes } from '@quadrats/core';
+import { unwrapNodesByTypes, isNodesTypeIn, Range, Editor, Element, Transforms, Text, getAboveByTypes, wrapNodesWithUnhangRange, getRangeBeforeFromAboveBlockStart, getRangeBefore } from '@quadrats/core';
 import { LINK_TYPE } from './constants.js';
 
 function createLink({ type = LINK_TYPE, isUrl: isUrl$1 = isUrl, prevUrlToLinkAfterSpaceEntered = true, wrappableVoidTypes, } = {}) {

package/list/createList.js

@@ -1,4 +1,4 @@
-import { Range, isSelectionAtBlockEdge, deleteSelectionFragmentIfExpanded, isAboveBlockEmpty, Transforms, isNodesTypeIn, getAboveByTypes, getParent, unwrapNodesByTypes, wrapNodesWithUnhangRange, getNodesByTypes, PARAGRAPH_TYPE, isFirstChild, Editor, Path } from '@quadrats/core';
+import { PARAGRAPH_TYPE, isNodesTypeIn, Range, isSelectionAtBlockEdge, deleteSelectionFragmentIfExpanded, isAboveBlockEmpty, Transforms, Editor, Path, isFirstChild, wrapNodesWithUnhangRange, getNodesByTypes, unwrapNodesByTypes, getAboveByTypes, getParent } from '@quadrats/core';
 import { LIST_TYPES } from './constants.js';
 
 function createList(options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quadrats/common",
-  "version": "0.7.3",
+  "version": "0.7.7",
   "description": "",
   "author": "Rytass",
   "homepage": "https://github.com/Quadrats/quadrats#readme",
@@ -18,8 +18,8 @@
     "url": "https://github.com/Quadrats/quadrats/issues"
   },
   "dependencies": {
-    "@quadrats/core": "^0.7.2",
-    "@quadrats/locales": "^0.7.0",
+    "@quadrats/core": "^0.7.7",
+    "@quadrats/locales": "^0.7.7",
     "@quadrats/utils": "^0.7.2"
   }
 }

package/read-more/createReadMore.js

@@ -1,4 +1,4 @@
-import { Element, normalizeVoidElementChildren, normalizeOnlyAtRoot, Path, Transforms, getNodesByTypes, deleteSelectionFragmentIfExpanded, createParagraphElement } from '@quadrats/core';
+import { Element, normalizeVoidElementChildren, normalizeOnlyAtRoot, getNodesByTypes, Path, Transforms, deleteSelectionFragmentIfExpanded, createParagraphElement } from '@quadrats/core';
 import { READ_MORE_TYPE } from './constants.js';
 
 function createReadMore(options = {}) {

package/strikethrough/createStrikethrough.d.ts

@@ -1,2 +1,2 @@
 import { Editor } from '@quadrats/core';
-export declare function createStrikethrough<E extends Editor = Editor>(variant?: string): ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark<E>;
+export declare function createStrikethrough<E extends Editor = Editor>(variant?: string): ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions) => import("@quadrats/common/toggle-mark").ToggleMark<E>;

package/underline/createUnderline.d.ts

@@ -1,2 +1,2 @@
 import { Editor } from '@quadrats/core';
-export declare function createUnderline<E extends Editor = Editor>(variant?: string): ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions | undefined) => import("@quadrats/common/toggle-mark").ToggleMark<E>;
+export declare function createUnderline<E extends Editor = Editor>(variant?: string): ({ type, variant }?: import("@quadrats/common/toggle-mark").CreateToggleMarkOptions) => import("@quadrats/common/toggle-mark").ToggleMark<E>;