mirror of
https://github.com/CharaChorder/DeviceManager.git
synced 2026-01-20 17:03:42 +00:00
2099 lines
62 KiB
JavaScript
2099 lines
62 KiB
JavaScript
import {
|
|
Decoration,
|
|
DecorationSet,
|
|
Extension,
|
|
Fragment,
|
|
Mapping,
|
|
Mark,
|
|
Node,
|
|
NodeSelection,
|
|
Plugin,
|
|
PluginKey,
|
|
Selection,
|
|
Slice,
|
|
TextSelection,
|
|
callOrReturn,
|
|
dropPoint,
|
|
getExtensionField,
|
|
getMarkAttributes,
|
|
isMacOS,
|
|
keydownHandler,
|
|
markInputRule,
|
|
markPasteRule,
|
|
mergeAttributes,
|
|
nodeInputRule,
|
|
textblockTypeInputRule,
|
|
wrappingInputRule
|
|
} from "./chunk-XGFUOMNA.js";
|
|
import "./chunk-2B2CG5KL.js";
|
|
|
|
// node_modules/@tiptap/extension-blockquote/dist/index.js
|
|
var inputRegex = /^\s*>\s$/;
|
|
var Blockquote = Node.create({
|
|
name: "blockquote",
|
|
addOptions() {
|
|
return {
|
|
HTMLAttributes: {}
|
|
};
|
|
},
|
|
content: "block+",
|
|
group: "block",
|
|
defining: true,
|
|
parseHTML() {
|
|
return [
|
|
{ tag: "blockquote" }
|
|
];
|
|
},
|
|
renderHTML({ HTMLAttributes }) {
|
|
return ["blockquote", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
|
|
},
|
|
addCommands() {
|
|
return {
|
|
setBlockquote: () => ({ commands }) => {
|
|
return commands.wrapIn(this.name);
|
|
},
|
|
toggleBlockquote: () => ({ commands }) => {
|
|
return commands.toggleWrap(this.name);
|
|
},
|
|
unsetBlockquote: () => ({ commands }) => {
|
|
return commands.lift(this.name);
|
|
}
|
|
};
|
|
},
|
|
addKeyboardShortcuts() {
|
|
return {
|
|
"Mod-Shift-b": () => this.editor.commands.toggleBlockquote()
|
|
};
|
|
},
|
|
addInputRules() {
|
|
return [
|
|
wrappingInputRule({
|
|
find: inputRegex,
|
|
type: this.type
|
|
})
|
|
];
|
|
}
|
|
});
|
|
|
|
// node_modules/@tiptap/extension-bold/dist/index.js
|
|
var starInputRegex = /(?:^|\s)((?:\*\*)((?:[^*]+))(?:\*\*))$/;
|
|
var starPasteRegex = /(?:^|\s)((?:\*\*)((?:[^*]+))(?:\*\*))/g;
|
|
var underscoreInputRegex = /(?:^|\s)((?:__)((?:[^__]+))(?:__))$/;
|
|
var underscorePasteRegex = /(?:^|\s)((?:__)((?:[^__]+))(?:__))/g;
|
|
var Bold = Mark.create({
|
|
name: "bold",
|
|
addOptions() {
|
|
return {
|
|
HTMLAttributes: {}
|
|
};
|
|
},
|
|
parseHTML() {
|
|
return [
|
|
{
|
|
tag: "strong"
|
|
},
|
|
{
|
|
tag: "b",
|
|
getAttrs: (node) => node.style.fontWeight !== "normal" && null
|
|
},
|
|
{
|
|
style: "font-weight",
|
|
getAttrs: (value) => /^(bold(er)?|[5-9]\d{2,})$/.test(value) && null
|
|
}
|
|
];
|
|
},
|
|
renderHTML({ HTMLAttributes }) {
|
|
return ["strong", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
|
|
},
|
|
addCommands() {
|
|
return {
|
|
setBold: () => ({ commands }) => {
|
|
return commands.setMark(this.name);
|
|
},
|
|
toggleBold: () => ({ commands }) => {
|
|
return commands.toggleMark(this.name);
|
|
},
|
|
unsetBold: () => ({ commands }) => {
|
|
return commands.unsetMark(this.name);
|
|
}
|
|
};
|
|
},
|
|
addKeyboardShortcuts() {
|
|
return {
|
|
"Mod-b": () => this.editor.commands.toggleBold(),
|
|
"Mod-B": () => this.editor.commands.toggleBold()
|
|
};
|
|
},
|
|
addInputRules() {
|
|
return [
|
|
markInputRule({
|
|
find: starInputRegex,
|
|
type: this.type
|
|
}),
|
|
markInputRule({
|
|
find: underscoreInputRegex,
|
|
type: this.type
|
|
})
|
|
];
|
|
},
|
|
addPasteRules() {
|
|
return [
|
|
markPasteRule({
|
|
find: starPasteRegex,
|
|
type: this.type
|
|
}),
|
|
markPasteRule({
|
|
find: underscorePasteRegex,
|
|
type: this.type
|
|
})
|
|
];
|
|
}
|
|
});
|
|
|
|
// node_modules/@tiptap/extension-bullet-list/dist/index.js
|
|
var ListItem = Node.create({
|
|
name: "listItem",
|
|
addOptions() {
|
|
return {
|
|
HTMLAttributes: {},
|
|
bulletListTypeName: "bulletList",
|
|
orderedListTypeName: "orderedList"
|
|
};
|
|
},
|
|
content: "paragraph block*",
|
|
defining: true,
|
|
parseHTML() {
|
|
return [
|
|
{
|
|
tag: "li"
|
|
}
|
|
];
|
|
},
|
|
renderHTML({ HTMLAttributes }) {
|
|
return ["li", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
|
|
},
|
|
addKeyboardShortcuts() {
|
|
return {
|
|
Enter: () => this.editor.commands.splitListItem(this.name),
|
|
Tab: () => this.editor.commands.sinkListItem(this.name),
|
|
"Shift-Tab": () => this.editor.commands.liftListItem(this.name)
|
|
};
|
|
}
|
|
});
|
|
var TextStyle = Mark.create({
|
|
name: "textStyle",
|
|
addOptions() {
|
|
return {
|
|
HTMLAttributes: {}
|
|
};
|
|
},
|
|
parseHTML() {
|
|
return [
|
|
{
|
|
tag: "span",
|
|
getAttrs: (element) => {
|
|
const hasStyles = element.hasAttribute("style");
|
|
if (!hasStyles) {
|
|
return false;
|
|
}
|
|
return {};
|
|
}
|
|
}
|
|
];
|
|
},
|
|
renderHTML({ HTMLAttributes }) {
|
|
return ["span", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
|
|
},
|
|
addCommands() {
|
|
return {
|
|
removeEmptyTextStyle: () => ({ state, commands }) => {
|
|
const attributes = getMarkAttributes(state, this.type);
|
|
const hasStyles = Object.entries(attributes).some(([, value]) => !!value);
|
|
if (hasStyles) {
|
|
return true;
|
|
}
|
|
return commands.unsetMark(this.name);
|
|
}
|
|
};
|
|
}
|
|
});
|
|
var inputRegex2 = /^\s*([-+*])\s$/;
|
|
var BulletList = Node.create({
|
|
name: "bulletList",
|
|
addOptions() {
|
|
return {
|
|
itemTypeName: "listItem",
|
|
HTMLAttributes: {},
|
|
keepMarks: false,
|
|
keepAttributes: false
|
|
};
|
|
},
|
|
group: "block list",
|
|
content() {
|
|
return `${this.options.itemTypeName}+`;
|
|
},
|
|
parseHTML() {
|
|
return [
|
|
{ tag: "ul" }
|
|
];
|
|
},
|
|
renderHTML({ HTMLAttributes }) {
|
|
return ["ul", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
|
|
},
|
|
addCommands() {
|
|
return {
|
|
toggleBulletList: () => ({ commands, chain }) => {
|
|
if (this.options.keepAttributes) {
|
|
return chain().toggleList(this.name, this.options.itemTypeName, this.options.keepMarks).updateAttributes(ListItem.name, this.editor.getAttributes(TextStyle.name)).run();
|
|
}
|
|
return commands.toggleList(this.name, this.options.itemTypeName, this.options.keepMarks);
|
|
}
|
|
};
|
|
},
|
|
addKeyboardShortcuts() {
|
|
return {
|
|
"Mod-Shift-8": () => this.editor.commands.toggleBulletList()
|
|
};
|
|
},
|
|
addInputRules() {
|
|
let inputRule = wrappingInputRule({
|
|
find: inputRegex2,
|
|
type: this.type
|
|
});
|
|
if (this.options.keepMarks || this.options.keepAttributes) {
|
|
inputRule = wrappingInputRule({
|
|
find: inputRegex2,
|
|
type: this.type,
|
|
keepMarks: this.options.keepMarks,
|
|
keepAttributes: this.options.keepAttributes,
|
|
getAttributes: () => {
|
|
return this.editor.getAttributes(TextStyle.name);
|
|
},
|
|
editor: this.editor
|
|
});
|
|
}
|
|
return [
|
|
inputRule
|
|
];
|
|
}
|
|
});
|
|
|
|
// node_modules/@tiptap/extension-code/dist/index.js
|
|
var inputRegex3 = /(?:^|\s)((?:`)((?:[^`]+))(?:`))$/;
|
|
var pasteRegex = /(?:^|\s)((?:`)((?:[^`]+))(?:`))/g;
|
|
var Code = Mark.create({
|
|
name: "code",
|
|
addOptions() {
|
|
return {
|
|
HTMLAttributes: {}
|
|
};
|
|
},
|
|
excludes: "_",
|
|
code: true,
|
|
exitable: true,
|
|
parseHTML() {
|
|
return [
|
|
{ tag: "code" }
|
|
];
|
|
},
|
|
renderHTML({ HTMLAttributes }) {
|
|
return ["code", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
|
|
},
|
|
addCommands() {
|
|
return {
|
|
setCode: () => ({ commands }) => {
|
|
return commands.setMark(this.name);
|
|
},
|
|
toggleCode: () => ({ commands }) => {
|
|
return commands.toggleMark(this.name);
|
|
},
|
|
unsetCode: () => ({ commands }) => {
|
|
return commands.unsetMark(this.name);
|
|
}
|
|
};
|
|
},
|
|
addKeyboardShortcuts() {
|
|
return {
|
|
"Mod-e": () => this.editor.commands.toggleCode()
|
|
};
|
|
},
|
|
addInputRules() {
|
|
return [
|
|
markInputRule({
|
|
find: inputRegex3,
|
|
type: this.type
|
|
})
|
|
];
|
|
},
|
|
addPasteRules() {
|
|
return [
|
|
markPasteRule({
|
|
find: pasteRegex,
|
|
type: this.type
|
|
})
|
|
];
|
|
}
|
|
});
|
|
|
|
// node_modules/@tiptap/extension-code-block/dist/index.js
|
|
var backtickInputRegex = /^```([a-z]+)?[\s\n]$/;
|
|
var tildeInputRegex = /^~~~([a-z]+)?[\s\n]$/;
|
|
var CodeBlock = Node.create({
|
|
name: "codeBlock",
|
|
addOptions() {
|
|
return {
|
|
languageClassPrefix: "language-",
|
|
exitOnTripleEnter: true,
|
|
exitOnArrowDown: true,
|
|
HTMLAttributes: {}
|
|
};
|
|
},
|
|
content: "text*",
|
|
marks: "",
|
|
group: "block",
|
|
code: true,
|
|
defining: true,
|
|
addAttributes() {
|
|
return {
|
|
language: {
|
|
default: null,
|
|
parseHTML: (element) => {
|
|
var _a;
|
|
const { languageClassPrefix } = this.options;
|
|
const classNames = [...((_a = element.firstElementChild) === null || _a === void 0 ? void 0 : _a.classList) || []];
|
|
const languages = classNames.filter((className) => className.startsWith(languageClassPrefix)).map((className) => className.replace(languageClassPrefix, ""));
|
|
const language = languages[0];
|
|
if (!language) {
|
|
return null;
|
|
}
|
|
return language;
|
|
},
|
|
rendered: false
|
|
}
|
|
};
|
|
},
|
|
parseHTML() {
|
|
return [
|
|
{
|
|
tag: "pre",
|
|
preserveWhitespace: "full"
|
|
}
|
|
];
|
|
},
|
|
renderHTML({ node, HTMLAttributes }) {
|
|
return [
|
|
"pre",
|
|
mergeAttributes(this.options.HTMLAttributes, HTMLAttributes),
|
|
[
|
|
"code",
|
|
{
|
|
class: node.attrs.language ? this.options.languageClassPrefix + node.attrs.language : null
|
|
},
|
|
0
|
|
]
|
|
];
|
|
},
|
|
addCommands() {
|
|
return {
|
|
setCodeBlock: (attributes) => ({ commands }) => {
|
|
return commands.setNode(this.name, attributes);
|
|
},
|
|
toggleCodeBlock: (attributes) => ({ commands }) => {
|
|
return commands.toggleNode(this.name, "paragraph", attributes);
|
|
}
|
|
};
|
|
},
|
|
addKeyboardShortcuts() {
|
|
return {
|
|
"Mod-Alt-c": () => this.editor.commands.toggleCodeBlock(),
|
|
// remove code block when at start of document or code block is empty
|
|
Backspace: () => {
|
|
const { empty, $anchor } = this.editor.state.selection;
|
|
const isAtStart = $anchor.pos === 1;
|
|
if (!empty || $anchor.parent.type.name !== this.name) {
|
|
return false;
|
|
}
|
|
if (isAtStart || !$anchor.parent.textContent.length) {
|
|
return this.editor.commands.clearNodes();
|
|
}
|
|
return false;
|
|
},
|
|
// exit node on triple enter
|
|
Enter: ({ editor }) => {
|
|
if (!this.options.exitOnTripleEnter) {
|
|
return false;
|
|
}
|
|
const { state } = editor;
|
|
const { selection } = state;
|
|
const { $from, empty } = selection;
|
|
if (!empty || $from.parent.type !== this.type) {
|
|
return false;
|
|
}
|
|
const isAtEnd = $from.parentOffset === $from.parent.nodeSize - 2;
|
|
const endsWithDoubleNewline = $from.parent.textContent.endsWith("\n\n");
|
|
if (!isAtEnd || !endsWithDoubleNewline) {
|
|
return false;
|
|
}
|
|
return editor.chain().command(({ tr }) => {
|
|
tr.delete($from.pos - 2, $from.pos);
|
|
return true;
|
|
}).exitCode().run();
|
|
},
|
|
// exit node on arrow down
|
|
ArrowDown: ({ editor }) => {
|
|
if (!this.options.exitOnArrowDown) {
|
|
return false;
|
|
}
|
|
const { state } = editor;
|
|
const { selection, doc } = state;
|
|
const { $from, empty } = selection;
|
|
if (!empty || $from.parent.type !== this.type) {
|
|
return false;
|
|
}
|
|
const isAtEnd = $from.parentOffset === $from.parent.nodeSize - 2;
|
|
if (!isAtEnd) {
|
|
return false;
|
|
}
|
|
const after = $from.after();
|
|
if (after === void 0) {
|
|
return false;
|
|
}
|
|
const nodeAfter = doc.nodeAt(after);
|
|
if (nodeAfter) {
|
|
return false;
|
|
}
|
|
return editor.commands.exitCode();
|
|
}
|
|
};
|
|
},
|
|
addInputRules() {
|
|
return [
|
|
textblockTypeInputRule({
|
|
find: backtickInputRegex,
|
|
type: this.type,
|
|
getAttributes: (match) => ({
|
|
language: match[1]
|
|
})
|
|
}),
|
|
textblockTypeInputRule({
|
|
find: tildeInputRegex,
|
|
type: this.type,
|
|
getAttributes: (match) => ({
|
|
language: match[1]
|
|
})
|
|
})
|
|
];
|
|
},
|
|
addProseMirrorPlugins() {
|
|
return [
|
|
// this plugin creates a code block for pasted content from VS Code
|
|
// we can also detect the copied code language
|
|
new Plugin({
|
|
key: new PluginKey("codeBlockVSCodeHandler"),
|
|
props: {
|
|
handlePaste: (view, event) => {
|
|
if (!event.clipboardData) {
|
|
return false;
|
|
}
|
|
if (this.editor.isActive(this.type.name)) {
|
|
return false;
|
|
}
|
|
const text = event.clipboardData.getData("text/plain");
|
|
const vscode = event.clipboardData.getData("vscode-editor-data");
|
|
const vscodeData = vscode ? JSON.parse(vscode) : void 0;
|
|
const language = vscodeData === null || vscodeData === void 0 ? void 0 : vscodeData.mode;
|
|
if (!text || !language) {
|
|
return false;
|
|
}
|
|
const { tr } = view.state;
|
|
tr.replaceSelectionWith(this.type.create({ language }));
|
|
tr.setSelection(TextSelection.near(tr.doc.resolve(Math.max(0, tr.selection.from - 2))));
|
|
tr.insertText(text.replace(/\r\n?/g, "\n"));
|
|
tr.setMeta("paste", true);
|
|
view.dispatch(tr);
|
|
return true;
|
|
}
|
|
}
|
|
})
|
|
];
|
|
}
|
|
});
|
|
|
|
// node_modules/@tiptap/extension-document/dist/index.js
|
|
var Document = Node.create({
|
|
name: "doc",
|
|
topNode: true,
|
|
content: "block+"
|
|
});
|
|
|
|
// node_modules/prosemirror-dropcursor/dist/index.js
|
|
function dropCursor(options = {}) {
|
|
return new Plugin({
|
|
view(editorView) {
|
|
return new DropCursorView(editorView, options);
|
|
}
|
|
});
|
|
}
|
|
var DropCursorView = class {
|
|
constructor(editorView, options) {
|
|
var _a;
|
|
this.editorView = editorView;
|
|
this.cursorPos = null;
|
|
this.element = null;
|
|
this.timeout = -1;
|
|
this.width = (_a = options.width) !== null && _a !== void 0 ? _a : 1;
|
|
this.color = options.color === false ? void 0 : options.color || "black";
|
|
this.class = options.class;
|
|
this.handlers = ["dragover", "dragend", "drop", "dragleave"].map((name) => {
|
|
let handler = (e) => {
|
|
this[name](e);
|
|
};
|
|
editorView.dom.addEventListener(name, handler);
|
|
return { name, handler };
|
|
});
|
|
}
|
|
destroy() {
|
|
this.handlers.forEach(({ name, handler }) => this.editorView.dom.removeEventListener(name, handler));
|
|
}
|
|
update(editorView, prevState) {
|
|
if (this.cursorPos != null && prevState.doc != editorView.state.doc) {
|
|
if (this.cursorPos > editorView.state.doc.content.size)
|
|
this.setCursor(null);
|
|
else
|
|
this.updateOverlay();
|
|
}
|
|
}
|
|
setCursor(pos) {
|
|
if (pos == this.cursorPos)
|
|
return;
|
|
this.cursorPos = pos;
|
|
if (pos == null) {
|
|
this.element.parentNode.removeChild(this.element);
|
|
this.element = null;
|
|
} else {
|
|
this.updateOverlay();
|
|
}
|
|
}
|
|
updateOverlay() {
|
|
let $pos = this.editorView.state.doc.resolve(this.cursorPos);
|
|
let isBlock = !$pos.parent.inlineContent, rect;
|
|
if (isBlock) {
|
|
let before = $pos.nodeBefore, after = $pos.nodeAfter;
|
|
if (before || after) {
|
|
let node = this.editorView.nodeDOM(this.cursorPos - (before ? before.nodeSize : 0));
|
|
if (node) {
|
|
let nodeRect = node.getBoundingClientRect();
|
|
let top = before ? nodeRect.bottom : nodeRect.top;
|
|
if (before && after)
|
|
top = (top + this.editorView.nodeDOM(this.cursorPos).getBoundingClientRect().top) / 2;
|
|
rect = { left: nodeRect.left, right: nodeRect.right, top: top - this.width / 2, bottom: top + this.width / 2 };
|
|
}
|
|
}
|
|
}
|
|
if (!rect) {
|
|
let coords = this.editorView.coordsAtPos(this.cursorPos);
|
|
rect = { left: coords.left - this.width / 2, right: coords.left + this.width / 2, top: coords.top, bottom: coords.bottom };
|
|
}
|
|
let parent = this.editorView.dom.offsetParent;
|
|
if (!this.element) {
|
|
this.element = parent.appendChild(document.createElement("div"));
|
|
if (this.class)
|
|
this.element.className = this.class;
|
|
this.element.style.cssText = "position: absolute; z-index: 50; pointer-events: none;";
|
|
if (this.color) {
|
|
this.element.style.backgroundColor = this.color;
|
|
}
|
|
}
|
|
this.element.classList.toggle("prosemirror-dropcursor-block", isBlock);
|
|
this.element.classList.toggle("prosemirror-dropcursor-inline", !isBlock);
|
|
let parentLeft, parentTop;
|
|
if (!parent || parent == document.body && getComputedStyle(parent).position == "static") {
|
|
parentLeft = -pageXOffset;
|
|
parentTop = -pageYOffset;
|
|
} else {
|
|
let rect2 = parent.getBoundingClientRect();
|
|
parentLeft = rect2.left - parent.scrollLeft;
|
|
parentTop = rect2.top - parent.scrollTop;
|
|
}
|
|
this.element.style.left = rect.left - parentLeft + "px";
|
|
this.element.style.top = rect.top - parentTop + "px";
|
|
this.element.style.width = rect.right - rect.left + "px";
|
|
this.element.style.height = rect.bottom - rect.top + "px";
|
|
}
|
|
scheduleRemoval(timeout) {
|
|
clearTimeout(this.timeout);
|
|
this.timeout = setTimeout(() => this.setCursor(null), timeout);
|
|
}
|
|
dragover(event) {
|
|
if (!this.editorView.editable)
|
|
return;
|
|
let pos = this.editorView.posAtCoords({ left: event.clientX, top: event.clientY });
|
|
let node = pos && pos.inside >= 0 && this.editorView.state.doc.nodeAt(pos.inside);
|
|
let disableDropCursor = node && node.type.spec.disableDropCursor;
|
|
let disabled = typeof disableDropCursor == "function" ? disableDropCursor(this.editorView, pos, event) : disableDropCursor;
|
|
if (pos && !disabled) {
|
|
let target = pos.pos;
|
|
if (this.editorView.dragging && this.editorView.dragging.slice) {
|
|
let point = dropPoint(this.editorView.state.doc, target, this.editorView.dragging.slice);
|
|
if (point != null)
|
|
target = point;
|
|
}
|
|
this.setCursor(target);
|
|
this.scheduleRemoval(5e3);
|
|
}
|
|
}
|
|
dragend() {
|
|
this.scheduleRemoval(20);
|
|
}
|
|
drop() {
|
|
this.scheduleRemoval(20);
|
|
}
|
|
dragleave(event) {
|
|
if (event.target == this.editorView.dom || !this.editorView.dom.contains(event.relatedTarget))
|
|
this.setCursor(null);
|
|
}
|
|
};
|
|
|
|
// node_modules/@tiptap/extension-dropcursor/dist/index.js
|
|
var Dropcursor = Extension.create({
|
|
name: "dropCursor",
|
|
addOptions() {
|
|
return {
|
|
color: "currentColor",
|
|
width: 1,
|
|
class: void 0
|
|
};
|
|
},
|
|
addProseMirrorPlugins() {
|
|
return [
|
|
dropCursor(this.options)
|
|
];
|
|
}
|
|
});
|
|
|
|
// node_modules/prosemirror-gapcursor/dist/index.js
|
|
var GapCursor = class _GapCursor extends Selection {
|
|
/**
|
|
Create a gap cursor.
|
|
*/
|
|
constructor($pos) {
|
|
super($pos, $pos);
|
|
}
|
|
map(doc, mapping) {
|
|
let $pos = doc.resolve(mapping.map(this.head));
|
|
return _GapCursor.valid($pos) ? new _GapCursor($pos) : Selection.near($pos);
|
|
}
|
|
content() {
|
|
return Slice.empty;
|
|
}
|
|
eq(other) {
|
|
return other instanceof _GapCursor && other.head == this.head;
|
|
}
|
|
toJSON() {
|
|
return { type: "gapcursor", pos: this.head };
|
|
}
|
|
/**
|
|
@internal
|
|
*/
|
|
static fromJSON(doc, json) {
|
|
if (typeof json.pos != "number")
|
|
throw new RangeError("Invalid input for GapCursor.fromJSON");
|
|
return new _GapCursor(doc.resolve(json.pos));
|
|
}
|
|
/**
|
|
@internal
|
|
*/
|
|
getBookmark() {
|
|
return new GapBookmark(this.anchor);
|
|
}
|
|
/**
|
|
@internal
|
|
*/
|
|
static valid($pos) {
|
|
let parent = $pos.parent;
|
|
if (parent.isTextblock || !closedBefore($pos) || !closedAfter($pos))
|
|
return false;
|
|
let override = parent.type.spec.allowGapCursor;
|
|
if (override != null)
|
|
return override;
|
|
let deflt = parent.contentMatchAt($pos.index()).defaultType;
|
|
return deflt && deflt.isTextblock;
|
|
}
|
|
/**
|
|
@internal
|
|
*/
|
|
static findGapCursorFrom($pos, dir, mustMove = false) {
|
|
search:
|
|
for (; ; ) {
|
|
if (!mustMove && _GapCursor.valid($pos))
|
|
return $pos;
|
|
let pos = $pos.pos, next = null;
|
|
for (let d = $pos.depth; ; d--) {
|
|
let parent = $pos.node(d);
|
|
if (dir > 0 ? $pos.indexAfter(d) < parent.childCount : $pos.index(d) > 0) {
|
|
next = parent.child(dir > 0 ? $pos.indexAfter(d) : $pos.index(d) - 1);
|
|
break;
|
|
} else if (d == 0) {
|
|
return null;
|
|
}
|
|
pos += dir;
|
|
let $cur = $pos.doc.resolve(pos);
|
|
if (_GapCursor.valid($cur))
|
|
return $cur;
|
|
}
|
|
for (; ; ) {
|
|
let inside = dir > 0 ? next.firstChild : next.lastChild;
|
|
if (!inside) {
|
|
if (next.isAtom && !next.isText && !NodeSelection.isSelectable(next)) {
|
|
$pos = $pos.doc.resolve(pos + next.nodeSize * dir);
|
|
mustMove = false;
|
|
continue search;
|
|
}
|
|
break;
|
|
}
|
|
next = inside;
|
|
pos += dir;
|
|
let $cur = $pos.doc.resolve(pos);
|
|
if (_GapCursor.valid($cur))
|
|
return $cur;
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
};
|
|
GapCursor.prototype.visible = false;
|
|
GapCursor.findFrom = GapCursor.findGapCursorFrom;
|
|
Selection.jsonID("gapcursor", GapCursor);
|
|
var GapBookmark = class _GapBookmark {
|
|
constructor(pos) {
|
|
this.pos = pos;
|
|
}
|
|
map(mapping) {
|
|
return new _GapBookmark(mapping.map(this.pos));
|
|
}
|
|
resolve(doc) {
|
|
let $pos = doc.resolve(this.pos);
|
|
return GapCursor.valid($pos) ? new GapCursor($pos) : Selection.near($pos);
|
|
}
|
|
};
|
|
function closedBefore($pos) {
|
|
for (let d = $pos.depth; d >= 0; d--) {
|
|
let index = $pos.index(d), parent = $pos.node(d);
|
|
if (index == 0) {
|
|
if (parent.type.spec.isolating)
|
|
return true;
|
|
continue;
|
|
}
|
|
for (let before = parent.child(index - 1); ; before = before.lastChild) {
|
|
if (before.childCount == 0 && !before.inlineContent || before.isAtom || before.type.spec.isolating)
|
|
return true;
|
|
if (before.inlineContent)
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function closedAfter($pos) {
|
|
for (let d = $pos.depth; d >= 0; d--) {
|
|
let index = $pos.indexAfter(d), parent = $pos.node(d);
|
|
if (index == parent.childCount) {
|
|
if (parent.type.spec.isolating)
|
|
return true;
|
|
continue;
|
|
}
|
|
for (let after = parent.child(index); ; after = after.firstChild) {
|
|
if (after.childCount == 0 && !after.inlineContent || after.isAtom || after.type.spec.isolating)
|
|
return true;
|
|
if (after.inlineContent)
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function gapCursor() {
|
|
return new Plugin({
|
|
props: {
|
|
decorations: drawGapCursor,
|
|
createSelectionBetween(_view, $anchor, $head) {
|
|
return $anchor.pos == $head.pos && GapCursor.valid($head) ? new GapCursor($head) : null;
|
|
},
|
|
handleClick,
|
|
handleKeyDown,
|
|
handleDOMEvents: { beforeinput }
|
|
}
|
|
});
|
|
}
|
|
var handleKeyDown = keydownHandler({
|
|
"ArrowLeft": arrow("horiz", -1),
|
|
"ArrowRight": arrow("horiz", 1),
|
|
"ArrowUp": arrow("vert", -1),
|
|
"ArrowDown": arrow("vert", 1)
|
|
});
|
|
function arrow(axis, dir) {
|
|
const dirStr = axis == "vert" ? dir > 0 ? "down" : "up" : dir > 0 ? "right" : "left";
|
|
return function(state, dispatch, view) {
|
|
let sel = state.selection;
|
|
let $start = dir > 0 ? sel.$to : sel.$from, mustMove = sel.empty;
|
|
if (sel instanceof TextSelection) {
|
|
if (!view.endOfTextblock(dirStr) || $start.depth == 0)
|
|
return false;
|
|
mustMove = false;
|
|
$start = state.doc.resolve(dir > 0 ? $start.after() : $start.before());
|
|
}
|
|
let $found = GapCursor.findGapCursorFrom($start, dir, mustMove);
|
|
if (!$found)
|
|
return false;
|
|
if (dispatch)
|
|
dispatch(state.tr.setSelection(new GapCursor($found)));
|
|
return true;
|
|
};
|
|
}
|
|
function handleClick(view, pos, event) {
|
|
if (!view || !view.editable)
|
|
return false;
|
|
let $pos = view.state.doc.resolve(pos);
|
|
if (!GapCursor.valid($pos))
|
|
return false;
|
|
let clickPos = view.posAtCoords({ left: event.clientX, top: event.clientY });
|
|
if (clickPos && clickPos.inside > -1 && NodeSelection.isSelectable(view.state.doc.nodeAt(clickPos.inside)))
|
|
return false;
|
|
view.dispatch(view.state.tr.setSelection(new GapCursor($pos)));
|
|
return true;
|
|
}
|
|
function beforeinput(view, event) {
|
|
if (event.inputType != "insertCompositionText" || !(view.state.selection instanceof GapCursor))
|
|
return false;
|
|
let { $from } = view.state.selection;
|
|
let insert = $from.parent.contentMatchAt($from.index()).findWrapping(view.state.schema.nodes.text);
|
|
if (!insert)
|
|
return false;
|
|
let frag = Fragment.empty;
|
|
for (let i = insert.length - 1; i >= 0; i--)
|
|
frag = Fragment.from(insert[i].createAndFill(null, frag));
|
|
let tr = view.state.tr.replace($from.pos, $from.pos, new Slice(frag, 0, 0));
|
|
tr.setSelection(TextSelection.near(tr.doc.resolve($from.pos + 1)));
|
|
view.dispatch(tr);
|
|
return false;
|
|
}
|
|
function drawGapCursor(state) {
|
|
if (!(state.selection instanceof GapCursor))
|
|
return null;
|
|
let node = document.createElement("div");
|
|
node.className = "ProseMirror-gapcursor";
|
|
return DecorationSet.create(state.doc, [Decoration.widget(state.selection.head, node, { key: "gapcursor" })]);
|
|
}
|
|
|
|
// node_modules/@tiptap/extension-gapcursor/dist/index.js
|
|
var Gapcursor = Extension.create({
|
|
name: "gapCursor",
|
|
addProseMirrorPlugins() {
|
|
return [
|
|
gapCursor()
|
|
];
|
|
},
|
|
extendNodeSchema(extension) {
|
|
var _a;
|
|
const context = {
|
|
name: extension.name,
|
|
options: extension.options,
|
|
storage: extension.storage
|
|
};
|
|
return {
|
|
allowGapCursor: (_a = callOrReturn(getExtensionField(extension, "allowGapCursor", context))) !== null && _a !== void 0 ? _a : null
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/@tiptap/extension-hard-break/dist/index.js
|
|
var HardBreak = Node.create({
|
|
name: "hardBreak",
|
|
addOptions() {
|
|
return {
|
|
keepMarks: true,
|
|
HTMLAttributes: {}
|
|
};
|
|
},
|
|
inline: true,
|
|
group: "inline",
|
|
selectable: false,
|
|
parseHTML() {
|
|
return [
|
|
{ tag: "br" }
|
|
];
|
|
},
|
|
renderHTML({ HTMLAttributes }) {
|
|
return ["br", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes)];
|
|
},
|
|
renderText() {
|
|
return "\n";
|
|
},
|
|
addCommands() {
|
|
return {
|
|
setHardBreak: () => ({ commands, chain, state, editor }) => {
|
|
return commands.first([
|
|
() => commands.exitCode(),
|
|
() => commands.command(() => {
|
|
const { selection, storedMarks } = state;
|
|
if (selection.$from.parent.type.spec.isolating) {
|
|
return false;
|
|
}
|
|
const { keepMarks } = this.options;
|
|
const { splittableMarks } = editor.extensionManager;
|
|
const marks = storedMarks || selection.$to.parentOffset && selection.$from.marks();
|
|
return chain().insertContent({ type: this.name }).command(({ tr, dispatch }) => {
|
|
if (dispatch && marks && keepMarks) {
|
|
const filteredMarks = marks.filter((mark) => splittableMarks.includes(mark.type.name));
|
|
tr.ensureMarks(filteredMarks);
|
|
}
|
|
return true;
|
|
}).run();
|
|
})
|
|
]);
|
|
}
|
|
};
|
|
},
|
|
addKeyboardShortcuts() {
|
|
return {
|
|
"Mod-Enter": () => this.editor.commands.setHardBreak(),
|
|
"Shift-Enter": () => this.editor.commands.setHardBreak()
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/@tiptap/extension-heading/dist/index.js
|
|
var Heading = Node.create({
|
|
name: "heading",
|
|
addOptions() {
|
|
return {
|
|
levels: [1, 2, 3, 4, 5, 6],
|
|
HTMLAttributes: {}
|
|
};
|
|
},
|
|
content: "inline*",
|
|
group: "block",
|
|
defining: true,
|
|
addAttributes() {
|
|
return {
|
|
level: {
|
|
default: 1,
|
|
rendered: false
|
|
}
|
|
};
|
|
},
|
|
parseHTML() {
|
|
return this.options.levels.map((level) => ({
|
|
tag: `h${level}`,
|
|
attrs: { level }
|
|
}));
|
|
},
|
|
renderHTML({ node, HTMLAttributes }) {
|
|
const hasLevel = this.options.levels.includes(node.attrs.level);
|
|
const level = hasLevel ? node.attrs.level : this.options.levels[0];
|
|
return [`h${level}`, mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
|
|
},
|
|
addCommands() {
|
|
return {
|
|
setHeading: (attributes) => ({ commands }) => {
|
|
if (!this.options.levels.includes(attributes.level)) {
|
|
return false;
|
|
}
|
|
return commands.setNode(this.name, attributes);
|
|
},
|
|
toggleHeading: (attributes) => ({ commands }) => {
|
|
if (!this.options.levels.includes(attributes.level)) {
|
|
return false;
|
|
}
|
|
return commands.toggleNode(this.name, "paragraph", attributes);
|
|
}
|
|
};
|
|
},
|
|
addKeyboardShortcuts() {
|
|
return this.options.levels.reduce((items, level) => ({
|
|
...items,
|
|
...{
|
|
[`Mod-Alt-${level}`]: () => this.editor.commands.toggleHeading({ level })
|
|
}
|
|
}), {});
|
|
},
|
|
addInputRules() {
|
|
return this.options.levels.map((level) => {
|
|
return textblockTypeInputRule({
|
|
find: new RegExp(`^(#{1,${level}})\\s$`),
|
|
type: this.type,
|
|
getAttributes: {
|
|
level
|
|
}
|
|
});
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/rope-sequence/dist/index.js
|
|
var GOOD_LEAF_SIZE = 200;
|
|
var RopeSequence = function RopeSequence2() {
|
|
};
|
|
RopeSequence.prototype.append = function append(other) {
|
|
if (!other.length) {
|
|
return this;
|
|
}
|
|
other = RopeSequence.from(other);
|
|
return !this.length && other || other.length < GOOD_LEAF_SIZE && this.leafAppend(other) || this.length < GOOD_LEAF_SIZE && other.leafPrepend(this) || this.appendInner(other);
|
|
};
|
|
RopeSequence.prototype.prepend = function prepend(other) {
|
|
if (!other.length) {
|
|
return this;
|
|
}
|
|
return RopeSequence.from(other).append(this);
|
|
};
|
|
RopeSequence.prototype.appendInner = function appendInner(other) {
|
|
return new Append(this, other);
|
|
};
|
|
RopeSequence.prototype.slice = function slice(from2, to) {
|
|
if (from2 === void 0)
|
|
from2 = 0;
|
|
if (to === void 0)
|
|
to = this.length;
|
|
if (from2 >= to) {
|
|
return RopeSequence.empty;
|
|
}
|
|
return this.sliceInner(Math.max(0, from2), Math.min(this.length, to));
|
|
};
|
|
RopeSequence.prototype.get = function get(i) {
|
|
if (i < 0 || i >= this.length) {
|
|
return void 0;
|
|
}
|
|
return this.getInner(i);
|
|
};
|
|
RopeSequence.prototype.forEach = function forEach(f, from2, to) {
|
|
if (from2 === void 0)
|
|
from2 = 0;
|
|
if (to === void 0)
|
|
to = this.length;
|
|
if (from2 <= to) {
|
|
this.forEachInner(f, from2, to, 0);
|
|
} else {
|
|
this.forEachInvertedInner(f, from2, to, 0);
|
|
}
|
|
};
|
|
RopeSequence.prototype.map = function map(f, from2, to) {
|
|
if (from2 === void 0)
|
|
from2 = 0;
|
|
if (to === void 0)
|
|
to = this.length;
|
|
var result = [];
|
|
this.forEach(function(elt, i) {
|
|
return result.push(f(elt, i));
|
|
}, from2, to);
|
|
return result;
|
|
};
|
|
RopeSequence.from = function from(values) {
|
|
if (values instanceof RopeSequence) {
|
|
return values;
|
|
}
|
|
return values && values.length ? new Leaf(values) : RopeSequence.empty;
|
|
};
|
|
var Leaf = function(RopeSequence3) {
|
|
function Leaf2(values) {
|
|
RopeSequence3.call(this);
|
|
this.values = values;
|
|
}
|
|
if (RopeSequence3)
|
|
Leaf2.__proto__ = RopeSequence3;
|
|
Leaf2.prototype = Object.create(RopeSequence3 && RopeSequence3.prototype);
|
|
Leaf2.prototype.constructor = Leaf2;
|
|
var prototypeAccessors = { length: { configurable: true }, depth: { configurable: true } };
|
|
Leaf2.prototype.flatten = function flatten() {
|
|
return this.values;
|
|
};
|
|
Leaf2.prototype.sliceInner = function sliceInner(from2, to) {
|
|
if (from2 == 0 && to == this.length) {
|
|
return this;
|
|
}
|
|
return new Leaf2(this.values.slice(from2, to));
|
|
};
|
|
Leaf2.prototype.getInner = function getInner(i) {
|
|
return this.values[i];
|
|
};
|
|
Leaf2.prototype.forEachInner = function forEachInner(f, from2, to, start) {
|
|
for (var i = from2; i < to; i++) {
|
|
if (f(this.values[i], start + i) === false) {
|
|
return false;
|
|
}
|
|
}
|
|
};
|
|
Leaf2.prototype.forEachInvertedInner = function forEachInvertedInner(f, from2, to, start) {
|
|
for (var i = from2 - 1; i >= to; i--) {
|
|
if (f(this.values[i], start + i) === false) {
|
|
return false;
|
|
}
|
|
}
|
|
};
|
|
Leaf2.prototype.leafAppend = function leafAppend(other) {
|
|
if (this.length + other.length <= GOOD_LEAF_SIZE) {
|
|
return new Leaf2(this.values.concat(other.flatten()));
|
|
}
|
|
};
|
|
Leaf2.prototype.leafPrepend = function leafPrepend(other) {
|
|
if (this.length + other.length <= GOOD_LEAF_SIZE) {
|
|
return new Leaf2(other.flatten().concat(this.values));
|
|
}
|
|
};
|
|
prototypeAccessors.length.get = function() {
|
|
return this.values.length;
|
|
};
|
|
prototypeAccessors.depth.get = function() {
|
|
return 0;
|
|
};
|
|
Object.defineProperties(Leaf2.prototype, prototypeAccessors);
|
|
return Leaf2;
|
|
}(RopeSequence);
|
|
RopeSequence.empty = new Leaf([]);
|
|
var Append = function(RopeSequence3) {
|
|
function Append2(left, right) {
|
|
RopeSequence3.call(this);
|
|
this.left = left;
|
|
this.right = right;
|
|
this.length = left.length + right.length;
|
|
this.depth = Math.max(left.depth, right.depth) + 1;
|
|
}
|
|
if (RopeSequence3)
|
|
Append2.__proto__ = RopeSequence3;
|
|
Append2.prototype = Object.create(RopeSequence3 && RopeSequence3.prototype);
|
|
Append2.prototype.constructor = Append2;
|
|
Append2.prototype.flatten = function flatten() {
|
|
return this.left.flatten().concat(this.right.flatten());
|
|
};
|
|
Append2.prototype.getInner = function getInner(i) {
|
|
return i < this.left.length ? this.left.get(i) : this.right.get(i - this.left.length);
|
|
};
|
|
Append2.prototype.forEachInner = function forEachInner(f, from2, to, start) {
|
|
var leftLen = this.left.length;
|
|
if (from2 < leftLen && this.left.forEachInner(f, from2, Math.min(to, leftLen), start) === false) {
|
|
return false;
|
|
}
|
|
if (to > leftLen && this.right.forEachInner(f, Math.max(from2 - leftLen, 0), Math.min(this.length, to) - leftLen, start + leftLen) === false) {
|
|
return false;
|
|
}
|
|
};
|
|
Append2.prototype.forEachInvertedInner = function forEachInvertedInner(f, from2, to, start) {
|
|
var leftLen = this.left.length;
|
|
if (from2 > leftLen && this.right.forEachInvertedInner(f, from2 - leftLen, Math.max(to, leftLen) - leftLen, start + leftLen) === false) {
|
|
return false;
|
|
}
|
|
if (to < leftLen && this.left.forEachInvertedInner(f, Math.min(from2, leftLen), to, start) === false) {
|
|
return false;
|
|
}
|
|
};
|
|
Append2.prototype.sliceInner = function sliceInner(from2, to) {
|
|
if (from2 == 0 && to == this.length) {
|
|
return this;
|
|
}
|
|
var leftLen = this.left.length;
|
|
if (to <= leftLen) {
|
|
return this.left.slice(from2, to);
|
|
}
|
|
if (from2 >= leftLen) {
|
|
return this.right.slice(from2 - leftLen, to - leftLen);
|
|
}
|
|
return this.left.slice(from2, leftLen).append(this.right.slice(0, to - leftLen));
|
|
};
|
|
Append2.prototype.leafAppend = function leafAppend(other) {
|
|
var inner = this.right.leafAppend(other);
|
|
if (inner) {
|
|
return new Append2(this.left, inner);
|
|
}
|
|
};
|
|
Append2.prototype.leafPrepend = function leafPrepend(other) {
|
|
var inner = this.left.leafPrepend(other);
|
|
if (inner) {
|
|
return new Append2(inner, this.right);
|
|
}
|
|
};
|
|
Append2.prototype.appendInner = function appendInner2(other) {
|
|
if (this.left.depth >= Math.max(this.right.depth, other.depth) + 1) {
|
|
return new Append2(this.left, new Append2(this.right, other));
|
|
}
|
|
return new Append2(this, other);
|
|
};
|
|
return Append2;
|
|
}(RopeSequence);
|
|
var dist_default = RopeSequence;
|
|
|
|
// node_modules/prosemirror-history/dist/index.js
|
|
var max_empty_items = 500;
|
|
var Branch = class _Branch {
|
|
constructor(items, eventCount) {
|
|
this.items = items;
|
|
this.eventCount = eventCount;
|
|
}
|
|
// Pop the latest event off the branch's history and apply it
|
|
// to a document transform.
|
|
popEvent(state, preserveItems) {
|
|
if (this.eventCount == 0)
|
|
return null;
|
|
let end = this.items.length;
|
|
for (; ; end--) {
|
|
let next = this.items.get(end - 1);
|
|
if (next.selection) {
|
|
--end;
|
|
break;
|
|
}
|
|
}
|
|
let remap, mapFrom;
|
|
if (preserveItems) {
|
|
remap = this.remapping(end, this.items.length);
|
|
mapFrom = remap.maps.length;
|
|
}
|
|
let transform = state.tr;
|
|
let selection, remaining;
|
|
let addAfter = [], addBefore = [];
|
|
this.items.forEach((item, i) => {
|
|
if (!item.step) {
|
|
if (!remap) {
|
|
remap = this.remapping(end, i + 1);
|
|
mapFrom = remap.maps.length;
|
|
}
|
|
mapFrom--;
|
|
addBefore.push(item);
|
|
return;
|
|
}
|
|
if (remap) {
|
|
addBefore.push(new Item(item.map));
|
|
let step = item.step.map(remap.slice(mapFrom)), map2;
|
|
if (step && transform.maybeStep(step).doc) {
|
|
map2 = transform.mapping.maps[transform.mapping.maps.length - 1];
|
|
addAfter.push(new Item(map2, void 0, void 0, addAfter.length + addBefore.length));
|
|
}
|
|
mapFrom--;
|
|
if (map2)
|
|
remap.appendMap(map2, mapFrom);
|
|
} else {
|
|
transform.maybeStep(item.step);
|
|
}
|
|
if (item.selection) {
|
|
selection = remap ? item.selection.map(remap.slice(mapFrom)) : item.selection;
|
|
remaining = new _Branch(this.items.slice(0, end).append(addBefore.reverse().concat(addAfter)), this.eventCount - 1);
|
|
return false;
|
|
}
|
|
}, this.items.length, 0);
|
|
return { remaining, transform, selection };
|
|
}
|
|
// Create a new branch with the given transform added.
|
|
addTransform(transform, selection, histOptions, preserveItems) {
|
|
let newItems = [], eventCount = this.eventCount;
|
|
let oldItems = this.items, lastItem = !preserveItems && oldItems.length ? oldItems.get(oldItems.length - 1) : null;
|
|
for (let i = 0; i < transform.steps.length; i++) {
|
|
let step = transform.steps[i].invert(transform.docs[i]);
|
|
let item = new Item(transform.mapping.maps[i], step, selection), merged;
|
|
if (merged = lastItem && lastItem.merge(item)) {
|
|
item = merged;
|
|
if (i)
|
|
newItems.pop();
|
|
else
|
|
oldItems = oldItems.slice(0, oldItems.length - 1);
|
|
}
|
|
newItems.push(item);
|
|
if (selection) {
|
|
eventCount++;
|
|
selection = void 0;
|
|
}
|
|
if (!preserveItems)
|
|
lastItem = item;
|
|
}
|
|
let overflow = eventCount - histOptions.depth;
|
|
if (overflow > DEPTH_OVERFLOW) {
|
|
oldItems = cutOffEvents(oldItems, overflow);
|
|
eventCount -= overflow;
|
|
}
|
|
return new _Branch(oldItems.append(newItems), eventCount);
|
|
}
|
|
remapping(from2, to) {
|
|
let maps = new Mapping();
|
|
this.items.forEach((item, i) => {
|
|
let mirrorPos = item.mirrorOffset != null && i - item.mirrorOffset >= from2 ? maps.maps.length - item.mirrorOffset : void 0;
|
|
maps.appendMap(item.map, mirrorPos);
|
|
}, from2, to);
|
|
return maps;
|
|
}
|
|
addMaps(array) {
|
|
if (this.eventCount == 0)
|
|
return this;
|
|
return new _Branch(this.items.append(array.map((map2) => new Item(map2))), this.eventCount);
|
|
}
|
|
// When the collab module receives remote changes, the history has
|
|
// to know about those, so that it can adjust the steps that were
|
|
// rebased on top of the remote changes, and include the position
|
|
// maps for the remote changes in its array of items.
|
|
rebased(rebasedTransform, rebasedCount) {
|
|
if (!this.eventCount)
|
|
return this;
|
|
let rebasedItems = [], start = Math.max(0, this.items.length - rebasedCount);
|
|
let mapping = rebasedTransform.mapping;
|
|
let newUntil = rebasedTransform.steps.length;
|
|
let eventCount = this.eventCount;
|
|
this.items.forEach((item) => {
|
|
if (item.selection)
|
|
eventCount--;
|
|
}, start);
|
|
let iRebased = rebasedCount;
|
|
this.items.forEach((item) => {
|
|
let pos = mapping.getMirror(--iRebased);
|
|
if (pos == null)
|
|
return;
|
|
newUntil = Math.min(newUntil, pos);
|
|
let map2 = mapping.maps[pos];
|
|
if (item.step) {
|
|
let step = rebasedTransform.steps[pos].invert(rebasedTransform.docs[pos]);
|
|
let selection = item.selection && item.selection.map(mapping.slice(iRebased + 1, pos));
|
|
if (selection)
|
|
eventCount++;
|
|
rebasedItems.push(new Item(map2, step, selection));
|
|
} else {
|
|
rebasedItems.push(new Item(map2));
|
|
}
|
|
}, start);
|
|
let newMaps = [];
|
|
for (let i = rebasedCount; i < newUntil; i++)
|
|
newMaps.push(new Item(mapping.maps[i]));
|
|
let items = this.items.slice(0, start).append(newMaps).append(rebasedItems);
|
|
let branch = new _Branch(items, eventCount);
|
|
if (branch.emptyItemCount() > max_empty_items)
|
|
branch = branch.compress(this.items.length - rebasedItems.length);
|
|
return branch;
|
|
}
|
|
emptyItemCount() {
|
|
let count = 0;
|
|
this.items.forEach((item) => {
|
|
if (!item.step)
|
|
count++;
|
|
});
|
|
return count;
|
|
}
|
|
// Compressing a branch means rewriting it to push the air (map-only
|
|
// items) out. During collaboration, these naturally accumulate
|
|
// because each remote change adds one. The `upto` argument is used
|
|
// to ensure that only the items below a given level are compressed,
|
|
// because `rebased` relies on a clean, untouched set of items in
|
|
// order to associate old items with rebased steps.
|
|
compress(upto = this.items.length) {
|
|
let remap = this.remapping(0, upto), mapFrom = remap.maps.length;
|
|
let items = [], events = 0;
|
|
this.items.forEach((item, i) => {
|
|
if (i >= upto) {
|
|
items.push(item);
|
|
if (item.selection)
|
|
events++;
|
|
} else if (item.step) {
|
|
let step = item.step.map(remap.slice(mapFrom)), map2 = step && step.getMap();
|
|
mapFrom--;
|
|
if (map2)
|
|
remap.appendMap(map2, mapFrom);
|
|
if (step) {
|
|
let selection = item.selection && item.selection.map(remap.slice(mapFrom));
|
|
if (selection)
|
|
events++;
|
|
let newItem = new Item(map2.invert(), step, selection), merged, last = items.length - 1;
|
|
if (merged = items.length && items[last].merge(newItem))
|
|
items[last] = merged;
|
|
else
|
|
items.push(newItem);
|
|
}
|
|
} else if (item.map) {
|
|
mapFrom--;
|
|
}
|
|
}, this.items.length, 0);
|
|
return new _Branch(dist_default.from(items.reverse()), events);
|
|
}
|
|
};
|
|
Branch.empty = new Branch(dist_default.empty, 0);
|
|
function cutOffEvents(items, n) {
|
|
let cutPoint;
|
|
items.forEach((item, i) => {
|
|
if (item.selection && n-- == 0) {
|
|
cutPoint = i;
|
|
return false;
|
|
}
|
|
});
|
|
return items.slice(cutPoint);
|
|
}
|
|
var Item = class _Item {
|
|
constructor(map2, step, selection, mirrorOffset) {
|
|
this.map = map2;
|
|
this.step = step;
|
|
this.selection = selection;
|
|
this.mirrorOffset = mirrorOffset;
|
|
}
|
|
merge(other) {
|
|
if (this.step && other.step && !other.selection) {
|
|
let step = other.step.merge(this.step);
|
|
if (step)
|
|
return new _Item(step.getMap().invert(), step, this.selection);
|
|
}
|
|
}
|
|
};
|
|
var HistoryState = class {
|
|
constructor(done, undone, prevRanges, prevTime, prevComposition) {
|
|
this.done = done;
|
|
this.undone = undone;
|
|
this.prevRanges = prevRanges;
|
|
this.prevTime = prevTime;
|
|
this.prevComposition = prevComposition;
|
|
}
|
|
};
|
|
var DEPTH_OVERFLOW = 20;
|
|
function applyTransaction(history2, state, tr, options) {
|
|
let historyTr = tr.getMeta(historyKey), rebased;
|
|
if (historyTr)
|
|
return historyTr.historyState;
|
|
if (tr.getMeta(closeHistoryKey))
|
|
history2 = new HistoryState(history2.done, history2.undone, null, 0, -1);
|
|
let appended = tr.getMeta("appendedTransaction");
|
|
if (tr.steps.length == 0) {
|
|
return history2;
|
|
} else if (appended && appended.getMeta(historyKey)) {
|
|
if (appended.getMeta(historyKey).redo)
|
|
return new HistoryState(history2.done.addTransform(tr, void 0, options, mustPreserveItems(state)), history2.undone, rangesFor(tr.mapping.maps[tr.steps.length - 1]), history2.prevTime, history2.prevComposition);
|
|
else
|
|
return new HistoryState(history2.done, history2.undone.addTransform(tr, void 0, options, mustPreserveItems(state)), null, history2.prevTime, history2.prevComposition);
|
|
} else if (tr.getMeta("addToHistory") !== false && !(appended && appended.getMeta("addToHistory") === false)) {
|
|
let composition = tr.getMeta("composition");
|
|
let newGroup = history2.prevTime == 0 || !appended && history2.prevComposition != composition && (history2.prevTime < (tr.time || 0) - options.newGroupDelay || !isAdjacentTo(tr, history2.prevRanges));
|
|
let prevRanges = appended ? mapRanges(history2.prevRanges, tr.mapping) : rangesFor(tr.mapping.maps[tr.steps.length - 1]);
|
|
return new HistoryState(history2.done.addTransform(tr, newGroup ? state.selection.getBookmark() : void 0, options, mustPreserveItems(state)), Branch.empty, prevRanges, tr.time, composition == null ? history2.prevComposition : composition);
|
|
} else if (rebased = tr.getMeta("rebased")) {
|
|
return new HistoryState(history2.done.rebased(tr, rebased), history2.undone.rebased(tr, rebased), mapRanges(history2.prevRanges, tr.mapping), history2.prevTime, history2.prevComposition);
|
|
} else {
|
|
return new HistoryState(history2.done.addMaps(tr.mapping.maps), history2.undone.addMaps(tr.mapping.maps), mapRanges(history2.prevRanges, tr.mapping), history2.prevTime, history2.prevComposition);
|
|
}
|
|
}
|
|
function isAdjacentTo(transform, prevRanges) {
|
|
if (!prevRanges)
|
|
return false;
|
|
if (!transform.docChanged)
|
|
return true;
|
|
let adjacent = false;
|
|
transform.mapping.maps[0].forEach((start, end) => {
|
|
for (let i = 0; i < prevRanges.length; i += 2)
|
|
if (start <= prevRanges[i + 1] && end >= prevRanges[i])
|
|
adjacent = true;
|
|
});
|
|
return adjacent;
|
|
}
|
|
function rangesFor(map2) {
|
|
let result = [];
|
|
map2.forEach((_from, _to, from2, to) => result.push(from2, to));
|
|
return result;
|
|
}
|
|
function mapRanges(ranges, mapping) {
|
|
if (!ranges)
|
|
return null;
|
|
let result = [];
|
|
for (let i = 0; i < ranges.length; i += 2) {
|
|
let from2 = mapping.map(ranges[i], 1), to = mapping.map(ranges[i + 1], -1);
|
|
if (from2 <= to)
|
|
result.push(from2, to);
|
|
}
|
|
return result;
|
|
}
|
|
function histTransaction(history2, state, dispatch, redo2) {
|
|
let preserveItems = mustPreserveItems(state);
|
|
let histOptions = historyKey.get(state).spec.config;
|
|
let pop = (redo2 ? history2.undone : history2.done).popEvent(state, preserveItems);
|
|
if (!pop)
|
|
return;
|
|
let selection = pop.selection.resolve(pop.transform.doc);
|
|
let added = (redo2 ? history2.done : history2.undone).addTransform(pop.transform, state.selection.getBookmark(), histOptions, preserveItems);
|
|
let newHist = new HistoryState(redo2 ? added : pop.remaining, redo2 ? pop.remaining : added, null, 0, -1);
|
|
dispatch(pop.transform.setSelection(selection).setMeta(historyKey, { redo: redo2, historyState: newHist }).scrollIntoView());
|
|
}
|
|
var cachedPreserveItems = false;
|
|
var cachedPreserveItemsPlugins = null;
|
|
function mustPreserveItems(state) {
|
|
let plugins = state.plugins;
|
|
if (cachedPreserveItemsPlugins != plugins) {
|
|
cachedPreserveItems = false;
|
|
cachedPreserveItemsPlugins = plugins;
|
|
for (let i = 0; i < plugins.length; i++)
|
|
if (plugins[i].spec.historyPreserveItems) {
|
|
cachedPreserveItems = true;
|
|
break;
|
|
}
|
|
}
|
|
return cachedPreserveItems;
|
|
}
|
|
var historyKey = new PluginKey("history");
|
|
var closeHistoryKey = new PluginKey("closeHistory");
|
|
function history(config = {}) {
|
|
config = {
|
|
depth: config.depth || 100,
|
|
newGroupDelay: config.newGroupDelay || 500
|
|
};
|
|
return new Plugin({
|
|
key: historyKey,
|
|
state: {
|
|
init() {
|
|
return new HistoryState(Branch.empty, Branch.empty, null, 0, -1);
|
|
},
|
|
apply(tr, hist, state) {
|
|
return applyTransaction(hist, state, tr, config);
|
|
}
|
|
},
|
|
config,
|
|
props: {
|
|
handleDOMEvents: {
|
|
beforeinput(view, e) {
|
|
let inputType = e.inputType;
|
|
let command = inputType == "historyUndo" ? undo : inputType == "historyRedo" ? redo : null;
|
|
if (!command)
|
|
return false;
|
|
e.preventDefault();
|
|
return command(view.state, view.dispatch);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
var undo = (state, dispatch) => {
|
|
let hist = historyKey.getState(state);
|
|
if (!hist || hist.done.eventCount == 0)
|
|
return false;
|
|
if (dispatch)
|
|
histTransaction(hist, state, dispatch, false);
|
|
return true;
|
|
};
|
|
var redo = (state, dispatch) => {
|
|
let hist = historyKey.getState(state);
|
|
if (!hist || hist.undone.eventCount == 0)
|
|
return false;
|
|
if (dispatch)
|
|
histTransaction(hist, state, dispatch, true);
|
|
return true;
|
|
};
|
|
|
|
// node_modules/@tiptap/extension-history/dist/index.js
|
|
var History = Extension.create({
|
|
name: "history",
|
|
addOptions() {
|
|
return {
|
|
depth: 100,
|
|
newGroupDelay: 500
|
|
};
|
|
},
|
|
addCommands() {
|
|
return {
|
|
undo: () => ({ state, dispatch }) => {
|
|
return undo(state, dispatch);
|
|
},
|
|
redo: () => ({ state, dispatch }) => {
|
|
return redo(state, dispatch);
|
|
}
|
|
};
|
|
},
|
|
addProseMirrorPlugins() {
|
|
return [
|
|
history(this.options)
|
|
];
|
|
},
|
|
addKeyboardShortcuts() {
|
|
return {
|
|
"Mod-z": () => this.editor.commands.undo(),
|
|
"Mod-Z": () => this.editor.commands.undo(),
|
|
"Mod-y": () => this.editor.commands.redo(),
|
|
"Mod-Y": () => this.editor.commands.redo(),
|
|
"Shift-Mod-z": () => this.editor.commands.redo(),
|
|
"Shift-Mod-Z": () => this.editor.commands.redo(),
|
|
// Russian keyboard layouts
|
|
"Mod-я": () => this.editor.commands.undo(),
|
|
"Shift-Mod-я": () => this.editor.commands.redo()
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/@tiptap/extension-horizontal-rule/dist/index.js
|
|
var HorizontalRule = Node.create({
|
|
name: "horizontalRule",
|
|
addOptions() {
|
|
return {
|
|
HTMLAttributes: {}
|
|
};
|
|
},
|
|
group: "block",
|
|
parseHTML() {
|
|
return [{ tag: "hr" }];
|
|
},
|
|
renderHTML({ HTMLAttributes }) {
|
|
return ["hr", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes)];
|
|
},
|
|
addCommands() {
|
|
return {
|
|
setHorizontalRule: () => ({ chain, state }) => {
|
|
const { $to: $originTo } = state.selection;
|
|
const currentChain = chain();
|
|
if ($originTo.parentOffset === 0) {
|
|
currentChain.insertContentAt(Math.max($originTo.pos - 2, 0), { type: this.name });
|
|
} else {
|
|
currentChain.insertContent({ type: this.name });
|
|
}
|
|
return currentChain.command(({ tr, dispatch }) => {
|
|
var _a;
|
|
if (dispatch) {
|
|
const { $to } = tr.selection;
|
|
const posAfter = $to.end();
|
|
if ($to.nodeAfter) {
|
|
if ($to.nodeAfter.isTextblock) {
|
|
tr.setSelection(TextSelection.create(tr.doc, $to.pos + 1));
|
|
} else if ($to.nodeAfter.isBlock) {
|
|
tr.setSelection(NodeSelection.create(tr.doc, $to.pos));
|
|
} else {
|
|
tr.setSelection(TextSelection.create(tr.doc, $to.pos));
|
|
}
|
|
} else {
|
|
const node = (_a = $to.parent.type.contentMatch.defaultType) === null || _a === void 0 ? void 0 : _a.create();
|
|
if (node) {
|
|
tr.insert(posAfter, node);
|
|
tr.setSelection(TextSelection.create(tr.doc, posAfter + 1));
|
|
}
|
|
}
|
|
tr.scrollIntoView();
|
|
}
|
|
return true;
|
|
}).run();
|
|
}
|
|
};
|
|
},
|
|
addInputRules() {
|
|
return [
|
|
nodeInputRule({
|
|
find: /^(?:---|—-|___\s|\*\*\*\s)$/,
|
|
type: this.type
|
|
})
|
|
];
|
|
}
|
|
});
|
|
|
|
// node_modules/@tiptap/extension-italic/dist/index.js
|
|
var starInputRegex2 = /(?:^|\s)((?:\*)((?:[^*]+))(?:\*))$/;
|
|
var starPasteRegex2 = /(?:^|\s)((?:\*)((?:[^*]+))(?:\*))/g;
|
|
var underscoreInputRegex2 = /(?:^|\s)((?:_)((?:[^_]+))(?:_))$/;
|
|
var underscorePasteRegex2 = /(?:^|\s)((?:_)((?:[^_]+))(?:_))/g;
|
|
var Italic = Mark.create({
|
|
name: "italic",
|
|
addOptions() {
|
|
return {
|
|
HTMLAttributes: {}
|
|
};
|
|
},
|
|
parseHTML() {
|
|
return [
|
|
{
|
|
tag: "em"
|
|
},
|
|
{
|
|
tag: "i",
|
|
getAttrs: (node) => node.style.fontStyle !== "normal" && null
|
|
},
|
|
{
|
|
style: "font-style=italic"
|
|
}
|
|
];
|
|
},
|
|
renderHTML({ HTMLAttributes }) {
|
|
return ["em", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
|
|
},
|
|
addCommands() {
|
|
return {
|
|
setItalic: () => ({ commands }) => {
|
|
return commands.setMark(this.name);
|
|
},
|
|
toggleItalic: () => ({ commands }) => {
|
|
return commands.toggleMark(this.name);
|
|
},
|
|
unsetItalic: () => ({ commands }) => {
|
|
return commands.unsetMark(this.name);
|
|
}
|
|
};
|
|
},
|
|
addKeyboardShortcuts() {
|
|
return {
|
|
"Mod-i": () => this.editor.commands.toggleItalic(),
|
|
"Mod-I": () => this.editor.commands.toggleItalic()
|
|
};
|
|
},
|
|
addInputRules() {
|
|
return [
|
|
markInputRule({
|
|
find: starInputRegex2,
|
|
type: this.type
|
|
}),
|
|
markInputRule({
|
|
find: underscoreInputRegex2,
|
|
type: this.type
|
|
})
|
|
];
|
|
},
|
|
addPasteRules() {
|
|
return [
|
|
markPasteRule({
|
|
find: starPasteRegex2,
|
|
type: this.type
|
|
}),
|
|
markPasteRule({
|
|
find: underscorePasteRegex2,
|
|
type: this.type
|
|
})
|
|
];
|
|
}
|
|
});
|
|
|
|
// node_modules/@tiptap/extension-list-item/dist/index.js
|
|
var ListItem2 = Node.create({
|
|
name: "listItem",
|
|
addOptions() {
|
|
return {
|
|
HTMLAttributes: {},
|
|
bulletListTypeName: "bulletList",
|
|
orderedListTypeName: "orderedList"
|
|
};
|
|
},
|
|
content: "paragraph block*",
|
|
defining: true,
|
|
parseHTML() {
|
|
return [
|
|
{
|
|
tag: "li"
|
|
}
|
|
];
|
|
},
|
|
renderHTML({ HTMLAttributes }) {
|
|
return ["li", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
|
|
},
|
|
addKeyboardShortcuts() {
|
|
return {
|
|
Enter: () => this.editor.commands.splitListItem(this.name),
|
|
Tab: () => this.editor.commands.sinkListItem(this.name),
|
|
"Shift-Tab": () => this.editor.commands.liftListItem(this.name)
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/@tiptap/extension-ordered-list/dist/index.js
|
|
var ListItem3 = Node.create({
|
|
name: "listItem",
|
|
addOptions() {
|
|
return {
|
|
HTMLAttributes: {},
|
|
bulletListTypeName: "bulletList",
|
|
orderedListTypeName: "orderedList"
|
|
};
|
|
},
|
|
content: "paragraph block*",
|
|
defining: true,
|
|
parseHTML() {
|
|
return [
|
|
{
|
|
tag: "li"
|
|
}
|
|
];
|
|
},
|
|
renderHTML({ HTMLAttributes }) {
|
|
return ["li", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
|
|
},
|
|
addKeyboardShortcuts() {
|
|
return {
|
|
Enter: () => this.editor.commands.splitListItem(this.name),
|
|
Tab: () => this.editor.commands.sinkListItem(this.name),
|
|
"Shift-Tab": () => this.editor.commands.liftListItem(this.name)
|
|
};
|
|
}
|
|
});
|
|
var TextStyle2 = Mark.create({
|
|
name: "textStyle",
|
|
addOptions() {
|
|
return {
|
|
HTMLAttributes: {}
|
|
};
|
|
},
|
|
parseHTML() {
|
|
return [
|
|
{
|
|
tag: "span",
|
|
getAttrs: (element) => {
|
|
const hasStyles = element.hasAttribute("style");
|
|
if (!hasStyles) {
|
|
return false;
|
|
}
|
|
return {};
|
|
}
|
|
}
|
|
];
|
|
},
|
|
renderHTML({ HTMLAttributes }) {
|
|
return ["span", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
|
|
},
|
|
addCommands() {
|
|
return {
|
|
removeEmptyTextStyle: () => ({ state, commands }) => {
|
|
const attributes = getMarkAttributes(state, this.type);
|
|
const hasStyles = Object.entries(attributes).some(([, value]) => !!value);
|
|
if (hasStyles) {
|
|
return true;
|
|
}
|
|
return commands.unsetMark(this.name);
|
|
}
|
|
};
|
|
}
|
|
});
|
|
var inputRegex4 = /^(\d+)\.\s$/;
|
|
var OrderedList = Node.create({
|
|
name: "orderedList",
|
|
addOptions() {
|
|
return {
|
|
itemTypeName: "listItem",
|
|
HTMLAttributes: {},
|
|
keepMarks: false,
|
|
keepAttributes: false
|
|
};
|
|
},
|
|
group: "block list",
|
|
content() {
|
|
return `${this.options.itemTypeName}+`;
|
|
},
|
|
addAttributes() {
|
|
return {
|
|
start: {
|
|
default: 1,
|
|
parseHTML: (element) => {
|
|
return element.hasAttribute("start") ? parseInt(element.getAttribute("start") || "", 10) : 1;
|
|
}
|
|
}
|
|
};
|
|
},
|
|
parseHTML() {
|
|
return [
|
|
{
|
|
tag: "ol"
|
|
}
|
|
];
|
|
},
|
|
renderHTML({ HTMLAttributes }) {
|
|
const { start, ...attributesWithoutStart } = HTMLAttributes;
|
|
return start === 1 ? ["ol", mergeAttributes(this.options.HTMLAttributes, attributesWithoutStart), 0] : ["ol", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
|
|
},
|
|
addCommands() {
|
|
return {
|
|
toggleOrderedList: () => ({ commands, chain }) => {
|
|
if (this.options.keepAttributes) {
|
|
return chain().toggleList(this.name, this.options.itemTypeName, this.options.keepMarks).updateAttributes(ListItem3.name, this.editor.getAttributes(TextStyle2.name)).run();
|
|
}
|
|
return commands.toggleList(this.name, this.options.itemTypeName, this.options.keepMarks);
|
|
}
|
|
};
|
|
},
|
|
addKeyboardShortcuts() {
|
|
return {
|
|
"Mod-Shift-7": () => this.editor.commands.toggleOrderedList()
|
|
};
|
|
},
|
|
addInputRules() {
|
|
let inputRule = wrappingInputRule({
|
|
find: inputRegex4,
|
|
type: this.type,
|
|
getAttributes: (match) => ({ start: +match[1] }),
|
|
joinPredicate: (match, node) => node.childCount + node.attrs.start === +match[1]
|
|
});
|
|
if (this.options.keepMarks || this.options.keepAttributes) {
|
|
inputRule = wrappingInputRule({
|
|
find: inputRegex4,
|
|
type: this.type,
|
|
keepMarks: this.options.keepMarks,
|
|
keepAttributes: this.options.keepAttributes,
|
|
getAttributes: (match) => ({ start: +match[1], ...this.editor.getAttributes(TextStyle2.name) }),
|
|
joinPredicate: (match, node) => node.childCount + node.attrs.start === +match[1],
|
|
editor: this.editor
|
|
});
|
|
}
|
|
return [
|
|
inputRule
|
|
];
|
|
}
|
|
});
|
|
|
|
// node_modules/@tiptap/extension-paragraph/dist/index.js
|
|
var Paragraph = Node.create({
|
|
name: "paragraph",
|
|
priority: 1e3,
|
|
addOptions() {
|
|
return {
|
|
HTMLAttributes: {}
|
|
};
|
|
},
|
|
group: "block",
|
|
content: "inline*",
|
|
parseHTML() {
|
|
return [
|
|
{ tag: "p" }
|
|
];
|
|
},
|
|
renderHTML({ HTMLAttributes }) {
|
|
return ["p", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
|
|
},
|
|
addCommands() {
|
|
return {
|
|
setParagraph: () => ({ commands }) => {
|
|
return commands.setNode(this.name);
|
|
}
|
|
};
|
|
},
|
|
addKeyboardShortcuts() {
|
|
return {
|
|
"Mod-Alt-0": () => this.editor.commands.setParagraph()
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/@tiptap/extension-strike/dist/index.js
|
|
var inputRegex5 = /(?:^|\s)((?:~~)((?:[^~]+))(?:~~))$/;
|
|
var pasteRegex2 = /(?:^|\s)((?:~~)((?:[^~]+))(?:~~))/g;
|
|
var Strike = Mark.create({
|
|
name: "strike",
|
|
addOptions() {
|
|
return {
|
|
HTMLAttributes: {}
|
|
};
|
|
},
|
|
parseHTML() {
|
|
return [
|
|
{
|
|
tag: "s"
|
|
},
|
|
{
|
|
tag: "del"
|
|
},
|
|
{
|
|
tag: "strike"
|
|
},
|
|
{
|
|
style: "text-decoration",
|
|
consuming: false,
|
|
getAttrs: (style) => style.includes("line-through") ? {} : false
|
|
}
|
|
];
|
|
},
|
|
renderHTML({ HTMLAttributes }) {
|
|
return ["s", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
|
|
},
|
|
addCommands() {
|
|
return {
|
|
setStrike: () => ({ commands }) => {
|
|
return commands.setMark(this.name);
|
|
},
|
|
toggleStrike: () => ({ commands }) => {
|
|
return commands.toggleMark(this.name);
|
|
},
|
|
unsetStrike: () => ({ commands }) => {
|
|
return commands.unsetMark(this.name);
|
|
}
|
|
};
|
|
},
|
|
addKeyboardShortcuts() {
|
|
const shortcuts = {};
|
|
if (isMacOS()) {
|
|
shortcuts["Mod-Shift-s"] = () => this.editor.commands.toggleStrike();
|
|
} else {
|
|
shortcuts["Ctrl-Shift-s"] = () => this.editor.commands.toggleStrike();
|
|
}
|
|
return shortcuts;
|
|
},
|
|
addInputRules() {
|
|
return [
|
|
markInputRule({
|
|
find: inputRegex5,
|
|
type: this.type
|
|
})
|
|
];
|
|
},
|
|
addPasteRules() {
|
|
return [
|
|
markPasteRule({
|
|
find: pasteRegex2,
|
|
type: this.type
|
|
})
|
|
];
|
|
}
|
|
});
|
|
|
|
// node_modules/@tiptap/extension-text/dist/index.js
|
|
var Text = Node.create({
|
|
name: "text",
|
|
group: "inline"
|
|
});
|
|
|
|
// node_modules/@tiptap/starter-kit/dist/index.js
|
|
var StarterKit = Extension.create({
|
|
name: "starterKit",
|
|
addExtensions() {
|
|
var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
|
|
const extensions = [];
|
|
if (this.options.blockquote !== false) {
|
|
extensions.push(Blockquote.configure((_a = this.options) === null || _a === void 0 ? void 0 : _a.blockquote));
|
|
}
|
|
if (this.options.bold !== false) {
|
|
extensions.push(Bold.configure((_b = this.options) === null || _b === void 0 ? void 0 : _b.bold));
|
|
}
|
|
if (this.options.bulletList !== false) {
|
|
extensions.push(BulletList.configure((_c = this.options) === null || _c === void 0 ? void 0 : _c.bulletList));
|
|
}
|
|
if (this.options.code !== false) {
|
|
extensions.push(Code.configure((_d = this.options) === null || _d === void 0 ? void 0 : _d.code));
|
|
}
|
|
if (this.options.codeBlock !== false) {
|
|
extensions.push(CodeBlock.configure((_e = this.options) === null || _e === void 0 ? void 0 : _e.codeBlock));
|
|
}
|
|
if (this.options.document !== false) {
|
|
extensions.push(Document.configure((_f = this.options) === null || _f === void 0 ? void 0 : _f.document));
|
|
}
|
|
if (this.options.dropcursor !== false) {
|
|
extensions.push(Dropcursor.configure((_g = this.options) === null || _g === void 0 ? void 0 : _g.dropcursor));
|
|
}
|
|
if (this.options.gapcursor !== false) {
|
|
extensions.push(Gapcursor.configure((_h = this.options) === null || _h === void 0 ? void 0 : _h.gapcursor));
|
|
}
|
|
if (this.options.hardBreak !== false) {
|
|
extensions.push(HardBreak.configure((_j = this.options) === null || _j === void 0 ? void 0 : _j.hardBreak));
|
|
}
|
|
if (this.options.heading !== false) {
|
|
extensions.push(Heading.configure((_k = this.options) === null || _k === void 0 ? void 0 : _k.heading));
|
|
}
|
|
if (this.options.history !== false) {
|
|
extensions.push(History.configure((_l = this.options) === null || _l === void 0 ? void 0 : _l.history));
|
|
}
|
|
if (this.options.horizontalRule !== false) {
|
|
extensions.push(HorizontalRule.configure((_m = this.options) === null || _m === void 0 ? void 0 : _m.horizontalRule));
|
|
}
|
|
if (this.options.italic !== false) {
|
|
extensions.push(Italic.configure((_o = this.options) === null || _o === void 0 ? void 0 : _o.italic));
|
|
}
|
|
if (this.options.listItem !== false) {
|
|
extensions.push(ListItem2.configure((_p = this.options) === null || _p === void 0 ? void 0 : _p.listItem));
|
|
}
|
|
if (this.options.orderedList !== false) {
|
|
extensions.push(OrderedList.configure((_q = this.options) === null || _q === void 0 ? void 0 : _q.orderedList));
|
|
}
|
|
if (this.options.paragraph !== false) {
|
|
extensions.push(Paragraph.configure((_r = this.options) === null || _r === void 0 ? void 0 : _r.paragraph));
|
|
}
|
|
if (this.options.strike !== false) {
|
|
extensions.push(Strike.configure((_s = this.options) === null || _s === void 0 ? void 0 : _s.strike));
|
|
}
|
|
if (this.options.text !== false) {
|
|
extensions.push(Text.configure((_t = this.options) === null || _t === void 0 ? void 0 : _t.text));
|
|
}
|
|
return extensions;
|
|
}
|
|
});
|
|
export {
|
|
StarterKit,
|
|
StarterKit as default
|
|
};
|
|
//# sourceMappingURL=@tiptap_starter-kit.js.map
|