123 lines
3.3 KiB
JavaScript
123 lines
3.3 KiB
JavaScript
import {
|
|
convert,
|
|
visitParents
|
|
} from "./chunk-5YG5I5XG.js";
|
|
|
|
// node_modules/escape-string-regexp/index.js
|
|
function escapeStringRegexp(string) {
|
|
if (typeof string !== "string") {
|
|
throw new TypeError("Expected a string");
|
|
}
|
|
return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
|
|
}
|
|
|
|
// node_modules/mdast-util-find-and-replace/lib/index.js
|
|
function findAndReplace(tree, list, options) {
|
|
const settings = options || {};
|
|
const ignored = convert(settings.ignore || []);
|
|
const pairs = toPairs(list);
|
|
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 replace = 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 = replace(...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 list = !tupleOrList[0] || Array.isArray(tupleOrList[0]) ? tupleOrList : [tupleOrList];
|
|
let index = -1;
|
|
while (++index < list.length) {
|
|
const tuple = list[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(replace) {
|
|
return typeof replace === "function" ? replace : function() {
|
|
return replace;
|
|
};
|
|
}
|
|
|
|
export {
|
|
findAndReplace
|
|
};
|
|
//# sourceMappingURL=chunk-SXF7NEGZ.js.map
|