";
return out;
}
image(href, title, text) {
href = cleanUrl(this.options.sanitize, this.options.baseUrl, href);
if (href === null) {
return text;
}
let out = `
" : ">";
return out;
}
text(text) {
return text;
}
}
class TextRenderer {
strong(text) {
return text;
}
em(text) {
return text;
}
codespan(text) {
return text;
}
del(text) {
return text;
}
html(text) {
return text;
}
text(text) {
return text;
}
link(href, title, text) {
return "" + text;
}
image(href, title, text) {
return "" + text;
}
br() {
return "";
}
}
class Slugger {
constructor() {
this.seen = {};
}
serialize(value) {
return value.toLowerCase().trim().replace(/<[!\/a-z].*?>/ig, "").replace(/[\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,./:;<=>?@[\]^`{|}~]/g, "").replace(/\s/g, "-");
}
getNextSafeSlug(originalSlug, isDryRun) {
let slug = originalSlug;
let occurenceAccumulator = 0;
if (this.seen.hasOwnProperty(slug)) {
occurenceAccumulator = this.seen[originalSlug];
do {
occurenceAccumulator++;
slug = originalSlug + "-" + occurenceAccumulator;
} while (this.seen.hasOwnProperty(slug));
}
if (!isDryRun) {
this.seen[originalSlug] = occurenceAccumulator;
this.seen[slug] = 0;
}
return slug;
}
slug(value, options = {}) {
const slug = this.serialize(value);
return this.getNextSafeSlug(slug, options.dryrun);
}
}
class Parser {
constructor(options) {
this.options = options || defaults;
this.options.renderer = this.options.renderer || new Renderer();
this.renderer = this.options.renderer;
this.renderer.options = this.options;
this.textRenderer = new TextRenderer();
this.slugger = new Slugger();
}
static parse(tokens, options) {
const parser = new Parser(options);
return parser.parse(tokens);
}
static parseInline(tokens, options) {
const parser = new Parser(options);
return parser.parseInline(tokens);
}
parse(tokens, top = true) {
let out = "", i, j, k, l2, l3, row, cell, header, body, token, ordered, start, loose, itemBody, item, checked, task, checkbox, ret;
const l = tokens.length;
for (i = 0; i < l; i++) {
token = tokens[i];
if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {
ret = this.options.extensions.renderers[token.type].call({ parser: this }, token);
if (ret !== false || !["space", "hr", "heading", "code", "table", "blockquote", "list", "html", "paragraph", "text"].includes(token.type)) {
out += ret || "";
continue;
}
}
switch (token.type) {
case "space": {
continue;
}
case "hr": {
out += this.renderer.hr();
continue;
}
case "heading": {
out += this.renderer.heading(this.parseInline(token.tokens), token.depth, unescape(this.parseInline(token.tokens, this.textRenderer)), this.slugger);
continue;
}
case "code": {
out += this.renderer.code(token.text, token.lang, token.escaped);
continue;
}
case "table": {
header = "";
cell = "";
l2 = token.header.length;
for (j = 0; j < l2; j++) {
cell += this.renderer.tablecell(this.parseInline(token.header[j].tokens), { header: true, align: token.align[j] });
}
header += this.renderer.tablerow(cell);
body = "";
l2 = token.rows.length;
for (j = 0; j < l2; j++) {
row = token.rows[j];
cell = "";
l3 = row.length;
for (k = 0; k < l3; k++) {
cell += this.renderer.tablecell(this.parseInline(row[k].tokens), { header: false, align: token.align[k] });
}
body += this.renderer.tablerow(cell);
}
out += this.renderer.table(header, body);
continue;
}
case "blockquote": {
body = this.parse(token.tokens);
out += this.renderer.blockquote(body);
continue;
}
case "list": {
ordered = token.ordered;
start = token.start;
loose = token.loose;
l2 = token.items.length;
body = "";
for (j = 0; j < l2; j++) {
item = token.items[j];
checked = item.checked;
task = item.task;
itemBody = "";
if (item.task) {
checkbox = this.renderer.checkbox(checked);
if (loose) {
if (item.tokens.length > 0 && item.tokens[0].type === "paragraph") {
item.tokens[0].text = checkbox + " " + item.tokens[0].text;
if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type === "text") {
item.tokens[0].tokens[0].text = checkbox + " " + item.tokens[0].tokens[0].text;
}
} else {
item.tokens.unshift({
type: "text",
text: checkbox
});
}
} else {
itemBody += checkbox;
}
}
itemBody += this.parse(item.tokens, loose);
body += this.renderer.listitem(itemBody, task, checked);
}
out += this.renderer.list(body, ordered, start);
continue;
}
case "html": {
out += this.renderer.html(token.text);
continue;
}
case "paragraph": {
out += this.renderer.paragraph(this.parseInline(token.tokens));
continue;
}
case "text": {
body = token.tokens ? this.parseInline(token.tokens) : token.text;
while (i + 1 < l && tokens[i + 1].type === "text") {
token = tokens[++i];
body += "\n" + (token.tokens ? this.parseInline(token.tokens) : token.text);
}
out += top ? this.renderer.paragraph(body) : body;
continue;
}
default: {
const errMsg = 'Token with "' + token.type + '" type was not found.';
if (this.options.silent) {
console.error(errMsg);
return;
} else {
throw new Error(errMsg);
}
}
}
}
return out;
}
parseInline(tokens, renderer) {
renderer = renderer || this.renderer;
let out = "", i, token, ret;
const l = tokens.length;
for (i = 0; i < l; i++) {
token = tokens[i];
if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {
ret = this.options.extensions.renderers[token.type].call({ parser: this }, token);
if (ret !== false || !["escape", "html", "link", "image", "strong", "em", "codespan", "br", "del", "text"].includes(token.type)) {
out += ret || "";
continue;
}
}
switch (token.type) {
case "escape": {
out += renderer.text(token.text);
break;
}
case "html": {
out += renderer.html(token.text);
break;
}
case "link": {
out += renderer.link(token.href, token.title, this.parseInline(token.tokens, renderer));
break;
}
case "image": {
out += renderer.image(token.href, token.title, token.text);
break;
}
case "strong": {
out += renderer.strong(this.parseInline(token.tokens, renderer));
break;
}
case "em": {
out += renderer.em(this.parseInline(token.tokens, renderer));
break;
}
case "codespan": {
out += renderer.codespan(token.text);
break;
}
case "br": {
out += renderer.br();
break;
}
case "del": {
out += renderer.del(this.parseInline(token.tokens, renderer));
break;
}
case "text": {
out += renderer.text(token.text);
break;
}
default: {
const errMsg = 'Token with "' + token.type + '" type was not found.';
if (this.options.silent) {
console.error(errMsg);
return;
} else {
throw new Error(errMsg);
}
}
}
}
return out;
}
}
function marked(src, opt, callback) {
if (typeof src === "undefined" || src === null) {
throw new Error("marked(): input parameter is undefined or null");
}
if (typeof src !== "string") {
throw new Error("marked(): input parameter is of type " + Object.prototype.toString.call(src) + ", string expected");
}
if (typeof opt === "function") {
callback = opt;
opt = null;
}
opt = merge({}, marked.defaults, opt || {});
checkSanitizeDeprecation(opt);
if (callback) {
const highlight = opt.highlight;
let tokens;
try {
tokens = Lexer.lex(src, opt);
} catch (e) {
return callback(e);
}
const done = function(err) {
let out;
if (!err) {
try {
if (opt.walkTokens) {
marked.walkTokens(tokens, opt.walkTokens);
}
out = Parser.parse(tokens, opt);
} catch (e) {
err = e;
}
}
opt.highlight = highlight;
return err ? callback(err) : callback(null, out);
};
if (!highlight || highlight.length < 3) {
return done();
}
delete opt.highlight;
if (!tokens.length)
return done();
let pending = 0;
marked.walkTokens(tokens, function(token) {
if (token.type === "code") {
pending++;
setTimeout(() => {
highlight(token.text, token.lang, function(err, code) {
if (err) {
return done(err);
}
if (code != null && code !== token.text) {
token.text = code;
token.escaped = true;
}
pending--;
if (pending === 0) {
done();
}
});
}, 0);
}
});
if (pending === 0) {
done();
}
return;
}
function onError(e) {
e.message += "\nPlease report this to https://github.com/markedjs/marked.";
if (opt.silent) {
return "An error occurred:
" + escape(e.message + "", true) + "
";
}
throw e;
}
try {
const tokens = Lexer.lex(src, opt);
if (opt.walkTokens) {
if (opt.async) {
return Promise.all(marked.walkTokens(tokens, opt.walkTokens)).then(() => {
return Parser.parse(tokens, opt);
}).catch(onError);
}
marked.walkTokens(tokens, opt.walkTokens);
}
return Parser.parse(tokens, opt);
} catch (e) {
onError(e);
}
}
marked.options = marked.setOptions = function(opt) {
merge(marked.defaults, opt);
changeDefaults(marked.defaults);
return marked;
};
marked.getDefaults = getDefaults;
marked.defaults = defaults;
marked.use = function(...args) {
const extensions = marked.defaults.extensions || { renderers: {}, childTokens: {} };
args.forEach((pack) => {
const opts = merge({}, pack);
opts.async = marked.defaults.async || opts.async;
if (pack.extensions) {
pack.extensions.forEach((ext) => {
if (!ext.name) {
throw new Error("extension name required");
}
if (ext.renderer) {
const prevRenderer = extensions.renderers[ext.name];
if (prevRenderer) {
extensions.renderers[ext.name] = function(...args2) {
let ret = ext.renderer.apply(this, args2);
if (ret === false) {
ret = prevRenderer.apply(this, args2);
}
return ret;
};
} else {
extensions.renderers[ext.name] = ext.renderer;
}
}
if (ext.tokenizer) {
if (!ext.level || ext.level !== "block" && ext.level !== "inline") {
throw new Error("extension level must be 'block' or 'inline'");
}
if (extensions[ext.level]) {
extensions[ext.level].unshift(ext.tokenizer);
} else {
extensions[ext.level] = [ext.tokenizer];
}
if (ext.start) {
if (ext.level === "block") {
if (extensions.startBlock) {
extensions.startBlock.push(ext.start);
} else {
extensions.startBlock = [ext.start];
}
} else if (ext.level === "inline") {
if (extensions.startInline) {
extensions.startInline.push(ext.start);
} else {
extensions.startInline = [ext.start];
}
}
}
}
if (ext.childTokens) {
extensions.childTokens[ext.name] = ext.childTokens;
}
});
opts.extensions = extensions;
}
if (pack.renderer) {
const renderer = marked.defaults.renderer || new Renderer();
for (const prop in pack.renderer) {
const prevRenderer = renderer[prop];
renderer[prop] = (...args2) => {
let ret = pack.renderer[prop].apply(renderer, args2);
if (ret === false) {
ret = prevRenderer.apply(renderer, args2);
}
return ret;
};
}
opts.renderer = renderer;
}
if (pack.tokenizer) {
const tokenizer = marked.defaults.tokenizer || new Tokenizer();
for (const prop in pack.tokenizer) {
const prevTokenizer = tokenizer[prop];
tokenizer[prop] = (...args2) => {
let ret = pack.tokenizer[prop].apply(tokenizer, args2);
if (ret === false) {
ret = prevTokenizer.apply(tokenizer, args2);
}
return ret;
};
}
opts.tokenizer = tokenizer;
}
if (pack.walkTokens) {
const walkTokens = marked.defaults.walkTokens;
opts.walkTokens = function(token) {
let values = [];
values.push(pack.walkTokens.call(this, token));
if (walkTokens) {
values = values.concat(walkTokens.call(this, token));
}
return values;
};
}
marked.setOptions(opts);
});
};
marked.walkTokens = function(tokens, callback) {
let values = [];
for (const token of tokens) {
values = values.concat(callback.call(marked, token));
switch (token.type) {
case "table": {
for (const cell of token.header) {
values = values.concat(marked.walkTokens(cell.tokens, callback));
}
for (const row of token.rows) {
for (const cell of row) {
values = values.concat(marked.walkTokens(cell.tokens, callback));
}
}
break;
}
case "list": {
values = values.concat(marked.walkTokens(token.items, callback));
break;
}
default: {
if (marked.defaults.extensions && marked.defaults.extensions.childTokens && marked.defaults.extensions.childTokens[token.type]) {
marked.defaults.extensions.childTokens[token.type].forEach(function(childTokens) {
values = values.concat(marked.walkTokens(token[childTokens], callback));
});
} else if (token.tokens) {
values = values.concat(marked.walkTokens(token.tokens, callback));
}
}
}
}
return values;
};
marked.parseInline = function(src, opt) {
if (typeof src === "undefined" || src === null) {
throw new Error("marked.parseInline(): input parameter is undefined or null");
}
if (typeof src !== "string") {
throw new Error("marked.parseInline(): input parameter is of type " + Object.prototype.toString.call(src) + ", string expected");
}
opt = merge({}, marked.defaults, opt || {});
checkSanitizeDeprecation(opt);
try {
const tokens = Lexer.lexInline(src, opt);
if (opt.walkTokens) {
marked.walkTokens(tokens, opt.walkTokens);
}
return Parser.parseInline(tokens, opt);
} catch (e) {
e.message += "\nPlease report this to https://github.com/markedjs/marked.";
if (opt.silent) {
return "An error occurred:
" + escape(e.message + "", true) + "
";
}
throw e;
}
};
marked.Parser = Parser;
marked.parser = Parser.parse;
marked.Renderer = Renderer;
marked.TextRenderer = TextRenderer;
marked.Lexer = Lexer;
marked.lexer = Lexer.lex;
marked.Tokenizer = Tokenizer;
marked.Slugger = Slugger;
marked.parse = marked;
Parser.parse;
Lexer.lex;
var toggleSelection = function() {
var selection = document.getSelection();
if (!selection.rangeCount) {
return function() {
};
}
var active = document.activeElement;
var ranges = [];
for (var i = 0; i < selection.rangeCount; i++) {
ranges.push(selection.getRangeAt(i));
}
switch (active.tagName.toUpperCase()) {
case "INPUT":
case "TEXTAREA":
active.blur();
break;
default:
active = null;
break;
}
selection.removeAllRanges();
return function() {
selection.type === "Caret" && selection.removeAllRanges();
if (!selection.rangeCount) {
ranges.forEach(function(range) {
selection.addRange(range);
});
}
active && active.focus();
};
};
var deselectCurrent = toggleSelection;
var clipboardToIE11Formatting = {
"text/plain": "Text",
"text/html": "Url",
"default": "Text"
};
var defaultMessage = "Copy to clipboard: #{key}, Enter";
function format(message) {
var copyKey = (/mac os x/i.test(navigator.userAgent) ? "\u2318" : "Ctrl") + "+C";
return message.replace(/#{\s*key\s*}/g, copyKey);
}
function copy(text, options) {
var debug, message, reselectPrevious, range, selection, mark, success = false;
if (!options) {
options = {};
}
debug = options.debug || false;
try {
reselectPrevious = deselectCurrent();
range = document.createRange();
selection = document.getSelection();
mark = document.createElement("span");
mark.textContent = text;
mark.style.all = "unset";
mark.style.position = "fixed";
mark.style.top = 0;
mark.style.clip = "rect(0, 0, 0, 0)";
mark.style.whiteSpace = "pre";
mark.style.webkitUserSelect = "text";
mark.style.MozUserSelect = "text";
mark.style.msUserSelect = "text";
mark.style.userSelect = "text";
mark.addEventListener("copy", function(e) {
e.stopPropagation();
if (options.format) {
e.preventDefault();
if (typeof e.clipboardData === "undefined") {
debug && console.warn("unable to use e.clipboardData");
debug && console.warn("trying IE specific stuff");
window.clipboardData.clearData();
var format2 = clipboardToIE11Formatting[options.format] || clipboardToIE11Formatting["default"];
window.clipboardData.setData(format2, text);
} else {
e.clipboardData.clearData();
e.clipboardData.setData(options.format, text);
}
}
if (options.onCopy) {
e.preventDefault();
options.onCopy(e.clipboardData);
}
});
document.body.appendChild(mark);
range.selectNodeContents(mark);
selection.addRange(range);
var successful = document.execCommand("copy");
if (!successful) {
throw new Error("copy command was unsuccessful");
}
success = true;
} catch (err) {
debug && console.error("unable to copy using execCommand: ", err);
debug && console.warn("trying IE specific stuff");
try {
window.clipboardData.setData(options.format || "text", text);
options.onCopy && options.onCopy(window.clipboardData);
success = true;
} catch (err2) {
debug && console.error("unable to copy using clipboardData: ", err2);
debug && console.error("falling back to prompt");
message = format("message" in options ? options.message : defaultMessage);
window.prompt(message, text);
}
} finally {
if (selection) {
if (typeof selection.removeRange == "function") {
selection.removeRange(range);
} else {
selection.removeAllRanges();
}
}
if (mark) {
document.body.removeChild(mark);
}
reselectPrevious();
}
return success;
}
var copyToClipboard = copy;
/*! medium-zoom 1.0.8 | MIT License | https://github.com/francoischalifour/medium-zoom */
var _extends = Object.assign || function(target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i];
for (var key in source) {
if (Object.prototype.hasOwnProperty.call(source, key)) {
target[key] = source[key];
}
}
}
return target;
};
var isSupported = function isSupported2(node) {
return node.tagName === "IMG";
};
var isNodeList = function isNodeList2(selector) {
return NodeList.prototype.isPrototypeOf(selector);
};
var isNode = function isNode2(selector) {
return selector && selector.nodeType === 1;
};
var isSvg = function isSvg2(image) {
var source = image.currentSrc || image.src;
return source.substr(-4).toLowerCase() === ".svg";
};
var getImagesFromSelector = function getImagesFromSelector2(selector) {
try {
if (Array.isArray(selector)) {
return selector.filter(isSupported);
}
if (isNodeList(selector)) {
return [].slice.call(selector).filter(isSupported);
}
if (isNode(selector)) {
return [selector].filter(isSupported);
}
if (typeof selector === "string") {
return [].slice.call(document.querySelectorAll(selector)).filter(isSupported);
}
return [];
} catch (err) {
throw new TypeError("The provided selector is invalid.\nExpects a CSS selector, a Node element, a NodeList or an array.\nSee: https://github.com/francoischalifour/medium-zoom");
}
};
var createOverlay = function createOverlay2(background) {
var overlay = document.createElement("div");
overlay.classList.add("medium-zoom-overlay");
overlay.style.background = background;
return overlay;
};
var cloneTarget = function cloneTarget2(template) {
var _template$getBounding = template.getBoundingClientRect(), top = _template$getBounding.top, left = _template$getBounding.left, width = _template$getBounding.width, height = _template$getBounding.height;
var clone = template.cloneNode();
var scrollTop = window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;
var scrollLeft = window.pageXOffset || document.documentElement.scrollLeft || document.body.scrollLeft || 0;
clone.removeAttribute("id");
clone.style.position = "absolute";
clone.style.top = top + scrollTop + "px";
clone.style.left = left + scrollLeft + "px";
clone.style.width = width + "px";
clone.style.height = height + "px";
clone.style.transform = "";
return clone;
};
var createCustomEvent = function createCustomEvent2(type, params) {
var eventParams = _extends({
bubbles: false,
cancelable: false,
detail: void 0
}, params);
if (typeof window.CustomEvent === "function") {
return new CustomEvent(type, eventParams);
}
var customEvent = document.createEvent("CustomEvent");
customEvent.initCustomEvent(type, eventParams.bubbles, eventParams.cancelable, eventParams.detail);
return customEvent;
};
var mediumZoom = function mediumZoom2(selector) {
var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
var Promise2 = window.Promise || function Promise3(fn) {
function noop() {
}
fn(noop, noop);
};
var _handleClick = function _handleClick2(event) {
var target = event.target;
if (target === overlay) {
close();
return;
}
if (images.indexOf(target) === -1) {
return;
}
toggle({ target });
};
var _handleScroll = function _handleScroll2() {
if (isAnimating || !active.original) {
return;
}
var currentScroll = window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;
if (Math.abs(scrollTop - currentScroll) > zoomOptions.scrollOffset) {
setTimeout(close, 150);
}
};
var _handleKeyUp = function _handleKeyUp2(event) {
var key = event.key || event.keyCode;
if (key === "Escape" || key === "Esc" || key === 27) {
close();
}
};
var update = function update2() {
var options2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
var newOptions = options2;
if (options2.background) {
overlay.style.background = options2.background;
}
if (options2.container && options2.container instanceof Object) {
newOptions.container = _extends({}, zoomOptions.container, options2.container);
}
if (options2.template) {
var template = isNode(options2.template) ? options2.template : document.querySelector(options2.template);
newOptions.template = template;
}
zoomOptions = _extends({}, zoomOptions, newOptions);
images.forEach(function(image) {
image.dispatchEvent(createCustomEvent("medium-zoom:update", {
detail: { zoom }
}));
});
return zoom;
};
var clone = function clone2() {
var options2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
return mediumZoom2(_extends({}, zoomOptions, options2));
};
var attach = function attach2() {
for (var _len = arguments.length, selectors = Array(_len), _key = 0; _key < _len; _key++) {
selectors[_key] = arguments[_key];
}
var newImages = selectors.reduce(function(imagesAccumulator, currentSelector) {
return [].concat(imagesAccumulator, getImagesFromSelector(currentSelector));
}, []);
newImages.filter(function(newImage) {
return images.indexOf(newImage) === -1;
}).forEach(function(newImage) {
images.push(newImage);
newImage.classList.add("medium-zoom-image");
});
eventListeners.forEach(function(_ref) {
var type = _ref.type, listener = _ref.listener, options2 = _ref.options;
newImages.forEach(function(image) {
image.addEventListener(type, listener, options2);
});
});
return zoom;
};
var detach = function detach2() {
for (var _len2 = arguments.length, selectors = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
selectors[_key2] = arguments[_key2];
}
if (active.zoomed) {
close();
}
var imagesToDetach = selectors.length > 0 ? selectors.reduce(function(imagesAccumulator, currentSelector) {
return [].concat(imagesAccumulator, getImagesFromSelector(currentSelector));
}, []) : images;
imagesToDetach.forEach(function(image) {
image.classList.remove("medium-zoom-image");
image.dispatchEvent(createCustomEvent("medium-zoom:detach", {
detail: { zoom }
}));
});
images = images.filter(function(image) {
return imagesToDetach.indexOf(image) === -1;
});
return zoom;
};
var on = function on2(type, listener) {
var options2 = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
images.forEach(function(image) {
image.addEventListener("medium-zoom:" + type, listener, options2);
});
eventListeners.push({ type: "medium-zoom:" + type, listener, options: options2 });
return zoom;
};
var off = function off2(type, listener) {
var options2 = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
images.forEach(function(image) {
image.removeEventListener("medium-zoom:" + type, listener, options2);
});
eventListeners = eventListeners.filter(function(eventListener) {
return !(eventListener.type === "medium-zoom:" + type && eventListener.listener.toString() === listener.toString());
});
return zoom;
};
var open = function open2() {
var _ref2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, target = _ref2.target;
var _animate = function _animate2() {
var container = {
width: document.documentElement.clientWidth,
height: document.documentElement.clientHeight,
left: 0,
top: 0,
right: 0,
bottom: 0
};
var viewportWidth = void 0;
var viewportHeight = void 0;
if (zoomOptions.container) {
if (zoomOptions.container instanceof Object) {
container = _extends({}, container, zoomOptions.container);
viewportWidth = container.width - container.left - container.right - zoomOptions.margin * 2;
viewportHeight = container.height - container.top - container.bottom - zoomOptions.margin * 2;
} else {
var zoomContainer = isNode(zoomOptions.container) ? zoomOptions.container : document.querySelector(zoomOptions.container);
var _zoomContainer$getBou = zoomContainer.getBoundingClientRect(), _width = _zoomContainer$getBou.width, _height = _zoomContainer$getBou.height, _left = _zoomContainer$getBou.left, _top = _zoomContainer$getBou.top;
container = _extends({}, container, {
width: _width,
height: _height,
left: _left,
top: _top
});
}
}
viewportWidth = viewportWidth || container.width - zoomOptions.margin * 2;
viewportHeight = viewportHeight || container.height - zoomOptions.margin * 2;
var zoomTarget = active.zoomedHd || active.original;
var naturalWidth = isSvg(zoomTarget) ? viewportWidth : zoomTarget.naturalWidth || viewportWidth;
var naturalHeight = isSvg(zoomTarget) ? viewportHeight : zoomTarget.naturalHeight || viewportHeight;
var _zoomTarget$getBoundi = zoomTarget.getBoundingClientRect(), top = _zoomTarget$getBoundi.top, left = _zoomTarget$getBoundi.left, width = _zoomTarget$getBoundi.width, height = _zoomTarget$getBoundi.height;
var scaleX = Math.min(Math.max(width, naturalWidth), viewportWidth) / width;
var scaleY = Math.min(Math.max(height, naturalHeight), viewportHeight) / height;
var scale = Math.min(scaleX, scaleY);
var translateX = (-left + (viewportWidth - width) / 2 + zoomOptions.margin + container.left) / scale;
var translateY = (-top + (viewportHeight - height) / 2 + zoomOptions.margin + container.top) / scale;
var transform = "scale(" + scale + ") translate3d(" + translateX + "px, " + translateY + "px, 0)";
active.zoomed.style.transform = transform;
if (active.zoomedHd) {
active.zoomedHd.style.transform = transform;
}
};
return new Promise2(function(resolve) {
if (target && images.indexOf(target) === -1) {
resolve(zoom);
return;
}
var _handleOpenEnd = function _handleOpenEnd2() {
isAnimating = false;
active.zoomed.removeEventListener("transitionend", _handleOpenEnd2);
active.original.dispatchEvent(createCustomEvent("medium-zoom:opened", {
detail: { zoom }
}));
resolve(zoom);
};
if (active.zoomed) {
resolve(zoom);
return;
}
if (target) {
active.original = target;
} else if (images.length > 0) {
var _images = images;
active.original = _images[0];
} else {
resolve(zoom);
return;
}
active.original.dispatchEvent(createCustomEvent("medium-zoom:open", {
detail: { zoom }
}));
scrollTop = window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;
isAnimating = true;
active.zoomed = cloneTarget(active.original);
document.body.appendChild(overlay);
if (zoomOptions.template) {
var template = isNode(zoomOptions.template) ? zoomOptions.template : document.querySelector(zoomOptions.template);
active.template = document.createElement("div");
active.template.appendChild(template.content.cloneNode(true));
document.body.appendChild(active.template);
}
if (active.original.parentElement && active.original.parentElement.tagName === "PICTURE" && active.original.currentSrc) {
active.zoomed.src = active.original.currentSrc;
}
document.body.appendChild(active.zoomed);
window.requestAnimationFrame(function() {
document.body.classList.add("medium-zoom--opened");
});
active.original.classList.add("medium-zoom-image--hidden");
active.zoomed.classList.add("medium-zoom-image--opened");
active.zoomed.addEventListener("click", close);
active.zoomed.addEventListener("transitionend", _handleOpenEnd);
if (active.original.getAttribute("data-zoom-src")) {
active.zoomedHd = active.zoomed.cloneNode();
active.zoomedHd.removeAttribute("srcset");
active.zoomedHd.removeAttribute("sizes");
active.zoomedHd.removeAttribute("loading");
active.zoomedHd.src = active.zoomed.getAttribute("data-zoom-src");
active.zoomedHd.onerror = function() {
clearInterval(getZoomTargetSize);
console.warn("Unable to reach the zoom image target " + active.zoomedHd.src);
active.zoomedHd = null;
_animate();
};
var getZoomTargetSize = setInterval(function() {
if (active.zoomedHd.complete) {
clearInterval(getZoomTargetSize);
active.zoomedHd.classList.add("medium-zoom-image--opened");
active.zoomedHd.addEventListener("click", close);
document.body.appendChild(active.zoomedHd);
_animate();
}
}, 10);
} else if (active.original.hasAttribute("srcset")) {
active.zoomedHd = active.zoomed.cloneNode();
active.zoomedHd.removeAttribute("sizes");
active.zoomedHd.removeAttribute("loading");
var loadEventListener = active.zoomedHd.addEventListener("load", function() {
active.zoomedHd.removeEventListener("load", loadEventListener);
active.zoomedHd.classList.add("medium-zoom-image--opened");
active.zoomedHd.addEventListener("click", close);
document.body.appendChild(active.zoomedHd);
_animate();
});
} else {
_animate();
}
});
};
var close = function close2() {
return new Promise2(function(resolve) {
if (isAnimating || !active.original) {
resolve(zoom);
return;
}
var _handleCloseEnd = function _handleCloseEnd2() {
active.original.classList.remove("medium-zoom-image--hidden");
document.body.removeChild(active.zoomed);
if (active.zoomedHd) {
document.body.removeChild(active.zoomedHd);
}
document.body.removeChild(overlay);
active.zoomed.classList.remove("medium-zoom-image--opened");
if (active.template) {
document.body.removeChild(active.template);
}
isAnimating = false;
active.zoomed.removeEventListener("transitionend", _handleCloseEnd2);
active.original.dispatchEvent(createCustomEvent("medium-zoom:closed", {
detail: { zoom }
}));
active.original = null;
active.zoomed = null;
active.zoomedHd = null;
active.template = null;
resolve(zoom);
};
isAnimating = true;
document.body.classList.remove("medium-zoom--opened");
active.zoomed.style.transform = "";
if (active.zoomedHd) {
active.zoomedHd.style.transform = "";
}
if (active.template) {
active.template.style.transition = "opacity 150ms";
active.template.style.opacity = 0;
}
active.original.dispatchEvent(createCustomEvent("medium-zoom:close", {
detail: { zoom }
}));
active.zoomed.addEventListener("transitionend", _handleCloseEnd);
});
};
var toggle = function toggle2() {
var _ref3 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, target = _ref3.target;
if (active.original) {
return close();
}
return open({ target });
};
var getOptions = function getOptions2() {
return zoomOptions;
};
var getImages = function getImages2() {
return images;
};
var getZoomedImage = function getZoomedImage2() {
return active.original;
};
var images = [];
var eventListeners = [];
var isAnimating = false;
var scrollTop = 0;
var zoomOptions = options;
var active = {
original: null,
zoomed: null,
zoomedHd: null,
template: null
};
if (Object.prototype.toString.call(selector) === "[object Object]") {
zoomOptions = selector;
} else if (selector || typeof selector === "string") {
attach(selector);
}
zoomOptions = _extends({
margin: 0,
background: "#fff",
scrollOffset: 40,
container: null,
template: null
}, zoomOptions);
var overlay = createOverlay(zoomOptions.background);
document.addEventListener("click", _handleClick);
document.addEventListener("keyup", _handleKeyUp);
document.addEventListener("scroll", _handleScroll);
window.addEventListener("resize", close);
var zoom = {
open,
close,
toggle,
update,
clone,
attach,
detach,
on,
off,
getOptions,
getImages,
getZoomedImage
};
return zoom;
};
function styleInject(css2, ref2) {
if (ref2 === void 0)
ref2 = {};
var insertAt = ref2.insertAt;
if (!css2 || typeof document === "undefined") {
return;
}
var head = document.head || document.getElementsByTagName("head")[0];
var style2 = document.createElement("style");
style2.type = "text/css";
if (insertAt === "top") {
if (head.firstChild) {
head.insertBefore(style2, head.firstChild);
} else {
head.appendChild(style2);
}
} else {
head.appendChild(style2);
}
if (style2.styleSheet) {
style2.styleSheet.cssText = css2;
} else {
style2.appendChild(document.createTextNode(css2));
}
}
var css = ".medium-zoom-overlay{position:fixed;top:0;right:0;bottom:0;left:0;opacity:0;transition:opacity .3s;will-change:opacity}.medium-zoom--opened .medium-zoom-overlay{cursor:pointer;cursor:zoom-out;opacity:1}.medium-zoom-image{cursor:pointer;cursor:zoom-in;transition:transform .3s cubic-bezier(.2,0,.2,1)!important}.medium-zoom-image--hidden{visibility:hidden}.medium-zoom-image--opened{position:relative;cursor:pointer;cursor:zoom-out;will-change:transform}";
styleInject(css);
var mediumZoom$1 = mediumZoom;
const splitHelp = (textarea) => {
const text = textarea.value;
const prefixStr = text.substring(0, textarea.selectionStart);
const subfixStr = text.substring(textarea.selectionEnd, text.length);
const prefixStrIndexOfLineCode = prefixStr.lastIndexOf("\n");
const prefixStrEndRow = prefixStr.substring(0, prefixStrIndexOfLineCode + 1);
const subfixStrIndexOfLineCode = subfixStr.indexOf("\n");
const subfixStrEndRow = subfixStr.substring(subfixStrIndexOfLineCode === -1 ? subfixStr.length : subfixStrIndexOfLineCode, subfixStr.length);
const prefixSupply = prefixStr.substring(prefixStrIndexOfLineCode + 1, prefixStr.length);
const subfixSupply = subfixStr.substring(0, subfixStrIndexOfLineCode);
return {
prefixStr,
subfixStr,
prefixStrEndRow,
subfixStrEndRow,
prefixSupply,
subfixSupply
};
};
const directive2flag = (direct, selectedText = "", inputArea, params) => {
var _a, _b, _c, _d, _e, _f;
let targetValue = "";
let deviationStart = 0;
let deviationEnd = 0;
let select = false;
let prefixVal;
let subfixVal;
const mermaidTemplate = (_a = configOption.editorConfig) == null ? void 0 : _a.mermaidTemplate;
if (/^h[1-6]{1}$/.test(direct)) {
const pix = direct.replace(/^h(\d)/, (_, num) => {
return new Array(Number(num)).fill("#", 0, num).join("");
});
targetValue = `${pix} ${selectedText}`;
deviationStart = pix.length + 1;
} else if (direct === "prettier") {
const prettier = window.prettier || ((_c = (_b = configOption.editorExtensions) == null ? void 0 : _b.prettier) == null ? void 0 : _c.prettierInstance);
const prettierPlugins = [
((_d = window.prettierPlugins) == null ? void 0 : _d.markdown) || ((_f = (_e = configOption.editorExtensions) == null ? void 0 : _e.prettier) == null ? void 0 : _f.parserMarkdownInstance)
];
if (!prettier || prettierPlugins[0] === void 0) {
bus.emit(params.editorId, "errorCatcher", {
name: "prettier",
message: "prettier is undefined"
});
return inputArea.value;
}
return prettier.format(inputArea.value, {
parser: "markdown",
plugins: prettierPlugins
});
} else {
switch (direct) {
case "bold": {
targetValue = `**${selectedText}**`;
deviationStart = 2;
deviationEnd = -2;
break;
}
case "underline": {
targetValue = `${selectedText}`;
deviationStart = 3;
deviationEnd = -4;
break;
}
case "italic": {
targetValue = `*${selectedText}*`;
deviationStart = 1;
deviationEnd = -1;
break;
}
case "strikeThrough": {
targetValue = `~${selectedText}~`;
deviationStart = 1;
deviationEnd = -1;
break;
}
case "sub": {
targetValue = `${selectedText}`;
deviationStart = 5;
deviationEnd = -6;
break;
}
case "sup": {
targetValue = `${selectedText}`;
deviationStart = 5;
deviationEnd = -6;
break;
}
case "codeRow": {
targetValue = "`" + selectedText + "`";
deviationStart = 1;
deviationEnd = -1;
break;
}
case "quote": {
targetValue = `> ${selectedText}`;
deviationStart = 2;
break;
}
case "orderedList": {
targetValue = `1. ${selectedText}`;
deviationStart = 3;
break;
}
case "unorderedList": {
targetValue = `- ${selectedText}`;
deviationStart = 2;
break;
}
case "task": {
targetValue = `- [ ] ${selectedText}`;
deviationStart = 6;
select = true;
break;
}
case "code": {
const text = params.text || selectedText || "";
const mode = params.mode || "language";
targetValue = `\`\`\`${mode}
${text}
\`\`\`
`;
deviationStart = 3;
deviationEnd = 3 + mode.length - targetValue.length;
select = true;
break;
}
case "table": {
targetValue = "|";
const { selectedShape = { x: 1, y: 1 } } = params;
const { x, y } = selectedShape;
for (let i = 0; i <= y; i++) {
targetValue += " col |";
}
targetValue += "\n|";
for (let i = 0; i <= y; i++) {
targetValue += " - |";
}
for (let row = 0; row <= x; row++) {
targetValue += "\n|";
for (let col = 0; col <= y; col++) {
targetValue += " content |";
}
}
deviationStart = 2;
deviationEnd = 5 - targetValue.length;
select = true;
break;
}
case "link": {
const { desc, url } = params;
targetValue = `[${desc}](${url})`;
break;
}
case "image": {
const { desc, url, urls } = params;
if (urls instanceof Array) {
targetValue = urls.reduce((pVal, url2) => {
return pVal + `
`;
}, "");
} else {
targetValue = `
`;
}
break;
}
case "tab": {
const { tabWidth = 2 } = params;
const retract = new Array(tabWidth).fill(" ").join("");
if (selectedText === "") {
targetValue = retract;
} else if (/\n/.test(selectedText)) {
const { prefixStr, subfixStr, prefixSupply, subfixSupply } = splitHelp(inputArea);
const str2adjust = `${prefixSupply}${selectedText}${subfixSupply}`;
const str2AdjustRows = str2adjust.split("\n");
targetValue = str2AdjustRows.map((strItem) => {
return `${retract}${strItem}`;
}).join("\n");
prefixVal = prefixStr.substring(0, prefixStr.length - prefixSupply.length);
subfixVal = subfixStr.substring(subfixSupply.length, subfixStr.length);
select = true;
deviationStart = tabWidth;
deviationEnd = -prefixSupply.length - subfixSupply.length;
} else {
const mdText = inputArea.value;
const prefixStr = mdText.substring(0, inputArea.selectionStart);
if (/\n$/.test(prefixStr) || prefixStr === "") {
targetValue = `${retract}${selectedText}`;
select = true;
} else {
targetValue = retract;
}
}
break;
}
case "shiftTab": {
const { tabWidth = 2 } = params;
const {
prefixStr,
prefixStrEndRow,
subfixStrEndRow,
prefixSupply,
subfixSupply
} = splitHelp(inputArea);
const normalReg = new RegExp(`^\\s{${tabWidth}}`);
const notMultiRow = (selected = false, row = false) => {
const str2adjust = `${prefixSupply}${selectedText}${subfixSupply}`;
if (normalReg.test(str2adjust)) {
const startPos = prefixStr.length - (row ? 0 : tabWidth);
const endPos = selected ? startPos + selectedText.length - tabWidth : startPos;
setPosition(inputArea, startPos, endPos);
return `${prefixStrEndRow}${str2adjust.replace(normalReg, "")}${subfixStrEndRow}`;
} else if (/^\s/.test(str2adjust)) {
const deletedTabStr = str2adjust.replace(/^\s/, "");
const deletedLength = str2adjust.length - deletedTabStr.length;
const startPos = inputArea.selectionStart - (row ? 0 : deletedLength);
const endPos = selected ? startPos + selectedText.length - deletedLength : startPos;
setPosition(inputArea, startPos, endPos);
return `${prefixStrEndRow}${deletedTabStr}${subfixStrEndRow}`;
} else {
targetValue = selectedText;
}
};
if (selectedText === "") {
const newContent = notMultiRow();
if (newContent) {
return newContent;
}
} else if (/\n/.test(selectedText)) {
const str2adjust = `${prefixSupply}${selectedText}${subfixSupply}`;
const str2AdjustRows = str2adjust.split("\n");
let [firstRowDelNum, totalRowDelNum] = [0, 0];
const str2AdjustRowsMod = str2AdjustRows.map((strItem, index2) => {
if (normalReg.test(strItem)) {
if (index2 === 0) {
firstRowDelNum = tabWidth;
}
totalRowDelNum += tabWidth;
return strItem.replace(normalReg, "");
} else if (/^\s/.test(strItem)) {
const deletedTabStr = strItem.replace(/^\s/, "");
totalRowDelNum += strItem.length - deletedTabStr.length;
return deletedTabStr;
}
return strItem;
}).join("\n");
setPosition(inputArea, inputArea.selectionStart - firstRowDelNum, inputArea.selectionEnd - totalRowDelNum);
return `${prefixStrEndRow}${str2AdjustRowsMod}${subfixStrEndRow}`;
} else {
const newContent = notMultiRow(true, true);
if (newContent) {
return newContent;
}
}
break;
}
case "ctrlC": {
const { prefixSupply, subfixSupply } = splitHelp(inputArea);
if (selectedText === "") {
copyToClipboard(`${prefixSupply}${subfixSupply}`);
} else {
copyToClipboard(selectedText);
}
return inputArea.value;
}
case "ctrlX": {
const {
prefixStrEndRow,
subfixStrEndRow,
prefixStr,
subfixStr,
prefixSupply,
subfixSupply
} = splitHelp(inputArea);
if (selectedText === "") {
copyToClipboard(`${prefixSupply}${subfixSupply}`);
setPosition(inputArea, prefixStrEndRow.length);
return `${prefixStrEndRow}${subfixStrEndRow.replace(/^\n/, "")}`;
} else {
copyToClipboard(selectedText);
setPosition(inputArea, prefixStr.length);
return `${prefixStr}${subfixStr}`;
}
}
case "ctrlD": {
const { prefixStrEndRow, subfixStrEndRow } = splitHelp(inputArea);
setPosition(inputArea, prefixStrEndRow.length);
return `${prefixStrEndRow}${subfixStrEndRow.replace(/^\n/, "")}`;
}
case "flow": {
targetValue = `\`\`\`mermaid
${(mermaidTemplate == null ? void 0 : mermaidTemplate.flow) || "flowchart TD \n Start --> Stop"}
\`\`\`
`;
deviationStart = 2;
break;
}
case "sequence": {
targetValue = `\`\`\`mermaid
${(mermaidTemplate == null ? void 0 : mermaidTemplate.sequence) || "sequenceDiagram\n A->>B: hello!\n B-->>A: hi!\n A-)B: bye!"}
\`\`\`
`;
deviationStart = 2;
break;
}
case "gantt": {
targetValue = `\`\`\`mermaid
${(mermaidTemplate == null ? void 0 : mermaidTemplate.gantt) || "gantt\ntitle A Gantt Diagram\ndateFormat YYYY-MM-DD\nsection Section\nA task :a1, 2014-01-01, 30d\nAnother task :after a1, 20d"}
\`\`\`
`;
deviationStart = 2;
break;
}
case "class": {
targetValue = `\`\`\`mermaid
${(mermaidTemplate == null ? void 0 : mermaidTemplate.class) || "classDiagram\n class Animal\n Vehicle <|-- Car"}
\`\`\`
`;
deviationStart = 2;
break;
}
case "state": {
targetValue = `\`\`\`mermaid
${(mermaidTemplate == null ? void 0 : mermaidTemplate.state) || "stateDiagram-v2\n s1 --> s2"}
\`\`\`
`;
deviationStart = 2;
break;
}
case "pie": {
targetValue = `\`\`\`mermaid
${(mermaidTemplate == null ? void 0 : mermaidTemplate.pie) || 'pie title Pets adopted by volunteers\n "Dogs" : 386\n "Cats" : 85\n "Rats" : 15'}
\`\`\`
`;
deviationStart = 2;
break;
}
case "relationship": {
targetValue = `\`\`\`mermaid
${(mermaidTemplate == null ? void 0 : mermaidTemplate.relationship) || "erDiagram\n CAR ||--o{ NAMED-DRIVER : allows\n PERSON ||--o{ NAMED-DRIVER : is"}
\`\`\`
`;
deviationStart = 2;
break;
}
case "journey": {
targetValue = `\`\`\`mermaid
${(mermaidTemplate == null ? void 0 : mermaidTemplate.journey) || "journey\n title My working day\n section Go to work\n Make tea: 5: Me\n Go upstairs: 3: Me\n Do work: 1: Me, Cat\n section Go home\n Go downstairs: 5: Me\n Sit down: 5: Me"}
\`\`\`
`;
deviationStart = 2;
break;
}
case "katexInline": {
targetValue = "$$";
deviationStart = 1;
deviationEnd = -1;
break;
}
case "katexBlock": {
targetValue = "$$\n\n$$\n";
deviationStart = 1;
deviationEnd = -4;
break;
}
case "universal": {
const { generate } = params;
const insertOptions = generate(selectedText);
targetValue = insertOptions.targetValue;
select = insertOptions.select;
deviationStart = insertOptions.deviationStart;
deviationEnd = insertOptions.deviationEnd;
}
}
}
return insert(inputArea, targetValue, {
deviationStart,
deviationEnd,
select,
prefixVal,
subfixVal
});
};
var kaTexExtensions = {
block(prefix2, katex) {
return {
name: "KaTexBlockExtension",
level: "block",
start: (text) => {
var _a;
return (_a = text.match(/\n\$\$\n/)) == null ? void 0 : _a.index;
},
tokenizer(text) {
if (/^\$\$\n/.test(text) && text.split("$$").length > 2) {
const match = splitKatexValue(text, "$$");
return {
type: "KaTexBlockExtension",
raw: match[0],
text: match[1].trim(),
tokens: []
};
}
},
renderer(token) {
const _katex = katex || typeof window !== "undefined" && window.katex;
if (_katex) {
const html = _katex.renderToString(token.text, {
throwOnError: false,
displayMode: true
});
return `${html}
`;
} else {
return `${token.text}
`;
}
}
};
},
inline(prefix2, katex) {
return {
name: "KaTexInlineExtension",
level: "inline",
start: (text) => {
var _a;
return (_a = text.match(/\$[^\n]*/)) == null ? void 0 : _a.index;
},
tokenizer(text) {
if (/^\$[^\n]*\$/.test(text)) {
const match = splitKatexValue(text);
return {
type: "KaTexInlineExtension",
raw: match[0],
text: match[1].trim(),
tokens: []
};
}
},
renderer(token) {
const _katex = katex || typeof window !== "undefined" && window.katex;
if (_katex) {
const html = _katex.renderToString(token.text, {
throwOnError: false
});
return `${html}`;
} else {
return `${token.text}`;
}
}
};
}
};
const alertTypes = [
"abstract",
"attention",
"bug",
"caution",
"danger",
"error",
"example",
"failure",
"hint",
"info",
"note",
"question",
"quote",
"success",
"tip",
"warning"
];
const startReg = new RegExp(`^!!!\\s+(${alertTypes.join("|")})\\s+(.*)$`);
const endReg = /^!!!\s*$/;
const Alert = {
name: "alert",
level: "block",
start(src) {
var _a;
const index2 = (_a = src.match(new RegExp(`(^|[\\r\\n])!!!\\s+(${alertTypes.join("|")})\\s+(.*)`))) == null ? void 0 : _a.index;
return index2;
},
tokenizer(src) {
const lines = src.split(/\n/);
if (startReg.test(lines[0])) {
const section = { x: -1, y: -1 };
const sections = [];
for (let i = 0, k = lines.length; i < k; i++) {
if (startReg.test(lines[i])) {
section.x = i;
} else if (endReg.test(lines[i])) {
section.y = i;
if (section.x >= 0) {
sections.push(__spreadValues({}, section));
section.x = -1;
section.y = -1;
}
}
}
if (sections.length) {
const section2 = sections[0];
const [_, icon, title] = startReg.exec(lines[section2.x]) || [];
const text = lines.slice(section2.x + 1, section2.y).join("\n");
const raw = lines.slice(section2.x, section2.y + 1).join("\n");
const token = {
type: "alert",
raw,
icon,
title,
text,
titleTokens: [],
tokens: [],
childTokens: ["title", "text"]
};
this.lexer.inlineTokens(token.title, token.titleTokens);
this.lexer.blockTokens(token.text, token.tokens);
return token;
}
}
},
renderer(token) {
const html = `
${this.parser.parseInline(token.titleTokens, null)}
${this.parser.parse(token.tokens)}
`;
return html;
}
};
const useHistory = (props, textAreaRef, completeStatus) => {
var _a, _b;
const previewOnly = inject("previewOnly");
const historyLength = inject("historyLength");
const editorId = inject("editorId");
if (previewOnly) {
return;
}
let saveHistoryId = -1;
const history = {
list: [
{
content: props.value,
startPos: ((_a = textAreaRef.value) == null ? void 0 : _a.selectionStart) || 0,
endPos: ((_b = textAreaRef.value) == null ? void 0 : _b.selectionEnd) || 0
}
],
userUpdated: true,
curr: 0
};
const POSITION_START = [0, 0];
let historyPos = POSITION_START;
const keyZCallback = (curr) => {
var _a2, _b2;
const startPos = ((_a2 = textAreaRef.value) == null ? void 0 : _a2.selectionStart) || 0;
const endPos = ((_b2 = textAreaRef.value) == null ? void 0 : _b2.selectionEnd) || 0;
history.list[history.curr].startPos = startPos;
history.list[history.curr].endPos = endPos;
history.userUpdated = false;
history.curr = curr;
const currHistory = history.list[history.curr];
historyPos = [currHistory.startPos, currHistory.endPos];
props.onChange(currHistory.content);
setPosition(textAreaRef.value, currHistory.startPos, currHistory.endPos).then(() => {
bus.emit(editorId, "selectTextChange");
});
};
const saveHistory = (content) => {
var _a2, _b2;
clearTimeout(saveHistoryId);
const startPos = ((_a2 = textAreaRef.value) == null ? void 0 : _a2.selectionStart) || 0;
const endPos = ((_b2 = textAreaRef.value) == null ? void 0 : _b2.selectionEnd) || 0;
saveHistoryId = setTimeout(() => {
if (history.userUpdated) {
if (history.curr < history.list.length - 1) {
history.list = history.list.slice(0, history.curr + 1);
}
if (history.list.length > historyLength) {
history.list.shift();
}
const lastStep = history.list.pop() || {
startPos: 0,
endPos: 0,
content
};
lastStep.startPos = historyPos[0];
lastStep.endPos = historyPos[1];
historyPos = POSITION_START;
Array.prototype.push.call(history.list, lastStep, {
content,
startPos,
endPos
});
history.curr = history.list.length - 1;
} else {
history.userUpdated = true;
}
}, 150);
};
const saveHistoryPos = (force) => {
var _a2, _b2;
if (historyPos === POSITION_START || force) {
historyPos = [(_a2 = textAreaRef.value) == null ? void 0 : _a2.selectionStart, (_b2 = textAreaRef.value) == null ? void 0 : _b2.selectionEnd];
}
};
watch([toRef(props, "value"), completeStatus], () => {
if (completeStatus.value) {
saveHistory(props.value);
}
});
watch(() => props.value, () => {
bus.emit(editorId, "selectTextChange");
}, {
flush: "post"
});
onMounted(() => {
bus.on(editorId, {
name: "ctrlZ",
callback() {
keyZCallback(history.curr - 1 < 0 ? 0 : history.curr - 1);
}
});
bus.on(editorId, {
name: "ctrlShiftZ",
callback() {
keyZCallback(history.curr + 1 === history.list.length ? history.curr : history.curr + 1);
}
});
bus.on(editorId, {
name: "saveHistoryPos",
callback: saveHistoryPos
});
});
};
const useMarked = (props, mermaidData) => {
var _a, _b, _c;
const {
markedRenderer,
markedExtensions,
markedOptions,
editorExtensions,
editorConfig
} = configOption;
const showCodeRowNumber = inject("showCodeRowNumber");
const editorId = inject("editorId");
const highlightUrl2 = inject("highlight");
const previewOnly = inject("previewOnly");
const highlightIns = (_a = editorExtensions == null ? void 0 : editorExtensions.highlight) == null ? void 0 : _a.instance;
const mermaidIns = (_b = editorExtensions == null ? void 0 : editorExtensions.mermaid) == null ? void 0 : _b.instance;
const katexIns = (_c = editorExtensions == null ? void 0 : editorExtensions.katex) == null ? void 0 : _c.instance;
const katexConf = editorExtensions == null ? void 0 : editorExtensions.katex;
const highlightInited = ref(false);
const katexInited = ref(false);
const heads = ref([]);
let renderer = new marked.Renderer();
marked.use({
extensions: [Alert]
});
const markedCode = renderer.code;
renderer.code = (code, language, isEscaped) => {
if (!props.noMermaid && language === "mermaid") {
const idRand = `${prefix}-mermaid-${Date.now().toString(36)}`;
try {
let svgCode;
if (mermaidIns) {
svgCode = mermaidIns.render(idRand, code);
} else if (typeof window !== "undefined" && window.mermaid) {
svgCode = window.mermaid.render(idRand, code);
} else {
svgCode = `${code}
`;
}
return `${svgCode}
`;
} catch (error) {
return `Error: ${(error == null ? void 0 : error.message) || ""}
`;
}
}
return markedCode.call(renderer, code, language, isEscaped);
};
renderer.image = (href, title, desc) => {
return `${desc || ""}`;
};
renderer.listitem = (text, task) => {
if (task) {
return `${text}`;
}
return `${text}`;
};
const markedheading = renderer.heading;
if (markedRenderer instanceof Function) {
renderer = markedRenderer(renderer);
}
const newHeading = renderer.heading;
const isNewHeading = markedheading !== newHeading;
renderer.heading = (text, level, raw, slugger) => {
heads.value.push({ text: raw, level });
if (isNewHeading) {
return newHeading.call(renderer, text, level, raw, slugger, heads.value.length);
}
const id = props.markedHeadingId(raw, level, heads.value.length);
if (text !== raw) {
return `${text}`;
} else {
return `${raw}`;
}
};
marked.setOptions(__spreadValues({
breaks: true
}, markedOptions));
if (!props.noKatex) {
marked.use({
extensions: [
kaTexExtensions.inline(prefix, katexIns),
kaTexExtensions.block(prefix, katexIns)
]
});
}
if (highlightIns) {
marked.setOptions({
highlight: (code, language) => {
let codeHtml;
const hljsLang = highlightIns.getLanguage(language);
if (language && hljsLang) {
codeHtml = highlightIns.highlight(code, {
language,
ignoreIllegals: true
}).value;
} else {
codeHtml = highlightIns.highlightAuto(code).value;
}
return showCodeRowNumber ? generateCodeRowNumber(codeHtml) : `${codeHtml}`;
}
});
}
if (markedExtensions instanceof Array && markedExtensions.length > 0) {
marked.use({
extensions: markedExtensions
});
}
const html = ref(props.sanitize(marked(props.value || "", { renderer })));
const markHtml = debounce(() => {
heads.value = [];
const _html = props.sanitize(marked(props.value || "", { renderer }));
html.value = _html;
bus.emit(editorId, "buildFinished", _html);
props.onHtmlChanged(_html);
}, (editorConfig == null ? void 0 : editorConfig.renderDelay) !== void 0 ? editorConfig == null ? void 0 : editorConfig.renderDelay : previewOnly ? 0 : 500);
watch([
highlightInited,
toRef(mermaidData, "reRender"),
toRef(mermaidData, "mermaidInited"),
katexInited,
toRef(props, "value")
], markHtml);
const highlightLoad = () => {
marked.setOptions({
highlight: (code, language) => {
let codeHtml;
const hljsLang = window.hljs.getLanguage(language);
if (language && hljsLang) {
codeHtml = window.hljs.highlight(code, {
language,
ignoreIllegals: true
}).value;
} else {
codeHtml = window.hljs.highlightAuto(code).value;
}
return showCodeRowNumber ? generateCodeRowNumber(codeHtml) : `${codeHtml}`;
}
});
highlightInited.value = true;
};
watch(() => heads.value, (list) => {
props.onGetCatalog(list);
bus.emit(editorId, "catalogChanged", list);
});
onMounted(() => {
if (!props.noKatex && !katexIns) {
const katexScript = document.createElement("script");
katexScript.src = (katexConf == null ? void 0 : katexConf.js) || katexUrl.js;
katexScript.onload = () => {
katexInited.value = true;
};
katexScript.id = `${prefix}-katex`;
const katexLink = document.createElement("link");
katexLink.rel = "stylesheet";
katexLink.href = (katexConf == null ? void 0 : katexConf.css) || katexUrl.css;
katexLink.id = `${prefix}-katexCss`;
appendHandler(katexScript, "katex");
appendHandler(katexLink);
}
if (!highlightIns) {
const highlightLink = document.createElement("link");
highlightLink.rel = "stylesheet";
highlightLink.href = highlightUrl2.value.css;
highlightLink.id = `${prefix}-hlCss`;
const highlightScript = document.createElement("script");
highlightScript.src = highlightUrl2.value.js;
highlightScript.onload = highlightLoad;
highlightScript.id = `${prefix}-hljs`;
appendHandler(highlightLink);
appendHandler(highlightScript, "hljs");
}
});
watch(() => highlightUrl2.value.css, (url) => {
updateHandler(`${prefix}-hlCss`, "href", url);
});
onMounted(() => {
bus.on(editorId, {
name: "pushCatalog",
callback() {
bus.emit(editorId, "catalogChanged", heads.value);
}
});
});
return {
html
};
};
const useAutoScroll = (props, html, textAreaRef, previewRef, htmlRef) => {
const previewOnly = inject("previewOnly");
const ult = inject("usedLanguageText");
const editorId = inject("editorId");
let clearScrollAuto = () => {
};
let initScrollAuto = () => {
};
const initCopyEntry = () => {
document.querySelectorAll(`#${editorId}-preview pre`).forEach((pre) => {
var _a, _b;
(_a = pre.querySelector(".copy-button")) == null ? void 0 : _a.remove();
const copyBtnText = ((_b = ult.value.copyCode) == null ? void 0 : _b.text) || "\u590D\u5236\u4EE3\u7801";
const copyButton = document.createElement("span");
copyButton.setAttribute("class", "copy-button");
copyButton.innerText = copyBtnText;
copyButton.addEventListener("click", () => {
var _a2, _b2;
const codeText = pre.querySelector("code").innerText;
const success = copyToClipboard(props.formatCopiedText(codeText));
const succssTip = ((_a2 = ult.value.copyCode) == null ? void 0 : _a2.successTips) || "\u5DF2\u590D\u5236\uFF01";
const failTip = ((_b2 = ult.value.copyCode) == null ? void 0 : _b2.failTips) || "\u5DF2\u590D\u5236\uFF01";
copyButton.innerText = success ? succssTip : failTip;
setTimeout(() => {
copyButton.innerText = copyBtnText;
}, 1500);
});
pre.appendChild(copyButton);
});
};
const htmlChanged = () => {
nextTick(() => {
if (props.setting.preview && !previewOnly && props.scrollAuto) {
clearScrollAuto();
initScrollAuto();
}
initCopyEntry();
});
};
const settingPreviewChanged = (nVal) => {
if (nVal && !previewOnly) {
nextTick(() => {
clearScrollAuto();
[initScrollAuto, clearScrollAuto] = scrollAuto(textAreaRef.value, previewRef.value || htmlRef.value);
initScrollAuto();
});
}
};
watch(() => html.value, htmlChanged);
watch(() => ult.value, initCopyEntry);
watch(() => props.setting.preview, settingPreviewChanged);
watch(() => props.setting.htmlPreview, settingPreviewChanged);
watch(() => props.scrollAuto, (sa) => {
if (sa) {
initScrollAuto();
} else {
clearScrollAuto();
}
});
onMounted(() => {
initCopyEntry();
if (!previewOnly && (previewRef.value || htmlRef.value)) {
[initScrollAuto, clearScrollAuto] = scrollAuto(textAreaRef.value, previewRef.value || htmlRef.value);
}
if (props.scrollAuto) {
initScrollAuto();
}
});
};
const useAutoGenrator = (props, textAreaRef) => {
const previewOnly = inject("previewOnly");
const tabWidth = inject("tabWidth");
const editorId = inject("editorId");
const selectedText = ref("");
onMounted(() => {
var _a;
if (!previewOnly) {
(_a = textAreaRef.value) == null ? void 0 : _a.addEventListener("keypress", (event) => {
var _a2, _b, _c;
if (event.key === "Enter") {
const endPoint = (_a2 = textAreaRef.value) == null ? void 0 : _a2.selectionStart;
const prefixStr = (_b = textAreaRef.value) == null ? void 0 : _b.value.substring(0, endPoint);
const subStr = (_c = textAreaRef.value) == null ? void 0 : _c.value.substring(endPoint);
const lastIndexBR = prefixStr == null ? void 0 : prefixStr.lastIndexOf("\n");
const enterPressRow = prefixStr == null ? void 0 : prefixStr.substring(lastIndexBR + 1, endPoint);
if (/^\d+\.\s|^-\s/.test(enterPressRow)) {
event.cancelBubble = true;
event.preventDefault();
event.stopPropagation();
if (/^(\d+\.|-)\s+(\[[x\s]\]\s+)?$/.test(enterPressRow)) {
const resetPrefixStr = prefixStr == null ? void 0 : prefixStr.replace(/(\d+\.|-)\s+(\[[x\s]\]\s+)?$/, "");
props.onChange(resetPrefixStr + subStr);
setPosition(textAreaRef.value, resetPrefixStr == null ? void 0 : resetPrefixStr.length);
} else if (/^-\s+.+/.test(enterPressRow)) {
const newLine = /^-\s+\[[x\s]\]/.test(enterPressRow) ? "\n- [ ] " : "\n- ";
props.onChange(insert(textAreaRef.value, newLine, {}));
} else {
const lastOrderMatch = enterPressRow == null ? void 0 : enterPressRow.match(/\d+(?=\.)/);
const nextOrder = lastOrderMatch && Number(lastOrderMatch[0]) + 1 || 1;
const newLine = /^\d\.\s+\[[x\s]\]/.test(enterPressRow) ? `
${nextOrder}. [ ] ` : `
${nextOrder}. `;
props.onChange(insert(textAreaRef.value, newLine, {}));
}
}
}
});
bus.on(editorId, {
name: "replace",
callback(direct, params = {}) {
props.onChange(directive2flag(direct, selectedText.value, textAreaRef.value, __spreadProps(__spreadValues({}, params), {
tabWidth,
editorId
})));
}
});
}
});
watch(() => props.value, () => {
selectedText.value = "";
});
bus.on(editorId, {
name: "selectTextChange",
callback() {
selectedText.value = getSelectionText(textAreaRef.value);
}
});
};
const useMermaid = (props) => {
const theme = inject("theme");
const { editorExtensions } = configOption;
const mermaidConf = editorExtensions == null ? void 0 : editorExtensions.mermaid;
const mermaidData = reactive({
reRender: false,
mermaidInited: !!(mermaidConf == null ? void 0 : mermaidConf.instance)
});
const reSetMermaidTheme = () => {
if (!props.noMermaid) {
if (mermaidConf == null ? void 0 : mermaidConf.instance) {
mermaidConf.instance.initialize({
theme: theme.value === "dark" ? "dark" : "default"
});
} else if (window.mermaid) {
window.mermaid.initialize({
theme: theme.value === "dark" ? "dark" : "default"
});
}
mermaidData.reRender = !mermaidData.reRender;
}
};
watch(() => theme.value, reSetMermaidTheme);
let mermaidScript;
onMounted(() => {
if (!props.noMermaid && !(mermaidConf == null ? void 0 : mermaidConf.instance)) {
mermaidScript = document.createElement("script");
mermaidScript.src = (mermaidConf == null ? void 0 : mermaidConf.js) || mermaidUrl;
mermaidScript.onload = () => {
window.mermaid.initialize({
theme: theme.value === "dark" ? "dark" : "default",
logLevel: "Fatal"
});
mermaidData.mermaidInited = true;
};
mermaidScript.id = `${prefix}-mermaid`;
appendHandler(mermaidScript, "mermaid");
} else if (!props.noMermaid) {
reSetMermaidTheme();
}
});
return mermaidData;
};
const usePasteUpload = (props, textAreaRef) => {
const editorId = inject("editorId");
const previewOnly = inject("previewOnly");
const pasteHandler = (e) => {
if (!e.clipboardData) {
return;
}
if (e.clipboardData.files.length > 0) {
const { files } = e.clipboardData;
bus.emit(editorId, "uploadImage", Array.from(files).filter((file) => {
return /image\/.*/.test(file.type);
}));
e.preventDefault();
}
if (props.autoDetectCode && e.clipboardData.types.includes("vscode-editor-data")) {
const vscCoodInfo = JSON.parse(e.clipboardData.getData("vscode-editor-data"));
bus.emit(editorId, "replace", "code", {
mode: vscCoodInfo.mode,
text: e.clipboardData.getData("text/plain")
});
e.preventDefault();
}
};
onMounted(() => {
if (!previewOnly) {
textAreaRef.value.addEventListener("paste", pasteHandler);
}
});
onBeforeUnmount(() => {
if (!previewOnly) {
textAreaRef.value.removeEventListener("paste", pasteHandler);
}
});
};
const userZoom = (props, html) => {
const editorId = inject("editorId");
const zoomHander = debounce(() => {
const imgs = document.querySelectorAll(`#${editorId}-preview img[zoom]`);
if (imgs.length === 0) {
return;
}
mediumZoom$1(imgs, {
background: "#00000073"
});
});
onMounted(zoomHander);
watch([html, toRef(props.setting, "preview")], zoomHander);
};
const useAttach = (textAreaRef) => {
const editorId = inject("editorId");
bus.on(editorId, {
name: TEXTAREA_FOCUS,
callback() {
var _a;
(_a = textAreaRef.value) == null ? void 0 : _a.focus();
}
});
};
const contentProps = () => ({
value: {
type: String,
default: ""
},
onChange: {
type: Function,
default: () => () => {
}
},
setting: {
type: Object,
default: () => ({})
},
onHtmlChanged: {
type: Function,
default: () => () => {
}
},
onGetCatalog: {
type: Function,
default: () => () => {
}
},
markedHeadingId: {
type: Function,
default: () => ""
},
noMermaid: {
type: Boolean,
default: false
},
sanitize: {
type: Function,
default: (html) => html
},
placeholder: {
type: String,
default: ""
},
noKatex: {
type: Boolean,
default: false
},
scrollAuto: {
type: Boolean
},
formatCopiedText: {
type: Function,
default: (text) => text
},
autofocus: {
type: Boolean
},
disabled: {
type: Boolean
},
readonly: {
type: Boolean
},
maxlength: {
type: Number
},
autoDetectCode: {
type: Boolean
}
});
var Content = defineComponent({
name: "MDEditorContent",
props: contentProps(),
setup(props) {
const completeStatus = ref(true);
const previewOnly = inject("previewOnly");
const showCodeRowNumber = inject("showCodeRowNumber");
const previewTheme = inject("previewTheme");
const editorId = inject("editorId");
const textAreaRef = ref();
const previewRef = ref();
const htmlRef = ref();
const mermaidData = useMermaid(props);
const {
html
} = useMarked(props, mermaidData);
useAutoScroll(props, html, textAreaRef, previewRef, htmlRef);
useAutoGenrator(props, textAreaRef);
useHistory(props, textAreaRef, completeStatus);
usePasteUpload(props, textAreaRef);
userZoom(props, html);
useAttach(textAreaRef);
return () => {
const attrs = omit(props, ["formatCopiedText", "markedHeadingId", "noKatex", "noMermaid", "onChange", "onGetCatalog", "onHtmlChanged", "sanitize", "scrollAuto", "setting", "autoDetectCode"]);
return createVNode(Fragment, null, [createVNode("div", {
"class": `${prefix}-content`
}, [!previewOnly && createVNode("div", {
"class": `${prefix}-input-wrapper`
}, [createVNode("textarea", mergeProps(attrs, {
"id": `${editorId}-textarea`,
"ref": textAreaRef,
"onBlur": () => {
bus.emit(editorId, "selectTextChange");
},
"onKeydown": () => {
bus.emit(editorId, "saveHistoryPos", true);
},
"onCompositionstart": () => {
completeStatus.value = false;
},
"onInput": (e) => {
props.onChange(e.target.value);
},
"onCompositionend": () => {
completeStatus.value = true;
},
"class": [props.setting.preview || props.setting.htmlPreview ? "" : "textarea-only"]
}), null)]), props.setting.preview && createVNode("div", {
"id": `${editorId}-preview-wrapper`,
"class": `${prefix}-preview-wrapper`,
"ref": previewRef,
"key": "content-preview-wrapper"
}, [createVNode("article", {
"id": `${editorId}-preview`,
"class": [`${prefix}-preview`, `${previewTheme == null ? void 0 : previewTheme.value}-theme`, showCodeRowNumber && `${prefix}-scrn`],
"innerHTML": html.value
}, null)]), props.setting.htmlPreview && createVNode("div", {
"class": `${prefix}-preview-wrapper`,
"ref": htmlRef,
"key": "html-preview-wrapper"
}, [createVNode("div", {
"class": `${prefix}-html`
}, [html.value])])])]);
};
}
});
var MarkdownTotal = defineComponent({
props: {
modelValue: {
type: String,
default: ""
}
},
setup(props) {
const ult = inject("usedLanguageText");
return () => {
var _a, _b;
return createVNode("div", {
"class": `${prefix}-footer-item`
}, [createVNode("label", {
"class": `${prefix}-footer-label`
}, [`${(_a = ult.value.footer) == null ? void 0 : _a.markdownTotal}:`]), createVNode("span", null, [((_b = props.modelValue) == null ? void 0 : _b.length) || 0])]);
};
}
});
var style$1 = "";
const checkboxProps = () => ({
checked: {
type: Boolean,
default: false
},
onChange: {
type: Function,
default: () => () => {
}
}
});
var Checkbox = defineComponent({
props: checkboxProps(),
setup(props) {
return () => {
return createVNode("div", {
"class": [`${prefix}-checkbox`, props.checked && `${prefix}-checkbox-checked`],
"onClick": () => {
props.onChange(!props.checked);
}
}, null);
};
}
});
const scrollAutoProps = () => ({
scrollAuto: {
type: Boolean
},
onScrollAutoChange: {
type: Function,
default: () => () => {
}
}
});
var ScrollAuto = defineComponent({
props: scrollAutoProps(),
setup(props) {
const ult = inject("usedLanguageText");
return () => {
var _a;
return createVNode("div", {
"class": `${prefix}-footer-item`
}, [createVNode("label", {
"class": `${prefix}-footer-label`,
"onClick": () => {
props.onScrollAutoChange(!props.scrollAuto);
}
}, [(_a = ult.value.footer) == null ? void 0 : _a.scrollAuto]), createVNode(Checkbox, {
"checked": props.scrollAuto,
"onChange": props.onScrollAutoChange
}, null)]);
};
}
});
const footerProps = () => ({
modelValue: {
type: String,
default: ""
},
footers: {
type: Array,
default: []
},
scrollAuto: {
type: Boolean
},
onScrollAutoChange: {
type: Function,
default: () => () => {
}
},
defFooters: {
type: Object
}
});
var Footer = defineComponent({
name: "MDEditorFooter",
props: footerProps(),
setup(props) {
const splitedItems = computed(() => {
const moduleSplitIndex = props.footers.indexOf("=");
const barLeft = moduleSplitIndex === -1 ? props.footers : props.footers.slice(0, moduleSplitIndex);
const barRight = moduleSplitIndex === -1 ? [] : props.footers.slice(moduleSplitIndex, Number.MAX_SAFE_INTEGER);
return [barLeft, barRight];
});
const footerRender = (name) => {
if (allFooter.includes(name)) {
switch (name) {
case "markdownTotal": {
return createVNode(MarkdownTotal, {
"modelValue": props.modelValue
}, null);
}
case "scrollSwitch": {
return createVNode(ScrollAuto, {
"scrollAuto": props.scrollAuto,
"onScrollAutoChange": props.onScrollAutoChange
}, null);
}
}
} else if (props.defFooters instanceof Array) {
return props.defFooters[name] || "";
} else if (props.defFooters && props.defFooters.children instanceof Array) {
return props.defFooters.children[name] || "";
} else {
return "";
}
};
return () => {
const LeftFooter = splitedItems.value[0].map((name) => footerRender(name));
const RightFooter = splitedItems.value[1].map((name) => footerRender(name));
return createVNode("div", {
"class": `${prefix}-footer`
}, [createVNode("div", {
"class": `${prefix}-footer-left`
}, [LeftFooter]), createVNode("div", {
"class": `${prefix}-footer-right`
}, [RightFooter])]);
};
}
});
const catalogLinkProps = () => ({
tocItem: {
type: Object,
default: () => ({})
},
markedHeadingId: {
type: Function,
default: () => () => {
}
},
scrollElement: {
type: [String, Object],
default: ""
},
onClick: {
type: Function,
default: () => () => {
}
},
scrollElementOffsetTop: {
type: Number,
default: 0
}
});
const CatalogLink = defineComponent({
props: catalogLinkProps(),
setup(props) {
return () => {
const {
tocItem,
markedHeadingId: markedHeadingId2,
scrollElement,
onClick,
scrollElementOffsetTop
} = props;
return createVNode("div", {
"class": [`${prefix}-catalog-link`, tocItem.active && `${prefix}-catalog-active`],
"onClick": (e) => {
onClick(e, tocItem);
e.stopPropagation();
const id = markedHeadingId2(tocItem.text, tocItem.level, tocItem.index);
const targetHeadEle = document.getElementById(id);
const scrollContainer = scrollElement instanceof Element ? scrollElement : document.querySelector(scrollElement);
if (targetHeadEle && scrollContainer) {
let par = targetHeadEle.offsetParent;
let offsetTop = targetHeadEle.offsetTop;
if (scrollContainer.contains(par)) {
while (par && scrollContainer != par) {
offsetTop += par == null ? void 0 : par.offsetTop;
par = par == null ? void 0 : par.offsetParent;
}
}
scrollContainer == null ? void 0 : scrollContainer.scrollTo({
top: offsetTop - scrollElementOffsetTop,
behavior: "smooth"
});
}
}
}, [createVNode("span", {
"title": tocItem.text
}, [tocItem.text]), createVNode("div", {
"class": `${prefix}-catalog-wrapper`
}, [tocItem.children && tocItem.children.map((item) => createVNode(CatalogLink, {
"markedHeadingId": markedHeadingId2,
"key": `${tocItem.text}-link-${item.level}-${item.text}`,
"tocItem": item,
"scrollElement": scrollElement,
"onClick": onClick,
"scrollElementOffsetTop": scrollElementOffsetTop
}, null))])]);
};
}
});
var style = "";
const mdCatalogProps = () => ({
editorId: {
type: String
},
class: {
type: String,
default: ""
},
markedHeadingId: {
type: Function,
default: (text) => text
},
scrollElement: {
type: [String, Object]
},
theme: {
type: String,
default: "light"
},
offsetTop: {
type: Number,
default: 20
},
scrollElementOffsetTop: {
type: Number,
default: 0
}
});
const MdCatalog = defineComponent({
name: "MdCatalog",
props: mdCatalogProps(),
emits: ["onClick"],
setup(props, ctx) {
const editorId = props.editorId;
const state = reactive({
list: [],
show: false,
scrollElement: props.scrollElement || `#${editorId}-preview-wrapper`
});
const catalogs = computed(() => {
const tocItems = [];
state.list.forEach(({
text,
level,
active
}, index2) => {
const item = {
level,
text,
index: index2 + 1,
active: !!active
};
if (tocItems.length === 0) {
tocItems.push(item);
} else {
let lastItem = tocItems[tocItems.length - 1];
if (item.level > lastItem.level) {
for (let i = lastItem.level + 1; i <= 6; i++) {
const {
children
} = lastItem;
if (!children) {
lastItem.children = [item];
break;
}
lastItem = children[children.length - 1];
if (item.level <= lastItem.level) {
children.push(item);
break;
}
}
} else {
tocItems.push(item);
}
}
});
return tocItems;
});
onMounted(() => {
bus.on(editorId, {
name: "catalogChanged",
callback: (_list) => {
state.list = _list.map((item, index2) => {
if (index2 === 0) {
return __spreadProps(__spreadValues({}, item), {
active: true
});
}
return __spreadValues({}, item);
});
}
});
bus.emit(editorId, "pushCatalog");
});
onMounted(() => {
var _a;
const scrollElement = state.scrollElement instanceof HTMLElement ? state.scrollElement : document.querySelector(state.scrollElement);
(_a = scrollElement === document.documentElement ? window : scrollElement) == null ? void 0 : _a.addEventListener("scroll", throttle(() => {
if (state.list.length === 0) {
return false;
}
const {
activeHead
} = state.list.reduce((activeData, link, index2) => {
const linkEle = document.getElementById(props.markedHeadingId(link.text, link.level, index2 + 1));
if (linkEle instanceof HTMLElement) {
const relativeTop = getRelativeTop(linkEle, scrollElement);
if (relativeTop < props.offsetTop && relativeTop > activeData.minTop) {
return {
activeHead: link,
minTop: relativeTop
};
}
}
return activeData;
}, {
activeHead: state.list[0],
minTop: Number.MIN_SAFE_INTEGER
});
state.list = state.list.map((item) => {
if (item === activeHead) {
return __spreadProps(__spreadValues({}, item), {
active: true
});
}
return __spreadProps(__spreadValues({}, item), {
active: false
});
});
}));
});
return () => createVNode("div", {
"class": `${prefix}-catalog${props.theme === "dark" ? "-dark" : ""} ${props.class}`
}, [catalogs.value.map((item) => {
return createVNode(CatalogLink, {
"markedHeadingId": props.markedHeadingId,
"tocItem": item,
"key": `link-${item.level}-${item.text}`,
"scrollElement": state.scrollElement,
"onClick": (e, t) => {
ctx.emit("onClick", e, t);
},
"scrollElementOffsetTop": props.scrollElementOffsetTop
}, null);
})]);
}
});
const editorProps = () => ({
modelValue: {
type: String,
default: ""
},
theme: {
type: String,
default: "light"
},
class: {
type: String,
default: ""
},
historyLength: {
type: Number,
default: 10
},
onChange: {
type: Function
},
onSave: {
type: Function
},
onUploadImg: {
type: Function
},
pageFullscreen: {
type: Boolean,
default: false
},
preview: {
type: Boolean,
default: true
},
htmlPreview: {
type: Boolean,
default: false
},
previewOnly: {
type: Boolean,
default: false
},
language: {
type: String,
default: "zh-CN"
},
toolbars: {
type: Array,
default: allToolbar
},
toolbarsExclude: {
type: Array,
default: []
},
noPrettier: {
type: Boolean,
default: false
},
onHtmlChanged: {
type: Function
},
onGetCatalog: {
type: Function
},
editorId: {
type: String,
default: defaultEditorId
},
tabWidth: {
type: Number,
default: 2
},
showCodeRowNumber: {
type: Boolean,
default: false
},
previewTheme: {
type: String,
default: "default"
},
style: {
type: Object,
default: () => ({})
},
markedHeadingId: {
type: Function,
default: markedHeadingId
},
tableShape: {
type: Array,
default: () => [6, 4]
},
noMermaid: {
type: Boolean,
default: false
},
sanitize: {
type: Function,
default: (html) => html
},
placeholder: {
type: String,
default: ""
},
noKatex: {
type: Boolean,
default: false
},
defToolbars: {
type: [String, Object]
},
onError: {
type: Function
},
codeTheme: {
type: String,
default: "atom"
},
footers: {
type: Array,
default: allFooter
},
scrollAuto: {
type: Boolean,
default: true
},
defFooters: {
type: [String, Object]
},
noIconfont: {
type: Boolean
},
formatCopiedText: {
type: Function,
default: (text) => text
},
noUploadImg: {
type: Boolean
},
codeStyleReverse: {
type: Boolean,
default: true
},
codeStyleReverseList: {
type: Array,
default: ["default", "mk-cute"]
},
autoFocus: {
type: Boolean
},
disabled: {
type: Boolean
},
readOnly: {
type: Boolean
},
maxLength: {
type: Number
},
autoDetectCode: {
type: Boolean
}
});
const markedHeadingId = (text) => text;
var index = "";
var alert = "";
var all = "";
const Editor = defineComponent({
name: "MdEditorV3",
props: editorProps(),
emits: ["onChange", "onSave", "onUploadImg", "onHtmlChanged", "onGetCatalog", "onError", "update:modelValue"],
setup(props, context) {
const {
editorId,
previewOnly,
noKatex,
noMermaid,
noPrettier,
noUploadImg
} = props;
const state = reactive({
scrollAuto: props.scrollAuto
});
useKeyBoard(props, context);
useProvide(props);
useExpansion(props);
const [setting, updateSetting] = useConfig(props, context);
const [catalogVisible, catalogShow] = useCatalog(props);
onBeforeUnmount(() => {
bus.clear(editorId);
});
useExpose(props, context, catalogVisible, setting, updateSetting);
return () => {
var _a;
const defToolbars = getSlot({
props,
ctx: context
}, "defToolbars");
const defFooters = getSlot({
props,
ctx: context
}, "defFooters");
return createVNode("div", {
"id": editorId,
"class": [prefix, props.class, props.theme === "dark" && `${prefix}-dark`, setting.fullscreen || setting.pageFullscreen ? `${prefix}-fullscreen` : "", previewOnly && `${prefix}-previewOnly`],
"style": props.style
}, [!previewOnly && createVNode(ToolBar, {
"noPrettier": noPrettier,
"toolbars": props.toolbars,
"toolbarsExclude": props.toolbarsExclude,
"setting": setting,
"updateSetting": updateSetting,
"tableShape": props.tableShape,
"defToolbars": defToolbars,
"noUploadImg": noUploadImg
}, null), createVNode(Content, {
"value": props.modelValue,
"onChange": (value) => {
bus.emit(editorId, "saveHistoryPos");
if (props.onChange) {
props.onChange(value);
} else {
context.emit("update:modelValue", value);
context.emit("onChange", value);
}
},
"setting": setting,
"onHtmlChanged": (html) => {
if (props.onHtmlChanged) {
props.onHtmlChanged(html);
} else {
context.emit("onHtmlChanged", html);
}
},
"onGetCatalog": (list) => {
if (props.onGetCatalog) {
props.onGetCatalog(list);
} else {
context.emit("onGetCatalog", list);
}
},
"markedHeadingId": props.markedHeadingId,
"noMermaid": noMermaid,
"sanitize": props.sanitize,
"placeholder": props.placeholder,
"noKatex": noKatex,
"scrollAuto": state.scrollAuto,
"formatCopiedText": props.formatCopiedText,
"autofocus": props.autoFocus,
"disabled": props.disabled,
"readonly": props.readOnly,
"maxlength": props.maxLength,
"autoDetectCode": props.autoDetectCode
}, null), !previewOnly && ((_a = props.footers) == null ? void 0 : _a.length) > 0 && createVNode(Footer, {
"modelValue": props.modelValue,
"footers": props.footers,
"defFooters": defFooters,
"scrollAuto": state.scrollAuto,
"onScrollAutoChange": (v) => state.scrollAuto = v
}, null), catalogShow.value && !previewOnly && createVNode(MdCatalog, {
"theme": props.theme,
"style": {
display: catalogVisible.value ? "block" : "none"
},
"class": `${prefix}-catalog-editor`,
"editorId": editorId,
"markedHeadingId": props.markedHeadingId
}, null)]);
};
}
});
const normalToolbarProps = () => ({
title: {
type: String,
default: ""
},
trigger: {
type: [String, Object]
},
onClick: {
type: Function
}
});
var NormalToolbar = defineComponent({
name: "NormalToolbar",
props: normalToolbarProps(),
emits: ["onClick"],
setup(props, ctx) {
return () => {
const Trigger = getSlot({
props,
ctx
}, "trigger");
return createVNode("div", {
"class": `${prefix}-toolbar-item`,
"title": props.title,
"onClick": (e) => {
if (props.onClick instanceof Function) {
props.onClick(e);
} else {
ctx.emit("onClick", e);
}
}
}, [Trigger]);
};
}
});
const dropdownToolbarProps = () => ({
title: {
type: String,
default: ""
},
visible: {
type: Boolean
},
trigger: {
type: [String, Object]
},
onChange: {
type: Function
},
overlay: {
type: [String, Object]
}
});
var DropdownToolbar = defineComponent({
name: "DropdownToolbar",
props: dropdownToolbarProps(),
emits: ["onChange"],
setup(props, ctx) {
const editorId = inject("editorId");
return () => {
const Trigger = getSlot({
props,
ctx
}, "trigger");
const Overlay = getSlot({
props,
ctx
}, "overlay");
return createVNode(Dropdown, {
"relative": `#${editorId}-toolbar-wrapper`,
"visible": props.visible,
"onChange": (v) => {
if (props.onChange instanceof Function) {
props.onChange(v);
} else {
ctx.emit("onChange", v);
}
},
"overlay": Overlay
}, {
default: () => [createVNode("div", {
"class": `${prefix}-toolbar-item`,
"title": props.title || ""
}, [Trigger])]
});
};
}
});
function _isSlot(s) {
return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
}
const modalToolbarProps = () => ({
title: {
type: String,
default: ""
},
modalTitle: {
type: String,
default: ""
},
visible: {
type: Boolean
},
width: {
type: String,
default: "auto"
},
height: {
type: String,
default: "auto"
},
trigger: {
type: [String, Object]
},
onClick: {
type: Function
},
onClose: {
type: Function
},
showAdjust: {
type: Boolean,
default: false
},
isFullscreen: {
type: Boolean,
default: false
},
onAdjust: {
type: Function
}
});
var ModalToolbar = defineComponent({
name: "ModalToolbar",
props: modalToolbarProps(),
emits: ["onClick", "onClose", "onAdjust"],
setup(props, ctx) {
return () => {
const Trigger = getSlot({
props,
ctx
}, "trigger");
const Default = getSlot({
props,
ctx
}, "default");
return createVNode(Fragment, null, [createVNode("div", {
"class": `${prefix}-toolbar-item`,
"title": props.title,
"onClick": () => {
if (props.onClick instanceof Function) {
props.onClick();
} else {
ctx.emit("onClick");
}
}
}, [Trigger]), createVNode(Modal, {
"width": props.width,
"height": props.height,
"title": props.modalTitle,
"visible": props.visible,
"onClose": () => {
if (props.onClose instanceof Function) {
props.onClose();
} else {
ctx.emit("onClose");
}
},
"showAdjust": props.showAdjust,
"isFullscreen": props.isFullscreen,
"onAdjust": (v) => {
if (props.onAdjust instanceof Function) {
props.onAdjust(v);
} else {
ctx.emit("onAdjust", v);
}
}
}, _isSlot(Default) ? Default : {
default: () => [Default]
})]);
};
}
});
Editor.install = (app) => {
app.component(Editor.name, Editor);
app.component(NormalToolbar.name, NormalToolbar);
app.component(DropdownToolbar.name, DropdownToolbar);
app.component(MdCatalog.name, MdCatalog);
app.component(ModalToolbar.name, ModalToolbar);
return app;
};
Editor.NormalToolbar = NormalToolbar;
Editor.DropdownToolbar = DropdownToolbar;
Editor.MdCatalog = MdCatalog;
Editor.ModalToolbar = ModalToolbar;
Editor.config = config;
export { Editor as default };