@nextcloud/vue
Version:
Nextcloud vue components
3,721 lines • 114 kB
JavaScript
import '../assets/NcRichText-BTu-LT3p.css';
import { toString } from "mdast-util-to-string";
import rehypeExternalLinks from "rehype-external-links";
import rehype2react from "rehype-react";
import breaks from "remark-breaks";
import remarkParse from "remark-parse";
import remark2rehype from "remark-rehype";
import remarkUnlinkProtocols from "remark-unlink-protocols";
import { unified } from "unified";
import { resolveComponent, openBlock, createElementBlock, normalizeClass, Fragment, renderList, createBlock, createCommentVNode, defineComponent, unref, withCtx, createVNode, ref, h } from "vue";
import { RouterLink } from "vue-router";
import { N as NcCheckboxRadioSwitch } from "./NcCheckboxRadioSwitch-BVTMQSAg.mjs";
import { getCurrentUser } from "@nextcloud/auth";
import axios from "@nextcloud/axios";
import { generateOcsUrl } from "@nextcloud/router";
import { getSharingToken } from "@nextcloud/sharing/public";
import { f as NcReferenceWidget } from "./referencePickerModal-CD1BjLPe.mjs";
import { l as logger } from "./logger-D3RVzcfQ.mjs";
import { U as URL_PATTERN, g as getRoute, N as NcRichTextExternalLink, p as parseUrl, r as remarkAutolink } from "./autolink-B2azbG18.mjs";
import { _ as _export_sfc } from "./_plugin-vue_export-helper-1tPrXgE0.mjs";
import { N as NcButton } from "./NcButton-QbPBynlU.mjs";
import { N as NcIconSvgWrapper } from "./NcIconSvgWrapper-g8ubWhoz.mjs";
import { u as useCopy } from "./useCopy-PckLYUAU.mjs";
import { c as createElementId } from "./createElementId-DhjFt1I9.mjs";
import { u } from "unist-builder";
import { visitParents, EXIT, SKIP } from "unist-util-visit-parents";
const _sfc_main$2 = {
name: "NcReferenceList",
components: {
NcReferenceWidget
},
/* eslint vue/require-prop-comment: warn -- TODO: Add a proper doc block about what this props do */
props: {
text: {
type: String,
default: ""
},
referenceData: {
type: Array,
default: null
},
limit: {
type: Number,
default: 1
},
displayFallback: {
type: Boolean,
default: false
},
interactive: {
type: Boolean,
default: true
},
interactiveOptIn: {
type: Boolean,
default: false
}
},
emits: ["loaded"],
data() {
return {
references: null,
loading: true
};
},
computed: {
isVisible() {
return this.loading || this.displayedReferences.length !== 0;
},
values() {
if (this.referenceData) {
return this.referenceData;
}
if (this.displayFallback && !this.loading && !this.references) {
return [this.fallbackReference];
}
return this.references ? Object.values(this.references) : [];
},
firstReference() {
return this.values[0] ?? null;
},
displayedReferences() {
return this.values.filter(Boolean).slice(0, this.limit);
},
fallbackReference() {
return {
accessible: true,
openGraphObject: {
id: this.text,
link: this.text,
name: this.text
},
richObjectType: "open-graph"
};
}
},
watch: {
text: "fetch"
},
mounted() {
this.fetch();
},
methods: {
fetch() {
this.loading = true;
if (this.referenceData) {
this.references = null;
this.loading = false;
return;
}
if (!new RegExp(URL_PATTERN).exec(this.text)) {
this.references = null;
this.loading = false;
return;
}
this.resolve().then((response) => {
this.references = response.data.ocs.data.references;
this.loading = false;
this.$emit("loaded");
}).catch((error) => {
logger.error("[NcReferenceList] Failed to extract references", { error });
this.loading = false;
this.$emit("loaded");
});
},
resolve() {
const match = new RegExp(URL_PATTERN).exec(this.text.trim());
const isPublic = getCurrentUser() === null;
if (this.limit === 1 && match) {
return isPublic ? axios.get(generateOcsUrl("references/resolvePublic") + `?reference=${encodeURIComponent(match[0])}&sharingToken=${getSharingToken()}`) : axios.get(generateOcsUrl("references/resolve") + `?reference=${encodeURIComponent(match[0])}`);
}
return isPublic ? axios.post(generateOcsUrl("references/extractPublic"), {
text: this.text,
resolve: true,
limit: this.limit,
sharingToken: getSharingToken()
}) : axios.post(generateOcsUrl("references/extract"), {
text: this.text,
resolve: true,
limit: this.limit
});
}
}
};
function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
const _component_NcReferenceWidget = resolveComponent("NcReferenceWidget");
return $options.isVisible ? (openBlock(), createElementBlock("div", {
key: 0,
class: normalizeClass(["widgets--list", { "icon-loading": $data.loading }])
}, [
(openBlock(true), createElementBlock(Fragment, null, renderList($options.displayedReferences, (reference) => {
return openBlock(), createBlock(_component_NcReferenceWidget, {
key: reference.openGraphObject?.id,
reference,
interactive: $props.interactive,
interactiveOptIn: $props.interactiveOptIn
}, null, 8, ["reference", "interactive", "interactiveOptIn"]);
}), 128))
], 2)) : createCommentVNode("", true);
}
const NcReferenceList = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["render", _sfc_render], ["__scopeId", "data-v-9cde5a6a"]]);
function ccount(value, character) {
const source = String(value);
if (typeof character !== "string") {
throw new TypeError("Expected character");
}
let count = 0;
let index = source.indexOf(character);
while (index !== -1) {
count++;
index = source.indexOf(character, index + character.length);
}
return count;
}
function ok$1() {
}
const asciiAlpha = regexCheck(/[A-Za-z]/);
const asciiAlphanumeric = regexCheck(/[\dA-Za-z]/);
function asciiControl(code2) {
return (
// Special whitespace codes (which have negative values), C0 and Control
// character DEL
code2 !== null && (code2 < 32 || code2 === 127)
);
}
function markdownLineEnding(code2) {
return code2 !== null && code2 < -2;
}
function markdownLineEndingOrSpace(code2) {
return code2 !== null && (code2 < 0 || code2 === 32);
}
function markdownSpace(code2) {
return code2 === -2 || code2 === -1 || code2 === 32;
}
const unicodePunctuation = regexCheck(new RegExp("\\p{P}|\\p{S}", "u"));
const unicodeWhitespace = regexCheck(/\s/);
function regexCheck(regex) {
return check;
function check(code2) {
return code2 !== null && code2 > -1 && regex.test(String.fromCharCode(code2));
}
}
function escapeStringRegexp(string) {
if (typeof string !== "string") {
throw new TypeError("Expected a string");
}
return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
}
const convert = (
// Note: overloads in JSDoc can’t yet use different `@template`s.
/**
* @type {(
* (<Condition extends string>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &
* (<Condition extends Props>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &
* (<Condition extends TestFunction>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &
* ((test?: null | undefined) => (node?: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &
* ((test?: Test) => Check)
* )}
*/
/**
* @param {Test} [test]
* @returns {Check}
*/
(function(test) {
if (test === null || test === void 0) {
return ok;
}
if (typeof test === "function") {
return castFactory(test);
}
if (typeof test === "object") {
return Array.isArray(test) ? anyFactory(test) : (
// Cast because `ReadonlyArray` goes into the above but `isArray`
// narrows to `Array`.
propertiesFactory(
/** @type {Props} */
test
)
);
}
if (typeof test === "string") {
return typeFactory(test);
}
throw new Error("Expected function, string, or object as test");
})
);
function anyFactory(tests) {
const checks = [];
let index = -1;
while (++index < tests.length) {
checks[index] = convert(tests[index]);
}
return castFactory(any);
function any(...parameters) {
let index2 = -1;
while (++index2 < checks.length) {
if (checks[index2].apply(this, parameters)) return true;
}
return false;
}
}
function propertiesFactory(check) {
const checkAsRecord = (
/** @type {Record<string, unknown>} */
check
);
return castFactory(all);
function all(node) {
const nodeAsRecord = (
/** @type {Record<string, unknown>} */
/** @type {unknown} */
node
);
let key;
for (key in check) {
if (nodeAsRecord[key] !== checkAsRecord[key]) return false;
}
return true;
}
}
function typeFactory(check) {
return castFactory(type);
function type(node) {
return node && node.type === check;
}
}
function castFactory(testFunction) {
return check;
function check(value, index, parent) {
return Boolean(
looksLikeANode(value) && testFunction.call(
this,
value,
typeof index === "number" ? index : void 0,
parent || void 0
)
);
}
}
function ok() {
return true;
}
function looksLikeANode(value) {
return value !== null && typeof value === "object" && "type" in value;
}
function findAndReplace(tree, list2, options) {
const settings = options || {};
const ignored = convert(settings.ignore || []);
const pairs = toPairs(list2);
let pairIndex = -1;
while (++pairIndex < pairs.length) {
visitParents(tree, "text", visitor);
}
function visitor(node, parents) {
let index = -1;
let grandparent;
while (++index < parents.length) {
const parent = parents[index];
const siblings = grandparent ? grandparent.children : void 0;
if (ignored(
parent,
siblings ? siblings.indexOf(parent) : void 0,
grandparent
)) {
return;
}
grandparent = parent;
}
if (grandparent) {
return handler(node, parents);
}
}
function handler(node, parents) {
const parent = parents[parents.length - 1];
const find = pairs[pairIndex][0];
const replace2 = pairs[pairIndex][1];
let start = 0;
const siblings = parent.children;
const index = siblings.indexOf(node);
let change = false;
let nodes = [];
find.lastIndex = 0;
let match = find.exec(node.value);
while (match) {
const position = match.index;
const matchObject = {
index: match.index,
input: match.input,
stack: [...parents, node]
};
let value = replace2(...match, matchObject);
if (typeof value === "string") {
value = value.length > 0 ? { type: "text", value } : void 0;
}
if (value === false) {
find.lastIndex = position + 1;
} else {
if (start !== position) {
nodes.push({
type: "text",
value: node.value.slice(start, position)
});
}
if (Array.isArray(value)) {
nodes.push(...value);
} else if (value) {
nodes.push(value);
}
start = position + match[0].length;
change = true;
}
if (!find.global) {
break;
}
match = find.exec(node.value);
}
if (change) {
if (start < node.value.length) {
nodes.push({ type: "text", value: node.value.slice(start) });
}
parent.children.splice(index, 1, ...nodes);
} else {
nodes = [node];
}
return index + nodes.length;
}
}
function toPairs(tupleOrList) {
const result = [];
if (!Array.isArray(tupleOrList)) {
throw new TypeError("Expected find and replace tuple or list of tuples");
}
const list2 = !tupleOrList[0] || Array.isArray(tupleOrList[0]) ? tupleOrList : [tupleOrList];
let index = -1;
while (++index < list2.length) {
const tuple = list2[index];
result.push([toExpression(tuple[0]), toFunction(tuple[1])]);
}
return result;
}
function toExpression(find) {
return typeof find === "string" ? new RegExp(escapeStringRegexp(find), "g") : find;
}
function toFunction(replace2) {
return typeof replace2 === "function" ? replace2 : function() {
return replace2;
};
}
const inConstruct = "phrasing";
const notInConstruct = ["autolink", "link", "image", "label"];
function gfmAutolinkLiteralFromMarkdown() {
return {
transforms: [transformGfmAutolinkLiterals],
enter: {
literalAutolink: enterLiteralAutolink,
literalAutolinkEmail: enterLiteralAutolinkValue,
literalAutolinkHttp: enterLiteralAutolinkValue,
literalAutolinkWww: enterLiteralAutolinkValue
},
exit: {
literalAutolink: exitLiteralAutolink,
literalAutolinkEmail: exitLiteralAutolinkEmail,
literalAutolinkHttp: exitLiteralAutolinkHttp,
literalAutolinkWww: exitLiteralAutolinkWww
}
};
}
function gfmAutolinkLiteralToMarkdown() {
return {
unsafe: [
{
character: "@",
before: "[+\\-.\\w]",
after: "[\\-.\\w]",
inConstruct,
notInConstruct
},
{
character: ".",
before: "[Ww]",
after: "[\\-.\\w]",
inConstruct,
notInConstruct
},
{
character: ":",
before: "[ps]",
after: "\\/",
inConstruct,
notInConstruct
}
]
};
}
function enterLiteralAutolink(token) {
this.enter({ type: "link", title: null, url: "", children: [] }, token);
}
function enterLiteralAutolinkValue(token) {
this.config.enter.autolinkProtocol.call(this, token);
}
function exitLiteralAutolinkHttp(token) {
this.config.exit.autolinkProtocol.call(this, token);
}
function exitLiteralAutolinkWww(token) {
this.config.exit.data.call(this, token);
const node = this.stack[this.stack.length - 1];
ok$1(node.type === "link");
node.url = "http://" + this.sliceSerialize(token);
}
function exitLiteralAutolinkEmail(token) {
this.config.exit.autolinkEmail.call(this, token);
}
function exitLiteralAutolink(token) {
this.exit(token);
}
function transformGfmAutolinkLiterals(tree) {
findAndReplace(
tree,
[
[/(https?:\/\/|www(?=\.))([-.\w]+)([^ \t\r\n]*)/gi, findUrl],
[/([-.\w+]+)@([-\w]+(?:\.[-\w]+)+)/g, findEmail]
],
{ ignore: ["link", "linkReference"] }
);
}
function findUrl(_, protocol, domain2, path2, match) {
let prefix = "";
if (!previous(match)) {
return false;
}
if (/^w/i.test(protocol)) {
domain2 = protocol + domain2;
protocol = "";
prefix = "http://";
}
if (!isCorrectDomain(domain2)) {
return false;
}
const parts = splitUrl(domain2 + path2);
if (!parts[0]) return false;
const result = {
type: "link",
title: null,
url: prefix + protocol + parts[0],
children: [{ type: "text", value: protocol + parts[0] }]
};
if (parts[1]) {
return [result, { type: "text", value: parts[1] }];
}
return result;
}
function findEmail(_, atext, label, match) {
if (
// Not an expected previous character.
!previous(match, true) || // Label ends in not allowed character.
/[-\d_]$/.test(label)
) {
return false;
}
return {
type: "link",
title: null,
url: "mailto:" + atext + "@" + label,
children: [{ type: "text", value: atext + "@" + label }]
};
}
function isCorrectDomain(domain2) {
const parts = domain2.split(".");
if (parts.length < 2 || parts[parts.length - 1] && (/_/.test(parts[parts.length - 1]) || !/[a-zA-Z\d]/.test(parts[parts.length - 1])) || parts[parts.length - 2] && (/_/.test(parts[parts.length - 2]) || !/[a-zA-Z\d]/.test(parts[parts.length - 2]))) {
return false;
}
return true;
}
function splitUrl(url) {
const trailExec = /[!"&'),.:;<>?\]}]+$/.exec(url);
if (!trailExec) {
return [url, void 0];
}
url = url.slice(0, trailExec.index);
let trail2 = trailExec[0];
let closingParenIndex = trail2.indexOf(")");
const openingParens = ccount(url, "(");
let closingParens = ccount(url, ")");
while (closingParenIndex !== -1 && openingParens > closingParens) {
url += trail2.slice(0, closingParenIndex + 1);
trail2 = trail2.slice(closingParenIndex + 1);
closingParenIndex = trail2.indexOf(")");
closingParens++;
}
return [url, trail2];
}
function previous(match, email) {
const code2 = match.input.charCodeAt(match.index - 1);
return (match.index === 0 || unicodeWhitespace(code2) || unicodePunctuation(code2)) && (!email || code2 !== 47);
}
function normalizeIdentifier(value) {
return value.replace(/[\t\n\r ]+/g, " ").replace(/^ | $/g, "").toLowerCase().toUpperCase();
}
footnoteReference.peek = footnoteReferencePeek;
function enterFootnoteCallString() {
this.buffer();
}
function enterFootnoteCall(token) {
this.enter({ type: "footnoteReference", identifier: "", label: "" }, token);
}
function enterFootnoteDefinitionLabelString() {
this.buffer();
}
function enterFootnoteDefinition(token) {
this.enter(
{ type: "footnoteDefinition", identifier: "", label: "", children: [] },
token
);
}
function exitFootnoteCallString(token) {
const label = this.resume();
const node = this.stack[this.stack.length - 1];
ok$1(node.type === "footnoteReference");
node.identifier = normalizeIdentifier(
this.sliceSerialize(token)
).toLowerCase();
node.label = label;
}
function exitFootnoteCall(token) {
this.exit(token);
}
function exitFootnoteDefinitionLabelString(token) {
const label = this.resume();
const node = this.stack[this.stack.length - 1];
ok$1(node.type === "footnoteDefinition");
node.identifier = normalizeIdentifier(
this.sliceSerialize(token)
).toLowerCase();
node.label = label;
}
function exitFootnoteDefinition(token) {
this.exit(token);
}
function footnoteReferencePeek() {
return "[";
}
function footnoteReference(node, _, state, info) {
const tracker = state.createTracker(info);
let value = tracker.move("[^");
const exit2 = state.enter("footnoteReference");
const subexit = state.enter("reference");
value += tracker.move(
state.safe(state.associationId(node), { after: "]", before: value })
);
subexit();
exit2();
value += tracker.move("]");
return value;
}
function gfmFootnoteFromMarkdown() {
return {
enter: {
gfmFootnoteCallString: enterFootnoteCallString,
gfmFootnoteCall: enterFootnoteCall,
gfmFootnoteDefinitionLabelString: enterFootnoteDefinitionLabelString,
gfmFootnoteDefinition: enterFootnoteDefinition
},
exit: {
gfmFootnoteCallString: exitFootnoteCallString,
gfmFootnoteCall: exitFootnoteCall,
gfmFootnoteDefinitionLabelString: exitFootnoteDefinitionLabelString,
gfmFootnoteDefinition: exitFootnoteDefinition
}
};
}
function gfmFootnoteToMarkdown(options) {
let firstLineBlank = false;
if (options && options.firstLineBlank) {
firstLineBlank = true;
}
return {
handlers: { footnoteDefinition, footnoteReference },
// This is on by default already.
unsafe: [{ character: "[", inConstruct: ["label", "phrasing", "reference"] }]
};
function footnoteDefinition(node, _, state, info) {
const tracker = state.createTracker(info);
let value = tracker.move("[^");
const exit2 = state.enter("footnoteDefinition");
const subexit = state.enter("label");
value += tracker.move(
state.safe(state.associationId(node), { before: value, after: "]" })
);
subexit();
value += tracker.move("]:");
if (node.children && node.children.length > 0) {
tracker.shift(4);
value += tracker.move(
(firstLineBlank ? "\n" : " ") + state.indentLines(
state.containerFlow(node, tracker.current()),
firstLineBlank ? mapAll : mapExceptFirst
)
);
}
exit2();
return value;
}
}
function mapExceptFirst(line, index, blank) {
return index === 0 ? line : mapAll(line, index, blank);
}
function mapAll(line, index, blank) {
return (blank ? "" : " ") + line;
}
const constructsWithoutStrikethrough = [
"autolink",
"destinationLiteral",
"destinationRaw",
"reference",
"titleQuote",
"titleApostrophe"
];
handleDelete.peek = peekDelete;
function gfmStrikethroughFromMarkdown() {
return {
canContainEols: ["delete"],
enter: { strikethrough: enterStrikethrough },
exit: { strikethrough: exitStrikethrough }
};
}
function gfmStrikethroughToMarkdown() {
return {
unsafe: [
{
character: "~",
inConstruct: "phrasing",
notInConstruct: constructsWithoutStrikethrough
}
],
handlers: { delete: handleDelete }
};
}
function enterStrikethrough(token) {
this.enter({ type: "delete", children: [] }, token);
}
function exitStrikethrough(token) {
this.exit(token);
}
function handleDelete(node, _, state, info) {
const tracker = state.createTracker(info);
const exit2 = state.enter("strikethrough");
let value = tracker.move("~~");
value += state.containerPhrasing(node, {
...tracker.current(),
before: value,
after: "~"
});
value += tracker.move("~~");
exit2();
return value;
}
function peekDelete() {
return "~";
}
function defaultStringLength(value) {
return value.length;
}
function markdownTable(table, options) {
const settings = options || {};
const align = (settings.align || []).concat();
const stringLength = settings.stringLength || defaultStringLength;
const alignments = [];
const cellMatrix = [];
const sizeMatrix = [];
const longestCellByColumn = [];
let mostCellsPerRow = 0;
let rowIndex = -1;
while (++rowIndex < table.length) {
const row2 = [];
const sizes2 = [];
let columnIndex2 = -1;
if (table[rowIndex].length > mostCellsPerRow) {
mostCellsPerRow = table[rowIndex].length;
}
while (++columnIndex2 < table[rowIndex].length) {
const cell = serialize(table[rowIndex][columnIndex2]);
if (settings.alignDelimiters !== false) {
const size = stringLength(cell);
sizes2[columnIndex2] = size;
if (longestCellByColumn[columnIndex2] === void 0 || size > longestCellByColumn[columnIndex2]) {
longestCellByColumn[columnIndex2] = size;
}
}
row2.push(cell);
}
cellMatrix[rowIndex] = row2;
sizeMatrix[rowIndex] = sizes2;
}
let columnIndex = -1;
if (typeof align === "object" && "length" in align) {
while (++columnIndex < mostCellsPerRow) {
alignments[columnIndex] = toAlignment(align[columnIndex]);
}
} else {
const code2 = toAlignment(align);
while (++columnIndex < mostCellsPerRow) {
alignments[columnIndex] = code2;
}
}
columnIndex = -1;
const row = [];
const sizes = [];
while (++columnIndex < mostCellsPerRow) {
const code2 = alignments[columnIndex];
let before = "";
let after = "";
if (code2 === 99) {
before = ":";
after = ":";
} else if (code2 === 108) {
before = ":";
} else if (code2 === 114) {
after = ":";
}
let size = settings.alignDelimiters === false ? 1 : Math.max(
1,
longestCellByColumn[columnIndex] - before.length - after.length
);
const cell = before + "-".repeat(size) + after;
if (settings.alignDelimiters !== false) {
size = before.length + size + after.length;
if (size > longestCellByColumn[columnIndex]) {
longestCellByColumn[columnIndex] = size;
}
sizes[columnIndex] = size;
}
row[columnIndex] = cell;
}
cellMatrix.splice(1, 0, row);
sizeMatrix.splice(1, 0, sizes);
rowIndex = -1;
const lines = [];
while (++rowIndex < cellMatrix.length) {
const row2 = cellMatrix[rowIndex];
const sizes2 = sizeMatrix[rowIndex];
columnIndex = -1;
const line = [];
while (++columnIndex < mostCellsPerRow) {
const cell = row2[columnIndex] || "";
let before = "";
let after = "";
if (settings.alignDelimiters !== false) {
const size = longestCellByColumn[columnIndex] - (sizes2[columnIndex] || 0);
const code2 = alignments[columnIndex];
if (code2 === 114) {
before = " ".repeat(size);
} else if (code2 === 99) {
if (size % 2) {
before = " ".repeat(size / 2 + 0.5);
after = " ".repeat(size / 2 - 0.5);
} else {
before = " ".repeat(size / 2);
after = before;
}
} else {
after = " ".repeat(size);
}
}
if (settings.delimiterStart !== false && !columnIndex) {
line.push("|");
}
if (settings.padding !== false && // Don’t add the opening space if we’re not aligning and the cell is
// empty: there will be a closing space.
!(settings.alignDelimiters === false && cell === "") && (settings.delimiterStart !== false || columnIndex)) {
line.push(" ");
}
if (settings.alignDelimiters !== false) {
line.push(before);
}
line.push(cell);
if (settings.alignDelimiters !== false) {
line.push(after);
}
if (settings.padding !== false) {
line.push(" ");
}
if (settings.delimiterEnd !== false || columnIndex !== mostCellsPerRow - 1) {
line.push("|");
}
}
lines.push(
settings.delimiterEnd === false ? line.join("").replace(/ +$/, "") : line.join("")
);
}
return lines.join("\n");
}
function serialize(value) {
return value === null || value === void 0 ? "" : String(value);
}
function toAlignment(value) {
const code2 = typeof value === "string" ? value.codePointAt(0) : 0;
return code2 === 67 || code2 === 99 ? 99 : code2 === 76 || code2 === 108 ? 108 : code2 === 82 || code2 === 114 ? 114 : 0;
}
function blockquote(node, _, state, info) {
const exit2 = state.enter("blockquote");
const tracker = state.createTracker(info);
tracker.move("> ");
tracker.shift(2);
const value = state.indentLines(
state.containerFlow(node, tracker.current()),
map$1
);
exit2();
return value;
}
function map$1(line, _, blank) {
return ">" + (blank ? "" : " ") + line;
}
function patternInScope(stack, pattern) {
return listInScope(stack, pattern.inConstruct, true) && !listInScope(stack, pattern.notInConstruct, false);
}
function listInScope(stack, list2, none) {
if (typeof list2 === "string") {
list2 = [list2];
}
if (!list2 || list2.length === 0) {
return none;
}
let index = -1;
while (++index < list2.length) {
if (stack.includes(list2[index])) {
return true;
}
}
return false;
}
function hardBreak(_, _1, state, info) {
let index = -1;
while (++index < state.unsafe.length) {
if (state.unsafe[index].character === "\n" && patternInScope(state.stack, state.unsafe[index])) {
return /[ \t]/.test(info.before) ? "" : " ";
}
}
return "\\\n";
}
function longestStreak(value, substring) {
const source = String(value);
let index = source.indexOf(substring);
let expected = index;
let count = 0;
let max = 0;
if (typeof substring !== "string") {
throw new TypeError("Expected substring");
}
while (index !== -1) {
if (index === expected) {
if (++count > max) {
max = count;
}
} else {
count = 1;
}
expected = index + substring.length;
index = source.indexOf(substring, expected);
}
return max;
}
function formatCodeAsIndented(node, state) {
return Boolean(
state.options.fences === false && node.value && // If there’s no info…
!node.lang && // And there’s a non-whitespace character…
/[^ \r\n]/.test(node.value) && // And the value doesn’t start or end in a blank…
!/^[\t ]*(?:[\r\n]|$)|(?:^|[\r\n])[\t ]*$/.test(node.value)
);
}
function checkFence(state) {
const marker = state.options.fence || "`";
if (marker !== "`" && marker !== "~") {
throw new Error(
"Cannot serialize code with `" + marker + "` for `options.fence`, expected `` ` `` or `~`"
);
}
return marker;
}
function code$1(node, _, state, info) {
const marker = checkFence(state);
const raw = node.value || "";
const suffix = marker === "`" ? "GraveAccent" : "Tilde";
if (formatCodeAsIndented(node, state)) {
const exit3 = state.enter("codeIndented");
const value2 = state.indentLines(raw, map);
exit3();
return value2;
}
const tracker = state.createTracker(info);
const sequence = marker.repeat(Math.max(longestStreak(raw, marker) + 1, 3));
const exit2 = state.enter("codeFenced");
let value = tracker.move(sequence);
if (node.lang) {
const subexit = state.enter(`codeFencedLang${suffix}`);
value += tracker.move(
state.safe(node.lang, {
before: value,
after: " ",
encode: ["`"],
...tracker.current()
})
);
subexit();
}
if (node.lang && node.meta) {
const subexit = state.enter(`codeFencedMeta${suffix}`);
value += tracker.move(" ");
value += tracker.move(
state.safe(node.meta, {
before: value,
after: "\n",
encode: ["`"],
...tracker.current()
})
);
subexit();
}
value += tracker.move("\n");
if (raw) {
value += tracker.move(raw + "\n");
}
value += tracker.move(sequence);
exit2();
return value;
}
function map(line, _, blank) {
return (blank ? "" : " ") + line;
}
function checkQuote(state) {
const marker = state.options.quote || '"';
if (marker !== '"' && marker !== "'") {
throw new Error(
"Cannot serialize title with `" + marker + "` for `options.quote`, expected `\"`, or `'`"
);
}
return marker;
}
function definition(node, _, state, info) {
const quote = checkQuote(state);
const suffix = quote === '"' ? "Quote" : "Apostrophe";
const exit2 = state.enter("definition");
let subexit = state.enter("label");
const tracker = state.createTracker(info);
let value = tracker.move("[");
value += tracker.move(
state.safe(state.associationId(node), {
before: value,
after: "]",
...tracker.current()
})
);
value += tracker.move("]: ");
subexit();
if (
// If there’s no url, or…
!node.url || // If there are control characters or whitespace.
/[\0- \u007F]/.test(node.url)
) {
subexit = state.enter("destinationLiteral");
value += tracker.move("<");
value += tracker.move(
state.safe(node.url, { before: value, after: ">", ...tracker.current() })
);
value += tracker.move(">");
} else {
subexit = state.enter("destinationRaw");
value += tracker.move(
state.safe(node.url, {
before: value,
after: node.title ? " " : "\n",
...tracker.current()
})
);
}
subexit();
if (node.title) {
subexit = state.enter(`title${suffix}`);
value += tracker.move(" " + quote);
value += tracker.move(
state.safe(node.title, {
before: value,
after: quote,
...tracker.current()
})
);
value += tracker.move(quote);
subexit();
}
exit2();
return value;
}
function checkEmphasis(state) {
const marker = state.options.emphasis || "*";
if (marker !== "*" && marker !== "_") {
throw new Error(
"Cannot serialize emphasis with `" + marker + "` for `options.emphasis`, expected `*`, or `_`"
);
}
return marker;
}
function encodeCharacterReference(code2) {
return "&#x" + code2.toString(16).toUpperCase() + ";";
}
function classifyCharacter(code2) {
if (code2 === null || markdownLineEndingOrSpace(code2) || unicodeWhitespace(code2)) {
return 1;
}
if (unicodePunctuation(code2)) {
return 2;
}
}
function encodeInfo(outside, inside, marker) {
const outsideKind = classifyCharacter(outside);
const insideKind = classifyCharacter(inside);
if (outsideKind === void 0) {
return insideKind === void 0 ? (
// Letter inside:
// we have to encode *both* letters for `_` as it is looser.
// it already forms for `*` (and GFMs `~`).
marker === "_" ? { inside: true, outside: true } : { inside: false, outside: false }
) : insideKind === 1 ? (
// Whitespace inside: encode both (letter, whitespace).
{ inside: true, outside: true }
) : (
// Punctuation inside: encode outer (letter)
{ inside: false, outside: true }
);
}
if (outsideKind === 1) {
return insideKind === void 0 ? (
// Letter inside: already forms.
{ inside: false, outside: false }
) : insideKind === 1 ? (
// Whitespace inside: encode both (whitespace).
{ inside: true, outside: true }
) : (
// Punctuation inside: already forms.
{ inside: false, outside: false }
);
}
return insideKind === void 0 ? (
// Letter inside: already forms.
{ inside: false, outside: false }
) : insideKind === 1 ? (
// Whitespace inside: encode inner (whitespace).
{ inside: true, outside: false }
) : (
// Punctuation inside: already forms.
{ inside: false, outside: false }
);
}
emphasis.peek = emphasisPeek;
function emphasis(node, _, state, info) {
const marker = checkEmphasis(state);
const exit2 = state.enter("emphasis");
const tracker = state.createTracker(info);
const before = tracker.move(marker);
let between = tracker.move(
state.containerPhrasing(node, {
after: marker,
before,
...tracker.current()
})
);
const betweenHead = between.charCodeAt(0);
const open = encodeInfo(
info.before.charCodeAt(info.before.length - 1),
betweenHead,
marker
);
if (open.inside) {
between = encodeCharacterReference(betweenHead) + between.slice(1);
}
const betweenTail = between.charCodeAt(between.length - 1);
const close = encodeInfo(info.after.charCodeAt(0), betweenTail, marker);
if (close.inside) {
between = between.slice(0, -1) + encodeCharacterReference(betweenTail);
}
const after = tracker.move(marker);
exit2();
state.attentionEncodeSurroundingInfo = {
after: close.outside,
before: open.outside
};
return before + between + after;
}
function emphasisPeek(_, _1, state) {
return state.options.emphasis || "*";
}
function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {
let reverse;
let test;
let visitor;
if (typeof testOrVisitor === "function" && typeof visitorOrReverse !== "function") {
test = void 0;
visitor = testOrVisitor;
reverse = visitorOrReverse;
} else {
test = testOrVisitor;
visitor = visitorOrReverse;
reverse = maybeReverse;
}
visitParents(tree, test, overload, reverse);
function overload(node, parents) {
const parent = parents[parents.length - 1];
const index = parent ? parent.children.indexOf(node) : void 0;
return visitor(node, index, parent);
}
}
function formatHeadingAsSetext(node, state) {
let literalWithBreak = false;
visit(node, function(node2) {
if ("value" in node2 && /\r?\n|\r/.test(node2.value) || node2.type === "break") {
literalWithBreak = true;
return EXIT;
}
});
return Boolean(
(!node.depth || node.depth < 3) && toString(node) && (state.options.setext || literalWithBreak)
);
}
function heading(node, _, state, info) {
const rank = Math.max(Math.min(6, node.depth || 1), 1);
const tracker = state.createTracker(info);
if (formatHeadingAsSetext(node, state)) {
const exit3 = state.enter("headingSetext");
const subexit2 = state.enter("phrasing");
const value2 = state.containerPhrasing(node, {
...tracker.current(),
before: "\n",
after: "\n"
});
subexit2();
exit3();
return value2 + "\n" + (rank === 1 ? "=" : "-").repeat(
// The whole size…
value2.length - // Minus the position of the character after the last EOL (or
// 0 if there is none)…
(Math.max(value2.lastIndexOf("\r"), value2.lastIndexOf("\n")) + 1)
);
}
const sequence = "#".repeat(rank);
const exit2 = state.enter("headingAtx");
const subexit = state.enter("phrasing");
tracker.move(sequence + " ");
let value = state.containerPhrasing(node, {
before: "# ",
after: "\n",
...tracker.current()
});
if (/^[\t ]/.test(value)) {
value = encodeCharacterReference(value.charCodeAt(0)) + value.slice(1);
}
value = value ? sequence + " " + value : sequence;
if (state.options.closeAtx) {
value += " " + sequence;
}
subexit();
exit2();
return value;
}
html.peek = htmlPeek;
function html(node) {
return node.value || "";
}
function htmlPeek() {
return "<";
}
image.peek = imagePeek;
function image(node, _, state, info) {
const quote = checkQuote(state);
const suffix = quote === '"' ? "Quote" : "Apostrophe";
const exit2 = state.enter("image");
let subexit = state.enter("label");
const tracker = state.createTracker(info);
let value = tracker.move("![");
value += tracker.move(
state.safe(node.alt, { before: value, after: "]", ...tracker.current() })
);
value += tracker.move("](");
subexit();
if (
// If there’s no url but there is a title…
!node.url && node.title || // If there are control characters or whitespace.
/[\0- \u007F]/.test(node.url)
) {
subexit = state.enter("destinationLiteral");
value += tracker.move("<");
value += tracker.move(
state.safe(node.url, { before: value, after: ">", ...tracker.current() })
);
value += tracker.move(">");
} else {
subexit = state.enter("destinationRaw");
value += tracker.move(
state.safe(node.url, {
before: value,
after: node.title ? " " : ")",
...tracker.current()
})
);
}
subexit();
if (node.title) {
subexit = state.enter(`title${suffix}`);
value += tracker.move(" " + quote);
value += tracker.move(
state.safe(node.title, {
before: value,
after: quote,
...tracker.current()
})
);
value += tracker.move(quote);
subexit();
}
value += tracker.move(")");
exit2();
return value;
}
function imagePeek() {
return "!";
}
imageReference.peek = imageReferencePeek;
function imageReference(node, _, state, info) {
const type = node.referenceType;
const exit2 = state.enter("imageReference");
let subexit = state.enter("label");
const tracker = state.createTracker(info);
let value = tracker.move("![");
const alt = state.safe(node.alt, {
before: value,
after: "]",
...tracker.current()
});
value += tracker.move(alt + "][");
subexit();
const stack = state.stack;
state.stack = [];
subexit = state.enter("reference");
const reference = state.safe(state.associationId(node), {
before: value,
after: "]",
...tracker.current()
});
subexit();
state.stack = stack;
exit2();
if (type === "full" || !alt || alt !== reference) {
value += tracker.move(reference + "]");
} else if (type === "shortcut") {
value = value.slice(0, -1);
} else {
value += tracker.move("]");
}
return value;
}
function imageReferencePeek() {
return "!";
}
inlineCode.peek = inlineCodePeek;
function inlineCode(node, _, state) {
let value = node.value || "";
let sequence = "`";
let index = -1;
while (new RegExp("(^|[^`])" + sequence + "([^`]|$)").test(value)) {
sequence += "`";
}
if (/[^ \r\n]/.test(value) && (/^[ \r\n]/.test(value) && /[ \r\n]$/.test(value) || /^`|`$/.test(value))) {
value = " " + value + " ";
}
while (++index < state.unsafe.length) {
const pattern = state.unsafe[index];
const expression = state.compilePattern(pattern);
let match;
if (!pattern.atBreak) continue;
while (match = expression.exec(value)) {
let position = match.index;
if (value.charCodeAt(position) === 10 && value.charCodeAt(position - 1) === 13) {
position--;
}
value = value.slice(0, position) + " " + value.slice(match.index + 1);
}
}
return sequence + value + sequence;
}
function inlineCodePeek() {
return "`";
}
function formatLinkAsAutolink(node, state) {
const raw = toString(node);
return Boolean(
!state.options.resourceLink && // If there’s a url…
node.url && // And there’s a no title…
!node.title && // And the content of `node` is a single text node…
node.children && node.children.length === 1 && node.children[0].type === "text" && // And if the url is the same as the content…
(raw === node.url || "mailto:" + raw === node.url) && // And that starts w/ a protocol…
/^[a-z][a-z+.-]+:/i.test(node.url) && // And that doesn’t contain ASCII control codes (character escapes and
// references don’t work), space, or angle brackets…
!/[\0- <>\u007F]/.test(node.url)
);
}
link.peek = linkPeek;
function link(node, _, state, info) {
const quote = checkQuote(state);
const suffix = quote === '"' ? "Quote" : "Apostrophe";
const tracker = state.createTracker(info);
let exit2;
let subexit;
if (formatLinkAsAutolink(node, state)) {
const stack = state.stack;
state.stack = [];
exit2 = state.enter("autolink");
let value2 = tracker.move("<");
value2 += tracker.move(
state.containerPhrasing(node, {
before: value2,
after: ">",
...tracker.current()
})
);
value2 += tracker.move(">");
exit2();
state.stack = stack;
return value2;
}
exit2 = state.enter("link");
subexit = state.enter("label");
let value = tracker.move("[");
value += tracker.move(
state.containerPhrasing(node, {
before: value,
after: "](",
...tracker.current()
})
);
value += tracker.move("](");
subexit();
if (
// If there’s no url but there is a title…
!node.url && node.title || // If there are control characters or whitespace.
/[\0- \u007F]/.test(node.url)
) {
subexit = state.enter("destinationLiteral");
value += tracker.move("<");
value += tracker.move(
state.safe(node.url, { before: value, after: ">", ...tracker.current() })
);
value += tracker.move(">");
} else {
subexit = state.enter("destinationRaw");
value += tracker.move(
state.safe(node.url, {
before: value,
after: node.title ? " " : ")",
...tracker.current()
})
);
}
subexit();
if (node.title) {
subexit = state.enter(`title${suffix}`);
value += tracker.move(" " + quote);
value += tracker.move(
state.safe(node.title, {
before: value,
after: quote,
...tracker.current()
})
);
value += tracker.move(quote);
subexit();
}
value += tracker.move(")");
exit2();
return value;
}
function linkPeek(node, _, state) {
return formatLinkAsAutolink(node, state) ? "<" : "[";
}
linkReference.peek = linkReferencePeek;
function linkReference(node, _, state, info) {
const type = node.referenceType;
const exit2 = state.enter("linkReference");
let subexit = state.enter("label");
const tracker = state.createTracker(info);
let value = tracker.move("[");
const text2 = state.containerPhrasing(node, {
before: value,
after: "]",
...tracker.current()
});
value += tracker.move(text2 + "][");
subexit();
const stack = state.stack;
state.stack = [];
subexit = state.enter("reference");
const reference = state.safe(state.associationId(node), {
before: value,
after: "]",
...tracker.current()
});
subexit();
state.stack = stack;
exit2();
if (type === "full" || !text2 || text2 !== reference) {
value += tracker.move(reference + "]");
} else if (type === "shortcut") {
value = value.slice(0, -1);
} else {
value += tracker.move("]");
}
return value;
}
function linkReferencePeek() {
return "[";
}
function checkBullet(state) {
const marker = state.options.bullet || "*";
if (marker !== "*" && marker !== "+" && marker !== "-") {
throw new Error(
"Cannot serialize items with `" + marker + "` for `options.bullet`, expected `*`, `+`, or `-`"
);
}
return marker;
}
function checkBulletOther(state) {
const bullet = checkBullet(state);
const bulletOther = state.options.bulletOther;
if (!bulletOther) {
return bullet === "*" ? "-" : "*";
}
if (bulletOther !== "*" && bulletOther !== "+" && bulletOther !== "-") {
throw new Error(
"Cannot serialize items with `" + bulletOther + "` for `options.bulletOther`, expected `*`, `+`, or `-`"
);
}
if (bulletOther === bullet) {
throw new Error(
"Expected `bullet` (`" + bullet + "`) and `bulletOther` (`" + bulletOther + "`) to be different"
);
}
return bulletOther;
}
function checkBulletOrdered(state) {
const marker = state.options.bulletOrdered || ".";
if (marker !== "." && marker !== ")") {
throw new Error(
"Cannot serialize items with `" + marker + "` for `options.bulletOrdered`, expected `.` or `)`"
);
}
return marker;
}
function checkRule(state) {
const marker = state.options.rule || "*";
if (marker !== "*" && marker !== "-" && marker !== "_") {
throw new Error(
"Cannot serialize rules with `" + marker + "` for `options.rule`, expected `*`, `-`, or `_`"
);
}
return marker;
}
function list(node, parent, state, info) {
const exit2 = state.enter("list");
const bulletCurrent = state.bulletCurrent;
let bullet = node.ordered ? checkBulletOrdered(state) : checkBullet(state);
const bulletOther = node.ordered ? bullet === "." ? ")" : "." : checkBulletOther(state);
let useDifferentMarker = parent && state.bulletLastUsed ? bullet === state.bulletLastUsed : false;
if (!node.ordered) {
const firstListItem = node.children ? node.children[0] : void 0;
if (
// Bullet could be used as a thematic break marker:
(bullet === "*" || bullet === "-") && // Empty first list item:
firstListItem && (!firstListItem.children || !firstListItem.children[0]) && // Directly in two other list items:
state.stack[state.stack.length - 1] === "list" && state.stack[state.stack.length - 2] === "listItem" && state.stack[state.stack.length - 3] === "list" && state.stack[state.stack.length - 4] === "listItem" && // That are each the first child.
state.indexStack[state.indexStack.length - 1] === 0 && state.indexStack[state.indexStack.length - 2] === 0 && state.indexStack[state.indexStack.length - 3] === 0
) {
useDifferentMarker = true;
}
if (checkRule(state) === bullet && firstListItem) {
let index = -1;
while (++index < node.children.length) {
const item = node.children[index];
if (item && item.type === "listItem" && item.children && item.children[0] && item.children[0].type === "thematicBreak") {
useDifferentMarker = true;
break;
}
}
}
}
if (useDifferentMarker) {
bullet = bulletOther;
}
state.bulletCurrent = bullet;
const value = state.containerFlow(node, info);
state.bulletLastUsed = bullet;
state.bulletCurrent = bulletCurrent;
exit2();
return value;
}
function checkListItemIndent(state) {
const style = state.options.listItemIndent || "one";
if (style !== "tab" && style !== "one" && style !== "mixed") {
throw new Error(
"Cannot serialize items with `" + style + "` for `options.listItemIndent`, expected `tab`, `one`, or `mixed`"
);
}
return style;
}
function listItem(node, parent, state, info) {
const listItemIndent = checkListItemIndent(state);
let bullet = state.bulletCurrent || checkBullet(state);
if (parent && parent.type === "list" && parent.ordered) {
bullet = (typeof parent.start === "number" && parent.start > -1 ? parent.start : 1) + (state.options.incrementListMarker === false ? 0 : parent.children.indexOf(node)) + bullet;
}
let size = bullet.length + 1;
if (listItemIndent === "tab" || listItemIndent === "mixed" && (parent && parent.type === "list" && parent.spread || node.spread)) {
size = Math.ceil(size / 4) * 4;
}
const tracker = state.createTracker(info);
tracker.move(bullet + " ".repeat(size - bullet.length));
tracker.shift(size);
const exit2 = state.enter("listItem");
const value = state.indentLines(
state.containerFlow(node, tracker.current()),
map2
);
exit2();
return value;
function map2(line, index, blank) {
if (index) {
return (blank ? "" : " ".repeat(size)) + line;
}
return (blank ? bullet : bullet + " ".repeat(size - bullet.length)) + line;
}
}
function paragraph(node, _, state, info) {
const exit2 = state.enter("paragraph");
const subexit = state.enter("phrasing");
const value = state.containerPhrasing(node, info);
subexit();
exit2();
return value;
}
const phrasing = (
/** @type {(node?: unknown) => node is Exclude<PhrasingContent, Html>} */
convert([
"break",
"delete",
"emphasis",
// To do: next major: removed since footnotes were added to GFM.
"footnote",
"footnoteReference",
"image",
"imageReference",
"inlineCode",
// Enabled by `mdast-util-math`:
"inlineMath",
"link",
"linkReference",
// Enabled by `mdast-util-mdx`:
"mdxJsxTextElement",
// Enabled by `mdast-util-mdx`:
"mdxTextExpression",
"strong",
"text",
// Enabled by `mdast-util-directive`:
"textDirective"
])
);
function root(node, _, state, info) {
const hasPhrasing = node.children.some(function(d) {
return phrasing(d);
});
const container = hasPhrasing ? state.containerPhrasing : state.containerFlow;
return container.call(state, node, info);
}
function checkStrong(state) {
const marker = state.options.strong || "*";
if (marker !== "*" && marker !== "_") {
throw new Error(
"Cannot serialize strong with `" + marker + "` for `options.strong`, expected `*`, or `_`"
);
}
return marker;
}
strong.peek = strongPeek;
function strong(node, _, state, info) {
const marker = checkStrong(state);
const exit2 = state.enter("strong");
const tracker = state.createTracker(info);
const before = tracker.move(marker + marker);
let between = tracker.move(
state.containerPhrasing(node, {
after: marker,
before,
...tracker.current()
})
);
const betweenHead = between.charCodeAt(0);
const open = encodeInfo(
info.before.charCodeAt(info.before.length - 1),
betweenHead,
marker
);
if (open.inside) {
between = encodeCharacterReference(betweenHead) + between.slice(1);
}
const betweenTail = between.charCodeAt(between.length - 1);
const close = encodeInfo(info.after.charCodeAt(0), betweenTail, marker);
if (close.inside) {
between = between.slice(0, -1) + encodeCharacterReference(betweenTail);
}
const after = tracker.move(marker + marker);
exit2();
state.attentionEncodeSurroundingInfo = {
after: close.outside,
before: open.outside
};
return before + between + after;
}
function strongPeek(_, _1, state) {
return state.options.strong || "*";
}
function text$1(node, _, state, info) {
return state.safe(node.value, info);
}
function checkRuleRepetition(state) {
const repetition = state.options.ruleRepetition || 3;
if (repetition < 3) {
throw new Error(
"Cannot serialize rules with repetition `" + repetition + "` for `options.ruleRepetition`, expected `3` or more"
);
}
return repetition;
}
function thematicBreak(_, _1, state) {
const value = (checkRule(state) + (state.options.ruleSpaces ? " " : "")).repeat(checkRuleRepetition(state));
return state.options.ruleSpaces ? value.slice(0, -1) : value;
}
const handle = {
blockquote,
break: hardBreak,
code: code$1,
definition,
emphasis,
hardBreak,
heading,
html,
image,
imageReference,
inlineCode,
link,
linkReference,
list,
listItem,
paragraph,
root,
strong,
text: text$1,
thematicBreak
};
function gfmTableFromMarkdown() {
return {
enter: {
table: enterTable,
tableData: enterCell,
tableHeader: enterCell,
tableRow: enterRow
},
exit: {
codeText: exitCodeText,
table: exitTable,
tableData: exit,
tableHeader: exit,
tableRow: exit
}
};
}
function enterTable(token) {
const align = token._align;
this.enter(
{
type: "table",
align: align.map(function(d) {
return d === "none" ? null : d;
}),
children: []
},
token
);
this.data.inTable = true;
}
function exitTable(token) {
this.exit(token);
this.data.inTable = void 0;
}
function enterRow(token) {
this.enter({ type: "tableRow", children: [] }, token);
}
function exit(token) {
this.exit(token);
}
function enterCell(token) {
this.enter({ type: "tableCell", children: [] }, token);
}
function exitCodeText(token) {
let value = this.resume();
if (this.data.inTable) {
value = value.replace(/\\([\\|])/g, replace);
}
const node = this.stack[this.stack.length - 1];
ok$1(node.type === "inlineCode");
node.value = value;
this.exit(token);
}
function replace($0, $1) {
return $1 === "|" ? $1 : $0;
}
function gfmTableToMarkdown(options) {
const settings = options || {};
const padding = settings.tableCellPadding;
const alignDelimiters = settings.tablePipeAlign;
const stringLength = settings.stringLength;
const around = padding ? " " : "|";
return {
unsafe: [
{ character: "\r", inConstruct: "tableCell" },
{ character: "\n", inConstruct: "tableCell" },
// A pipe, when followed by a tab or space (padding), or a dash or colon
// (unpadded delimiter row), could result in a table.
{ atBreak: true, character: "|", after: "[ :-]" },
// A pipe in a cell must be encoded.
{ character: "|", inConstruct: "tableCell" },
// A colon must be followed by a dash, in which case it could start a
// delimiter row.
{ atBreak: true, character: ":", after: "-" },
// A delimiter row can also start with a dash, when followed by more
// dashes, a colon, or a pipe.
// This is a stricter version than the built in check for lists, thematic
// breaks, and setex heading underlines though:
// <https://github.com/syntax-tree/mdast-util-to-markdown/blob/51a2038/lib/unsafe.js#L57>
{ atBreak: true, character: "-", after: "[:|-]" }
],
handlers: {
inlineCode: inlineCodeWithTable,
table: handleTable,
tableCell: handleTableCell,
tableRow: handleTableRow
}
};
function handleTable(node, _, state, info) {
return serializeData(handleTableAsData(node, state, info), node.align);
}
function handleTableRow(node, _, state, info) {
const row = handleTableRowAsData(node, state, info);
const value = serializeData([row]);
return value.slice(0, value.indexOf("\n"));
}
function handleTableCell(node, _, state, info) {
const exit2 = state.enter("tableCell");
const subexit = state.enter("phrasing");
const value = state.containerPhrasing(node, {
...info,
before: around,
after: around
});
subexit();
exit2();
return value;
}
function serializeData(matrix, align) {
return markdownTable(matrix, {
align,
// @ts-expect-error: `markdown-table` types should support `null`.
alignDelimiters,
// @ts-expect-error: `markdown-table` types should support `null`.
padding,
// @ts-expect-error: `markdown-table` types should support `null`.
stringLength
});
}
function handleTableAsData(node, state, info) {
const children = node.children;
let index = -1;
const result = [];
const subexit = state.enter("table");
while (++index < children.length) {
result[index] = handleTableRowAsData(children[index], state, info);
}
subexit();
return result;
}
function handleTableRowAsData(node, state, info) {
const children = node.children;
let index = -1;
const result = [];
const subexit = state.enter("tableRow");
while (++index < children.length) {
result[index] = handleTableCell(children[index], node, state, info);
}
subexit();
return result;
}
function inlineCodeWithTable(node, parent, state) {
let value = handle.inlineCode(node, parent, state);
if (state.stack.includes("tableCell")) {
value = value.replace(/\|/g, "\\$&");
}
return value;
}
}
function gfmTaskListItemFromMarkdown() {
return {
exit: {
taskListCheckValueChecked: exitCheck,
taskListCheckValueUnchecked: exitCheck,
paragraph: exitParagraphWithTaskListItem
}
};
}
function gfmTaskListItemToMarkdown() {
return {
unsafe: [{ atBreak: true, character: "-", after: "[:|-]" }],
handlers: { listItem: listItemWithTaskListItem }
};
}
function exitCheck(token) {
const node = this.stack[this.stack.length - 2];
ok$1(node.type === "listItem");
node.checked = token.type === "taskListCheckValueChecked";
}
function exitParagraphWithTaskListItem(token) {
const parent = this.stack[this.stack.length - 2];
if (parent && parent.type === "listItem" && typeof parent.checked === "boolean") {
const node = this.stack[this.stack.length - 1];
ok$1(node.type === "paragraph");
const head = node.children[0];
if (head && head.type === "text") {
const siblings = parent.children;
let index = -1;
let firstParaghraph;
while (++index < siblings.length) {
const sibling = siblings[index];
if (sibling.type === "paragraph") {
firstParaghraph = sibling;
break;
}
}
if (firstParaghraph === node) {
head.value = head.value.slice(1);
if (head.value.length === 0) {
node.children.shift();
} else if (node.position && head.position && typeof head.position.start.offset === "number") {
head.position.start.column++;
head.position.start.offset++;
node.position.start = Object.assign({}, head.position.start);
}
}
}
}
this.exit(token);
}
function listItemWithTaskListItem(node, parent, state, info) {
const head = node.children[0];
const checkable = typeof node.checked === "boolean" && head && head.type === "paragraph";
const checkbox = "[" + (node.checked ? "x" : " ") + "] ";
const tracker = state.createTracker(info);
if (checkable) {
tracker.move(checkbox);
}
let value = handle.listItem(node, parent, state, {
...info,
...tracker.current()
});
if (checkable) {
value = value.replace(/^(?:[*+-]|\d+\.)([\r\n]| {1,3})/, check);
}
return value;
function check($0) {
return $0 + checkbox;
}
}
function gfmFromMarkdown() {
return [
gfmAutolinkLiteralFromMarkdown(),
gfmFootnoteFromMarkdown(),
gfmStrikethroughFromMarkdown(),
gfmTableFromMarkdown(),
gfmTaskListItemFromMarkdown()
];
}
function gfmToMarkdown(options) {
return {
extensions: [
gfmAutolinkLiteralToMarkdown(),
gfmFootnoteToMarkdown(options),
gfmStrikethroughToMarkdown(),
gfmTableToMarkdown(options),
gfmTaskListItemToMarkdown()
]
};
}
function splice(list2, start, remove, items) {
const end = list2.length;
let chunkStart = 0;
let parameters;
if (start < 0) {
start = -start > end ? 0 : end + start;
} else {
start = start > end ? end : start;
}
remove = remove > 0 ? remove : 0;
if (items.length < 1e4) {
parameters = Array.from(items);
parameters.unshift(start, remove);
list2.splice(...parameters);
} else {
if (remove) list2.splice(start, remove);
while (chunkStart < items.length) {
parameters = items.slice(chunkStart, chunkStart + 1e4);
parameters.unshift(start, 0);
list2.splice(...parameters);
chunkStart += 1e4;
start += 1e4;
}
}
}
const hasOwnProperty = {}.hasOwnProperty;
function combineExtensions(extensions) {
const all = {};
let index = -1;
while (++index < extensions.length) {
syntaxExtension(all, extensions[index]);
}
return all;
}
function syntaxExtension(all, extension) {
let hook;
for (hook in extension) {
const maybe = hasOwnProperty.call(all, hook) ? all[hook] : void 0;
const left = maybe || (all[hook] = {});
const right = extension[hook];
let code2;
if (right) {
for (code2 in right) {
if (!hasOwnProperty.call(left, code2)) left[code2] = [];
const value = right[code2];
constructs(
// @ts-expect-error Looks like a list.
left[code2],
Array.isArray(value) ? value : value ? [value] : []
);
}
}
}
}
function constructs(existing, list2) {
let index = -1;
const before = [];
while (++index < list2.length) {
(list2[index].add === "after" ? existing : before).push(list2[index]);
}
splice(existing, 0, 0, before);
}
const wwwPrefix = {
tokenize: tokenizeWwwPrefix,
partial: true
};
const domain = {
tokenize: tokenizeDomain,
partial: true
};
const path = {
tokenize: tokenizePath,
partial: true
};
const trail = {
tokenize: tokenizeTrail,
partial: true
};
const emailDomainDotTrail = {
tokenize: tokenizeEmailDomainDotTrail,
partial: true
};
const wwwAutolink = {
name: "wwwAutolink",
tokenize: tokenizeWwwAutolink,
previous: previousWww
};
const protocolAutolink = {
name: "protocolAutolink",
tokenize: tokenizeProtocolAutolink,
previous: previousProtocol
};
const emailAutolink = {
name: "emailAutolink",
tokenize: tokenizeEmailAutolink,
previous: previousEmail
};
const text = {};
function gfmAutolinkLiteral() {
return {
text
};
}
let code = 48;
while (code < 123) {
text[code] = emailAutolink;
code++;
if (code === 58) code = 65;
else if (code === 91) code = 97;
}
text[43] = emailAutolink;
text[45] = emailAutolink;
text[46] = emailAutolink;
text[95] = emailAutolink;
text[72] = [emailAutolink, protocolAutolink];
text[104] = [emailAutolink, protocolAutolink];
text[87] = [emailAutolink, wwwAutolink];
text[119] = [emailAutolink, wwwAutolink];
function tokenizeEmailAutolink(effects, ok2, nok) {
const self = this;
let dot;
let data;
return start;
function start(code2) {
if (!gfmAtext(code2) || !previousEmail.call(self, self.previous) || previousUnbalanced(self.events)) {
return nok(code2);
}
effects.enter("literalAutolink");
effects.enter("literalAutolinkEmail");
return atext(code2);
}
function atext(code2) {
if (gfmAtext(code2)) {
effects.consume(code2);
return atext;
}
if (code2 === 64) {
effects.consume(code2);
return emailDomain;
}
return nok(code2);
}
function emailDomain(code2) {
if (code2 === 46) {
return effects.check(emailDomainDotTrail, emailDomainAfter, emailDomainDot)(code2);
}
if (code2 === 45 || code2 === 95 || asciiAlphanumeric(code2)) {
data = true;
effects.consume(code2);
return emailDomain;
}
return emailDomainAfter(code2);
}
function emailDomainDot(code2) {
effects.consume(code2);
dot = true;
return emailDomain;
}
function emailDomainAfter(code2) {
if (data && dot && asciiAlpha(self.previous)) {
effects.exit("literalAutolinkEmail");
effects.exit("literalAutolink");
return ok2(code2);
}
return nok(code2);
}
}
function tokenizeWwwAutolink(effects, ok2, nok) {
const self = this;
return wwwStart;
function wwwStart(code2) {
if (code2 !== 87 && code2 !== 119 || !previousWww.call(self, self.previous) || previousUnbalanced(self.events)) {
return nok(code2);
}
effects.enter("literalAutolink");
effects.enter("literalAutolinkWww");
return effects.check(wwwPrefix, effects.attempt(domain, effects.attempt(path, wwwAfter), nok), nok)(code2);
}
function wwwAfter(code2) {
effects.exit("literalAutolinkWww");
effects.exit("literalAutolink");
return ok2(code2);
}
}
function tokenizeProtocolAutolink(effects, ok2, nok) {
const self = this;
let buffer = "";
let seen = false;
return protocolStart;
function protocolStart(code2) {
if ((code2 === 72 || code2 === 104) && previousProtocol.call(self, self.previous) && !previousUnbalanced(self.events)) {
effects.enter("literalAutolink");
effects.enter("literalAutolinkHttp");
buffer += String.fromCodePoint(code2);
effects.consume(code2);
return protocolPrefixInside;
}
return nok(code2);
}
function protocolPrefixInside(code2) {
if (asciiAlpha(code2) && buffer.length < 5) {
buffer += String.fromCodePoint(code2);
effects.consume(code2);
return protocolPrefixInside;
}
if (code2 === 58) {
const protocol = buffer.toLowerCase();
if (protocol === "http" || protocol === "https") {
effects.consume(code2);
return protocolSlashesInside;
}
}
return nok(code2);
}
function protocolSlashesInside(code2) {
if (code2 === 47) {
effects.consume(code2);
if (seen) {
return afterProtocol;
}
seen = true;
return protocolSlashesInside;
}
return nok(code2);
}
function afterProtocol(code2) {
return code2 === null || asciiControl(code2) || markdownLineEndingOrSpace(code2) || unicodeWhitespace(code2) || unicodePunctuation(code2) ? nok(code2) : effects.attempt(domain, effects.attempt(path, protocolAfter), nok)(code2);
}
function protocolAfter(code2) {
effects.exit("literalAutolinkHttp");
effects.exit("literalAutolink");
return ok2(code2);
}
}
function tokenizeWwwPrefix(effects, ok2, nok) {
let size = 0;
return wwwPrefixInside;
function wwwPrefixInside(code2) {
if ((code2 === 87 || code2 === 119) && size < 3) {
size++;
effects.consume(code2);
return wwwPrefixInside;
}
if (code2 === 46 && size === 3) {
effects.consume(code2);
return wwwPrefixAfter;
}
return nok(code2);
}
function wwwPrefixAfter(code2) {
return code2 === null ? nok(code2) : ok2(code2);
}
}
function tokenizeDomain(effects, ok2, nok) {
let underscoreInLastSegment;
let underscoreInLastLastSegment;
let seen;
return domainInside;
function domainInside(code2) {
if (code2 === 46 || code2 === 95) {
return effects.check(trail, domainAfter, domainAtPunctuation)(code2);
}
if (code2 === null || markdownLineEndingOrSpace(code2) || unicodeWhitespace(code2) || code2 !== 45 && unicodePunctuation(code2)) {
return domainAfter(code2);
}
seen = true;
effects.consume(code2);
return domainInside;
}
function domainAtPunctuation(code2) {
if (code2 === 95) {
underscoreInLastSegment = true;
} else {
underscoreInLastLastSegment = underscoreInLastSegment;
underscoreInLastSegment = void 0;
}
effects.consume(code2);
return domainInside;
}
function domainAfter(code2) {
if (underscoreInLastLastSegment || underscoreInLastSegment || !seen) {
return nok(code2);
}
return ok2(code2);
}
}
function tokenizePath(effects, ok2) {
let sizeOpen = 0;
let sizeClose = 0;
return pathInside;
function pathInside(code2) {
if (code2 === 40) {
sizeOpen++;
effects.consume(code2);
return pathInside;
}
if (code2 === 41 && sizeClose < sizeOpen) {
return pathAtPunctuation(code2);
}
if (code2 === 33 || code2 === 34 || code2 === 38 || code2 === 39 || code2 === 41 || code2 === 42 || code2 === 44 || code2 === 46 || code2 === 58 || code2 === 59 || code2 === 60 || code2 === 63 || code2 === 93 || code2 === 95 || code2 === 126) {
return effects.check(trail, ok2, pathAtPunctuation)(code2);
}
if (code2 === null || markdownLineEndingOrSpace(code2) || unicodeWhitespace(code2)) {
return ok2(code2);
}
effects.consume(code2);
return pathInside;
}
function pathAtPunctuation(code2) {
if (code2 === 41) {
sizeClose++;
}
effects.consume(code2);
return pathInside;
}
}
function tokenizeTrail(effects, ok2, nok) {
return trail2;
function trail2(code2) {
if (code2 === 33 || code2 === 34 || code2 === 39 || code2 === 41 || code2 === 42 || code2 === 44 || code2 === 46 || code2 === 58 || code2 === 59 || code2 === 63 || code2 === 95 || code2 === 126) {
effects.consume(code2);
return trail2;
}
if (code2 === 38) {
effects.consume(code2);
return trailCharacterReferenceStart;
}
if (code2 === 93) {
effects.consume(code2);
return trailBracketAfter;
}
if (
// `<` is an end.
code2 === 60 || // So is whitespace.
code2 === null || markdownLineEndingOrSpace(code2) || unicodeWhitespace(code2)
) {
return ok2(code2);
}
return nok(code2);
}
function trailBracketAfter(code2) {
if (code2 === null || code2 === 40 || code2 === 91 || markdownLineEndingOrSpace(code2) || unicodeWhitespace(code2)) {
return ok2(code2);
}
return trail2(code2);
}
function trailCharacterReferenceStart(code2) {
return asciiAlpha(code2) ? trailCharacterReferenceInside(code2) : nok(code2);
}
function trailCharacterReferenceInside(code2) {
if (code2 === 59) {
effects.consume(code2);
return trail2;
}
if (asciiAlpha(code2)) {
effects.consume(code2);
return trailCharacterReferenceInside;
}
return nok(code2);
}
}
function tokenizeEmailDomainDotTrail(effects, ok2, nok) {
return start;
function start(code2) {
effects.consume(code2);
return after;
}
function after(code2) {
return asciiAlphanumeric(code2) ? nok(code2) : ok2(code2);
}
}
function previousWww(code2) {
return code2 === null || code2 === 40 || code2 === 42 || code2 === 95 || code2 === 91 || code2 === 93 || code2 === 126 || markdownLineEndingOrSpace(code2);
}
function previousProtocol(code2) {
return !asciiAlpha(code2);
}
function previousEmail(code2) {
return !(code2 === 47 || gfmAtext(code2));
}
function gfmAtext(code2) {
return code2 === 43 || code2 === 45 || code2 === 46 || code2 === 95 || asciiAlphanumeric(code2);
}
function previousUnbalanced(events) {
let index = events.length;
let result = false;
while (index--) {
const token = events[index][1];
if ((token.type === "labelLink" || token.type === "labelImage") && !token._balanced) {
result = true;
break;
}
if (token._gfmAutolinkLiteralWalkedInto) {
result = false;
break;
}
}
if (events.length > 0 && !result) {
events[events.length - 1][1]._gfmAutolinkLiteralWalkedInto = true;
}
return result;
}
function resolveAll(constructs2, events, context) {
const called = [];
let index = -1;
while (++index < constructs2.length) {
const resolve = constructs2[index].resolveAll;
if (resolve && !called.includes(resolve)) {
events = resolve(events, context);
called.push(resolve);
}
}
return events;
}
function factorySpace(effects, ok2, type, max) {
const limit = max ? max - 1 : Number.POSITIVE_INFINITY;
let size = 0;
return start;
function start(code2) {
if (markdownSpace(code2)) {
effects.enter(type);
return prefix(code2);
}
return ok2(code2);
}
function prefix(code2) {
if (markdownSpace(code2) && size++ < limit) {
effects.consume(code2);
return prefix;
}
effects.exit(type);
return ok2(code2);
}
}
const blankLine = {
partial: true,
tokenize: tokenizeBlankLine
};
function tokenizeBlankLine(effects, ok2, nok) {
return start;
function start(code2) {
return markdownSpace(code2) ? factorySpace(effects, after, "linePrefix")(code2) : after(code2);
}
function after(code2) {
return code2 === null || markdownLineEnding(code2) ? ok2(code2) : nok(code2);
}
}
const indent = {
tokenize: tokenizeIndent,
partial: true
};
function gfmFootnote() {
return {
document: {
[91]: {
name: "gfmFootnoteDefinition",
tokenize: tokenizeDefinitionStart,
continuation: {
tokenize: tokenizeDefinitionContinuation
},
exit: gfmFootnoteDefinitionEnd
}
},
text: {
[91]: {
name: "gfmFootnoteCall",
tokenize: tokenizeGfmFootnoteCall
},
[93]: {
name: "gfmPotentialFootnoteCall",
add: "after",
tokenize: tokenizePotentialGfmFootnoteCall,
resolveTo: resolveToPotentialGfmFootnoteCall
}
}
};
}
function tokenizePotentialGfmFootnoteCall(effects, ok2, nok) {
const self = this;
let index = self.events.length;
const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);
let labelStart;
while (index--) {
const token = self.events[index][1];
if (token.type === "labelImage") {
labelStart = token;
break;
}
if (token.type === "gfmFootnoteCall" || token.type === "labelLink" || token.type === "label" || token.type === "image" || token.type === "link") {
break;
}
}
return start;
function start(code2) {
if (!labelStart || !labelStart._balanced) {
return nok(code2);
}
const id = normalizeIdentifier(self.sliceSerialize({
start: labelStart.end,
end: self.now()
}));
if (id.codePointAt(0) !== 94 || !defined.includes(id.slice(1))) {
return nok(code2);
}
effects.enter("gfmFootnoteCallLabelMarker");
effects.consume(code2);
effects.exit("gfmFootnoteCallLabelMarker");
return ok2(code2);
}
}
function resolveToPotentialGfmFootnoteCall(events, context) {
let index = events.length;
while (index--) {
if (events[index][1].type === "labelImage" && events[index][0] === "enter") {
events[index][1];
break;
}
}
events[index + 1][1].type = "data";
events[index + 3][1].type = "gfmFootnoteCallLabelMarker";
const call = {
type: "gfmFootnoteCall",
start: Object.assign({}, events[index + 3][1].start),
end: Object.assign({}, events[events.length - 1][1].end)
};
const marker = {
type: "gfmFootnoteCallMarker",
start: Object.assign({}, events[index + 3][1].end),
end: Object.assign({}, events[index + 3][1].end)
};
marker.end.column++;
marker.end.offset++;
marker.end._bufferIndex++;
const string = {
type: "gfmFootnoteCallString",
start: Object.assign({}, marker.end),
end: Object.assign({}, events[events.length - 1][1].start)
};
const chunk = {
type: "chunkString",
contentType: "string",
start: Object.assign({}, string.start),
end: Object.assign({}, string.end)
};
const replacement = [
// Take the `labelImageMarker` (now `data`, the `!`)
events[index + 1],
events[index + 2],
["enter", call, context],
// The `[`
events[index + 3],
events[index + 4],
// The `^`.
["enter", marker, context],
["exit", marker, context],
// Everything in between.
["enter", string, context],
["enter", chunk, context],
["exit", chunk, context],
["exit", string, context],
// The ending (`]`, properly parsed and labelled).
events[events.length - 2],
events[events.length - 1],
["exit", call, context]
];
events.splice(index, events.length - index + 1, ...replacement);
return events;
}
function tokenizeGfmFootnoteCall(effects, ok2, nok) {
const self = this;
const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);
let size = 0;
let data;
return start;
function start(code2) {
effects.enter("gfmFootnoteCall");
effects.enter("gfmFootnoteCallLabelMarker");
effects.consume(code2);
effects.exit("gfmFootnoteCallLabelMarker");
return callStart;
}
function callStart(code2) {
if (code2 !== 94) return nok(code2);
effects.enter("gfmFootnoteCallMarker");
effects.consume(code2);
effects.exit("gfmFootnoteCallMarker");
effects.enter("gfmFootnoteCallString");
effects.enter("chunkString").contentType = "string";
return callData;
}
function callData(code2) {
if (
// Too long.
size > 999 || // Closing brace with nothing.
code2 === 93 && !data || // Space or tab is not supported by GFM for some reason.
// `\n` and `[` not being supported makes sense.
code2 === null || code2 === 91 || markdownLineEndingOrSpace(code2)
) {
return nok(code2);
}
if (code2 === 93) {
effects.exit("chunkString");
const token = effects.exit("gfmFootnoteCallString");
if (!defined.includes(normalizeIdentifier(self.sliceSerialize(token)))) {
return nok(code2);
}
effects.enter("gfmFootnoteCallLabelMarker");
effects.consume(code2);
effects.exit("gfmFootnoteCallLabelMarker");
effects.exit("gfmFootnoteCall");
return ok2;
}
if (!markdownLineEndingOrSpace(code2)) {
data = true;
}
size++;
effects.consume(code2);
return code2 === 92 ? callEscape : callData;
}
function callEscape(code2) {
if (code2 === 91 || code2 === 92 || code2 === 93) {
effects.consume(code2);
size++;
return callData;
}
return callData(code2);
}
}
function tokenizeDefinitionStart(effects, ok2, nok) {
const self = this;
const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);
let identifier;
let size = 0;
let data;
return start;
function start(code2) {
effects.enter("gfmFootnoteDefinition")._container = true;
effects.enter("gfmFootnoteDefinitionLabel");
effects.enter("gfmFootnoteDefinitionLabelMarker");
effects.consume(code2);
effects.exit("gfmFootnoteDefinitionLabelMarker");
return labelAtMarker;
}
function labelAtMarker(code2) {
if (code2 === 94) {
effects.enter("gfmFootnoteDefinitionMarker");
effects.consume(code2);
effects.exit("gfmFootnoteDefinitionMarker");
effects.enter("gfmFootnoteDefinitionLabelString");
effects.enter("chunkString").contentType = "string";
return labelInside;
}
return nok(code2);
}
function labelInside(code2) {
if (
// Too long.
size > 999 || // Closing brace with nothing.
code2 === 93 && !data || // Space or tab is not supported by GFM for some reason.
// `\n` and `[` not being supported makes sense.
code2 === null || code2 === 91 || markdownLineEndingOrSpace(code2)
) {
return nok(code2);
}
if (code2 === 93) {
effects.exit("chunkString");
const token = effects.exit("gfmFootnoteDefinitionLabelString");
identifier = normalizeIdentifier(self.sliceSerialize(token));
effects.enter("gfmFootnoteDefinitionLabelMarker");
effects.consume(code2);
effects.exit("gfmFootnoteDefinitionLabelMarker");
effects.exit("gfmFootnoteDefinitionLabel");
return labelAfter;
}
if (!markdownLineEndingOrSpace(code2)) {
data = true;
}
size++;
effects.consume(code2);
return code2 === 92 ? labelEscape : labelInside;
}
function labelEscape(code2) {
if (code2 === 91 || code2 === 92 || code2 === 93) {
effects.consume(code2);
size++;
return labelInside;
}
return labelInside(code2);
}
function labelAfter(code2) {
if (code2 === 58) {
effects.enter("definitionMarker");
effects.consume(code2);
effects.exit("definitionMarker");
if (!defined.includes(identifier)) {
defined.push(identifier);
}
return factorySpace(effects, whitespaceAfter, "gfmFootnoteDefinitionWhitespace");
}
return nok(code2);
}
function whitespaceAfter(code2) {
return ok2(code2);
}
}
function tokenizeDefinitionContinuation(effects, ok2, nok) {
return effects.check(blankLine, ok2, effects.attempt(indent, ok2, nok));
}
function gfmFootnoteDefinitionEnd(effects) {
effects.exit("gfmFootnoteDefinition");
}
function tokenizeIndent(effects, ok2, nok) {
const self = this;
return factorySpace(effects, afterPrefix, "gfmFootnoteDefinitionIndent", 4 + 1);
function afterPrefix(code2) {
const tail = self.events[self.events.length - 1];
return tail && tail[1].type === "gfmFootnoteDefinitionIndent" && tail[2].sliceSerialize(tail[1], true).length === 4 ? ok2(code2) : nok(code2);
}
}
function gfmStrikethrough(options) {
const options_ = options || {};
let single = options_.singleTilde;
const tokenizer = {
name: "strikethrough",
tokenize: tokenizeStrikethrough,
resolveAll: resolveAllStrikethrough
};
if (single === null || single === void 0) {
single = true;
}
return {
text: {
[126]: tokenizer
},
insideSpan: {
null: [tokenizer]
},
attentionMarkers: {
null: [126]
}
};
function resolveAllStrikethrough(events, context) {
let index = -1;
while (++index < events.length) {
if (events[index][0] === "enter" && events[index][1].type === "strikethroughSequenceTemporary" && events[index][1]._close) {
let open = index;
while (open--) {
if (events[open][0] === "exit" && events[open][1].type === "strikethroughSequenceTemporary" && events[open][1]._open && // If the sizes are the same:
events[index][1].end.offset - events[index][1].start.offset === events[open][1].end.offset - events[open][1].start.offset) {
events[index][1].type = "strikethroughSequence";
events[open][1].type = "strikethroughSequence";
const strikethrough = {
type: "strikethrough",
start: Object.assign({}, events[open][1].start),
end: Object.assign({}, events[index][1].end)
};
const text2 = {
type: "strikethroughText",
start: Object.assign({}, events[open][1].end),
end: Object.assign({}, events[index][1].start)
};
const nextEvents = [["enter", strikethrough, context], ["enter", events[open][1], context], ["exit", events[open][1], context], ["enter", text2, context]];
const insideSpan = context.parser.constructs.insideSpan.null;
if (insideSpan) {
splice(nextEvents, nextEvents.length, 0, resolveAll(insideSpan, events.slice(open + 1, index), context));
}
splice(nextEvents, nextEvents.length, 0, [["exit", text2, context], ["enter", events[index][1], context], ["exit", events[index][1], context], ["exit", strikethrough, context]]);
splice(events, open - 1, index - open + 3, nextEvents);
index = open + nextEvents.length - 2;
break;
}
}
}
}
index = -1;
while (++index < events.length) {
if (events[index][1].type === "strikethroughSequenceTemporary") {
events[index][1].type = "data";
}
}
return events;
}
function tokenizeStrikethrough(effects, ok2, nok) {
const previous2 = this.previous;
const events = this.events;
let size = 0;
return start;
function start(code2) {
if (previous2 === 126 && events[events.length - 1][1].type !== "characterEscape") {
return nok(code2);
}
effects.enter("strikethroughSequenceTemporary");
return more(code2);
}
function more(code2) {
const before = classifyCharacter(previous2);
if (code2 === 126) {
if (size > 1) return nok(code2);
effects.consume(code2);
size++;
return more;
}
if (size < 2 && !single) return nok(code2);
const token = effects.exit("strikethroughSequenceTemporary");
const after = classifyCharacter(code2);
token._open = !after || after === 2 && Boolean(before);
token._close = !before || before === 2 && Boolean(after);
return ok2(code2);
}
}
}
class EditMap {
/**
* Create a new edit map.
*/
constructor() {
this.map = [];
}
/**
* Create an edit: a remove and/or add at a certain place.
*
* @param {number} index
* @param {number} remove
* @param {Array<Event>} add
* @returns {undefined}
*/
add(index, remove, add) {
addImplementation(this, index, remove, add);
}
// To do: add this when moving to `micromark`.
// /**
// * Create an edit: but insert `add` before existing additions.
// *
// * @param {number} index
// * @param {number} remove
// * @param {Array<Event>} add
// * @returns {undefined}
// */
// addBefore(index, remove, add) {
// addImplementation(this, index, remove, add, true)
// }
/**
* Done, change the events.
*
* @param {Array<Event>} events
* @returns {undefined}
*/
consume(events) {
this.map.sort(function(a, b) {
return a[0] - b[0];
});
if (this.map.length === 0) {
return;
}
let index = this.map.length;
const vecs = [];
while (index > 0) {
index -= 1;
vecs.push(events.slice(this.map[index][0] + this.map[index][1]), this.map[index][2]);
events.length = this.map[index][0];
}
vecs.push(events.slice());
events.length = 0;
let slice = vecs.pop();
while (slice) {
for (const element of slice) {
events.push(element);
}
slice = vecs.pop();
}
this.map.length = 0;
}
}
function addImplementation(editMap, at, remove, add) {
let index = 0;
if (remove === 0 && add.length === 0) {
return;
}
while (index < editMap.map.length) {
if (editMap.map[index][0] === at) {
editMap.map[index][1] += remove;
editMap.map[index][2].push(...add);
return;
}
index += 1;
}
editMap.map.push([at, remove, add]);
}
function gfmTableAlign(events, index) {
let inDelimiterRow = false;
const align = [];
while (index < events.length) {
const event = events[index];
if (inDelimiterRow) {
if (event[0] === "enter") {
if (event[1].type === "tableContent") {
align.push(events[index + 1][1].type === "tableDelimiterMarker" ? "left" : "none");
}
} else if (event[1].type === "tableContent") {
if (events[index - 1][1].type === "tableDelimiterMarker") {
const alignIndex = align.length - 1;
align[alignIndex] = align[alignIndex] === "left" ? "center" : "right";
}
} else if (event[1].type === "tableDelimiterRow") {
break;
}
} else if (event[0] === "enter" && event[1].type === "tableDelimiterRow") {
inDelimiterRow = true;
}
index += 1;
}
return align;
}
function gfmTable() {
return {
flow: {
null: {
name: "table",
tokenize: tokenizeTable,
resolveAll: resolveTable
}
}
};
}
function tokenizeTable(effects, ok2, nok) {
const self = this;
let size = 0;
let sizeB = 0;
let seen;
return start;
function start(code2) {
let index = self.events.length - 1;
while (index > -1) {
const type = self.events[index][1].type;
if (type === "lineEnding" || // Note: markdown-rs uses `whitespace` instead of `linePrefix`
type === "linePrefix") index--;
else break;
}
const tail = index > -1 ? self.events[index][1].type : null;
const next = tail === "tableHead" || tail === "tableRow" ? bodyRowStart : headRowBefore;
if (next === bodyRowStart && self.parser.lazy[self.now().line]) {
return nok(code2);
}
return next(code2);
}
function headRowBefore(code2) {
effects.enter("tableHead");
effects.enter("tableRow");
return headRowStart(code2);
}
function headRowStart(code2) {
if (code2 === 124) {
return headRowBreak(code2);
}
seen = true;
sizeB += 1;
return headRowBreak(code2);
}
function headRowBreak(code2) {
if (code2 === null) {
return nok(code2);
}
if (markdownLineEnding(code2)) {
if (sizeB > 1) {
sizeB = 0;
self.interrupt = true;
effects.exit("tableRow");
effects.enter("lineEnding");
effects.consume(code2);
effects.exit("lineEnding");
return headDelimiterStart;
}
return nok(code2);
}
if (markdownSpace(code2)) {
return factorySpace(effects, headRowBreak, "whitespace")(code2);
}
sizeB += 1;
if (seen) {
seen = false;
size += 1;
}
if (code2 === 124) {
effects.enter("tableCellDivider");
effects.consume(code2);
effects.exit("tableCellDivider");
seen = true;
return headRowBreak;
}
effects.enter("data");
return headRowData(code2);
}
function headRowData(code2) {
if (code2 === null || code2 === 124 || markdownLineEndingOrSpace(code2)) {
effects.exit("data");
return headRowBreak(code2);
}
effects.consume(code2);
return code2 === 92 ? headRowEscape : headRowData;
}
function headRowEscape(code2) {
if (code2 === 92 || code2 === 124) {
effects.consume(code2);
return headRowData;
}
return headRowData(code2);
}
function headDelimiterStart(code2) {
self.interrupt = false;
if (self.parser.lazy[self.now().line]) {
return nok(code2);
}
effects.enter("tableDelimiterRow");
seen = false;
if (markdownSpace(code2)) {
return factorySpace(effects, headDelimiterBefore, "linePrefix", self.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4)(code2);
}
return headDelimiterBefore(code2);
}
function headDelimiterBefore(code2) {
if (code2 === 45 || code2 === 58) {
return headDelimiterValueBefore(code2);
}
if (code2 === 124) {
seen = true;
effects.enter("tableCellDivider");
effects.consume(code2);
effects.exit("tableCellDivider");
return headDelimiterCellBefore;
}
return headDelimiterNok(code2);
}
function headDelimiterCellBefore(code2) {
if (markdownSpace(code2)) {
return factorySpace(effects, headDelimiterValueBefore, "whitespace")(code2);
}
return headDelimiterValueBefore(code2);
}
function headDelimiterValueBefore(code2) {
if (code2 === 58) {
sizeB += 1;
seen = true;
effects.enter("tableDelimiterMarker");
effects.consume(code2);
effects.exit("tableDelimiterMarker");
return headDelimiterLeftAlignmentAfter;
}
if (code2 === 45) {
sizeB += 1;
return headDelimiterLeftAlignmentAfter(code2);
}
if (code2 === null || markdownLineEnding(code2)) {
return headDelimiterCellAfter(code2);
}
return headDelimiterNok(code2);
}
function headDelimiterLeftAlignmentAfter(code2) {
if (code2 === 45) {
effects.enter("tableDelimiterFiller");
return headDelimiterFiller(code2);
}
return headDelimiterNok(code2);
}
function headDelimiterFiller(code2) {
if (code2 === 45) {
effects.consume(code2);
return headDelimiterFiller;
}
if (code2 === 58) {
seen = true;
effects.exit("tableDelimiterFiller");
effects.enter("tableDelimiterMarker");
effects.consume(code2);
effects.exit("tableDelimiterMarker");
return headDelimiterRightAlignmentAfter;
}
effects.exit("tableDelimiterFiller");
return headDelimiterRightAlignmentAfter(code2);
}
function headDelimiterRightAlignmentAfter(code2) {
if (markdownSpace(code2)) {
return factorySpace(effects, headDelimiterCellAfter, "whitespace")(code2);
}
return headDelimiterCellAfter(code2);
}
function headDelimiterCellAfter(code2) {
if (code2 === 124) {
return headDelimiterBefore(code2);
}
if (code2 === null || markdownLineEnding(code2)) {
if (!seen || size !== sizeB) {
return headDelimiterNok(code2);
}
effects.exit("tableDelimiterRow");
effects.exit("tableHead");
return ok2(code2);
}
return headDelimiterNok(code2);
}
function headDelimiterNok(code2) {
return nok(code2);
}
function bodyRowStart(code2) {
effects.enter("tableRow");
return bodyRowBreak(code2);
}
function bodyRowBreak(code2) {
if (code2 === 124) {
effects.enter("tableCellDivider");
effects.consume(code2);
effects.exit("tableCellDivider");
return bodyRowBreak;
}
if (code2 === null || markdownLineEnding(code2)) {
effects.exit("tableRow");
return ok2(code2);
}
if (markdownSpace(code2)) {
return factorySpace(effects, bodyRowBreak, "whitespace")(code2);
}
effects.enter("data");
return bodyRowData(code2);
}
function bodyRowData(code2) {
if (code2 === null || code2 === 124 || markdownLineEndingOrSpace(code2)) {
effects.exit("data");
return bodyRowBreak(code2);
}
effects.consume(code2);
return code2 === 92 ? bodyRowEscape : bodyRowData;
}
function bodyRowEscape(code2) {
if (code2 === 92 || code2 === 124) {
effects.consume(code2);
return bodyRowData;
}
return bodyRowData(code2);
}
}
function resolveTable(events, context) {
let index = -1;
let inFirstCellAwaitingPipe = true;
let rowKind = 0;
let lastCell = [0, 0, 0, 0];
let cell = [0, 0, 0, 0];
let afterHeadAwaitingFirstBodyRow = false;
let lastTableEnd = 0;
let currentTable;
let currentBody;
let currentCell;
const map2 = new EditMap();
while (++index < events.length) {
const event = events[index];
const token = event[1];
if (event[0] === "enter") {
if (token.type === "tableHead") {
afterHeadAwaitingFirstBodyRow = false;
if (lastTableEnd !== 0) {
flushTableEnd(map2, context, lastTableEnd, currentTable, currentBody);
currentBody = void 0;
lastTableEnd = 0;
}
currentTable = {
type: "table",
start: Object.assign({}, token.start),
// Note: correct end is set later.
end: Object.assign({}, token.end)
};
map2.add(index, 0, [["enter", currentTable, context]]);
} else if (token.type === "tableRow" || token.type === "tableDelimiterRow") {
inFirstCellAwaitingPipe = true;
currentCell = void 0;
lastCell = [0, 0, 0, 0];
cell = [0, index + 1, 0, 0];
if (afterHeadAwaitingFirstBodyRow) {
afterHeadAwaitingFirstBodyRow = false;
currentBody = {
type: "tableBody",
start: Object.assign({}, token.start),
// Note: correct end is set later.
end: Object.assign({}, token.end)
};
map2.add(index, 0, [["enter", currentBody, context]]);
}
rowKind = token.type === "tableDelimiterRow" ? 2 : currentBody ? 3 : 1;
} else if (rowKind && (token.type === "data" || token.type === "tableDelimiterMarker" || token.type === "tableDelimiterFiller")) {
inFirstCellAwaitingPipe = false;
if (cell[2] === 0) {
if (lastCell[1] !== 0) {
cell[0] = cell[1];
currentCell = flushCell(map2, context, lastCell, rowKind, void 0, currentCell);
lastCell = [0, 0, 0, 0];
}
cell[2] = index;
}
} else if (token.type === "tableCellDivider") {
if (inFirstCellAwaitingPipe) {
inFirstCellAwaitingPipe = false;
} else {
if (lastCell[1] !== 0) {
cell[0] = cell[1];
currentCell = flushCell(map2, context, lastCell, rowKind, void 0, currentCell);
}
lastCell = cell;
cell = [lastCell[1], index, 0, 0];
}
}
} else if (token.type === "tableHead") {
afterHeadAwaitingFirstBodyRow = true;
lastTableEnd = index;
} else if (token.type === "tableRow" || token.type === "tableDelimiterRow") {
lastTableEnd = index;
if (lastCell[1] !== 0) {
cell[0] = cell[1];
currentCell = flushCell(map2, context, lastCell, rowKind, index, currentCell);
} else if (cell[1] !== 0) {
currentCell = flushCell(map2, context, cell, rowKind, index, currentCell);
}
rowKind = 0;
} else if (rowKind && (token.type === "data" || token.type === "tableDelimiterMarker" || token.type === "tableDelimiterFiller")) {
cell[3] = index;
}
}
if (lastTableEnd !== 0) {
flushTableEnd(map2, context, lastTableEnd, currentTable, currentBody);
}
map2.consume(context.events);
index = -1;
while (++index < context.events.length) {
const event = context.events[index];
if (event[0] === "enter" && event[1].type === "table") {
event[1]._align = gfmTableAlign(context.events, index);
}
}
return events;
}
function flushCell(map2, context, range, rowKind, rowEnd, previousCell) {
const groupName = rowKind === 1 ? "tableHeader" : rowKind === 2 ? "tableDelimiter" : "tableData";
const valueName = "tableContent";
if (range[0] !== 0) {
previousCell.end = Object.assign({}, getPoint(context.events, range[0]));
map2.add(range[0], 0, [["exit", previousCell, context]]);
}
const now = getPoint(context.events, range[1]);
previousCell = {
type: groupName,
start: Object.assign({}, now),
// Note: correct end is set later.
end: Object.assign({}, now)
};
map2.add(range[1], 0, [["enter", previousCell, context]]);
if (range[2] !== 0) {
const relatedStart = getPoint(context.events, range[2]);
const relatedEnd = getPoint(context.events, range[3]);
const valueToken = {
type: valueName,
start: Object.assign({}, relatedStart),
end: Object.assign({}, relatedEnd)
};
map2.add(range[2], 0, [["enter", valueToken, context]]);
if (rowKind !== 2) {
const start = context.events[range[2]];
const end = context.events[range[3]];
start[1].end = Object.assign({}, end[1].end);
start[1].type = "chunkText";
start[1].contentType = "text";
if (range[3] > range[2] + 1) {
const a = range[2] + 1;
const b = range[3] - range[2] - 1;
map2.add(a, b, []);
}
}
map2.add(range[3] + 1, 0, [["exit", valueToken, context]]);
}
if (rowEnd !== void 0) {
previousCell.end = Object.assign({}, getPoint(context.events, rowEnd));
map2.add(rowEnd, 0, [["exit", previousCell, context]]);
previousCell = void 0;
}
return previousCell;
}
function flushTableEnd(map2, context, index, table, tableBody) {
const exits = [];
const related = getPoint(context.events, index);
if (tableBody) {
tableBody.end = Object.assign({}, related);
exits.push(["exit", tableBody, context]);
}
table.end = Object.assign({}, related);
exits.push(["exit", table, context]);
map2.add(index + 1, 0, exits);
}
function getPoint(events, index) {
const event = events[index];
const side = event[0] === "enter" ? "start" : "end";
return event[1][side];
}
const tasklistCheck = {
name: "tasklistCheck",
tokenize: tokenizeTasklistCheck
};
function gfmTaskListItem() {
return {
text: {
[91]: tasklistCheck
}
};
}
function tokenizeTasklistCheck(effects, ok2, nok) {
const self = this;
return open;
function open(code2) {
if (
// Exit if there’s stuff before.
self.previous !== null || // Exit if not in the first content that is the first child of a list
// item.
!self._gfmTasklistFirstContentOfListItem
) {
return nok(code2);
}
effects.enter("taskListCheck");
effects.enter("taskListCheckMarker");
effects.consume(code2);
effects.exit("taskListCheckMarker");
return inside;
}
function inside(code2) {
if (markdownLineEndingOrSpace(code2)) {
effects.enter("taskListCheckValueUnchecked");
effects.consume(code2);
effects.exit("taskListCheckValueUnchecked");
return close;
}
if (code2 === 88 || code2 === 120) {
effects.enter("taskListCheckValueChecked");
effects.consume(code2);
effects.exit("taskListCheckValueChecked");
return close;
}
return nok(code2);
}
function close(code2) {
if (code2 === 93) {
effects.enter("taskListCheckMarker");
effects.consume(code2);
effects.exit("taskListCheckMarker");
effects.exit("taskListCheck");
return after;
}
return nok(code2);
}
function after(code2) {
if (markdownLineEnding(code2)) {
return ok2(code2);
}
if (markdownSpace(code2)) {
return effects.check({
tokenize: spaceThenNonSpace
}, ok2, nok)(code2);
}
return nok(code2);
}
}
function spaceThenNonSpace(effects, ok2, nok) {
return factorySpace(effects, after, "whitespace");
function after(code2) {
return code2 === null ? nok(code2) : ok2(code2);
}
}
function gfm(options) {
return combineExtensions([
gfmAutolinkLiteral(),
gfmFootnote(),
gfmStrikethrough(options),
gfmTable(),
gfmTaskListItem()
]);
}
const emptyOptions = {};
function remarkGfm(options) {
const self = (
/** @type {Processor<Root>} */
this
);
const settings = options || emptyOptions;
const data = self.data();
const micromarkExtensions = data.micromarkExtensions || (data.micromarkExtensions = []);
const fromMarkdownExtensions = data.fromMarkdownExtensions || (data.fromMarkdownExtensions = []);
const toMarkdownExtensions = data.toMarkdownExtensions || (data.toMarkdownExtensions = []);
micromarkExtensions.push(gfm(settings));
fromMarkdownExtensions.push(gfmFromMarkdown());
toMarkdownExtensions.push(gfmToMarkdown(settings));
}
const _sfc_main$1 = /* @__PURE__ */ defineComponent({
__name: "NcRichTextCopyButton",
props: {
contentId: {}
},
setup(__props) {
const { copy, icon, altText } = useCopy(() => document.getElementById(__props.contentId).textContent);
return (_ctx, _cache) => {
return openBlock(), createBlock(NcButton, {
variant: "tertiary",
size: "small",
"aria-label": unref(altText),
title: unref(altText),
onClick: unref(copy)
}, {
icon: withCtx(() => [
createVNode(NcIconSvgWrapper, {
path: unref(icon),
inline: ""
}, null, 8, ["path"])
]),
_: 1
}, 8, ["aria-label", "title", "onClick"]);
};
}
});
/*!
* SPDX-FileCopyrightText: 2023 Nextcloud GmbH and Nextcloud contributors
* SPDX-License-Identifier: AGPL-3.0-or-later
*/
function isTextNode$1(node) {
return node.type === "text";
}
const transformPlaceholders = function(ast) {
visitParents(ast, isTextNode$1, (node, ancestors) => {
const parent = ancestors.at(-1);
const index = parent.children.indexOf(node);
const placeholders = node.value.split(/(\{[a-z\-_.0-9]+\})/ig).map((entry) => {
const matches = entry.match(/^\{([a-z\-_.0-9]+)\}$/i);
if (!matches) {
return u("text", entry);
}
const [, component] = matches;
return u("element", {
tagName: `#${component}`,
children: []
});
});
parent.children.splice(index, 1, ...placeholders);
});
};
const remarkPlaceholder = () => transformPlaceholders;
/*!
* SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
* SPDX-License-Identifier: AGPL-3.0-or-later
*/
function isCodeNode(node) {
return ["code", "inlineCode"].includes(node.type);
}
const remarkStripCode = function() {
return function(tree) {
visitParents(tree, isCodeNode, (node, ancestors) => {
const parent = ancestors.at(-1);
const index = parent.children.indexOf(node);
parent.children.splice(index, 1, {
...node,
value: ""
});
return [SKIP, index + 1];
});
};
};
/*!
* SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
* SPDX-License-Identifier: AGPL-3.0-or-later
*/
function isTextNode(node) {
return ["text", "code", "inlineCode"].includes(node.type);
}
const remarkUnescape = function() {
return function(tree) {
visitParents(tree, isTextNode, (node, ancestors) => {
const parent = ancestors.at(-1);
const index = parent.children.indexOf(node);
parent.children.splice(index, 1, {
...node,
value: node.value.replace(/</gmi, "<").replace(/>/gmi, ">")
});
return [SKIP, index + 1];
});
};
};
const LINK_PROTOCOLS = ["http", "https", "mailto", "tel"];
const rehypeHighlight = ref(null);
async function importRehypeHighlightLibrary() {
const module = await import("rehype-highlight");
rehypeHighlight.value = module.default;
}
const _sfc_main = {
name: "NcRichText",
components: {
NcReferenceList
},
/* eslint vue/require-prop-comment: warn -- TODO: Add a proper doc block about what this props do */
props: {
/**
* The main text
*/
text: {
type: String,
default: ""
},
arguments: {
type: Object,
default: () => {
return {};
}
},
referenceLimit: {
type: Number,
default: 0
},
referenceInteractive: {
type: Boolean,
default: true
},
referenceInteractiveOptIn: {
type: Boolean,
default: false
},
/** Provide data upfront to avoid extra http request */
references: {
type: Array,
default: null
},
/** Provide basic Markdown syntax */
useMarkdown: {
type: Boolean,
default: false
},
/** Provide GitHub Flavored Markdown syntax */
useExtendedMarkdown: {
type: Boolean,
default: false
},
/** Provide event from rendered markdown inputs */
interactive: {
type: Boolean,
default: false
},
/**
* Automatically convert link-like text to markdown links
*/
autolink: {
type: Boolean,
default: true
}
},
emits: [
"interactTodo"
],
data() {
return {
parentId: createElementId()
};
},
methods: {
renderPlaintext() {
const placeholders = this.text.split(/(\{[a-z\-_.0-9]+\})/ig).map((entry) => {
const matches = entry.match(/^\{([a-z\-_.0-9]+)\}$/i);
if (!matches) {
return this.prepareTextNode(entry);
}
const argumentId = matches[1];
const argument = this.arguments[argumentId];
if (typeof argument === "object") {
const { component, props } = argument;
return h(typeof component === "string" ? resolveComponent(component) : component, {
...props,
class: "rich-text--component"
});
}
if (argument) {
return h("span", { class: "rich-text--fallback" }, argument);
}
return entry;
});
return h("div", { class: "rich-text--wrapper" }, [
h("div", {}, placeholders.flat()),
this.referenceLimit > 0 ? h("div", { class: "rich-text--reference-widget" }, [
h(NcReferenceList, {
text: this.text,
referenceData: this.references,
interactive: this.referenceInteractive,
interactiveOptIn: this.referenceInteractiveOptIn
})
]) : null
]);
},
renderMarkdown() {
const renderedMarkdown = unified().use(remarkParse).use(remarkAutolink, {
autolink: this.autolink,
useMarkdown: this.useMarkdown,
useExtendedMarkdown: this.useExtendedMarkdown
}).use(remarkUnescape).use(this.useExtendedMarkdown ? remarkGfm : void 0).use(breaks).use(remarkUnlinkProtocols, { except: LINK_PROTOCOLS }).use(remark2rehype, {
handlers: {
component(toHast, node) {
return toHast(node, node.component, { value: node.value });
}
}
}).use(this.useExtendedMarkdown ? rehypeHighlight.value : void 0).use(remarkPlaceholder).use(rehypeExternalLinks, {
target: "_blank",
rel: ["noopener noreferrer"]
}).use(rehype2react, {
Fragment,
jsx: this.createElement,
jsxs: this.createElement,
elementAttributeNameCase: "html",
prefix: false
}).processSync(this.text.replace(/<[^>]+>/g, (match) => match.replace(/</g, "<")).replace(/>/gmi, ">")).result;
return h("div", { class: "rich-text--wrapper rich-text--wrapper-markdown" }, [
renderedMarkdown,
this.referenceLimit > 0 ? h("div", { class: "rich-text--reference-widget" }, [
h(NcReferenceList, {
text: this.prepareReferenceSource(this.text),
referenceData: this.references,
interactive: this.referenceInteractive,
interactiveOptIn: this.referenceInteractiveOptIn
})
]) : null
]);
},
/**
* Render plain text nodes
*
* @param {string} text - Content of the node
*/
prepareTextNode(text2) {
if (this.autolink) {
text2 = parseUrl(text2);
}
if (Array.isArray(text2)) {
return text2.map((entry) => {
if (typeof entry === "string") {
return entry;
}
const { component, props } = entry;
return h(component, {
...props,
class: "rich-text--component"
});
});
}
return text2;
},
/**
* Strip content of inline code and code blocks for reference widgets
* (e.g. ignore fenced links from being added as reference)
*
* @param {string} text - Content of the node
*/
prepareReferenceSource(text2) {
if (!this.useMarkdown && !this.useExtendedMarkdown) {
return text2;
}
const processor = unified();
processor.compiler = (tree) => toString(tree);
return processor.use(remarkParse).use(remarkStripCode).processSync(text2.replace(/\s/g, " ")).value;
},
createElement(type, props, key) {
if (key) {
props.key = key;
}
const children = props.children ?? [];
delete props.children;
if (!String(type).startsWith("#")) {
if (["h1", "h2", "h3", "h4", "h5", "h6"].includes(String(type))) {
type = `h${Math.min(+String(type)[1] + 3, 6)}`;
}
let nestedNode = null;
if (this.useExtendedMarkdown) {
if (String(type) === "code" && !rehypeHighlight.value && props?.class?.includes("language")) {
importRehypeHighlightLibrary();
}
if (String(type) === "pre" && children && String(children.type) === "code") {
const id = this.parentId + "-code-block-" + createElementId();
return h("p", { class: "rich-text__code-block" }, [
h(type, { ...props, id }, children),
h(_sfc_main$1, { class: "rich-text__code-block-button", contentId: id })
]);
}
if (String(type) === "li" && Array.isArray(children) && children.length !== 0 && children[0].type === "input" && children[0].props.type === "checkbox") {
const [inputNode, , ...labelParts] = children;
const nestedNodeIndex = labelParts.findIndex((child) => ["ul", "ol", "li", "blockquote", "pre"].includes(child.type));
if (nestedNodeIndex !== -1) {
nestedNode = labelParts[nestedNodeIndex];
labelParts.splice(nestedNodeIndex);
}
const id = this.parentId + "-markdown-input-" + createElementId();
const propsToForward = { ...inputNode.props };
delete propsToForward.checked;
const inputComponent = h(NcCheckboxRadioSwitch, {
...propsToForward,
modelValue: inputNode.props.checked,
id,
disabled: !this.interactive,
"onUpdate:modelValue": () => {
this.$emit("interactTodo", id);
}
}, { default: () => labelParts });
return h(type, props, [inputComponent, nestedNode]);
}
}
if (String(type) === "a") {
const route = getRoute(this.$router, props.href);
if (route) {
delete props.href;
delete props.target;
return h(RouterLink, {
...props,
to: route
}, { default: () => children });
}
const isAllowedScheme = /^(https?:\/\/|tel:|mailto:)/.test(props.href);
if (isAllowedScheme) {
props.href = props.href.trim();
return h(NcRichTextExternalLink, props, children);
} else {
delete props.href;
delete props.target;
return h("span", props, children);
}
}
return h(type, props, children);
}
const placeholder = this.arguments[type.slice(1)];
if (!placeholder) {
return h("span", { ...props, class: "rich-text--fallback" }, [`{${type.slice(1)}}`]);
}
if (!placeholder.component) {
return h("span", { ...props }, [placeholder]);
}
return h(
typeof placeholder.component === "string" ? resolveComponent(placeholder.component) : placeholder.component,
{
...props,
...placeholder.props,
class: "rich-text--component"
},
{ default: () => children }
);
}
},
render() {
return this.useMarkdown || this.useExtendedMarkdown ? this.renderMarkdown() : this.renderPlaintext();
}
};
const NcRichText = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-76a4a548"]]);
export {
NcRichText as N,
NcReferenceList as a
};
//# sourceMappingURL=NcRichText-Dkk6iX8F.mjs.map