rhino-editor
Version:
A custom element wrapped rich text editor
2,860 lines • 99.2 kB
JavaScript
import {
CodemarkPlugin
} from "./chunk-PXB77XQ7.js";
import {
BubbleMenuExtension
} from "./chunk-V5KR23GU.js";
import {
CustomStrike
} from "./chunk-2PXEVWXN.js";
import {
SelectionPlugin
} from "./chunk-A3CW73KJ.js";
import {
Paste
} from "./chunk-JBOGFHYG.js";
import {
Gallery
} from "./chunk-MJ2ED6KI.js";
import {
Attachment,
PreviewableAttachment
} from "./chunk-EWF3FTF7.js";
import {
Decoration,
DecorationSet,
Extension,
Mark,
callOrReturn,
combineTransactionSteps,
findChildrenInRange,
getAttributes,
getChangedRanges,
getExtensionField,
getMarksBetween,
isNodeEmpty,
isNodeSelection,
keydownHandler,
markPasteRule,
mergeAttributes
} from "./chunk-4CJ3F2XK.js";
import {
Fragment,
Mapping,
NodeSelection,
Plugin,
PluginKey,
Selection,
Slice,
TextSelection,
dropPoint
} from "./chunk-XG3W5CFT.js";
// node_modules/.pnpm/prosemirror-dropcursor@1.8.2/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;
let editorDOM = this.editorView.dom, editorRect = editorDOM.getBoundingClientRect();
let scaleX = editorRect.width / editorDOM.offsetWidth, scaleY = editorRect.height / editorDOM.offsetHeight;
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;
let halfWidth = this.width / 2 * scaleY;
rect = { left: nodeRect.left, right: nodeRect.right, top: top - halfWidth, bottom: top + halfWidth };
}
}
}
if (!rect) {
let coords = this.editorView.coordsAtPos(this.cursorPos);
let halfWidth = this.width / 2 * scaleX;
rect = { left: coords.left - halfWidth, right: coords.left + halfWidth, 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();
let parentScaleX = rect2.width / parent.offsetWidth, parentScaleY = rect2.height / parent.offsetHeight;
parentLeft = rect2.left - parent.scrollLeft * parentScaleX;
parentTop = rect2.top - parent.scrollTop * parentScaleY;
}
this.element.style.left = (rect.left - parentLeft) / scaleX + "px";
this.element.style.top = (rect.top - parentTop) / scaleY + "px";
this.element.style.width = (rect.right - rect.left) / scaleX + "px";
this.element.style.height = (rect.bottom - rect.top) / scaleY + "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 (!this.editorView.dom.contains(event.relatedTarget))
this.setCursor(null);
}
};
// node_modules/.pnpm/prosemirror-gapcursor@1.3.2/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 tr2 = view.state.tr.replace($from.pos, $from.pos, new Slice(frag, 0, 0));
tr2.setSelection(TextSelection.near(tr2.doc.resolve($from.pos + 1)));
view.dispatch(tr2);
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/.pnpm/rope-sequence@1.3.4/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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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/.pnpm/prosemirror-history@1.4.1/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, tr2, options) {
let historyTr = tr2.getMeta(historyKey), rebased;
if (historyTr)
return historyTr.historyState;
if (tr2.getMeta(closeHistoryKey))
history2 = new HistoryState(history2.done, history2.undone, null, 0, -1);
let appended = tr2.getMeta("appendedTransaction");
if (tr2.steps.length == 0) {
return history2;
} else if (appended && appended.getMeta(historyKey)) {
if (appended.getMeta(historyKey).redo)
return new HistoryState(history2.done.addTransform(tr2, void 0, options, mustPreserveItems(state)), history2.undone, rangesFor(tr2.mapping.maps), history2.prevTime, history2.prevComposition);
else
return new HistoryState(history2.done, history2.undone.addTransform(tr2, void 0, options, mustPreserveItems(state)), null, history2.prevTime, history2.prevComposition);
} else if (tr2.getMeta("addToHistory") !== false && !(appended && appended.getMeta("addToHistory") === false)) {
let composition = tr2.getMeta("composition");
let newGroup = history2.prevTime == 0 || !appended && history2.prevComposition != composition && (history2.prevTime < (tr2.time || 0) - options.newGroupDelay || !isAdjacentTo(tr2, history2.prevRanges));
let prevRanges = appended ? mapRanges(history2.prevRanges, tr2.mapping) : rangesFor(tr2.mapping.maps);
return new HistoryState(history2.done.addTransform(tr2, newGroup ? state.selection.getBookmark() : void 0, options, mustPreserveItems(state)), Branch.empty, prevRanges, tr2.time, composition == null ? history2.prevComposition : composition);
} else if (rebased = tr2.getMeta("rebased")) {
return new HistoryState(history2.done.rebased(tr2, rebased), history2.undone.rebased(tr2, rebased), mapRanges(history2.prevRanges, tr2.mapping), history2.prevTime, history2.prevComposition);
} else {
return new HistoryState(history2.done.addMaps(tr2.mapping.maps), history2.undone.addMaps(tr2.mapping.maps), mapRanges(history2.prevRanges, tr2.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(maps) {
let result = [];
for (let i = maps.length - 1; i >= 0 && result.length == 0; i--)
maps[i].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, 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 null;
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);
return pop.transform.setSelection(selection).setMeta(historyKey, { redo: redo2, historyState: newHist });
}
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(tr2, hist, state) {
return applyTransaction(hist, state, tr2, 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);
}
}
}
});
}
function buildCommand(redo2, scroll) {
return (state, dispatch) => {
let hist = historyKey.getState(state);
if (!hist || (redo2 ? hist.undone : hist.done).eventCount == 0)
return false;
if (dispatch) {
let tr2 = histTransaction(hist, state, redo2);
if (tr2)
dispatch(scroll ? tr2.scrollIntoView() : tr2);
}
return true;
};
}
var undo = buildCommand(false, true);
var redo = buildCommand(true, true);
var undoNoScroll = buildCommand(false, false);
var redoNoScroll = buildCommand(true, false);
// node_modules/.pnpm/@tiptap+extensions@3.4.4_@tiptap+core@3.4.4_@tiptap+pm@3.4.4__@tiptap+pm@3.4.4/node_modules/@tiptap/extensions/dist/index.js
var CharacterCount = Extension.create({
name: "characterCount",
addOptions() {
return {
limit: null,
mode: "textSize",
textCounter: (text) => text.length,
wordCounter: (text) => text.split(" ").filter((word) => word !== "").length
};
},
addStorage() {
return {
characters: () => 0,
words: () => 0
};
},
onBeforeCreate() {
this.storage.characters = (options) => {
const node = (options == null ? void 0 : options.node) || this.editor.state.doc;
const mode = (options == null ? void 0 : options.mode) || this.options.mode;
if (mode === "textSize") {
const text = node.textBetween(0, node.content.size, void 0, " ");
return this.options.textCounter(text);
}
return node.nodeSize;
};
this.storage.words = (options) => {
const node = (options == null ? void 0 : options.node) || this.editor.state.doc;
const text = node.textBetween(0, node.content.size, " ", " ");
return this.options.wordCounter(text);
};
},
addProseMirrorPlugins() {
let initialEvaluationDone = false;
return [
new Plugin({
key: new PluginKey("characterCount"),
appendTransaction: (transactions, oldState, newState) => {
if (initialEvaluationDone) {
return;
}
const limit = this.options.limit;
if (limit === null || limit === void 0 || limit === 0) {
initialEvaluationDone = true;
return;
}
const initialContentSize = this.storage.characters({ node: newState.doc });
if (initialContentSize > limit) {
const over = initialContentSize - limit;
const from2 = 0;
const to = over;
console.warn(
`[CharacterCount] Initial content exceeded limit of ${limit} characters. Content was automatically trimmed.`
);
const tr2 = newState.tr.deleteRange(from2, to);
initialEvaluationDone = true;
return tr2;
}
initialEvaluationDone = true;
},
filterTransaction: (transaction, state) => {
const limit = this.options.limit;
if (!transaction.docChanged || limit === 0 || limit === null || limit === void 0) {
return true;
}
const oldSize = this.storage.characters({ node: state.doc });
const newSize = this.storage.characters({ node: transaction.doc });
if (newSize <= limit) {
return true;
}
if (oldSize > limit && newSize > limit && newSize <= oldSize) {
return true;
}
if (oldSize > limit && newSize > limit && newSize > oldSize) {
return false;
}
const isPaste = transaction.getMeta("paste");
if (!isPaste) {
return false;
}
const pos = transaction.selection.$head.pos;
const over = newSize - limit;
const from2 = pos - over;
const to = pos;
transaction.deleteRange(from2, to);
const updatedSize = this.storage.characters({ node: transaction.doc });
if (updatedSize > limit) {
return false;
}
return true;
}
})
];
}
});
var Dropcursor = Extension.create({
name: "dropCursor",
addOptions() {
return {
color: "currentColor",
width: 1,
class: void 0
};
},
addProseMirrorPlugins() {
return [dropCursor(this.options)];
}
});
var Focus = Extension.create({
name: "focus",
addOptions() {
return {
className: "has-focus",
mode: "all"
};
},
addProseMirrorPlugins() {
return [
new Plugin({
key: new PluginKey("focus"),
props: {
decorations: ({ doc, selection }) => {
const { isEditable, isFocused } = this.editor;
const { anchor } = selection;
const decorations = [];
if (!isEditable || !isFocused) {
return DecorationSet.create(doc, []);
}
let maxLevels = 0;
if (this.options.mode === "deepest") {
doc.descendants((node, pos) => {
if (node.isText) {
return;
}
const isCurrent = anchor >= pos && anchor <= pos + node.nodeSize - 1;
if (!isCurrent) {
return false;
}
maxLevels += 1;
});
}
let currentLevel = 0;
doc.descendants((node, pos) => {
if (node.isText) {
return false;
}
const isCurrent = anchor >= pos && anchor <= pos + node.nodeSize - 1;
if (!isCurrent) {
return false;
}
currentLevel += 1;
const outOfScope = this.options.mode === "deepest" && maxLevels - currentLevel > 0 || this.options.mode === "shallowest" && currentLevel > 1;
if (outOfScope) {
return this.options.mode === "deepest";
}
decorations.push(
Decoration.node(pos, pos + node.nodeSize, {
class: this.options.className
})
);
});
return DecorationSet.create(doc, decorations);
}
}
})
];
}
});
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 : null
};
}
});
var Placeholder = Extension.create({
name: "placeholder",
addOptions() {
return {
emptyEditorClass: "is-editor-empty",
emptyNodeClass: "is-empty",
placeholder: "Write something \u2026",
showOnlyWhenEditable: true,
showOnlyCurrent: true,
includeChildren: false
};
},
addProseMirrorPlugins() {
return [
new Plugin({
key: new PluginKey("placeholder"),
props: {
decorations: ({ doc, selection }) => {
const active = this.editor.isEditable || !this.options.showOnlyWhenEditable;
const { anchor } = selection;
const decorations = [];
if (!active) {
return null;
}
const isEmptyDoc = this.editor.isEmpty;
doc.descendants((node, pos) => {
const hasAnchor = anchor >= pos && anchor <= pos + node.nodeSize;
const isEmpty = !node.isLeaf && isNodeEmpty(node);
if ((hasAnchor || !this.options.showOnlyCurrent) && isEmpty) {
const classes = [this.options.emptyNodeClass];
if (isEmptyDoc) {
classes.push(this.options.emptyEditorClass);
}
const decoration = Decoration.node(pos, pos + node.nodeSize, {
class: classes.join(" "),
"data-placeholder": typeof this.options.placeholder === "function" ? this.options.placeholder({
editor: this.editor,
node,
pos,
hasAnchor
}) : this.options.placeholder
});
decorations.push(decoration);
}
return this.options.includeChildren;
});
return DecorationSet.create(doc, decorations);
}
}
})
];
}
});
var Selection2 = Extension.create({
name: "selection",
addOptions() {
return {
className: "selection"
};
},
addProseMirrorPlugins() {
const { editor, options } = this;
return [
new Plugin({
key: new PluginKey("selection"),
props: {
decorations(state) {
if (state.selection.empty || editor.isFocused || !editor.isEditable || isNodeSelection(state.selection) || editor.view.dragging) {
return null;
}
return DecorationSet.create(state.doc, [
Decoration.inline(state.selection.from, state.selection.to, {
class: options.className
})
]);
}
}
})
];
}
});
function nodeEqualsType({ types, node }) {
return node && Array.isArray(types) && types.includes(node.type) || (node == null ? void 0 : node.type) === types;
}
var TrailingNode = Extension.create({
name: "trailingNode",
addOptions() {
return {
node: "paragraph",
notAfter: []
};
},
addProseMirrorPlugins() {
const plugin = new PluginKey(this.name);
const disabledNodes = Object.entries(this.editor.schema.nodes).map(([, value]) => value).filter((node) => (this.options.notAfter || []).concat(this.options.node).includes(node.name));
return [
new Plugin({
key: plugin,
appendTransaction: (_, __, state) => {
const { doc, tr: tr2, schema } = state;
const shouldInsertNodeAtEnd = plugin.getState(state);
const endPosition = doc.content.size;
const type = schema.nodes[this.options.node];
if (!shouldInsertNodeAtEnd) {
return;
}
return tr2.insert(endPosition, type.create());
},
state: {
init: (_, state) => {
const lastNode = state.tr.doc.lastChild;
return !nodeEqualsType({ node: lastNode, types: disabledNodes });
},
apply: (tr2, value) => {
if (!tr2.docChanged) {
return value;
}
const lastNode = tr2.doc.lastChild;
return !nodeEqualsType({ node: lastNode, types: disabledNodes });
}
}
})
];
}
});
var UndoRedo = Extension.create({
name: "undoRedo",
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(),
"Shift-Mod-z": () => this.editor.commands.redo(),
"Mod-y": () => this.editor.commands.redo(),
// Russian keyboard layouts
"Mod-\u044F": () => this.editor.commands.undo(),
"Shift-Mod-\u044F": () => this.editor.commands.redo()
};
}
});
// node_modules/.pnpm/@tiptap+extension-placeholder@3.4.4_@tiptap+extensions@3.4.4_@tiptap+core@3.4.4_@tiptap+pm@3.4.4__@tiptap+pm@3.4.4_/node_modules/@tiptap/extension-placeholder/dist/index.js
var index_default = Placeholder;
// node_modules/.pnpm/@tiptap+extension-focus@3.4.4_@tiptap+extensions@3.4.4_@tiptap+core@3.4.4_@tiptap+pm@3.4.4__@tiptap+pm@3.4.4_/node_modules/@tiptap/extension-focus/dist/index.js
var index_default2 = Focus;
// node_modules/.pnpm/linkifyjs@4.3.2/node_modules/linkifyjs/dist/linkify.mjs
var encodedTlds = "aaa1rp3bb0ott3vie4c1le2ogado5udhabi7c0ademy5centure6ountant0s9o1tor4d0s1ult4e0g1ro2tna4f0l1rica5g0akhan5ency5i0g1rbus3force5tel5kdn3l0ibaba4pay4lfinanz6state5y2sace3tom5m0azon4ericanexpress7family11x2fam3ica3sterdam8nalytics7droid5quan4z2o0l2partments8p0le4q0uarelle8r0ab1mco4chi3my2pa2t0e3s0da2ia2sociates9t0hleta5torney7u0ction5di0ble3o3spost5thor3o0s4w0s2x0a2z0ure5ba0by2idu3namex4d1k2r0celona5laycard4s5efoot5gains6seball5ketball8uhaus5yern5b0c1t1va3cg1n2d1e0ats2uty4er2rlin4st0buy5t2f1g1h0arti5i0ble3d1ke2ng0o3o1z2j1lack0friday9ockbuster8g1omberg7ue3m0s1w2n0pparibas9o0ats3ehringer8fa2m1nd2o0k0ing5sch2tik2on4t1utique6x2r0adesco6idgestone9oadway5ker3ther5ussels7s1t1uild0ers6siness6y1zz3v1w1y1z0h3ca0b1fe2l0l1vinklein9m0era3p2non3petown5ital0one8r0avan4ds2e0er0s4s2sa1e1h1ino4t0ering5holic7ba1n1re3c1d1enter4o1rn3f0a1d2g1h0anel2nel4rity4se2t2eap3intai5ristmas6ome4urch5i0priani6rcle4sco3tadel4i0c2y3k1l0aims4eaning6ick2nic1que6othing5ud3ub0med6m1n1o0ach3des3ffee4llege4ogne5m0mbank4unity6pany2re3uter5sec4ndos3struction8ulting7tact3ractors9oking4l1p2rsica5untry4pon0s4rses6pa2r0edit0card4union9icket5own3s1uise0s6u0isinella9v1w1x1y0mru3ou3z2dad1nce3ta1e1ing3sun4y2clk3ds2e0al0er2s3gree4livery5l1oitte5ta3mocrat6ntal2ist5si0gn4v2hl2iamonds6et2gital5rect0ory7scount3ver5h2y2j1k1m1np2o0cs1tor4g1mains5t1wnload7rive4tv2ubai3nlop4pont4rban5vag2r2z2earth3t2c0o2deka3u0cation8e1g1mail3erck5nergy4gineer0ing9terprises10pson4quipment8r0icsson6ni3s0q1tate5t1u0rovision8s2vents5xchange6pert3osed4ress5traspace10fage2il1rwinds6th3mily4n0s2rm0ers5shion4t3edex3edback6rrari3ero6i0delity5o2lm2nal1nce1ial7re0stone6mdale6sh0ing5t0ness6j1k1lickr3ghts4r2orist4wers5y2m1o0o0d1tball6rd1ex2sale4um3undation8x2r0ee1senius7l1ogans4ntier7tr2ujitsu5n0d2rniture7tbol5yi3ga0l0lery3o1up4me0s3p1rden4y2b0iz3d0n2e0a1nt0ing5orge5f1g0ee3h1i0ft0s3ves2ing5l0ass3e1obal2o4m0ail3bh2o1x2n1odaddy5ld0point6f2o0dyear5g0le4p1t1v2p1q1r0ainger5phics5tis4een3ipe3ocery4up4s1t1u0cci3ge2ide2tars5ru3w1y2hair2mburg5ngout5us3bo2dfc0bank7ealth0care8lp1sinki6re1mes5iphop4samitsu7tachi5v2k0t2m1n1ockey4ldings5iday5medepot5goods5s0ense7nda3rse3spital5t0ing5t0els3mail5use3w2r1sbc3t1u0ghes5yatt3undai7ibm2cbc2e1u2d1e0ee3fm2kano4l1m0amat4db2mo0bilien9n0c1dustries8finiti5o2g1k1stitute6urance4e4t0ernational10uit4vestments10o1piranga7q1r0ish4s0maili5t0anbul7t0au2v3jaguar4va3cb2e0ep2tzt3welry6io2ll2m0p2nj2o0bs1urg4t1y2p0morgan6rs3uegos4niper7kaufen5ddi3e0rryhotels6properties14fh2g1h1i0a1ds2m1ndle4tchen5wi3m1n1oeln3matsu5sher5p0mg2n2r0d1ed3uokgroup8w1y0oto4z2la0caixa5mborghini8er3nd0rover6xess5salle5t0ino3robe5w0yer5b1c1ds2ease3clerc5frak4gal2o2xus4gbt3i0dl2fe0insurance9style7ghting6ke2lly3mited4o2ncoln4k2ve1ing5k1lc1p2oan0s3cker3us3l1ndon4tte1o3ve3pl0financial11r1s1t0d0a3u0ndbeck6xe1ury5v1y2ma0drid4if1son4keup4n0agement7go3p1rket0ing3s4riott5shalls7ttel5ba2c0kinsey7d1e0d0ia3et2lbourne7me1orial6n0u2rckmsd7g1h1iami3crosoft7l1ni1t2t0subishi9k1l0b1s2m0a2n1o0bi0le4da2e1i1m1nash3ey2ster5rmon3tgage6scow4to0rcycles9v0ie4p1q1r1s0d2t0n1r2u0seum3ic4v1w1x1y1z2na0b1goya4me2vy3ba2c1e0c1t0bank4flix4work5ustar5w0s2xt0direct7us4f0l2g0o2hk2i0co2ke1on3nja3ssan1y5l1o0kia3rton4w0ruz3tv4p1r0a1w2tt2u1yc2z2obi1server7ffice5kinawa6layan0group9lo3m0ega4ne1g1l0ine5oo2pen3racle3nge4g0anic5igins6saka4tsuka4t2vh3pa0ge2nasonic7ris2s1tners4s1y3y2ccw3e0t2f0izer5g1h0armacy6d1ilips5one2to0graphy6s4ysio5ics1tet2ures6d1n0g1k2oneer5zza4k1l0ace2y0station9umbing5s3m1n0c2ohl2ker3litie5rn2st3r0axi3ess3ime3o0d0uctions8f1gressive8mo2perties3y5tection8u0dential9s1t1ub2w0c2y2qa1pon3uebec3st5racing4dio4e0ad1lestate6tor2y4cipes5d0stone5umbrella9hab3ise0n3t2liance6n0t0als5pair3ort3ublican8st0aurant8view0s5xroth6ich0ardli6oh3l1o1p2o0cks3deo3gers4om3s0vp3u0gby3hr2n2w0e2yukyu6sa0arland6fe0ty4kura4le1on3msclub4ung5ndvik0coromant12ofi4p1rl2s1ve2xo3b0i1s2c0b1haeffler7midt4olarships8ol3ule3warz5ience5ot3d1e0arch3t2cure1ity6ek2lect4ner3rvices6ven3w1x0y3fr2g1h0angrila6rp3ell3ia1ksha5oes2p0ping5uji3w3i0lk2na1gles5te3j1k0i0n2y0pe4l0ing4m0art3ile4n0cf3o0ccer3ial4ftbank4ware6hu2lar2utions7ng1y2y2pa0ce3ort2t3r0l2s1t0ada2ples4r1tebank4farm7c0group6ockholm6rage3e3ream4udio2y3yle4u0cks3pplies3y2ort5rf1gery5zuki5v1watch4iss4x1y0dney4stems6z2tab1ipei4lk2obao4rget4tamotors6r2too4x0i3c0i2d0k2eam2ch0nology8l1masek5nnis4va3f1g1h0d1eater2re6iaa2ckets5enda4ps2res2ol4j0maxx4x2k0maxx5l1m0all4n1o0day3kyo3ols3p1ray3shiba5tal3urs3wn2yota3s3r0ade1ing4ining5vel0ers0insurance16ust3v2t1ube2i1nes3shu4v0s2w1z2ua1bank3s2g1k1nicom3versity8o2ol2ps2s1y1z2va0cations7na1guard7c1e0gas3ntures6risign5m\xF6gensberater2ung14sicherung10t2g1i0ajes4deo3g1king4llas4n1p1rgin4sa1ion4va1o3laanderen9n1odka3lvo3te1ing3o2yage5u2wales2mart4ter4ng0gou5tch0es6eather0channel12bcam3er2site5d0ding5ibo2r3f1hoswho6ien2ki2lliamhill9n0dows4e1ners6me2olterskluwer11odside6rk0s2ld3w2s1tc1f3xbox3erox4ihuan4n2xx2yz3yachts4hoo3maxun5ndex5e1odobashi7ga2kohama6u0tube6t1un3za0ppos4ra3ero3ip2m1one3uerich6w2";
var encodedUtlds = "\u03B5\u03BB1\u03C52\u0431\u04331\u0435\u043B3\u0434\u0435\u0442\u04384\u0435\u044E2\u043A\u0430\u0442\u043E\u043B\u0438\u043A6\u043E\u043C3\u043C\u043A\u04342\u043E\u043D1\u0441\u043A\u0432\u04306\u043E\u043D\u043B\u0430\u0439\u043D5\u0440\u04333\u0440\u0443\u04412\u04442\u0441\u0430\u0439\u04423\u0440\u04313\u0443\u043A\u04403\u049B\u0430\u04373\u0570\u0561\u05753\u05D9\u05E9\u05E8\u05D0\u05DC5\u05E7\u05D5\u05DD3\u0627\u0628\u0648\u0638\u0628\u064A5\u0631\u0627\u0645\u0643\u06485\u0644\u0627\u0631\u062F\u06464\u0628\u062D\u0631\u064A\u06465\u062C\u0632\u0627\u0626\u06315\u0633\u0639\u0648\u062F\u064A\u06296\u0639\u0644\u064A\u0627\u06465\u0645\u063A\u0631\u06285\u0645\u0627\u0631\u0627\u062A5\u06CC\u0631\u0627\u06465\u0628\u0627\u0631\u062A2\u0632\u0627\u06314\u064A\u062A\u06433\u06BE\u0627\u0631\u062A5\u062A\u0648\u0646\u06334\u0633\u0648\u062F\u0627\u06463\u0631\u064A\u06295\u0634\u0628\u0643\u06294\u0639\u0631\u0627\u06422\u06282\u0645\u0627\u06464\u0641\u0644\u0633\u0637\u064A\u06466\u0642\u0637\u06313\u0643\u0627\u062B\u0648\u0644\u064A\u06436\u0648\u06453\u0645\u0635\u06312\u0644\u064A\u0633\u064A\u06275\u0648\u0631\u064A\u062A\u0627\u0646\u064A\u06277\u0642\u06394\u0647\u0645\u0631\u0627\u06475\u067E\u0627\u06A9\u0633\u062A\u0627\u06467\u0680\u0627\u0631\u062A4\u0915\u0949\u092E3\u0928\u0947\u091F3\u092D\u093E\u0930\u09240\u092E\u094D3\u094B\u09245\u0938\u0902\u0917\u0920\u09285\u09AC\u09BE\u0982\u09B2\u09BE5\u09AD\u09BE\u09B0\u09A42\u09F0\u09A44\u0A2D\u0A3E\u0A30\u0A244\u0AAD\u0ABE\u0AB0\u0AA44\u0B2D\u0B3E\u0B30\u0B244\u0B87\u0BA8\u0BCD\u0BA4\u0BBF\u0BAF\u0BBE6\u0BB2\u0B99\u0BCD\u0B95\u0BC86\u0B9A\u0BBF\u0B99\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0BC2\u0BB0\u0BCD11\u0C2D\u0C3E\u0C30\u0C24\u0C4D5\u0CAD\u0CBE\u0CB0\u0CA44\u0D2D\u0D3E\u0D30\u0D24\u0D025\u0DBD\u0D82\u0D9A\u0DCF4\u0E04\u0E2D\u0E213\u0E44\u0E17\u0E223\u0EA5\u0EB2\u0EA73\u10D2\u10D42\u307F\u3093\u306A3\u30A2\u30DE\u30BE\u30F34\u30AF\u30E9\u30A6\u30C94\u30B0\u30FC\u30B0\u30EB4\u30B3\u30E02\u30B9\u30C8\u30A23\u30BB\u30FC\u30EB3\u30D5\u30A1\u30C3\u30B7\u30E7\u30F36\u30DD\u30A4\u30F3\u30C84\u4E16\u754C2\u4E2D\u4FE11\u56FD1\u570B1\u6587\u7F513\u4E9A\u9A6C\u900A3\u4F01\u4E1A2\u4F5B\u5C712\u4FE1\u606F2\u5065\u5EB72\u516B\u53662\u516C\u53F81\u76CA2\u53F0\u6E7E1\u70632\u5546\u57CE1\u5E971\u68072\u5609\u91CC0\u5927\u9152\u5E975\u5728\u7EBF2\u5927\u62FF2\u5929\u4E3B\u65593\u5A31\u4E502\u5BB6\u96FB2\u5E7F\u4E1C2\u5FAE\u535A2\u6148\u55842\u6211\u7231\u4F603\u624B\u673A2\u62DB\u80582\u653F\u52A11\u5E9C2\u65B0\u52A0\u57612\u95FB2\u65F6\u5C1A2\u66F8\u7C4D2\u673A\u67842\u6DE1\u9A6C\u95213\u6E38\u620F2\u6FB3\u95802\u70B9\u770B2\u79FB\u52A82\u7EC4\u7EC7\u673A\u67844\u7F51\u57401\u5E971\u7AD91\u7EDC2\u8054\u901A2\u8C37\u6B4C2\u8D2D\u72692\u901A\u8CA92\u96C6\u56E22\u96FB\u8A0A\u76C8\u79D14\u98DE\u5229\u6D663\u98DF\u54C12\u9910\u53852\u9999\u683C\u91CC\u62C93\u6E2F2\uB2F7\uB1371\uCEF42\uC0BC\uC1312\uD55C\uAD6D2";
var numeric = "numeric";
var ascii = "ascii";
var alpha = "alpha";
var asciinumeric = "asciinumeric";
var alphanumeric = "alphanumeric";
var domain = "domain";
var emoji = "emoji";
var scheme = "scheme";
var slashscheme = "slashscheme";
var whitespace = "whitespace";
function registerGroup(name, groups) {
if (!(name in groups)) {
groups[name] = [];
}
return groups[name];
}
function addToGroups(t, flags, groups) {
if (flags[numeric]) {
flags[asciinumeric] = true;
flags[alphanumeric] = true;
}
if (flags[ascii]) {
flags[asciinumeric] = true;
flags[alpha] = true;
}
if (flags[asciinumeric]) {
flags[alphanumeric] = true;
}
if (flags[alpha]) {
flags[alphanumeric] = true;
}
if (flags[alphanumeric]) {
flags[domain] = true;
}
if (flags[emoji]) {
flags[domain] = true;
}
for (const k in flags) {
const group = registerGroup(k, groups);
if (group.indexOf(t) < 0) {
group.push(t);
}
}
}
function flagsForToken(t, groups) {
const result = {};
for (const c in groups) {
if (groups[c].indexOf(t) >= 0) {
result[c] = true;
}
}
return result;
}
function State(token = null) {
this.j = {};
this.jr = [];
this.jd = null;
this.t = token;
}
State.groups = {};
State.prototype = {
accepts() {
return !!this.t;
},
/**
* Follow an existing transition from the given input to the next state.
* Does not mutate.
* @param {string} input character or token type to transition on
* @returns {?State<T>} the next state, if any
*/
go(input) {
const state = this;
const nextState = state.j[input];
if (nextState) {
return nextState;
}
for (let i = 0; i < state.jr.length; i++) {
const regex = state.jr[i][0];
const nextState2 = state.jr[i][1];
if (nextState2 && regex.test(input)) {
return nextState2;
}
}
return state.jd;
},
/**
* Whether the state has a transition for the given input. Set the second
* argument to true to only look for an exact match (and not a default or
* regular-expression-based transition)
* @param {string} input
* @param {boolean} exactOnly
*/
has(input, exactOnly = false) {
return exactOnly ? input in this.j : !!this.go(input);
},
/**
* Short for "transition all"; create a transition from the array of items
* in the given list to the same final resulting state.
* @param {string | string[]} inputs Group of inputs to transition on
* @param {Transition<T> | State<T>} [next] Transition options
* @param {Flags} [flags] Collections flags to add token to
* @param {Collections<T>} [groups] Master list of token groups
*/
ta(inputs, next, flags, groups) {
for (let i = 0; i < inputs.length; i++) {
this.tt(inputs[i], next, flags, groups);
}
},
/**
* Short for "take regexp transition"; defines a transition for this state
* when it encounters a token which matches the given regular expression
* @param {RegExp} regexp Regular expression transition (populate first)
* @param {T | State<T>} [next] Transition options
* @param {Flags} [flags] Collections flags to add token to
* @param {Collections<T>} [groups] Master list of token groups
* @returns {State<T>} taken after the given input
*/
tr(regexp, next, flags, groups) {
groups = groups || State.groups;
let nextState;
if (next && next.j) {
nextState = next;
} else {
nextState = new State(next);
if (flags && groups) {
addToGroups(next, flags, groups);
}
}
this.jr.push([regexp, nextState]);
return nextState;
},
/**
* Short for "take transitions", will take as many sequential transitions as
* the length of the given input and returns the
* resulting final state.
* @param {string | string[]} input
* @param {T | State<T>} [next] Transition options
* @param {Flags} [flags] Collections flags to add token to
* @param {Collections<T>} [groups] Master list of token groups
* @returns {State<T>} taken after the given input
*/
ts(input, next, flags, groups) {
let state = this;
const len = input.length;
if (!len) {
return state;
}
for (let i = 0; i < len - 1; i++) {
state = state.tt(input[i]);
}
return state.tt(input[len - 1], next, flags, groups);
},
/**
* Short for "take transition", this is a method for building/working with
* state machines.
*
* If a state already exists for the given input, returns it.
*
* If a token is specified, that state will emit that token when reached by
* the linkify engine.
*
* If no state exists, it will be initialized with some default transitions
* that resemble existing default transitions.
*
* If a state is given for the second argument, that state will be
* transitioned to on the given input regardless of what that input
* previously did.
*
* Specify a token group flags to define groups that this token belongs to.
* The token will be added to corresponding entires in the given groups
* object.
*
* @param {string} input character, token type to transition on
* @param {T | State<T>} [next] Transition options
* @param {Flags} [flags] Collections flags to add token to
* @param {Collections<T>} [groups] Master list of groups
* @returns {State<T>} taken after the given input
*/
tt(input, next, flags, groups) {
groups = groups || State.groups;
const state = this;
if (next && next.j) {
state.j[input] = next;
return next;
}
const t = next;
let nextState, templateState = state.go(input);
if (templateState) {
nextState = new State();
Object.assign(nextState.j, templateState.j);
nextState.jr.push.apply(nextState.jr, templateState.jr);
nextState.jd = templateState.jd;
nextState.t = templateState.t;
} else {
nextState = new State();
}
if (t) {
if (groups) {
if (nextState.t && typeof nextState.t === "string") {
const allFlags = Object.assign(flagsForToken(nextState.t, groups), flags);
addToGroups(t, allFlags, groups);
} else if (flags) {
addToGroups(t, flags, groups);
}
}
nextState.t = t;
}
state.j[input] = nextState;
return nextState;
}
};
var ta = (state, input, next, flags, groups) => state.ta(input, next, flags, groups);
var tr = (state, regexp, next, flags, groups) => state.tr(regexp, next, flags, groups);
var ts = (state, input, next, flags, groups) => state.ts(input, next, flags, groups);
var tt = (state, input, next, flags, groups) => state.tt(input, next, flags, groups);
var WORD = "WORD";
var UWORD = "UWORD";
var ASCIINUMERICAL = "ASCIINUMERICAL";
var ALPHANUMERICAL = "ALPHANUMERICAL";
var LOCALHOST = "LOCALHOST";
var TLD = "TLD";
var UTLD = "UTLD";
var SCHEME = "SCHEME";
var SLASH_SCHEME = "SLASH_SCHEME";
var NUM = "NUM";
var WS = "WS";
var NL = "NL";
var OPENBRACE = "OPENBRACE";
var CLOSEBRACE = "CLOSEBRACE";
var OPENBRACKET = "OPENBRACKET";
var CLOSEBRACKET = "CLOSEBRACKET";
var OPENPAREN = "OPENPAREN";
var CLOSEPAREN = "CLOSEPAREN";
var OPENANGLEBRACKET = "OPENANGLEBRACKET";
var CLOSEANGLEBRACKET = "CLOSEANGLEBRACKET";
var FULLWIDTHLEFTPAREN = "FULLWIDTHLEFTPAREN";
var FULLWIDTHRIGHTPAREN = "FULLWIDTHRIGHTPAREN";
var LEFTCORNERBRACKET = "LEFTCORNERBRACKET";
var RIGHTCORNERBRACKET = "RIGHTCORNERBRACKET";
var LEFTWHITECORNERBRACKET = "LEFTWHITECORNERBRACKET";
var RIGHTWHITECORNERBRACKET = "RIGHTWHITECORNERBRACKET";
var FULLWIDTHLESSTHAN = "FULLWIDTHLESSTHAN";
var FULLWIDTHGREATERTHAN = "FULLWIDTHGREATERTHAN";
var AMPERSAND = "AMPERSAND";
var APOSTROPHE = "APOSTROPHE";
var ASTERISK = "ASTERISK";
var AT = "AT";
var BACKSLASH = "BACKSLASH";
var BACKTICK = "BACKTICK";
var CARET = "CARET";
var COLON = "COLON";
var COMMA = "COMMA";
var DOLLAR = "DOLLAR";
var DOT = "DOT";
var EQUALS = "EQUALS";
var EXCLAMATION = "EXCLAMATION";
var HYPHEN = "HYPHEN";
var PERCENT = "PERCENT";
var PIPE = "PIPE";
var PLUS = "PLUS";
var POUND = "POUND";
var QUERY = "QUERY";
var QUOTE = "QUOTE";
var FULLWIDTHMIDDLEDOT = "FULLWIDTHMIDDLEDOT";
var SEMI = "SEMI";
var SLASH = "SLASH";
var TILDE = "TILDE";
var UNDERSCORE = "UNDERSCORE";
var EMOJI$1 = "EMOJI";
var SYM = "SYM";
var tk = /* @__PURE__ */ Object.freeze({
__proto__: null,
ALPHANUMERICAL,
AMPERSAND,
APOSTROPHE,
ASCIINUMERICAL,
ASTERISK,
AT,
BACKSLASH,
BACKTICK,
CARET,
CLOSEANGLEBRACKET,
CLOSEBRACE,
CLOSEBRACKET,
CLOSEPAREN,
COLON,
COMMA,
DOLLAR,
DOT,
EMOJI: EMOJI$1,
EQUALS,
EXCLAMATION,
FULLWIDTHGREATERTHAN,
FULLWIDTHLEFTPAREN,
FULLWIDTHLESSTHAN,
FULLWIDTHMIDDLEDOT,
FULLWIDTHRIGHTPAREN,
HYPHEN,
LEFTCORNERBRACKET,
LEFTWHITECORNERBRACKET,
LOCALHOST,
NL,
NUM,
OPENANGLEBRACKET,
OPENBRACE,
OPENBRACKET,
OPENPAREN,
PERCENT,
PIPE,
PLUS,
POUND,
QUERY,
QUOTE,
RIGHTCORNERBRACKET,
RIGHTWHITECORNERBRACKET,
SCHEME,
SEMI,
SLASH,
SLASH_SCHEME,
SYM,
TILDE,
TLD,
UNDERSCORE,
UTLD,
UWORD,
WORD,
WS
});
var ASCII_LETTER = /[a-z]/;
var LETTER = /\p{L}/u;
var EMOJI = /\p{Emoji}/u;
var DIGIT = /\d/;
var SPACE = /\s/;
var CR = "\r";
var LF = "\n";
var EMOJI_VARIATION = "\uFE0F";
var EMOJI_JOINER = "\u200D";
var OBJECT_REPLACEMENT = "\uFFFC";
var tlds = null;
var utlds = null;
function init$2(customSchemes = []) {
const groups = {};
State.groups = groups;
const Start = new State();
if (tlds == null) {
tlds = decodeTlds(encodedTlds);
}
if (utlds == null) {
utlds = decodeTlds(encodedUtlds);
}
tt(Start, "'", APOSTROPHE);
tt(Start, "{", OPENBRACE);
tt(Start, "}", CLOSEBRACE);
tt(Start, "[", OPENBRACKET);
tt(Start, "]", CLOSEBRACKET);
tt(Start, "(", OPENPAREN);
tt(Start, ")", CLOSEPAREN);
tt(Start, "<", OPENANGLEBRACKET);
tt(Start, ">", CLOSEANGLEBRACKET);
tt(Start, "\uFF08", FULLWIDTHLEFTPAREN);
tt(Start, "\uFF09", FULLWIDTHRIGHTPAREN);
tt(Start, "\u300C", LEFTCORNERBRACKET);
tt(Start, "\u300D", RIGHTCORNERBRACKET);
tt(Start, "\u300E", LEFTWHITECORNERBRACKET);
tt(Start, "\u300F", RIGHTWHITECORNERBRACKET);
tt(Start, "\uFF1C", FULLWIDTHLESSTHAN);
tt(Start, "\uFF1E", FULLWIDTHGREATERTHAN);
tt(Start, "&", AMPERSAND);
tt(Start, "*", ASTERISK);
tt(Start, "@", AT);
tt(Start, "`", BACKTICK);
tt(Start, "^", CARET);
tt(Start, ":", COLON);
tt(Start, ",", COMMA);
tt(Start, "$", DOLLAR);
tt(Start, ".", DOT);
tt(Start, "=", EQUALS);
tt(Start, "!", EXCLAMATION);
tt(Start, "-", HYPHEN);
tt(Start, "%", PERCENT);
tt(Start, "|", PIPE);
tt(Start, "+", PLUS);
tt(Start, "#", POUND);
tt(Start, "?", QUERY);
tt(Start, '"', QUOTE);
tt(Start, "/", SLASH);
tt(Start, ";", SEMI);
tt(Start, "~", TILDE);
tt(Start, "_", UNDERSCORE);
tt(Start, "\\", BACKSLASH);
tt(Start, "\u30FB", FULLWIDTHMIDDLEDOT);
const Num = tr(Start, DIGIT, NUM, {
[numeric]: true
});
tr(Num, DIGIT, Num);
const Asciinumeric = tr(Num, ASCII_LETTER, ASCIINUMERICAL, {
[asciinumeric]: true
});
const Alphanumeric = tr(Num, LETTER, ALPHANUMERICAL, {
[alphanumeric]: true
});
const Word = tr(Start, ASCII_LETTER, WORD, {
[ascii]: true
});
tr(Word, DIGIT, Asciinumeric);
tr(Word, ASCII_LETTER, Word);
tr(Asciinumeric, DIGIT, Asciinumeric);
tr(Asciinumeric, ASCII_LETTER, Asciinumeric);
const UWord = tr(Start, LETTER, UWORD, {
[alpha]: true
});
tr(UWord, ASCII_LETTER);
tr(UWord, DIGIT, Alphanumeric);
tr(UWord, LETTER, UWord);
tr(Alphanumeric, DIGIT, Alphanumeric);
tr(Alphanumeric, ASCII_LETTER);
tr(Alphanumeric, LETTER, Alphanumeric);
const Nl2 = tt(Start, LF, NL, {
[whitespace]: true
});
const Cr = tt(Start, CR, WS, {
[whitespace]: true
});
const Ws = tr(Start, SPACE, WS, {
[whitespace]: true
});
tt(Start, OBJECT_REPLACEMENT, Ws);
tt(Cr, LF, Nl2);
tt(Cr, OBJECT_REPLACEMENT, Ws);
tr(Cr, SPACE, Ws);
tt(Ws, CR);
tt(Ws, LF);
tr(Ws, SPACE, Ws);
tt(Ws, OBJECT_REPLACEMENT, Ws);
const Emoji = tr(Start, EMOJI, EMOJI$1, {
[emoji]: true
});
tt(Emoji, "#");
tr(Emoji, EMOJI, Emoji);
tt(Emoji, EMOJI_VARIATION, Emoji);
const EmojiJoiner = tt(Emoji, EMOJI_JOINER);
tt(EmojiJoiner, "#");
tr(EmojiJoiner, EMOJI, Emoji);
const wordjr = [[ASCII_LETTER, Word], [DIGIT, Asciinumeric]];
const uwordjr = [[ASCII_LETTER, null], [LETTER, UWord], [DIGIT, Alphanumeric]];
for (let i = 0; i < tlds.length; i++) {
fastts(Start, tlds[i], TLD, WORD, wordjr);
}
for (let i = 0; i < utlds.length; i++) {
fastts(Start, utlds[i], UTLD, UWORD, uwordjr);
}
addToGroups(TLD, {
tld: true,
ascii: true
}, groups);
addToGroups(UTLD, {
utld: true,
alpha: true
}, groups);
fastts(Start, "file", SCHEME, WORD, wordjr);
fastts(Start, "mailto", SCHEME, WORD, wordjr);
fastts(Start, "http", SLASH_SCHEME, WORD, wordjr);
fastts(Start, "https", SLASH_SCHEME, WORD, wordjr);
fastts(Start, "ftp", SLASH_SCHEME, WORD, wordjr);
fastts(Start, "ftps", SLASH_SCHEME, WORD, wordjr);
addToGroups(SCHEME, {
scheme: true,
ascii: true
}, groups);
addToGroups(SLASH_SCHEME, {
slashscheme: true,
ascii: true
}, groups);
customSchemes = customSchemes.sort((a, b) => a[0] > b[0] ? 1 : -1);
for (let i = 0; i < customSchemes.length; i++) {
const sch = customSchemes[i][0];
const optionalSlashSlash = customSchemes[i][1];
const flags = optionalSlashSlash ? {
[scheme]: true
} : {
[slashscheme]: true
};
if (sch.indexOf("-") >= 0) {
flags[domain] = true;
} else if (!ASCII_LETTER.test(sch)) {
flags[numeric] = true;
} else if (DIGIT.test(sch)) {
flags[asciinumeric] = true;
} else {
flags[ascii] = true;
}
ts(Start, sch, sch, flags);
}
ts(Start, "localhost", LOCALHOST, {
ascii: true
});
Start.jd = new State(SYM);
return {
start: Start,
tokens: Object.assign({
groups
}, tk)
};
}
function run$1(start, str) {
const iterable = stringToArray(str.replace(/[A-Z]/g, (c) => c.toLowerCase()));
const charCount = iterable.length;
const tokens = [];
let cursor = 0;
let charCursor = 0;
while (charCursor < charCount) {
let state = start;
let nextState = null;
let tokenLength = 0;
let latestAccepting = null;
let sinceAccepts = -1;
let charsSinceAccepts = -1;
while (charCursor < charCount && (nextState = state.go(iterable[charCursor]))) {
state = nextState;
if (state.accepts()) {
sinceAccepts = 0;
charsSinceAccepts = 0;
latestAccepting = state;
} else if (sinceAccepts >= 0) {
sinceAccepts += iterable[charCursor].length;
charsSinceAccepts++;
}
tokenLength += iterable[charCursor].length;
cursor += iterable[charCursor].length;
charCursor++;
}
cursor -= sinceAccepts;
charCursor -= charsSinceAccepts;
tokenLength -= sinceAccepts;
tokens.push({
t: latestAccepting.t,
// token type/name
v: str.slice(cursor - tokenLength, cursor),
// string value
s: cursor - tokenLength,
// start index
e: cursor
// end index (excluding)
});
}
return tokens;
}
function stringToArray(str) {
const result = [];
const len = str.length;
let index = 0;
while (index < len) {
let first = str.charCodeAt(index);
let second;
let char = first < 55296 || first > 56319 || index + 1 === len || (second = str.charCodeAt(index + 1)) < 56320 || second > 57343 ? str[index] : str.slice(index, index + 2);
result.push(char);
index += char.length;
}
return result;
}
function fastts(state, input, t, defaultt, jr) {
let next;
const len = input.length;
for (let i = 0; i < len - 1; i++) {
const char = input[i];
if (state.j[char]) {
next = state.j[char];
} else {
next = new State(defaultt);
next.jr = jr.slice();
state.j[char] = next;
}
state = next;
}
next = new State(t);
next.jr = jr.slice();
state.j[input[len - 1]] = next;
return next;
}
function decodeTlds(encoded) {
const words = [];
const stack = [];
let i = 0;
let digits = "0123456789";
while (i < encoded.length) {
let popDigitCount = 0;
while (digits.indexOf(encoded[i + popDigitCount]) >= 0) {
popDigitCount++;
}
if (popDigitCount > 0) {
words.push(stack.join(""));
for (let popCount = parseInt(encoded.substring(i, i + popDigitCount), 10); popCount > 0; popCount--) {
stack.pop();
}
i += popDigitCount;
} else {
stack.push(encoded[i]);
i++;
}
}
return words;
}
var defaults = {
defaultProtocol: "http",
events: null,
format: noop,
formatHref: noop,
nl2br: false,
tagName: "a",
target: null,
rel: null,
validate: true,
truncate: Infinity,
className: null,
attributes: null,
ignoreTags: [],
render: null
};
function Options(opts, defaultRender = null) {
let o = Object.assign({}, defaults);
if (opts) {
o = Object.assign(o, opts instanceof Options ? opts.o : opts);
}
const ignoredTags = o.ignoreTags;
const uppercaseIgnoredTags = [];
for (let i = 0; i < ignoredTags.length; i++) {
uppercaseIgnoredTags.push(ignoredTags[i].toUpperCase());
}
this.o = o;
if (defaultRender) {
this.defaultRender = defaultRender;
}
this.ignoreTags = uppercaseIgnoredTags;
}
Options.prototype = {
o: defaults,
/**
* @type string[]
*/
ignoreTags: [],
/**
* @param {IntermediateRepresentation} ir
* @returns {any}
*/
defaultRender(ir) {
return ir;
},
/**
* Returns true or false based on whether a token should be displayed as a
* link based on the user options.
* @param {MultiToken} token
* @returns {boolean}
*/
check(token) {
return this.get("validate", token.toString(), token);
},
// Private methods
/**
* Resolve an option's value based on the value of the option and the given
* params. If operator and token are specified and the target option is
* callable, automatically calls the function with the given argument.
* @template {keyof Opts} K
* @param {K} key Name of option to use
* @param {string} [operator] will be passed to the target option if it's a
* function. If not specified, RAW function value gets returned
* @param {MultiToken} [token] The token from linkify.tokenize
* @returns {Opts[K] | any}
*/
get(key, operator, token) {
const isCallable = operator != null;
let option = this.o[key];
if (!option) {
return option;
}
if (typeof option === "object") {
option = token.t in option ? option[token.t] : defaults[key];
if (typeof option === "function" && isCallable) {
option = option(operator, token);
}
} else if (typeof option === "function" && isCallable) {
option = option(operator, token.t, token);
}
return option;
},
/**
* @template {keyof Opts} L
* @param {L} key Name of options object to use
* @param {string} [operator]
* @param {MultiToken} [token]
* @returns {Opts[L] | any}
*/
getObj(key, operator, token) {
let obj = this.o[key];
if (typeof obj === "function" && operator != null) {
obj = obj(operator, token.t, token);
}
return obj;
},
/**
* Convert the given token to a rendered element that may be added to the
* calling-interface's DOM
* @param {MultiToken} token Token to render to an HTML element
* @returns {any} Render result; e.g., HTML string, DOM element, React
* Component, etc.
*/
render(token) {
const ir = token.render(this);
const renderFn = this.get("render", null, token) || this.defaultRender;
return renderFn(ir, token.t, token);
}
};
function noop(val) {
return val;
}
function MultiToken(value, tokens) {
this.t = "token";
this.v = value;
this.tk = tokens;
}
MultiToken.prototype = {
isLink: false,
/**
* Return the string this token represents.
* @return {string}
*/
toString() {
return this.v;
},
/**
* What should the value for this token be in the `href` HTML attribute?
* Returns the `.toString` value by default.
* @param {string} [scheme]
* @return {string}
*/
toHref(scheme2) {
return this.toString();
},
/**
* @param {Options} options Formatting options
* @returns {string}
*/
toFormattedString(options) {
const val = this.toString();
const truncate = options.get("truncate", val, this);
const formatted = options.get("format", val, this);
return truncate && formatted.length > truncate ? formatted.substring(0, truncate) + "\u2026" : formatted;
},
/**
*
* @param {Options} options
* @returns {string}
*/
toFormattedHref(options) {
return options.get("formatHref", this.toHref(options.get("defaultProtocol")), this);
},
/**
* The start index of this token in the original input string
* @returns {number}
*/
startIndex() {
return this.tk[0].s;
},
/**
* The end index of this token in the original input string (up to this
* index but not including it)
* @returns {number}
*/
endIndex() {
return this.tk[this.tk.length - 1].e;
},
/**
Returns an object of relevant values for this token, which includes keys
* type - Kind of token ('url', 'email', etc.)
* value - Original text
* href - The value that should be added to the anchor tag's href
attribute
@method toObject
@param {string} [protocol] `'http'` by default
*/
toObject(protocol = defaults.defaultProtocol) {
return {
type: this.t,
value: this.toString(),
isLink: this.isLink,
href: this.toHref(protocol),
start: this.startIndex(),
end: this.endIndex()
};
},
/**
*
* @param {Options} options Formatting option
*/
toFormattedObject(options) {
return {
type: this.t,
value: this.toFormattedString(options),
isLink: this.isLink,
href: this.toFormattedHref(options),
start: this.startIndex(),
end: this.endIndex()
};
},
/**
* Whether this token should be rendered as a link according to the given options
* @param {Options} options
* @returns {boolean}
*/
validate(options) {
return options.get("validate", this.toString(), this);
},
/**
* Return an object that represents how this link should be rendered.
* @param {Options} options Formattinng options
*/
render(options) {
const token = this;
const href = this.toHref(options.get("defaultProtocol"));
const formattedHref = options.get("formatHref", href, this);
const tagName = options.get("tagName", href, token);
const content = this.toFormattedString(options);
const attributes = {};
const className = options.get("className", href, token);
const target = options.get("target", href, token);
const rel = options.get("rel", href, token);
const attrs = options.getObj("attributes", href, token);
const eventListeners = options.getObj("events", href, token);
attributes.href = formattedHref;
if (className) {
attributes.class = className;
}
if (target) {
attributes.target = target;
}
if (rel) {
attributes.rel = rel;
}
if (attrs) {
Object.assign(attributes, attrs);
}
return {
tagName,
attributes,
content,
eventListeners
};
}
};
function createTokenClass(type, props) {
class Token extends MultiToken {
constructor(value, tokens) {
super(value, tokens);
this.t = type;
}
}
for (const p in props) {
Token.prototype[p] = props[p];
}
Token.t = type;
return Token;
}
var Email = createTokenClass("email", {
isLink: true,
toHref() {
return "mailto:" + this.toString();
}
});
var Text = createTokenClass("text");
var Nl = createTokenClass("nl");
var Url = createTokenClass("url", {
isLink: true,
/**
Lowercases relevant parts of the domain and adds the protocol if
required. Note that this will not escape unsafe HTML characters in the
URL.
@param {string} [scheme] default scheme (e.g., 'https')
@return {string} the full href
*/
toHref(scheme2 = defaults.defaultProtocol) {
return this.hasProtocol() ? this.v : `${scheme2}://${this.v}`;
},
/**
* Check whether this URL token has a protocol
* @return {boolean}
*/
hasProtocol() {
const tokens = this.tk;
return tokens.length >= 2 && tokens[0].t !== LOCALHOST && tokens[1].t === COLON;
}
});
var makeState = (arg) => new State(arg);
function init$1({
groups
}) {
const qsAccepting = groups.domain.concat([AMPERSAND, ASTERISK, AT, BACKSLASH, BACKTICK, CARET, DOLLAR, EQUALS, HYPHEN, NUM, PERCENT, PIPE, PLUS, POUND, SLASH, SYM, TILDE, UNDERSCORE]);
const qsNonAccepting = [APOSTROPHE, COLON, COMMA, DOT, EXCLAMATION, PERCENT, QUERY, QUOTE, SEMI, OPENANGLEBRACKET, CLOSEANGLEBRACKET, OPENBRACE, CLOSEBRACE, CLOSEBRACKET, OPENBRACKET, OPENPAREN, CLOSEPAREN, FULLWIDTHLEFTPAREN, FULLWIDTHRIGHTPAREN, LEFTCORNERBRACKET, RIGHTCORNERBRACKET, LEFTWHITECORNERBRACKET, RIGHTWHITECORNERBRACKET, FULLWIDTHLESSTHAN, FULLWIDTHGREATERTHAN];
const localpartAccepting = [AMPERSAND, APOSTROPHE, ASTERISK, BACKSLASH, BACKTICK, CARET, DOLLAR, EQUALS, HYPHEN, OPENBRACE, CLOSEBRACE, PERCENT, PIPE, PLUS, POUND, QUERY, SLASH, SYM, TILDE, UNDERSCORE];
const Start = makeState();
const Localpart = tt(Start, TILDE);
ta(Localpart, localpartAccepting, Localpart);
ta(Localpart, groups.domain, Localpart);
const Domain = makeState(), Scheme = makeState(), SlashScheme = makeState();
ta(Start, groups.domain, Domain);
ta(Start, groups.scheme, Scheme);
ta(Start, groups.slashscheme, SlashScheme);
ta(Domain, localpartAccepting, Localpart);
ta(Domain, groups.domain, Domain);
const LocalpartAt = tt(Domain, AT);
tt(Localpart, AT, LocalpartAt);
tt(Scheme, AT, LocalpartAt);
tt(SlashScheme, AT, LocalpartAt);
const LocalpartDot = tt(Localpart, DOT);
ta(LocalpartDot, localpartAccepting, Localpart);
ta(LocalpartDot, groups.domain, Localpart);
const EmailDomain = makeState();
ta(LocalpartAt, groups.domain, EmailDomain);
ta(EmailDomain, groups.domain, EmailDomain);
const EmailDomainDot = tt(EmailDomain, DOT);
ta(EmailDomainDot, groups.domain, EmailDomain);
const Email$1 = makeState(Email);
ta(EmailDomainDot, groups.tld, Email$1);
ta(EmailDomainDot, groups.utld, Email$1);
tt(LocalpartAt, LOCALHOST, Email$1);
const EmailDomainHyphen = tt(EmailDomain, HYPHEN);
tt(EmailDomainHyphen, HYPHEN, EmailDomainHyphen);
ta(EmailDomainHyphen, groups.domain, EmailDomain);
ta(Email$1, groups.domain, EmailDomain);
tt(Email$1, DOT, EmailDomainDot);
tt(Email$1, HYPHEN, EmailDomainHyphen);
const EmailColon = tt(Email$1, COLON);
ta(EmailColon, groups.numeric, Email);
const DomainHyphen = tt(Domain, HYPHEN);
const DomainDot = tt(Domain, DOT);
tt(DomainHyphen, HYPHEN, DomainHyphen);
ta(DomainHyphen, groups.domain, Domain);
ta(DomainDot, localpartAccepting, Localpart);
ta(DomainDot, groups.domain, Domain);
const DomainDotTld = makeState(Url);
ta(DomainDot, groups.tld, DomainDotTld);
ta(DomainDot, groups.utld, DomainDotTld);
ta(DomainDotTld, groups.domain, Domain);
ta(DomainDotTld, localpartAccepting, Localpart);
tt(DomainDotTld, DOT, DomainDot);
tt(DomainDotTld, HYPHEN, DomainHyphen);
tt(DomainDotTld, AT, LocalpartAt);
const DomainDotTldColon = tt(DomainDotTld, COLON);
const DomainDotTldColonPort = makeState(Url);
ta(DomainDotTldColon, groups.numeric, DomainDotTldColonPort);
const Url$1 = makeState(Url);
const UrlNonaccept = makeState();
ta(Url$1, qsAccepting, Url$1);
ta(Url$1, qsNonAccepting, UrlNonaccept);
ta(UrlNonaccept, qsAccepting, Url$1);
ta(UrlNonaccept, qsNonAccepting, UrlNonaccept);
tt(DomainDotTld, SLASH, Url$1);
tt(DomainDotTldColonPort, SLASH, Url$1);
const SchemeColon = tt(Scheme, COLON);
const SlashSchemeColon = tt(SlashScheme, COLON);
const SlashSchemeColonSlash = tt(SlashSchemeColon, SLASH);
const UriPrefix = tt(SlashSchemeColonSlash, SLASH);
ta(Scheme, groups.domain, Domain);
tt(Scheme, DOT, DomainDot);
tt(Scheme, HYPHEN, DomainHyphen);
ta(SlashScheme, groups.domain, Domain);
tt(SlashScheme, DOT, DomainDot);
tt(SlashScheme, HYPHEN, DomainHyphen);
ta(SchemeColon, groups.domain, Url$1);
tt(SchemeColon, SLASH, Url$1);
tt(SchemeColon, QUERY, Url$1);
ta(UriPrefix, groups.domain, Url$1);
ta(UriPrefix, qsAccepting, Url$1);
tt(UriPrefix, SLASH, Url$1);
const bracketPairs = [
[OPENBRACE, CLOSEBRACE],
// {}
[OPENBRACKET, CLOSEBRACKET],
// []
[OPENPAREN, CLOSEPAREN],
// ()
[OPENANGLEBRACKET, CLOSEANGLEBRACKET],
// <>
[FULLWIDTHLEFTPAREN, FULLWIDTHRIGHTPAREN],
// （）
[LEFTCORNERBRACKET, RIGHTCORNERBRACKET],
// 「」
[LEFTWHITECORNERBRACKET, RIGHTWHITECORNERBRACKET],
// 『』
[FULLWIDTHLESSTHAN, FULLWIDTHGREATERTHAN]
// ＜＞
];
for (let i = 0; i < bracketPairs.length; i++) {
const [OPEN, CLOSE] = bracketPairs[i];
const UrlOpen = tt(Url$1, OPEN);
tt(UrlNonaccept, OPEN, UrlOpen);
tt(UrlOpen, CLOSE, Url$1);
const UrlOpenQ = makeState(Url);
ta(UrlOpen, qsAccepting, UrlOpenQ);
const UrlOpenSyms = makeState();
ta(UrlOpen, qsNonAccepting);
ta(UrlOpenQ, qsAccepting, UrlOpenQ);
ta(UrlOpenQ, qsNonAccepting, UrlOpenSyms);
ta(UrlOpenSyms, qsAccepting, UrlOpenQ);
ta(UrlOpenSyms, qsNonAccepting, UrlOpenSyms);
tt(UrlOpenQ, CLOSE, Url$1);
tt(UrlOpenSyms, CLOSE, Url$1);
}
tt(Start, LOCALHOST, DomainDotTld);
tt(Start, NL, Nl);
return {
start: Start,
tokens: tk
};
}
function run(start, input, tokens) {
let len = tokens.length;
let cursor = 0;
let multis = [];
let textTokens = [];
while (cursor < len) {
let state = start;
let secondState = null;
let nextState = null;
let multiLength = 0;
let latestAccepting = null;
let sinceAccepts = -1;
while (cursor < len && !(secondState = state.go(tokens[cursor].t))) {
textTokens.push(tokens[cursor++]);
}
while (cursor < len && (nextState = secondState || state.go(tokens[cursor].t))) {
secondState = null;
state = nextState;
if (state.accepts()) {
sinceAccepts = 0;
latestAccepting = state;
} else if (sinceAccepts >= 0) {
sinceAccepts++;
}
cursor++;
multiLength++;
}
if (sinceAccepts < 0) {
cursor -= multiLength;
if (cursor < len) {
textTokens.push(tokens[cursor]);
cursor++;
}
} else {
if (textTokens.length > 0) {
multis.push(initMultiToken(Text, input, textTokens));
textTokens = [];
}
cursor -= sinceAccepts;
multiLength -= sinceAccepts;
const Multi = latestAccepting.t;
const subtokens = tokens.slice(cursor - multiLength, cursor);
multis.push(initMultiToken(Multi, input, subtokens));
}
}
if (textTokens.length > 0) {
multis.push(initMultiToken(Text, input, textTokens));
}
return multis;
}
function initMultiToken(Multi, input, tokens) {
const startIdx = tokens[0].s;
const endIdx = tokens[tokens.length - 1].e;
const value = input.slice(startIdx, endIdx);
return new Multi(value, tokens);
}
var warn = typeof console !== "undefined" && console && console.warn || (() => {
});
var warnAdvice = "until manual call of linkify.init(). Register all schemes and plugins before invoking linkify the first time.";
var INIT = {
scanner: null,
parser: null,
tokenQueue: [],
pluginQueue: [],
customSchemes: [],
initialized: false
};
function reset() {
State.groups = {};
INIT.scanner = null;
INIT.parser = null;
INIT.tokenQueue = [];
INIT.pluginQueue = [];
INIT.customSchemes = [];
INIT.initialized = false;
return INIT;
}
function registerCustomProtocol(scheme2, optionalSlashSlash = false) {
if (INIT.initialized) {
warn(`linkifyjs: already initialized - will not register custom scheme "${scheme2}" ${warnAdvice}`);
}
if (!/^[0-9a-z]+(-[0-9a-z]+)*$/.test(scheme2)) {
throw new Error(`linkifyjs: incorrect scheme format.
1. Must only contain digits, lowercase ASCII letters or "-"
2. Cannot start or end with "-"
3. "-" cannot repeat`);
}
INIT.customSchemes.push([scheme2, optionalSlashSlash]);
}
function init() {
INIT.scanner = init$2(INIT.customSchemes);
for (let i = 0; i < INIT.tokenQueue.length; i++) {
INIT.tokenQueue[i][1]({
scanner: INIT.scanner
});
}
INIT.parser = init$1(INIT.scanner.tokens);
for (let i = 0; i < INIT.pluginQueue.length; i++) {
INIT.pluginQueue[i][1]({
scanner: INIT.scanner,
parser: INIT.parser
});
}
INIT.initialized = true;
return INIT;
}
function tokenize(str) {
if (!INIT.initialized) {
init();
}
return run(INIT.parser.start, str, run$1(INIT.scanner.start, str));
}
tokenize.scan = run$1;
function find(str, type = null, opts = null) {
if (type && typeof type === "object") {
if (opts) {
throw Error(`linkifyjs: Invalid link type ${type}; must be a string`);
}
opts = type;
type = null;
}
const options = new Options(opts);
const tokens = tokenize(str);
const filtered = [];
for (let i = 0; i < tokens.length; i++) {
const token = tokens[i];
if (token.isLink && (!type || token.t === type) && options.check(token)) {
filtered.push(token.toFormattedObject(options));
}
}
return filtered;
}
// node_modules/.pnpm/@tiptap+extension-link@3.4.4_@tiptap+core@3.4.4_@tiptap+pm@3.4.4__@tiptap+pm@3.4.4/node_modules/@tiptap/extension-link/dist/index.js
var UNICODE_WHITESPACE_PATTERN = "[\0- \xA0\u1680\u180E\u2000-\u2029\u205F\u3000]";
var UNICODE_WHITESPACE_REGEX = new RegExp(UNICODE_WHITESPACE_PATTERN);
var UNICODE_WHITESPACE_REGEX_END = new RegExp(`${UNICODE_WHITESPACE_PATTERN}$`);
var UNICODE_WHITESPACE_REGEX_GLOBAL = new RegExp(UNICODE_WHITESPACE_PATTERN, "g");
function isValidLinkStructure(tokens) {
if (tokens.length === 1) {
return tokens[0].isLink;
}
if (tokens.length === 3 && tokens[1].isLink) {
return ["()", "[]"].includes(tokens[0].value + tokens[2].value);
}
return false;
}
function autolink(options) {
return new Plugin({
key: new PluginKey("autolink"),
appendTransaction: (transactions, oldState, newState) => {
const docChanges = transactions.some((transaction) => transaction.docChanged) && !oldState.doc.eq(newState.doc);
const preventAutolink = transactions.some((transaction) => transaction.getMeta("preventAutolink"));
if (!docChanges || preventAutolink) {
return;
}
const { tr: tr2 } = newState;
const transform = combineTransactionSteps(oldState.doc, [...transactions]);
const changes = getChangedRanges(transform);
changes.forEach(({ newRange }) => {
const nodesInChangedRanges = findChildrenInRange(newState.doc, newRange, (node) => node.isTextblock);
let textBlock;
let textBeforeWhitespace;
if (nodesInChangedRanges.length > 1) {
textBlock = nodesInChangedRanges[0];
textBeforeWhitespace = newState.doc.textBetween(
textBlock.pos,
textBlock.pos + textBlock.node.nodeSize,
void 0,
" "
);
} else if (nodesInChangedRanges.length) {
const endText = newState.doc.textBetween(newRange.from, newRange.to, " ", " ");
if (!UNICODE_WHITESPACE_REGEX_END.test(endText)) {
return;
}
textBlock = nodesInChangedRanges[0];
textBeforeWhitespace = newState.doc.textBetween(textBlock.pos, newRange.to, void 0, " ");
}
if (textBlock && textBeforeWhitespace) {
const wordsBeforeWhitespace = textBeforeWhitespace.split(UNICODE_WHITESPACE_REGEX).filter(Boolean);
if (wordsBeforeWhitespace.length <= 0) {
return false;
}
const lastWordBeforeSpace = wordsBeforeWhitespace[wordsBeforeWhitespace.length - 1];
const lastWordAndBlockOffset = textBlock.pos + textBeforeWhitespace.lastIndexOf(lastWordBeforeSpace);
if (!lastWordBeforeSpace) {
return false;
}
const linksBeforeSpace = tokenize(lastWordBeforeSpace).map((t) => t.toObject(options.defaultProtocol));
if (!isValidLinkStructure(linksBeforeSpace)) {
return false;
}
linksBeforeSpace.filter((link) => link.isLink).map((link) => ({
...link,
from: lastWordAndBlockOffset + link.start + 1,
to: lastWordAndBlockOffset + link.end + 1
})).filter((link) => {
if (!newState.schema.marks.code) {
return true;
}
return !newState.doc.rangeHasMark(link.from, link.to, newState.schema.marks.code);
}).filter((link) => options.validate(link.value)).filter((link) => options.shouldAutoLink(link.value)).forEach((link) => {
if (getMarksBetween(link.from, link.to, newState.doc).some((item) => item.mark.type === options.type)) {
return;
}
tr2.addMark(
link.from,
link.to,
options.type.create({
href: link.href
})
);
});
}
});
if (!tr2.steps.length) {
return;
}
return tr2;
}
});
}
function clickHandler(options) {
return new Plugin({
key: new PluginKey("handleClickLink"),
props: {
handleClick: (view, pos, event) => {
var _a, _b;
if (event.button !== 0) {
return false;
}
if (!view.editable) {
return false;
}
let link = null;
if (event.target instanceof HTMLAnchorElement) {
link = event.target;
} else {
let a = event.target;
const els = [];
while (a.nodeName !== "DIV") {
els.push(a);
a = a.parentNode;
}
link = els.find((value) => value.nodeName === "A");
}
if (!link) {
return false;
}
const attrs = getAttributes(view.state, options.type.name);
const href = (_a = link == null ? void 0 : link.href) != null ? _a : attrs.href;
const target = (_b = link == null ? void 0 : link.target) != null ? _b : attrs.target;
if (options.enableClickSelection) {
options.editor.commands.extendMarkRange(options.type.name);
}
if (link && href) {
window.open(href, target);
return true;
}
return false;
}
}
});
}
function pasteHandler(options) {
return new Plugin({
key: new PluginKey("handlePasteLink"),
props: {
handlePaste: (view, event, slice2) => {
const { state } = view;
const { selection } = state;
const { empty } = selection;
if (empty) {
return false;
}
let textContent = "";
slice2.content.forEach((node) => {
textContent += node.textContent;
});
const link = find(textContent, { defaultProtocol: options.defaultProtocol }).find(
(item) => item.isLink && item.value === textContent
);
if (!textContent || !link) {
return false;
}
return options.editor.commands.setMark(options.type, {
href: link.href
});
}
}
});
}
function isAllowedUri(uri, protocols) {
const allowedProtocols = ["http", "https", "ftp", "ftps", "mailto", "tel", "callto", "sms", "cid", "xmpp"];
if (protocols) {
protocols.forEach((protocol) => {
const nextProtocol = typeof protocol === "string" ? protocol : protocol.scheme;
if (nextProtocol) {
allowedProtocols.push(nextProtocol);
}
});
}
return !uri || uri.replace(UNICODE_WHITESPACE_REGEX_GLOBAL, "").match(
new RegExp(
// eslint-disable-next-line no-useless-escape
`^(?:(?:${allowedProtocols.join("|")}):|[^a-z]|[a-z0-9+.-]+(?:[^a-z+.-:]|$))`,
"i"
)
);
}
var Link = Mark.create({
name: "link",
priority: 1e3,
keepOnSplit: false,
exitable: true,
onCreate() {
if (this.options.validate && !this.options.shouldAutoLink) {
this.options.shouldAutoLink = this.options.validate;
console.warn("The `validate` option is deprecated. Rename to the `shouldAutoLink` option instead.");
}
this.options.protocols.forEach((protocol) => {
if (typeof protocol === "string") {
registerCustomProtocol(protocol);
return;
}
registerCustomProtocol(protocol.scheme, protocol.optionalSlashes);
});
},
onDestroy() {
reset();
},
inclusive() {
return this.options.autolink;
},
addOptions() {
return {
openOnClick: true,
enableClickSelection: false,
linkOnPaste: true,
autolink: true,
protocols: [],
defaultProtocol: "http",
HTMLAttributes: {
target: "_blank",
rel: "noopener noreferrer nofollow",
class: null
},
isAllowedUri: (url, ctx) => !!isAllowedUri(url, ctx.protocols),
validate: (url) => !!url,
shouldAutoLink: (url) => !!url
};
},
addAttributes() {
return {
href: {
default: null,
parseHTML(element) {
return element.getAttribute("href");
}
},
target: {
default: this.options.HTMLAttributes.target
},
rel: {
default: this.options.HTMLAttributes.rel
},
class: {
default: this.options.HTMLAttributes.class
}
};
},
parseHTML() {
return [
{
tag: "a[href]",
getAttrs: (dom) => {
const href = dom.getAttribute("href");
if (!href || !this.options.isAllowedUri(href, {
defaultValidate: (url) => !!isAllowedUri(url, this.options.protocols),
protocols: this.options.protocols,
defaultProtocol: this.options.defaultProtocol
})) {
return false;
}
return null;
}
}
];
},
renderHTML({ HTMLAttributes }) {
if (!this.options.isAllowedUri(HTMLAttributes.href, {
defaultValidate: (href) => !!isAllowedUri(href, this.options.protocols),
protocols: this.options.protocols,
defaultProtocol: this.options.defaultProtocol
})) {
return ["a", mergeAttributes(this.options.HTMLAttributes, { ...HTMLAttributes, href: "" }), 0];
}
return ["a", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
},
addCommands() {
return {
setLink: (attributes) => ({ chain }) => {
const { href } = attributes;
if (!this.options.isAllowedUri(href, {
defaultValidate: (url) => !!isAllowedUri(url, this.options.protocols),
protocols: this.options.protocols,
defaultProtocol: this.options.defaultProtocol
})) {
return false;
}
return chain().setMark(this.name, attributes).setMeta("preventAutolink", true).run();
},
toggleLink: (attributes) => ({ chain }) => {
const { href } = attributes || {};
if (href && !this.options.isAllowedUri(href, {
defaultValidate: (url) => !!isAllowedUri(url, this.options.protocols),
protocols: this.options.protocols,
defaultProtocol: this.options.defaultProtocol
})) {
return false;
}
return chain().toggleMark(this.name, attributes, { extendEmptyMarkRange: true }).setMeta("preventAutolink", true).run();
},
unsetLink: () => ({ chain }) => {
return chain().unsetMark(this.name, { extendEmptyMarkRange: true }).setMeta("preventAutolink", true).run();
}
};
},
addPasteRules() {
return [
markPasteRule({
find: (text) => {
const foundLinks = [];
if (text) {
const { protocols, defaultProtocol } = this.options;
const links = find(text).filter(
(item) => item.isLink && this.options.isAllowedUri(item.value, {
defaultValidate: (href) => !!isAllowedUri(href, protocols),
protocols,
defaultProtocol
})
);
if (links.length) {
links.forEach(
(link) => foundLinks.push({
text: link.value,
data: {
href: link.href
},
index: link.start
})
);
}
}
return foundLinks;
},
type: this.type,
getAttributes: (match) => {
var _a;
return {
href: (_a = match.data) == null ? void 0 : _a.href
};
}
})
];
},
addProseMirrorPlugins() {
const plugins = [];
const { protocols, defaultProtocol } = this.options;
if (this.options.autolink) {
plugins.push(
autolink({
type: this.type,
defaultProtocol: this.options.defaultProtocol,
validate: (url) => this.options.isAllowedUri(url, {
defaultValidate: (href) => !!isAllowedUri(href, protocols),
protocols,
defaultProtocol
}),
shouldAutoLink: this.options.shouldAutoLink
})
);
}
if (this.options.openOnClick === true) {
plugins.push(
clickHandler({
type: this.type,
editor: this.editor,
enableClickSelection: this.options.enableClickSelection
})
);
}
if (this.options.linkOnPaste) {
plugins.push(
pasteHandler({
editor: this.editor,
defaultProtocol: this.options.defaultProtocol,
type: this.type
})
);
}
return plugins;
}
});
var index_default3 = Link;
// src/exports/extensions/rhino-starter-kit.ts
var RhinoStarterKit = Extension.create({
name: "rhino-starter-kit",
addProseMirrorPlugins() {
const loadedExtensions = [];
const proseMirrorExtensions = [
// ["firefoxCaretPlugin", FirefoxCaretFixPlugin]
["rhinoPasteEvent", Paste]
];
proseMirrorExtensions.forEach(([string, extension]) => {
const options = this.options[string];
if (options !== false) {
loadedExtensions.push(extension(options));
}
});
return loadedExtensions;
},
addExtensions() {
const loadedExtensions = [];
const extensions = [
["rhinoGallery", Gallery],
["rhinoAttachment", Attachment],
["rhinoStrike", CustomStrike],
["rhinoLink", index_default3],
["rhinoFocus", index_default2],
["rhinoPlaceholder", index_default],
["rhinoBubbleMenu", BubbleMenuExtension],
["rhinoCodemarkPlugin", CodemarkPlugin],
["rhinoSelection", SelectionPlugin]
];
extensions.forEach(([string, extension]) => {
const options = this.options[string];
if (options !== false) {
loadedExtensions.push(extension.configure(options));
if (string === "rhinoAttachment") {
loadedExtensions.push(
PreviewableAttachment.configure(options)
);
}
}
});
return loadedExtensions;
}
});
export {
Link,
Dropcursor,
Gapcursor,
TrailingNode,
UndoRedo,
RhinoStarterKit
};
//# sourceMappingURL=chunk-77OKYKXL.js.map