trieve-search-component
Version:
The easiest way to get up and running in your app using trieve search.
10,027 lines • 296 kB
JavaScript
import {
__commonJS,
__export,
__toESM
} from "./chunk-SNAQBZPT.js";
// ../../node_modules/inline-style-parser/index.js
var require_inline_style_parser = __commonJS({
"../../node_modules/inline-style-parser/index.js"(exports, module) {
var COMMENT_REGEX = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//g;
var NEWLINE_REGEX = /\n/g;
var WHITESPACE_REGEX = /^\s*/;
var PROPERTY_REGEX = /^(\*?[-#/*\\\w]+(\[[0-9a-z_-]+\])?)\s*/;
var COLON_REGEX = /^:\s*/;
var VALUE_REGEX = /^((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};])+)/;
var SEMICOLON_REGEX = /^[;\s]*/;
var TRIM_REGEX = /^\s+|\s+$/g;
var NEWLINE = "\n";
var FORWARD_SLASH = "/";
var ASTERISK = "*";
var EMPTY_STRING = "";
var TYPE_COMMENT = "comment";
var TYPE_DECLARATION = "declaration";
module.exports = function(style, options) {
if (typeof style !== "string") {
throw new TypeError("First argument must be a string");
}
if (!style) return [];
options = options || {};
var lineno = 1;
var column = 1;
function updatePosition(str) {
var lines = str.match(NEWLINE_REGEX);
if (lines) lineno += lines.length;
var i = str.lastIndexOf(NEWLINE);
column = ~i ? str.length - i : column + str.length;
}
function position4() {
var start2 = { line: lineno, column };
return function(node2) {
node2.position = new Position(start2);
whitespace2();
return node2;
};
}
function Position(start2) {
this.start = start2;
this.end = { line: lineno, column };
this.source = options.source;
}
Position.prototype.content = style;
var errorsList = [];
function error(msg) {
var err = new Error(
options.source + ":" + lineno + ":" + column + ": " + msg
);
err.reason = msg;
err.filename = options.source;
err.line = lineno;
err.column = column;
err.source = style;
if (options.silent) {
errorsList.push(err);
} else {
throw err;
}
}
function match(re2) {
var m = re2.exec(style);
if (!m) return;
var str = m[0];
updatePosition(str);
style = style.slice(str.length);
return m;
}
function whitespace2() {
match(WHITESPACE_REGEX);
}
function comments(rules) {
var c;
rules = rules || [];
while (c = comment()) {
if (c !== false) {
rules.push(c);
}
}
return rules;
}
function comment() {
var pos = position4();
if (FORWARD_SLASH != style.charAt(0) || ASTERISK != style.charAt(1)) return;
var i = 2;
while (EMPTY_STRING != style.charAt(i) && (ASTERISK != style.charAt(i) || FORWARD_SLASH != style.charAt(i + 1))) {
++i;
}
i += 2;
if (EMPTY_STRING === style.charAt(i - 1)) {
return error("End of comment missing");
}
var str = style.slice(2, i - 2);
column += 2;
updatePosition(str);
style = style.slice(i);
column += 2;
return pos({
type: TYPE_COMMENT,
comment: str
});
}
function declaration() {
var pos = position4();
var prop = match(PROPERTY_REGEX);
if (!prop) return;
comment();
if (!match(COLON_REGEX)) return error("property missing ':'");
var val = match(VALUE_REGEX);
var ret = pos({
type: TYPE_DECLARATION,
property: trim(prop[0].replace(COMMENT_REGEX, EMPTY_STRING)),
value: val ? trim(val[0].replace(COMMENT_REGEX, EMPTY_STRING)) : EMPTY_STRING
});
match(SEMICOLON_REGEX);
return ret;
}
function declarations() {
var decls = [];
comments(decls);
var decl;
while (decl = declaration()) {
if (decl !== false) {
decls.push(decl);
comments(decls);
}
}
return decls;
}
whitespace2();
return declarations();
};
function trim(str) {
return str ? str.replace(TRIM_REGEX, EMPTY_STRING) : EMPTY_STRING;
}
}
});
// ../../node_modules/style-to-object/cjs/index.js
var require_cjs = __commonJS({
"../../node_modules/style-to-object/cjs/index.js"(exports) {
"use strict";
var __importDefault = exports && exports.__importDefault || function(mod) {
return mod && mod.__esModule ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = StyleToObject;
var inline_style_parser_1 = __importDefault(require_inline_style_parser());
function StyleToObject(style, iterator) {
var styleObject = null;
if (!style || typeof style !== "string") {
return styleObject;
}
var declarations = (0, inline_style_parser_1.default)(style);
var hasIterator = typeof iterator === "function";
declarations.forEach(function(declaration) {
if (declaration.type !== "declaration") {
return;
}
var property = declaration.property, value = declaration.value;
if (hasIterator) {
iterator(property, value, declaration);
} else if (value) {
styleObject = styleObject || {};
styleObject[property] = value;
}
});
return styleObject;
}
}
});
// ../../node_modules/style-to-js/cjs/utilities.js
var require_utilities = __commonJS({
"../../node_modules/style-to-js/cjs/utilities.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.camelCase = void 0;
var CUSTOM_PROPERTY_REGEX = /^--[a-zA-Z0-9_-]+$/;
var HYPHEN_REGEX = /-([a-z])/g;
var NO_HYPHEN_REGEX = /^[^-]+$/;
var VENDOR_PREFIX_REGEX = /^-(webkit|moz|ms|o|khtml)-/;
var MS_VENDOR_PREFIX_REGEX = /^-(ms)-/;
var skipCamelCase = function(property) {
return !property || NO_HYPHEN_REGEX.test(property) || CUSTOM_PROPERTY_REGEX.test(property);
};
var capitalize = function(match, character) {
return character.toUpperCase();
};
var trimHyphen = function(match, prefix) {
return "".concat(prefix, "-");
};
var camelCase = function(property, options) {
if (options === void 0) {
options = {};
}
if (skipCamelCase(property)) {
return property;
}
property = property.toLowerCase();
if (options.reactCompat) {
property = property.replace(MS_VENDOR_PREFIX_REGEX, trimHyphen);
} else {
property = property.replace(VENDOR_PREFIX_REGEX, trimHyphen);
}
return property.replace(HYPHEN_REGEX, capitalize);
};
exports.camelCase = camelCase;
}
});
// ../../node_modules/style-to-js/cjs/index.js
var require_cjs2 = __commonJS({
"../../node_modules/style-to-js/cjs/index.js"(exports, module) {
"use strict";
var __importDefault = exports && exports.__importDefault || function(mod) {
return mod && mod.__esModule ? mod : { "default": mod };
};
var style_to_object_1 = __importDefault(require_cjs());
var utilities_1 = require_utilities();
function StyleToJS(style, options) {
var output = {};
if (!style || typeof style !== "string") {
return output;
}
(0, style_to_object_1.default)(style, function(property, value) {
if (property && value) {
output[(0, utilities_1.camelCase)(property, options)] = value;
}
});
return output;
}
StyleToJS.default = StyleToJS;
module.exports = StyleToJS;
}
});
// ../../node_modules/extend/index.js
var require_extend = __commonJS({
"../../node_modules/extend/index.js"(exports, module) {
"use strict";
var hasOwn = Object.prototype.hasOwnProperty;
var toStr = Object.prototype.toString;
var defineProperty = Object.defineProperty;
var gOPD = Object.getOwnPropertyDescriptor;
var isArray = function isArray2(arr) {
if (typeof Array.isArray === "function") {
return Array.isArray(arr);
}
return toStr.call(arr) === "[object Array]";
};
var isPlainObject2 = function isPlainObject3(obj) {
if (!obj || toStr.call(obj) !== "[object Object]") {
return false;
}
var hasOwnConstructor = hasOwn.call(obj, "constructor");
var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, "isPrototypeOf");
if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {
return false;
}
var key;
for (key in obj) {
}
return typeof key === "undefined" || hasOwn.call(obj, key);
};
var setProperty = function setProperty2(target, options) {
if (defineProperty && options.name === "__proto__") {
defineProperty(target, options.name, {
enumerable: true,
configurable: true,
value: options.newValue,
writable: true
});
} else {
target[options.name] = options.newValue;
}
};
var getProperty = function getProperty2(obj, name2) {
if (name2 === "__proto__") {
if (!hasOwn.call(obj, name2)) {
return void 0;
} else if (gOPD) {
return gOPD(obj, name2).value;
}
}
return obj[name2];
};
module.exports = function extend2() {
var options, name2, src, copy, copyIsArray, clone;
var target = arguments[0];
var i = 1;
var length = arguments.length;
var deep = false;
if (typeof target === "boolean") {
deep = target;
target = arguments[1] || {};
i = 2;
}
if (target == null || typeof target !== "object" && typeof target !== "function") {
target = {};
}
for (; i < length; ++i) {
options = arguments[i];
if (options != null) {
for (name2 in options) {
src = getProperty(target, name2);
copy = getProperty(options, name2);
if (target !== copy) {
if (deep && copy && (isPlainObject2(copy) || (copyIsArray = isArray(copy)))) {
if (copyIsArray) {
copyIsArray = false;
clone = src && isArray(src) ? src : [];
} else {
clone = src && isPlainObject2(src) ? src : {};
}
setProperty(target, { name: name2, newValue: extend2(deep, clone, copy) });
} else if (typeof copy !== "undefined") {
setProperty(target, { name: name2, newValue: copy });
}
}
}
}
}
return target;
};
}
});
// ../../node_modules/devlop/lib/default.js
function ok() {
}
function unreachable() {
}
// ../../node_modules/comma-separated-tokens/index.js
function stringify(values, options) {
const settings = options || {};
const input = values[values.length - 1] === "" ? [...values, ""] : values;
return input.join(
(settings.padRight ? " " : "") + "," + (settings.padLeft === false ? "" : " ")
).trim();
}
// ../../node_modules/estree-util-is-identifier-name/lib/index.js
var nameRe = /^[$_\p{ID_Start}][$_\u{200C}\u{200D}\p{ID_Continue}]*$/u;
var nameReJsx = /^[$_\p{ID_Start}][-$_\u{200C}\u{200D}\p{ID_Continue}]*$/u;
var emptyOptions = {};
function name(name2, options) {
const settings = options || emptyOptions;
const re2 = settings.jsx ? nameReJsx : nameRe;
return re2.test(name2);
}
// ../../node_modules/hast-util-whitespace/lib/index.js
var re = /[ \t\n\f\r]/g;
function whitespace(thing) {
return typeof thing === "object" ? thing.type === "text" ? empty(thing.value) : false : empty(thing);
}
function empty(value) {
return value.replace(re, "") === "";
}
// ../../node_modules/property-information/lib/util/schema.js
var Schema = class {
/**
* @param {SchemaType['property']} property
* Property.
* @param {SchemaType['normal']} normal
* Normal.
* @param {Space | undefined} [space]
* Space.
* @returns
* Schema.
*/
constructor(property, normal, space2) {
this.normal = normal;
this.property = property;
if (space2) {
this.space = space2;
}
}
};
Schema.prototype.normal = {};
Schema.prototype.property = {};
Schema.prototype.space = void 0;
// ../../node_modules/property-information/lib/util/merge.js
function merge(definitions, space2) {
const property = {};
const normal = {};
for (const definition2 of definitions) {
Object.assign(property, definition2.property);
Object.assign(normal, definition2.normal);
}
return new Schema(property, normal, space2);
}
// ../../node_modules/property-information/lib/normalize.js
function normalize(value) {
return value.toLowerCase();
}
// ../../node_modules/property-information/lib/util/info.js
var Info = class {
/**
* @param {string} property
* Property.
* @param {string} attribute
* Attribute.
* @returns
* Info.
*/
constructor(property, attribute) {
this.attribute = attribute;
this.property = property;
}
};
Info.prototype.attribute = "";
Info.prototype.booleanish = false;
Info.prototype.boolean = false;
Info.prototype.commaOrSpaceSeparated = false;
Info.prototype.commaSeparated = false;
Info.prototype.defined = false;
Info.prototype.mustUseProperty = false;
Info.prototype.number = false;
Info.prototype.overloadedBoolean = false;
Info.prototype.property = "";
Info.prototype.spaceSeparated = false;
Info.prototype.space = void 0;
// ../../node_modules/property-information/lib/util/types.js
var types_exports = {};
__export(types_exports, {
boolean: () => boolean,
booleanish: () => booleanish,
commaOrSpaceSeparated: () => commaOrSpaceSeparated,
commaSeparated: () => commaSeparated,
number: () => number,
overloadedBoolean: () => overloadedBoolean,
spaceSeparated: () => spaceSeparated
});
var powers = 0;
var boolean = increment();
var booleanish = increment();
var overloadedBoolean = increment();
var number = increment();
var spaceSeparated = increment();
var commaSeparated = increment();
var commaOrSpaceSeparated = increment();
function increment() {
return 2 ** ++powers;
}
// ../../node_modules/property-information/lib/util/defined-info.js
var checks = (
/** @type {ReadonlyArray<keyof typeof types>} */
Object.keys(types_exports)
);
var DefinedInfo = class extends Info {
/**
* @constructor
* @param {string} property
* Property.
* @param {string} attribute
* Attribute.
* @param {number | null | undefined} [mask]
* Mask.
* @param {Space | undefined} [space]
* Space.
* @returns
* Info.
*/
constructor(property, attribute, mask, space2) {
let index3 = -1;
super(property, attribute);
mark(this, "space", space2);
if (typeof mask === "number") {
while (++index3 < checks.length) {
const check = checks[index3];
mark(this, checks[index3], (mask & types_exports[check]) === types_exports[check]);
}
}
}
};
DefinedInfo.prototype.defined = true;
function mark(values, key, value) {
if (value) {
values[key] = value;
}
}
// ../../node_modules/property-information/lib/util/create.js
function create(definition2) {
const properties = {};
const normals = {};
for (const [property, value] of Object.entries(definition2.properties)) {
const info = new DefinedInfo(
property,
definition2.transform(definition2.attributes || {}, property),
value,
definition2.space
);
if (definition2.mustUseProperty && definition2.mustUseProperty.includes(property)) {
info.mustUseProperty = true;
}
properties[property] = info;
normals[normalize(property)] = property;
normals[normalize(info.attribute)] = property;
}
return new Schema(properties, normals, definition2.space);
}
// ../../node_modules/property-information/lib/aria.js
var aria = create({
properties: {
ariaActiveDescendant: null,
ariaAtomic: booleanish,
ariaAutoComplete: null,
ariaBusy: booleanish,
ariaChecked: booleanish,
ariaColCount: number,
ariaColIndex: number,
ariaColSpan: number,
ariaControls: spaceSeparated,
ariaCurrent: null,
ariaDescribedBy: spaceSeparated,
ariaDetails: null,
ariaDisabled: booleanish,
ariaDropEffect: spaceSeparated,
ariaErrorMessage: null,
ariaExpanded: booleanish,
ariaFlowTo: spaceSeparated,
ariaGrabbed: booleanish,
ariaHasPopup: null,
ariaHidden: booleanish,
ariaInvalid: null,
ariaKeyShortcuts: null,
ariaLabel: null,
ariaLabelledBy: spaceSeparated,
ariaLevel: number,
ariaLive: null,
ariaModal: booleanish,
ariaMultiLine: booleanish,
ariaMultiSelectable: booleanish,
ariaOrientation: null,
ariaOwns: spaceSeparated,
ariaPlaceholder: null,
ariaPosInSet: number,
ariaPressed: booleanish,
ariaReadOnly: booleanish,
ariaRelevant: null,
ariaRequired: booleanish,
ariaRoleDescription: spaceSeparated,
ariaRowCount: number,
ariaRowIndex: number,
ariaRowSpan: number,
ariaSelected: booleanish,
ariaSetSize: number,
ariaSort: null,
ariaValueMax: number,
ariaValueMin: number,
ariaValueNow: number,
ariaValueText: null,
role: null
},
transform(_, property) {
return property === "role" ? property : "aria-" + property.slice(4).toLowerCase();
}
});
// ../../node_modules/property-information/lib/util/case-sensitive-transform.js
function caseSensitiveTransform(attributes, attribute) {
return attribute in attributes ? attributes[attribute] : attribute;
}
// ../../node_modules/property-information/lib/util/case-insensitive-transform.js
function caseInsensitiveTransform(attributes, property) {
return caseSensitiveTransform(attributes, property.toLowerCase());
}
// ../../node_modules/property-information/lib/html.js
var html = create({
attributes: {
acceptcharset: "accept-charset",
classname: "class",
htmlfor: "for",
httpequiv: "http-equiv"
},
mustUseProperty: ["checked", "multiple", "muted", "selected"],
properties: {
// Standard Properties.
abbr: null,
accept: commaSeparated,
acceptCharset: spaceSeparated,
accessKey: spaceSeparated,
action: null,
allow: null,
allowFullScreen: boolean,
allowPaymentRequest: boolean,
allowUserMedia: boolean,
alt: null,
as: null,
async: boolean,
autoCapitalize: null,
autoComplete: spaceSeparated,
autoFocus: boolean,
autoPlay: boolean,
blocking: spaceSeparated,
capture: null,
charSet: null,
checked: boolean,
cite: null,
className: spaceSeparated,
cols: number,
colSpan: null,
content: null,
contentEditable: booleanish,
controls: boolean,
controlsList: spaceSeparated,
coords: number | commaSeparated,
crossOrigin: null,
data: null,
dateTime: null,
decoding: null,
default: boolean,
defer: boolean,
dir: null,
dirName: null,
disabled: boolean,
download: overloadedBoolean,
draggable: booleanish,
encType: null,
enterKeyHint: null,
fetchPriority: null,
form: null,
formAction: null,
formEncType: null,
formMethod: null,
formNoValidate: boolean,
formTarget: null,
headers: spaceSeparated,
height: number,
hidden: boolean,
high: number,
href: null,
hrefLang: null,
htmlFor: spaceSeparated,
httpEquiv: spaceSeparated,
id: null,
imageSizes: null,
imageSrcSet: null,
inert: boolean,
inputMode: null,
integrity: null,
is: null,
isMap: boolean,
itemId: null,
itemProp: spaceSeparated,
itemRef: spaceSeparated,
itemScope: boolean,
itemType: spaceSeparated,
kind: null,
label: null,
lang: null,
language: null,
list: null,
loading: null,
loop: boolean,
low: number,
manifest: null,
max: null,
maxLength: number,
media: null,
method: null,
min: null,
minLength: number,
multiple: boolean,
muted: boolean,
name: null,
nonce: null,
noModule: boolean,
noValidate: boolean,
onAbort: null,
onAfterPrint: null,
onAuxClick: null,
onBeforeMatch: null,
onBeforePrint: null,
onBeforeToggle: null,
onBeforeUnload: null,
onBlur: null,
onCancel: null,
onCanPlay: null,
onCanPlayThrough: null,
onChange: null,
onClick: null,
onClose: null,
onContextLost: null,
onContextMenu: null,
onContextRestored: null,
onCopy: null,
onCueChange: null,
onCut: null,
onDblClick: null,
onDrag: null,
onDragEnd: null,
onDragEnter: null,
onDragExit: null,
onDragLeave: null,
onDragOver: null,
onDragStart: null,
onDrop: null,
onDurationChange: null,
onEmptied: null,
onEnded: null,
onError: null,
onFocus: null,
onFormData: null,
onHashChange: null,
onInput: null,
onInvalid: null,
onKeyDown: null,
onKeyPress: null,
onKeyUp: null,
onLanguageChange: null,
onLoad: null,
onLoadedData: null,
onLoadedMetadata: null,
onLoadEnd: null,
onLoadStart: null,
onMessage: null,
onMessageError: null,
onMouseDown: null,
onMouseEnter: null,
onMouseLeave: null,
onMouseMove: null,
onMouseOut: null,
onMouseOver: null,
onMouseUp: null,
onOffline: null,
onOnline: null,
onPageHide: null,
onPageShow: null,
onPaste: null,
onPause: null,
onPlay: null,
onPlaying: null,
onPopState: null,
onProgress: null,
onRateChange: null,
onRejectionHandled: null,
onReset: null,
onResize: null,
onScroll: null,
onScrollEnd: null,
onSecurityPolicyViolation: null,
onSeeked: null,
onSeeking: null,
onSelect: null,
onSlotChange: null,
onStalled: null,
onStorage: null,
onSubmit: null,
onSuspend: null,
onTimeUpdate: null,
onToggle: null,
onUnhandledRejection: null,
onUnload: null,
onVolumeChange: null,
onWaiting: null,
onWheel: null,
open: boolean,
optimum: number,
pattern: null,
ping: spaceSeparated,
placeholder: null,
playsInline: boolean,
popover: null,
popoverTarget: null,
popoverTargetAction: null,
poster: null,
preload: null,
readOnly: boolean,
referrerPolicy: null,
rel: spaceSeparated,
required: boolean,
reversed: boolean,
rows: number,
rowSpan: number,
sandbox: spaceSeparated,
scope: null,
scoped: boolean,
seamless: boolean,
selected: boolean,
shadowRootClonable: boolean,
shadowRootDelegatesFocus: boolean,
shadowRootMode: null,
shape: null,
size: number,
sizes: null,
slot: null,
span: number,
spellCheck: booleanish,
src: null,
srcDoc: null,
srcLang: null,
srcSet: null,
start: number,
step: null,
style: null,
tabIndex: number,
target: null,
title: null,
translate: null,
type: null,
typeMustMatch: boolean,
useMap: null,
value: booleanish,
width: number,
wrap: null,
writingSuggestions: null,
// Legacy.
// See: https://html.spec.whatwg.org/#other-elements,-attributes-and-apis
align: null,
// Several. Use CSS `text-align` instead,
aLink: null,
// `<body>`. Use CSS `a:active {color}` instead
archive: spaceSeparated,
// `<object>`. List of URIs to archives
axis: null,
// `<td>` and `<th>`. Use `scope` on `<th>`
background: null,
// `<body>`. Use CSS `background-image` instead
bgColor: null,
// `<body>` and table elements. Use CSS `background-color` instead
border: number,
// `<table>`. Use CSS `border-width` instead,
borderColor: null,
// `<table>`. Use CSS `border-color` instead,
bottomMargin: number,
// `<body>`
cellPadding: null,
// `<table>`
cellSpacing: null,
// `<table>`
char: null,
// Several table elements. When `align=char`, sets the character to align on
charOff: null,
// Several table elements. When `char`, offsets the alignment
classId: null,
// `<object>`
clear: null,
// `<br>`. Use CSS `clear` instead
code: null,
// `<object>`
codeBase: null,
// `<object>`
codeType: null,
// `<object>`
color: null,
// `<font>` and `<hr>`. Use CSS instead
compact: boolean,
// Lists. Use CSS to reduce space between items instead
declare: boolean,
// `<object>`
event: null,
// `<script>`
face: null,
// `<font>`. Use CSS instead
frame: null,
// `<table>`
frameBorder: null,
// `<iframe>`. Use CSS `border` instead
hSpace: number,
// `<img>` and `<object>`
leftMargin: number,
// `<body>`
link: null,
// `<body>`. Use CSS `a:link {color: *}` instead
longDesc: null,
// `<frame>`, `<iframe>`, and `<img>`. Use an `<a>`
lowSrc: null,
// `<img>`. Use a `<picture>`
marginHeight: number,
// `<body>`
marginWidth: number,
// `<body>`
noResize: boolean,
// `<frame>`
noHref: boolean,
// `<area>`. Use no href instead of an explicit `nohref`
noShade: boolean,
// `<hr>`. Use background-color and height instead of borders
noWrap: boolean,
// `<td>` and `<th>`
object: null,
// `<applet>`
profile: null,
// `<head>`
prompt: null,
// `<isindex>`
rev: null,
// `<link>`
rightMargin: number,
// `<body>`
rules: null,
// `<table>`
scheme: null,
// `<meta>`
scrolling: booleanish,
// `<frame>`. Use overflow in the child context
standby: null,
// `<object>`
summary: null,
// `<table>`
text: null,
// `<body>`. Use CSS `color` instead
topMargin: number,
// `<body>`
valueType: null,
// `<param>`
version: null,
// `<html>`. Use a doctype.
vAlign: null,
// Several. Use CSS `vertical-align` instead
vLink: null,
// `<body>`. Use CSS `a:visited {color}` instead
vSpace: number,
// `<img>` and `<object>`
// Non-standard Properties.
allowTransparency: null,
autoCorrect: null,
autoSave: null,
disablePictureInPicture: boolean,
disableRemotePlayback: boolean,
prefix: null,
property: null,
results: number,
security: null,
unselectable: null
},
space: "html",
transform: caseInsensitiveTransform
});
// ../../node_modules/property-information/lib/svg.js
var svg = create({
attributes: {
accentHeight: "accent-height",
alignmentBaseline: "alignment-baseline",
arabicForm: "arabic-form",
baselineShift: "baseline-shift",
capHeight: "cap-height",
className: "class",
clipPath: "clip-path",
clipRule: "clip-rule",
colorInterpolation: "color-interpolation",
colorInterpolationFilters: "color-interpolation-filters",
colorProfile: "color-profile",
colorRendering: "color-rendering",
crossOrigin: "crossorigin",
dataType: "datatype",
dominantBaseline: "dominant-baseline",
enableBackground: "enable-background",
fillOpacity: "fill-opacity",
fillRule: "fill-rule",
floodColor: "flood-color",
floodOpacity: "flood-opacity",
fontFamily: "font-family",
fontSize: "font-size",
fontSizeAdjust: "font-size-adjust",
fontStretch: "font-stretch",
fontStyle: "font-style",
fontVariant: "font-variant",
fontWeight: "font-weight",
glyphName: "glyph-name",
glyphOrientationHorizontal: "glyph-orientation-horizontal",
glyphOrientationVertical: "glyph-orientation-vertical",
hrefLang: "hreflang",
horizAdvX: "horiz-adv-x",
horizOriginX: "horiz-origin-x",
horizOriginY: "horiz-origin-y",
imageRendering: "image-rendering",
letterSpacing: "letter-spacing",
lightingColor: "lighting-color",
markerEnd: "marker-end",
markerMid: "marker-mid",
markerStart: "marker-start",
navDown: "nav-down",
navDownLeft: "nav-down-left",
navDownRight: "nav-down-right",
navLeft: "nav-left",
navNext: "nav-next",
navPrev: "nav-prev",
navRight: "nav-right",
navUp: "nav-up",
navUpLeft: "nav-up-left",
navUpRight: "nav-up-right",
onAbort: "onabort",
onActivate: "onactivate",
onAfterPrint: "onafterprint",
onBeforePrint: "onbeforeprint",
onBegin: "onbegin",
onCancel: "oncancel",
onCanPlay: "oncanplay",
onCanPlayThrough: "oncanplaythrough",
onChange: "onchange",
onClick: "onclick",
onClose: "onclose",
onCopy: "oncopy",
onCueChange: "oncuechange",
onCut: "oncut",
onDblClick: "ondblclick",
onDrag: "ondrag",
onDragEnd: "ondragend",
onDragEnter: "ondragenter",
onDragExit: "ondragexit",
onDragLeave: "ondragleave",
onDragOver: "ondragover",
onDragStart: "ondragstart",
onDrop: "ondrop",
onDurationChange: "ondurationchange",
onEmptied: "onemptied",
onEnd: "onend",
onEnded: "onended",
onError: "onerror",
onFocus: "onfocus",
onFocusIn: "onfocusin",
onFocusOut: "onfocusout",
onHashChange: "onhashchange",
onInput: "oninput",
onInvalid: "oninvalid",
onKeyDown: "onkeydown",
onKeyPress: "onkeypress",
onKeyUp: "onkeyup",
onLoad: "onload",
onLoadedData: "onloadeddata",
onLoadedMetadata: "onloadedmetadata",
onLoadStart: "onloadstart",
onMessage: "onmessage",
onMouseDown: "onmousedown",
onMouseEnter: "onmouseenter",
onMouseLeave: "onmouseleave",
onMouseMove: "onmousemove",
onMouseOut: "onmouseout",
onMouseOver: "onmouseover",
onMouseUp: "onmouseup",
onMouseWheel: "onmousewheel",
onOffline: "onoffline",
onOnline: "ononline",
onPageHide: "onpagehide",
onPageShow: "onpageshow",
onPaste: "onpaste",
onPause: "onpause",
onPlay: "onplay",
onPlaying: "onplaying",
onPopState: "onpopstate",
onProgress: "onprogress",
onRateChange: "onratechange",
onRepeat: "onrepeat",
onReset: "onreset",
onResize: "onresize",
onScroll: "onscroll",
onSeeked: "onseeked",
onSeeking: "onseeking",
onSelect: "onselect",
onShow: "onshow",
onStalled: "onstalled",
onStorage: "onstorage",
onSubmit: "onsubmit",
onSuspend: "onsuspend",
onTimeUpdate: "ontimeupdate",
onToggle: "ontoggle",
onUnload: "onunload",
onVolumeChange: "onvolumechange",
onWaiting: "onwaiting",
onZoom: "onzoom",
overlinePosition: "overline-position",
overlineThickness: "overline-thickness",
paintOrder: "paint-order",
panose1: "panose-1",
pointerEvents: "pointer-events",
referrerPolicy: "referrerpolicy",
renderingIntent: "rendering-intent",
shapeRendering: "shape-rendering",
stopColor: "stop-color",
stopOpacity: "stop-opacity",
strikethroughPosition: "strikethrough-position",
strikethroughThickness: "strikethrough-thickness",
strokeDashArray: "stroke-dasharray",
strokeDashOffset: "stroke-dashoffset",
strokeLineCap: "stroke-linecap",
strokeLineJoin: "stroke-linejoin",
strokeMiterLimit: "stroke-miterlimit",
strokeOpacity: "stroke-opacity",
strokeWidth: "stroke-width",
tabIndex: "tabindex",
textAnchor: "text-anchor",
textDecoration: "text-decoration",
textRendering: "text-rendering",
transformOrigin: "transform-origin",
typeOf: "typeof",
underlinePosition: "underline-position",
underlineThickness: "underline-thickness",
unicodeBidi: "unicode-bidi",
unicodeRange: "unicode-range",
unitsPerEm: "units-per-em",
vAlphabetic: "v-alphabetic",
vHanging: "v-hanging",
vIdeographic: "v-ideographic",
vMathematical: "v-mathematical",
vectorEffect: "vector-effect",
vertAdvY: "vert-adv-y",
vertOriginX: "vert-origin-x",
vertOriginY: "vert-origin-y",
wordSpacing: "word-spacing",
writingMode: "writing-mode",
xHeight: "x-height",
// These were camelcased in Tiny. Now lowercased in SVG 2
playbackOrder: "playbackorder",
timelineBegin: "timelinebegin"
},
properties: {
about: commaOrSpaceSeparated,
accentHeight: number,
accumulate: null,
additive: null,
alignmentBaseline: null,
alphabetic: number,
amplitude: number,
arabicForm: null,
ascent: number,
attributeName: null,
attributeType: null,
azimuth: number,
bandwidth: null,
baselineShift: null,
baseFrequency: null,
baseProfile: null,
bbox: null,
begin: null,
bias: number,
by: null,
calcMode: null,
capHeight: number,
className: spaceSeparated,
clip: null,
clipPath: null,
clipPathUnits: null,
clipRule: null,
color: null,
colorInterpolation: null,
colorInterpolationFilters: null,
colorProfile: null,
colorRendering: null,
content: null,
contentScriptType: null,
contentStyleType: null,
crossOrigin: null,
cursor: null,
cx: null,
cy: null,
d: null,
dataType: null,
defaultAction: null,
descent: number,
diffuseConstant: number,
direction: null,
display: null,
dur: null,
divisor: number,
dominantBaseline: null,
download: boolean,
dx: null,
dy: null,
edgeMode: null,
editable: null,
elevation: number,
enableBackground: null,
end: null,
event: null,
exponent: number,
externalResourcesRequired: null,
fill: null,
fillOpacity: number,
fillRule: null,
filter: null,
filterRes: null,
filterUnits: null,
floodColor: null,
floodOpacity: null,
focusable: null,
focusHighlight: null,
fontFamily: null,
fontSize: null,
fontSizeAdjust: null,
fontStretch: null,
fontStyle: null,
fontVariant: null,
fontWeight: null,
format: null,
fr: null,
from: null,
fx: null,
fy: null,
g1: commaSeparated,
g2: commaSeparated,
glyphName: commaSeparated,
glyphOrientationHorizontal: null,
glyphOrientationVertical: null,
glyphRef: null,
gradientTransform: null,
gradientUnits: null,
handler: null,
hanging: number,
hatchContentUnits: null,
hatchUnits: null,
height: null,
href: null,
hrefLang: null,
horizAdvX: number,
horizOriginX: number,
horizOriginY: number,
id: null,
ideographic: number,
imageRendering: null,
initialVisibility: null,
in: null,
in2: null,
intercept: number,
k: number,
k1: number,
k2: number,
k3: number,
k4: number,
kernelMatrix: commaOrSpaceSeparated,
kernelUnitLength: null,
keyPoints: null,
// SEMI_COLON_SEPARATED
keySplines: null,
// SEMI_COLON_SEPARATED
keyTimes: null,
// SEMI_COLON_SEPARATED
kerning: null,
lang: null,
lengthAdjust: null,
letterSpacing: null,
lightingColor: null,
limitingConeAngle: number,
local: null,
markerEnd: null,
markerMid: null,
markerStart: null,
markerHeight: null,
markerUnits: null,
markerWidth: null,
mask: null,
maskContentUnits: null,
maskUnits: null,
mathematical: null,
max: null,
media: null,
mediaCharacterEncoding: null,
mediaContentEncodings: null,
mediaSize: number,
mediaTime: null,
method: null,
min: null,
mode: null,
name: null,
navDown: null,
navDownLeft: null,
navDownRight: null,
navLeft: null,
navNext: null,
navPrev: null,
navRight: null,
navUp: null,
navUpLeft: null,
navUpRight: null,
numOctaves: null,
observer: null,
offset: null,
onAbort: null,
onActivate: null,
onAfterPrint: null,
onBeforePrint: null,
onBegin: null,
onCancel: null,
onCanPlay: null,
onCanPlayThrough: null,
onChange: null,
onClick: null,
onClose: null,
onCopy: null,
onCueChange: null,
onCut: null,
onDblClick: null,
onDrag: null,
onDragEnd: null,
onDragEnter: null,
onDragExit: null,
onDragLeave: null,
onDragOver: null,
onDragStart: null,
onDrop: null,
onDurationChange: null,
onEmptied: null,
onEnd: null,
onEnded: null,
onError: null,
onFocus: null,
onFocusIn: null,
onFocusOut: null,
onHashChange: null,
onInput: null,
onInvalid: null,
onKeyDown: null,
onKeyPress: null,
onKeyUp: null,
onLoad: null,
onLoadedData: null,
onLoadedMetadata: null,
onLoadStart: null,
onMessage: null,
onMouseDown: null,
onMouseEnter: null,
onMouseLeave: null,
onMouseMove: null,
onMouseOut: null,
onMouseOver: null,
onMouseUp: null,
onMouseWheel: null,
onOffline: null,
onOnline: null,
onPageHide: null,
onPageShow: null,
onPaste: null,
onPause: null,
onPlay: null,
onPlaying: null,
onPopState: null,
onProgress: null,
onRateChange: null,
onRepeat: null,
onReset: null,
onResize: null,
onScroll: null,
onSeeked: null,
onSeeking: null,
onSelect: null,
onShow: null,
onStalled: null,
onStorage: null,
onSubmit: null,
onSuspend: null,
onTimeUpdate: null,
onToggle: null,
onUnload: null,
onVolumeChange: null,
onWaiting: null,
onZoom: null,
opacity: null,
operator: null,
order: null,
orient: null,
orientation: null,
origin: null,
overflow: null,
overlay: null,
overlinePosition: number,
overlineThickness: number,
paintOrder: null,
panose1: null,
path: null,
pathLength: number,
patternContentUnits: null,
patternTransform: null,
patternUnits: null,
phase: null,
ping: spaceSeparated,
pitch: null,
playbackOrder: null,
pointerEvents: null,
points: null,
pointsAtX: number,
pointsAtY: number,
pointsAtZ: number,
preserveAlpha: null,
preserveAspectRatio: null,
primitiveUnits: null,
propagate: null,
property: commaOrSpaceSeparated,
r: null,
radius: null,
referrerPolicy: null,
refX: null,
refY: null,
rel: commaOrSpaceSeparated,
rev: commaOrSpaceSeparated,
renderingIntent: null,
repeatCount: null,
repeatDur: null,
requiredExtensions: commaOrSpaceSeparated,
requiredFeatures: commaOrSpaceSeparated,
requiredFonts: commaOrSpaceSeparated,
requiredFormats: commaOrSpaceSeparated,
resource: null,
restart: null,
result: null,
rotate: null,
rx: null,
ry: null,
scale: null,
seed: null,
shapeRendering: null,
side: null,
slope: null,
snapshotTime: null,
specularConstant: number,
specularExponent: number,
spreadMethod: null,
spacing: null,
startOffset: null,
stdDeviation: null,
stemh: null,
stemv: null,
stitchTiles: null,
stopColor: null,
stopOpacity: null,
strikethroughPosition: number,
strikethroughThickness: number,
string: null,
stroke: null,
strokeDashArray: commaOrSpaceSeparated,
strokeDashOffset: null,
strokeLineCap: null,
strokeLineJoin: null,
strokeMiterLimit: number,
strokeOpacity: number,
strokeWidth: null,
style: null,
surfaceScale: number,
syncBehavior: null,
syncBehaviorDefault: null,
syncMaster: null,
syncTolerance: null,
syncToleranceDefault: null,
systemLanguage: commaOrSpaceSeparated,
tabIndex: number,
tableValues: null,
target: null,
targetX: number,
targetY: number,
textAnchor: null,
textDecoration: null,
textRendering: null,
textLength: null,
timelineBegin: null,
title: null,
transformBehavior: null,
type: null,
typeOf: commaOrSpaceSeparated,
to: null,
transform: null,
transformOrigin: null,
u1: null,
u2: null,
underlinePosition: number,
underlineThickness: number,
unicode: null,
unicodeBidi: null,
unicodeRange: null,
unitsPerEm: number,
values: null,
vAlphabetic: number,
vMathematical: number,
vectorEffect: null,
vHanging: number,
vIdeographic: number,
version: null,
vertAdvY: number,
vertOriginX: number,
vertOriginY: number,
viewBox: null,
viewTarget: null,
visibility: null,
width: null,
widths: null,
wordSpacing: null,
writingMode: null,
x: null,
x1: null,
x2: null,
xChannelSelector: null,
xHeight: number,
y: null,
y1: null,
y2: null,
yChannelSelector: null,
z: null,
zoomAndPan: null
},
space: "svg",
transform: caseSensitiveTransform
});
// ../../node_modules/property-information/lib/xlink.js
var xlink = create({
properties: {
xLinkActuate: null,
xLinkArcRole: null,
xLinkHref: null,
xLinkRole: null,
xLinkShow: null,
xLinkTitle: null,
xLinkType: null
},
space: "xlink",
transform(_, property) {
return "xlink:" + property.slice(5).toLowerCase();
}
});
// ../../node_modules/property-information/lib/xmlns.js
var xmlns = create({
attributes: { xmlnsxlink: "xmlns:xlink" },
properties: { xmlnsXLink: null, xmlns: null },
space: "xmlns",
transform: caseInsensitiveTransform
});
// ../../node_modules/property-information/lib/xml.js
var xml = create({
properties: { xmlBase: null, xmlLang: null, xmlSpace: null },
space: "xml",
transform(_, property) {
return "xml:" + property.slice(3).toLowerCase();
}
});
// ../../node_modules/property-information/lib/hast-to-react.js
var hastToReact = {
classId: "classID",
dataType: "datatype",
itemId: "itemID",
strokeDashArray: "strokeDasharray",
strokeDashOffset: "strokeDashoffset",
strokeLineCap: "strokeLinecap",
strokeLineJoin: "strokeLinejoin",
strokeMiterLimit: "strokeMiterlimit",
typeOf: "typeof",
xLinkActuate: "xlinkActuate",
xLinkArcRole: "xlinkArcrole",
xLinkHref: "xlinkHref",
xLinkRole: "xlinkRole",
xLinkShow: "xlinkShow",
xLinkTitle: "xlinkTitle",
xLinkType: "xlinkType",
xmlnsXLink: "xmlnsXlink"
};
// ../../node_modules/property-information/lib/find.js
var cap = /[A-Z]/g;
var dash = /-[a-z]/g;
var valid = /^data[-\w.:]+$/i;
function find(schema, value) {
const normal = normalize(value);
let property = value;
let Type = Info;
if (normal in schema.normal) {
return schema.property[schema.normal[normal]];
}
if (normal.length > 4 && normal.slice(0, 4) === "data" && valid.test(value)) {
if (value.charAt(4) === "-") {
const rest = value.slice(5).replace(dash, camelcase);
property = "data" + rest.charAt(0).toUpperCase() + rest.slice(1);
} else {
const rest = value.slice(4);
if (!dash.test(rest)) {
let dashes = rest.replace(cap, kebab);
if (dashes.charAt(0) !== "-") {
dashes = "-" + dashes;
}
value = "data" + dashes;
}
}
Type = DefinedInfo;
}
return new Type(property, value);
}
function kebab($0) {
return "-" + $0.toLowerCase();
}
function camelcase($0) {
return $0.charAt(1).toUpperCase();
}
// ../../node_modules/property-information/index.js
var html2 = merge([aria, html, xlink, xmlns, xml], "html");
var svg2 = merge([aria, svg, xlink, xmlns, xml], "svg");
// ../../node_modules/space-separated-tokens/index.js
function stringify2(values) {
return values.join(" ").trim();
}
// ../../node_modules/hast-util-to-jsx-runtime/lib/index.js
var import_style_to_js = __toESM(require_cjs2(), 1);
// ../../node_modules/unist-util-position/lib/index.js
var pointEnd = point("end");
var pointStart = point("start");
function point(type) {
return point5;
function point5(node2) {
const point6 = node2 && node2.position && node2.position[type] || {};
if (typeof point6.line === "number" && point6.line > 0 && typeof point6.column === "number" && point6.column > 0) {
return {
line: point6.line,
column: point6.column,
offset: typeof point6.offset === "number" && point6.offset > -1 ? point6.offset : void 0
};
}
}
}
function position(node2) {
const start2 = pointStart(node2);
const end = pointEnd(node2);
if (start2 && end) {
return { start: start2, end };
}
}
// ../../node_modules/vfile-message/node_modules/unist-util-stringify-position/lib/index.js
function stringifyPosition(value) {
if (!value || typeof value !== "object") {
return "";
}
if ("position" in value || "type" in value) {
return position2(value.position);
}
if ("start" in value || "end" in value) {
return position2(value);
}
if ("line" in value || "column" in value) {
return point2(value);
}
return "";
}
function point2(point5) {
return index(point5 && point5.line) + ":" + index(point5 && point5.column);
}
function position2(pos) {
return point2(pos && pos.start) + "-" + point2(pos && pos.end);
}
function index(value) {
return value && typeof value === "number" ? value : 1;
}
// ../../node_modules/vfile-message/lib/index.js
var VFileMessage = class extends Error {
/**
* Create a message for `reason`.
*
* > 🪦 **Note**: also has obsolete signatures.
*
* @overload
* @param {string} reason
* @param {Options | null | undefined} [options]
* @returns
*
* @overload
* @param {string} reason
* @param {Node | NodeLike | null | undefined} parent
* @param {string | null | undefined} [origin]
* @returns
*
* @overload
* @param {string} reason
* @param {Point | Position | null | undefined} place
* @param {string | null | undefined} [origin]
* @returns
*
* @overload
* @param {string} reason
* @param {string | null | undefined} [origin]
* @returns
*
* @overload
* @param {Error | VFileMessage} cause
* @param {Node | NodeLike | null | undefined} parent
* @param {string | null | undefined} [origin]
* @returns
*
* @overload
* @param {Error | VFileMessage} cause
* @param {Point | Position | null | undefined} place
* @param {string | null | undefined} [origin]
* @returns
*
* @overload
* @param {Error | VFileMessage} cause
* @param {string | null | undefined} [origin]
* @returns
*
* @param {Error | VFileMessage | string} causeOrReason
* Reason for message, should use markdown.
* @param {Node | NodeLike | Options | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
* Configuration (optional).
* @param {string | null | undefined} [origin]
* Place in code where the message originates (example:
* `'my-package:my-rule'` or `'my-rule'`).
* @returns
* Instance of `VFileMessage`.
*/
// eslint-disable-next-line complexity
constructor(causeOrReason, optionsOrParentOrPlace, origin) {
super();
if (typeof optionsOrParentOrPlace === "string") {
origin = optionsOrParentOrPlace;
optionsOrParentOrPlace = void 0;
}
let reason = "";
let options = {};
let legacyCause = false;
if (optionsOrParentOrPlace) {
if ("line" in optionsOrParentOrPlace && "column" in optionsOrParentOrPlace) {
options = { place: optionsOrParentOrPlace };
} else if ("start" in optionsOrParentOrPlace && "end" in optionsOrParentOrPlace) {
options = { place: optionsOrParentOrPlace };
} else if ("type" in optionsOrParentOrPlace) {
options = {
ancestors: [optionsOrParentOrPlace],
place: optionsOrParentOrPlace.position
};
} else {
options = { ...optionsOrParentOrPlace };
}
}
if (typeof causeOrReason === "string") {
reason = causeOrReason;
} else if (!options.cause && causeOrReason) {
legacyCause = true;
reason = causeOrReason.message;
options.cause = causeOrReason;
}
if (!options.ruleId && !options.source && typeof origin === "string") {
const index3 = origin.indexOf(":");
if (index3 === -1) {
options.ruleId = origin;
} else {
options.source = origin.slice(0, index3);
options.ruleId = origin.slice(index3 + 1);
}
}
if (!options.place && options.ancestors && options.ancestors) {
const parent = options.ancestors[options.ancestors.length - 1];
if (parent) {
options.place = parent.position;
}
}
const start2 = options.place && "start" in options.place ? options.place.start : options.place;
this.ancestors = options.ancestors || void 0;
this.cause = options.cause || void 0;
this.column = start2 ? start2.column : void 0;
this.fatal = void 0;
this.file;
this.message = reason;
this.line = start2 ? start2.line : void 0;
this.name = stringifyPosition(options.place) || "1:1";
this.place = options.place || void 0;
this.reason = this.message;
this.ruleId = options.ruleId || void 0;
this.source = options.source || void 0;
this.stack = legacyCause && options.cause && typeof options.cause.stack === "string" ? options.cause.stack : "";
this.actual;
this.expected;
this.note;
this.url;
}
};
VFileMessage.prototype.file = "";
VFileMessage.prototype.name = "";
VFileMessage.prototype.reason = "";
VFileMessage.prototype.message = "";
VFileMessage.prototype.stack = "";
VFileMessage.prototype.column = void 0;
VFileMessage.prototype.line = void 0;
VFileMessage.prototype.ancestors = void 0;
VFileMessage.prototype.cause = void 0;
VFileMessage.prototype.fatal = void 0;
VFileMessage.prototype.place = void 0;
VFileMessage.prototype.ruleId = void 0;
VFileMessage.prototype.source = void 0;
// ../../node_modules/hast-util-to-jsx-runtime/lib/index.js
var own = {}.hasOwnProperty;
var emptyMap = /* @__PURE__ */ new Map();
var cap2 = /[A-Z]/g;
var tableElements = /* @__PURE__ */ new Set(["table", "tbody", "thead", "tfoot", "tr"]);
var tableCellElement = /* @__PURE__ */ new Set(["td", "th"]);
var docs = "https://github.com/syntax-tree/hast-util-to-jsx-runtime";
function toJsxRuntime(tree, options) {
if (!options || options.Fragment === void 0) {
throw new TypeError("Expected `Fragment` in options");
}
const filePath = options.filePath || void 0;
let create2;
if (options.development) {
if (typeof options.jsxDEV !== "function") {
throw new TypeError(
"Expected `jsxDEV` in options when `development: true`"
);
}
create2 = developmentCreate(filePath, options.jsxDEV);
} else {
if (typeof options.jsx !== "function") {
throw new TypeError("Expected `jsx` in production options");
}
if (typeof options.jsxs !== "function") {
throw new TypeError("Expected `jsxs` in production options");
}
create2 = productionCreate(filePath, options.jsx, options.jsxs);
}
const state = {
Fragment: options.Fragment,
ancestors: [],
components: options.components || {},
create: create2,
elementAttributeNameCase: options.elementAttributeNameCase || "react",
evaluater: options.createEvaluater ? options.createEvaluater() : void 0,
filePath,
ignoreInvalidStyle: options.ignoreInvalidStyle || false,
passKeys: options.passKeys !== false,
passNode: options.passNode || false,
schema: options.space === "svg" ? svg2 : html2,
stylePropertyNameCase: options.stylePropertyNameCase || "dom",
tableCellAlignToStyle: options.tableCellAlignToStyle !== false
};
const result = one(state, tree, void 0);
if (result && typeof result !== "string") {
return result;
}
return state.create(
tree,
state.Fragment,
{ children: result || void 0 },
void 0
);
}
function one(state, node2, key) {
if (node2.type === "element") {
return element(state, node2, key);
}
if (node2.type === "mdxFlowExpression" || node2.type === "mdxTextExpression") {
return mdxExpression(state, node2);
}
if (node2.type === "mdxJsxFlowElement" || node2.type === "mdxJsxTextElement") {
return mdxJsxElement(state, node2, key);
}
if (node2.type === "mdxjsEsm") {
return mdxEsm(state, node2);
}
if (node2.type === "root") {
return root(state, node2, key);
}
if (node2.type === "text") {
return text(state, node2);
}
}
function element(state, node2, key) {
const parentSchema = state.schema;
let schema = parentSchema;
if (node2.tagName.toLowerCase() === "svg" && parentSchema.space === "html") {
schema = svg2;
state.schema = schema;
}
state.ancestors.push(node2);
const type = findComponentFromName(state, node2.tagName, false);
const props = createElementProps(state, node2);
let children = createChildren(state, node2);
if (tableElements.has(node2.tagName)) {
children = children.filter(function(child) {
return typeof child === "string" ? !whitespace(child) : true;
});
}
addNode(state, props, type, node2);
addChildren(props, children);
state.ancestors.pop();
state.schema = parentSchema;
return state.create(node2, type, props, key);
}
function mdxExpression(state, node2) {
if (node2.data && node2.data.estree && state.evaluater) {
const program = node2.data.estree;
const expression = program.body[0];
ok(expression.type === "ExpressionStatement");
return (
/** @type {Child | undefined} */
state.evaluater.evaluateExpression(expression.expression)
);
}
crashEstree(state, node2.position);
}
function mdxEsm(state, node2) {
if (node2.data && node2.data.estree && state.evaluater) {
return (
/** @type {Child | undefined} */
state.evaluater.evaluateProgram(node2.data.estree)
);
}
crashEstree(state, node2.position);
}
function mdxJsxElement(state, node2, key) {
const parentSchema = state.schema;
let schema = parentSchema;
if (node2.name === "svg" && parentSchema.space === "html") {
schema = svg2;
state.schema = schema;
}
state.ancestors.push(node2);
const type = node2.name === null ? state.Fragment : findComponentFromName(state, node2.name, true);
const props = createJsxElementProps(state, node2);
const children = createChildren(state, node2);
addNode(state, props, type, node2);
addChildren(props, children);
state.ancestors.pop();
state.schema = parentSchema;
return state.create(node2, type, props, key);
}
function root(state, node2, key) {
const props = {};
addChildren(props, createChildren(state, node2));
return state.create(node2, state.Fragment, props, key);
}
function text(_, node2) {
return node2.value;
}
function addNode(state, props, type, node2) {
if (typeof type !== "string" && type !== state.Fragment && state.passNode) {
props.node = node2;
}
}
function addChildren(props, children) {
if (children.length > 0) {
const value = children.length > 1 ? children : children[0];
if (value) {
props.children = value;
}
}
}
function productionCreate(_, jsx2, jsxs2) {
return create2;
function create2(_2, type, props, key) {
const isStaticChildren = Array.isArray(props.children);
const fn = isStaticChildren ? jsxs2 : jsx2;
return key ? fn(type, props, key) : fn(type, props);
}
}
function developmentCreate(filePath, jsxDEV) {
return create2;
function create2(node2, type, props, key) {
const isStaticChildren = Array.isArray(props.children);
const point5 = pointStart(node2);
return jsxDEV(
type,
props,
key,
isStaticChildren,
{
columnNumber: point5 ? point5.column - 1 : void 0,
fileName: filePath,
lineNumber: point5 ? point5.line : void 0
},
void 0
);
}
}
function createElementProps(state, node2) {
const props = {};
let alignValue;
let prop;
for (prop in node2.properties) {
if (prop !== "children" && own.call(node2.properties, prop)) {
const result = createProperty(state, prop, node2.properties[prop]);
if (result) {
const [key, value] = result;
if (state.tableCellAlignToStyle && key === "align" && typeof value === "string" && tableCellElement.has(node2.tagName)) {
alignValue = value;
} else {
props[key] = value;
}
}
}
}
if (alignValue) {
const style = (
/** @type {Style} */
props.style || (props.style = {})
);
style[state.stylePropertyNameCase === "css" ? "text-align" : "textAlign"] = alignValue;
}
return props;
}
function createJsxElementProps(state, node2) {
const props = {};
for (const attribute of node2.attributes) {
if (attribute.type === "mdxJsxExpressionAttribute") {
if (attribute.data && attribute.data.estree && state.evaluater) {
const program = attribute.data.estree;
const expression = program.body[0];
ok(expression.type === "ExpressionStatement");
const objectExpression = expression.expression;
ok(objectExpression.type === "ObjectExpression");
const property = objectExpression.properties[0];
ok(property.type === "SpreadElement");
Object.assign(
props,
state.evaluater.evaluateExpression(property.argument)
);
} else {
crashEstree(state, node2.position);
}
} else {
const name2 = attribute.name;
let value;
if (attribute.value && typeof attribute.value === "object") {
if (attribute.value.data && attribute.value.data.estree && state.evaluater) {
const program = attribute.value.data.estree;
const expression = program.body[0];
ok(expression.type === "ExpressionStatement");
value = state.evaluater.evaluateExpression(expression.expression);
} else {
crashEstree(state, node2.position);
}
} else {
value = attribute.value === null ? true : attribute.value;
}
props[name2] = /** @type {Props[keyof Props]} */
value;
}
}
return props;
}
function createChildren(state, node2) {
const children = [];
let index3 = -1;
const countsByName = state.passKeys ? /* @__PURE__ */ new Map() : emptyMap;
while (++index3 < node2.children.length) {
const child = node2.children[index3];
let key;
if (state.passKeys) {
const name2 = child.type === "element" ? child.tagName : child.type === "mdxJsxFlowElement" || child.type === "mdxJsxTextElement" ? child.name : void 0;
if (name2) {
const count = countsByName.get(name2) || 0;
key = name2 + "-" + count;
countsByName.set(name2, count + 1);
}
}
const result = one(state, child, key);
if (result !== void 0) children.push(result);
}
return children;
}
function createProperty(state, prop, value) {
const info = find(state.schema, prop);
if (value === null || value === void 0 || typeof value === "number" && Number.isNaN(value)) {
return;
}
if (Array.isArray(value)) {
value = info.commaSeparated ? stringify(value) : stringify2(value);
}
if (info.property === "style") {
let styleObject = typeof value === "object" ? value : parseStyle(state, String(value));
if (state.stylePropertyNameCase === "css") {
styleObject = transformStylesToCssCasing(styleObject);
}
return ["style", styleObject];
}
return [
state.elementAttributeNameCase === "react" && info.space ? hastToReact[info.property] || info.property : info.attribute,
value
];
}
function parseStyle(state, value) {
try {
return (0, import_style_to_js.default)(value, { reactCompat: true });
} catch (error) {
if (state.ignoreInvalidStyle) {
return {};
}
const cause = (
/** @type {Error} */
error
);
const message = new VFileMessage("Cannot parse `style` attribute", {
ancestors: state.ancestors,
cause,
ruleId: "style",
source: "hast-util-to-jsx-runtime"
});
message.file = state.filePath || void 0;
message.url = docs + "#cannot-parse-style-attribute";
throw message;
}
}
function findComponentFromName(state, name2, allowExpression) {
let result;
if (!allowExpression) {
result = { type: "Literal", value: name2 };
} else if (name2.includes(".")) {
const identifiers = name2.split(".");
let index3 = -1;
let node2;
while (++index3 < identifiers.length) {
const prop = name(identifiers[index3]) ? { type: "Identifier", name: identifiers[index3] } : { type: "Literal", value: identifiers[index3] };
node2 = node2 ? {
type: "MemberExpression",
object: node2,
property: prop,
computed: Boolean(index3 && prop.type === "Literal"),
optional: false
} : prop;
}
ok(node2, "always a result");
result = node2;
} else {
result = name(name2) && !/^[a-z]/.test(name2) ? { type: "Identifier", name: name2 } : { type: "Literal", value: name2 };
}
if (result.type === "Literal") {
const name3 = (
/** @type {string | number} */
result.value
);
return own.call(state.components, name3) ? state.components[name3] : name3;
}
if (state.evaluater) {
return state.evaluater.evaluateExpression(result);
}
crashEstree(state);
}
function crashEstree(state, place) {
const message = new VFileMessage(
"Cannot handle MDX estrees without `createEvaluater`",
{
ancestors: state.ancestors,
place,
ruleId: "mdx-estree",
source: "hast-util-to-jsx-runtime"
}
);
message.file = state.filePath || void 0;
message.url = docs + "#cannot-handle-mdx-estrees-without-createevaluater";
throw message;
}
function transformStylesToCssCasing(domCasing) {
const cssCasing = {};
let from;
for (from in domCasing) {
if (own.call(domCasing, from)) {
cssCasing[transformStyleToCssCasing(from)] = domCasing[from];
}
}
return cssCasing;
}
function transformStyleToCssCasing(from) {
let to = from.replace(cap2, toDash);
if (to.slice(0, 3) === "ms-") to = "-" + to;
return to;
}
function toDash($0) {
return "-" + $0.toLowerCase();
}
// ../../node_modules/html-url-attributes/lib/index.js
var urlAttributes = {
action: ["form"],
cite: ["blockquote", "del", "ins", "q"],
data: ["object"],
formAction: ["button", "input"],
href: ["a", "area", "base", "link"],
icon: ["menuitem"],
itemId: null,
manifest: ["html"],
ping: ["a", "area"],
poster: ["video"],
src: [
"audio",
"embed",
"iframe",
"img",
"input",
"script",
"source",
"track",
"video"
]
};
// ../../node_modules/react-markdown/lib/index.js
import { Fragment, jsx, jsxs } from "react/jsx-runtime";
import { createElement, useEffect, useState } from "react";
// ../../node_modules/mdast-util-from-markdown/node_modules/mdast-util-to-string/lib/index.js
var emptyOptions2 = {};
function toString(value, options) {
const settings = options || emptyOptions2;
const includeImageAlt = typeof settings.includeImageAlt === "boolean" ? settings.includeImageAlt : true;
const includeHtml = typeof settings.includeHtml === "boolean" ? settings.includeHtml : true;
return one2(value, includeImageAlt, includeHtml);
}
function one2(value, includeImageAlt, includeHtml) {
if (node(value)) {
if ("value" in value) {
return value.type === "html" && !includeHtml ? "" : value.value;
}
if (includeImageAlt && "alt" in value && value.alt) {
return value.alt;
}
if ("children" in value) {
return all(value.children, includeImageAlt, includeHtml);
}
}
if (Array.isArray(value)) {
return all(value, includeImageAlt, includeHtml);
}
return "";
}
function all(values, includeImageAlt, includeHtml) {
const result = [];
let index3 = -1;
while (++index3 < values.length) {
result[index3] = one2(values[index3], includeImageAlt, includeHtml);
}
return result.join("");
}
function node(value) {
return Boolean(value && typeof value === "object");
}
// ../../node_modules/decode-named-character-reference/index.dom.js
var element2 = document.createElement("i");
function decodeNamedCharacterReference(value) {
const characterReference2 = "&" + value + ";";
element2.innerHTML = characterReference2;
const character = element2.textContent;
if (
// @ts-expect-error: TypeScript is wrong that `textContent` on elements can
// yield `null`.
character.charCodeAt(character.length - 1) === 59 && value !== "semi"
) {
return false;
}
return character === characterReference2 ? false : character;
}
// ../../node_modules/micromark/node_modules/micromark-util-chunked/index.js
function splice(list3, start2, remove, items) {
const end = list3.length;
let chunkStart = 0;
let parameters;
if (start2 < 0) {
start2 = -start2 > end ? 0 : end + start2;
} else {
start2 = start2 > end ? end : start2;
}
remove = remove > 0 ? remove : 0;
if (items.length < 1e4) {
parameters = Array.from(items);
parameters.unshift(start2, remove);
list3.splice(...parameters);
} else {
if (remove) list3.splice(start2, remove);
while (chunkStart < items.length) {
parameters = items.slice(chunkStart, chunkStart + 1e4);
parameters.unshift(start2, 0);
list3.splice(...parameters);
chunkStart += 1e4;
start2 += 1e4;
}
}
}
function push(list3, items) {
if (list3.length > 0) {
splice(list3, list3.length, 0, items);
return list3;
}
return items;
}
// ../../node_modules/micromark/node_modules/micromark-util-combine-extensions/index.js
var hasOwnProperty = {}.hasOwnProperty;
function combineExtensions(extensions) {
const all2 = {};
let index3 = -1;
while (++index3 < extensions.length) {
syntaxExtension(all2, extensions[index3]);
}
return all2;
}
function syntaxExtension(all2, extension2) {
let hook;
for (hook in extension2) {
const maybe = hasOwnProperty.call(all2, hook) ? all2[hook] : void 0;
const left = maybe || (all2[hook] = {});
const right = extension2[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, list3) {
let index3 = -1;
const before = [];
while (++index3 < list3.length) {
;
(list3[index3].add === "after" ? existing : before).push(list3[index3]);
}
splice(existing, 0, 0, before);
}
// ../../node_modules/micromark/node_modules/micromark-util-normalize-identifier/index.js
function normalizeIdentifier(value) {
return value.replace(/[\t\n\r ]+/g, " ").replace(/^ | $/g, "").toLowerCase().toUpperCase();
}
// ../../node_modules/micromark/node_modules/micromark-util-character/index.js
var asciiAlpha = regexCheck(/[A-Za-z]/);
var asciiAlphanumeric = regexCheck(/[\dA-Za-z]/);
var asciiAtext = regexCheck(/[#-'*+\--9=?A-Z^-~]/);
function asciiControl(code2) {
return (
// Special whitespace codes (which have negative values), C0 and Control
// character DEL
code2 !== null && (code2 < 32 || code2 === 127)
);
}
var asciiDigit = regexCheck(/\d/);
var asciiHexDigit = regexCheck(/[\dA-Fa-f]/);
var asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);
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;
}
var unicodePunctuation = regexCheck(/\p{P}|\p{S}/u);
var unicodeWhitespace = regexCheck(/\s/);
function regexCheck(regex) {
return check;
function check(code2) {
return code2 !== null && code2 > -1 && regex.test(String.fromCharCode(code2));
}
}
// ../../node_modules/micromark/node_modules/micromark-factory-space/index.js
function factorySpace(effects, ok3, type, max) {
const limit = max ? max - 1 : Number.POSITIVE_INFINITY;
let size = 0;
return start2;
function start2(code2) {
if (markdownSpace(code2)) {
effects.enter(type);
return prefix(code2);
}
return ok3(code2);
}
function prefix(code2) {
if (markdownSpace(code2) && size++ < limit) {
effects.consume(code2);
return prefix;
}
effects.exit(type);
return ok3(code2);
}
}
// ../../node_modules/micromark/lib/initialize/content.js
var content = {
tokenize: initializeContent
};
function initializeContent(effects) {
const contentStart = effects.attempt(this.parser.constructs.contentInitial, afterContentStartConstruct, paragraphInitial);
let previous2;
return contentStart;
function afterContentStartConstruct(code2) {
if (code2 === null) {
effects.consume(code2);
return;
}
effects.enter("lineEnding");
effects.consume(code2);
effects.exit("lineEnding");
return factorySpace(effects, contentStart, "linePrefix");
}
function paragraphInitial(code2) {
effects.enter("paragraph");
return lineStart(code2);
}
function lineStart(code2) {
const token = effects.enter("chunkText", {
contentType: "text",
previous: previous2
});
if (previous2) {
previous2.next = token;
}
previous2 = token;
return data(code2);
}
function data(code2) {
if (code2 === null) {
effects.exit("chunkText");
effects.exit("paragraph");
effects.consume(code2);
return;
}
if (markdownLineEnding(code2)) {
effects.consume(code2);
effects.exit("chunkText");
return lineStart;
}
effects.consume(code2);
return data;
}
}
// ../../node_modules/micromark/lib/initialize/document.js
var document2 = {
tokenize: initializeDocument
};
var containerConstruct = {
tokenize: tokenizeContainer
};
function initializeDocument(effects) {
const self2 = this;
const stack = [];
let continued = 0;
let childFlow;
let childToken;
let lineStartOffset;
return start2;
function start2(code2) {
if (continued < stack.length) {
const item = stack[continued];
self2.containerState = item[1];
return effects.attempt(item[0].continuation, documentContinue, checkNewContainers)(code2);
}
return checkNewContainers(code2);
}
function documentContinue(code2) {
continued++;
if (self2.containerState._closeFlow) {
self2.containerState._closeFlow = void 0;
if (childFlow) {
closeFlow();
}
const indexBeforeExits = self2.events.length;
let indexBeforeFlow = indexBeforeExits;
let point5;
while (indexBeforeFlow--) {
if (self2.events[indexBeforeFlow][0] === "exit" && self2.events[indexBeforeFlow][1].type === "chunkFlow") {
point5 = self2.events[indexBeforeFlow][1].end;
break;
}
}
exitContainers(continued);
let index3 = indexBeforeExits;
while (index3 < self2.events.length) {
self2.events[index3][1].end = {
...point5
};
index3++;
}
splice(self2.events, indexBeforeFlow + 1, 0, self2.events.slice(indexBeforeExits));
self2.events.length = index3;
return checkNewContainers(code2);
}
return start2(code2);
}
function checkNewContainers(code2) {
if (continued === stack.length) {
if (!childFlow) {
return documentContinued(code2);
}
if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {
return flowStart(code2);
}
self2.interrupt = Boolean(childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack);
}
self2.containerState = {};
return effects.check(containerConstruct, thereIsANewContainer, thereIsNoNewContainer)(code2);
}
function thereIsANewContainer(code2) {
if (childFlow) closeFlow();
exitContainers(continued);
return documentContinued(code2);
}
function thereIsNoNewContainer(code2) {
self2.parser.lazy[self2.now().line] = continued !== stack.length;
lineStartOffset = self2.now().offset;
return flowStart(code2);
}
function documentContinued(code2) {
self2.containerState = {};
return effects.attempt(containerConstruct, containerContinue, flowStart)(code2);
}
function containerContinue(code2) {
continued++;
stack.push([self2.currentConstruct, self2.containerState]);
return documentContinued(code2);
}
function flowStart(code2) {
if (code2 === null) {
if (childFlow) closeFlow();
exitContainers(0);
effects.consume(code2);
return;
}
childFlow = childFlow || self2.parser.flow(self2.now());
effects.enter("chunkFlow", {
_tokenizer: childFlow,
contentType: "flow",
previous: childToken
});
return flowContinue(code2);
}
function flowContinue(code2) {
if (code2 === null) {
writeToChild(effects.exit("chunkFlow"), true);
exitContainers(0);
effects.consume(code2);
return;
}
if (markdownLineEnding(code2)) {
effects.consume(code2);
writeToChild(effects.exit("chunkFlow"));
continued = 0;
self2.interrupt = void 0;
return start2;
}
effects.consume(code2);
return flowContinue;
}
function writeToChild(token, endOfFile) {
const stream = self2.sliceStream(token);
if (endOfFile) stream.push(null);
token.previous = childToken;
if (childToken) childToken.next = token;
childToken = token;
childFlow.defineSkip(token.start);
childFlow.write(stream);
if (self2.parser.lazy[token.start.line]) {
let index3 = childFlow.events.length;
while (index3--) {
if (
// The token starts before the line ending…
childFlow.events[index3][1].start.offset < lineStartOffset && // …and either is not ended yet…
(!childFlow.events[index3][1].end || // …or ends after it.
childFlow.events[index3][1].end.offset > lineStartOffset)
) {
return;
}
}
const indexBeforeExits = self2.events.length;
let indexBeforeFlow = indexBeforeExits;
let seen;
let point5;
while (indexBeforeFlow--) {
if (self2.events[indexBeforeFlow][0] === "exit" && self2.events[indexBeforeFlow][1].type === "chunkFlow") {
if (seen) {
point5 = self2.events[indexBeforeFlow][1].end;
break;
}
seen = true;
}
}
exitContainers(continued);
index3 = indexBeforeExits;
while (index3 < self2.events.length) {
self2.events[index3][1].end = {
...point5
};
index3++;
}
splice(self2.events, indexBeforeFlow + 1, 0, self2.events.slice(indexBeforeExits));
self2.events.length = index3;
}
}
function exitContainers(size) {
let index3 = stack.length;
while (index3-- > size) {
const entry = stack[index3];
self2.containerState = entry[1];
entry[0].exit.call(self2, effects);
}
stack.length = size;
}
function closeFlow() {
childFlow.write([null]);
childToken = void 0;
childFlow = void 0;
self2.containerState._closeFlow = void 0;
}
}
function tokenizeContainer(effects, ok3, nok) {
return factorySpace(effects, effects.attempt(this.parser.constructs.document, ok3, nok), "linePrefix", this.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4);
}
// ../../node_modules/micromark/node_modules/micromark-util-classify-character/index.js
function classifyCharacter(code2) {
if (code2 === null || markdownLineEndingOrSpace(code2) || unicodeWhitespace(code2)) {
return 1;
}
if (unicodePunctuation(code2)) {
return 2;
}
}
// ../../node_modules/micromark/node_modules/micromark-util-resolve-all/index.js
function resolveAll(constructs2, events, context) {
const called = [];
let index3 = -1;
while (++index3 < constructs2.length) {
const resolve = constructs2[index3].resolveAll;
if (resolve && !called.includes(resolve)) {
events = resolve(events, context);
called.push(resolve);
}
}
return events;
}
// ../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/attention.js
var attention = {
name: "attention",
resolveAll: resolveAllAttention,
tokenize: tokenizeAttention
};
function resolveAllAttention(events, context) {
let index3 = -1;
let open;
let group;
let text5;
let openingSequence;
let closingSequence;
let use;
let nextEvents;
let offset;
while (++index3 < events.length) {
if (events[index3][0] === "enter" && events[index3][1].type === "attentionSequence" && events[index3][1]._close) {
open = index3;
while (open--) {
if (events[open][0] === "exit" && events[open][1].type === "attentionSequence" && events[open][1]._open && // If the markers are the same:
context.sliceSerialize(events[open][1]).charCodeAt(0) === context.sliceSerialize(events[index3][1]).charCodeAt(0)) {
if ((events[open][1]._close || events[index3][1]._open) && (events[index3][1].end.offset - events[index3][1].start.offset) % 3 && !((events[open][1].end.offset - events[open][1].start.offset + events[index3][1].end.offset - events[index3][1].start.offset) % 3)) {
continue;
}
use = events[open][1].end.offset - events[open][1].start.offset > 1 && events[index3][1].end.offset - events[index3][1].start.offset > 1 ? 2 : 1;
const start2 = {
...events[open][1].end
};
const end = {
...events[index3][1].start
};
movePoint(start2, -use);
movePoint(end, use);
openingSequence = {
type: use > 1 ? "strongSequence" : "emphasisSequence",
start: start2,
end: {
...events[open][1].end
}
};
closingSequence = {
type: use > 1 ? "strongSequence" : "emphasisSequence",
start: {
...events[index3][1].start
},
end
};
text5 = {
type: use > 1 ? "strongText" : "emphasisText",
start: {
...events[open][1].end
},
end: {
...events[index3][1].start
}
};
group = {
type: use > 1 ? "strong" : "emphasis",
start: {
...openingSequence.start
},
end: {
...closingSequence.end
}
};
events[open][1].end = {
...openingSequence.start
};
events[index3][1].start = {
...closingSequence.end
};
nextEvents = [];
if (events[open][1].end.offset - events[open][1].start.offset) {
nextEvents = push(nextEvents, [["enter", events[open][1], context], ["exit", events[open][1], context]]);
}
nextEvents = push(nextEvents, [["enter", group, context], ["enter", openingSequence, context], ["exit", openingSequence, context], ["enter", text5, context]]);
nextEvents = push(nextEvents, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + 1, index3), context));
nextEvents = push(nextEvents, [["exit", text5, context], ["enter", closingSequence, context], ["exit", closingSequence, context], ["exit", group, context]]);
if (events[index3][1].end.offset - events[index3][1].start.offset) {
offset = 2;
nextEvents = push(nextEvents, [["enter", events[index3][1], context], ["exit", events[index3][1], context]]);
} else {
offset = 0;
}
splice(events, open - 1, index3 - open + 3, nextEvents);
index3 = open + nextEvents.length - offset - 2;
break;
}
}
}
}
index3 = -1;
while (++index3 < events.length) {
if (events[index3][1].type === "attentionSequence") {
events[index3][1].type = "data";
}
}
return events;
}
function tokenizeAttention(effects, ok3) {
const attentionMarkers2 = this.parser.constructs.attentionMarkers.null;
const previous2 = this.previous;
const before = classifyCharacter(previous2);
let marker;
return start2;
function start2(code2) {
marker = code2;
effects.enter("attentionSequence");
return inside(code2);
}
function inside(code2) {
if (code2 === marker) {
effects.consume(code2);
return inside;
}
const token = effects.exit("attentionSequence");
const after = classifyCharacter(code2);
const open = !after || after === 2 && before || attentionMarkers2.includes(code2);
const close = !before || before === 2 && after || attentionMarkers2.includes(previous2);
token._open = Boolean(marker === 42 ? open : open && (before || !close));
token._close = Boolean(marker === 42 ? close : close && (after || !open));
return ok3(code2);
}
}
function movePoint(point5, offset) {
point5.column += offset;
point5.offset += offset;
point5._bufferIndex += offset;
}
// ../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/autolink.js
var autolink = {
name: "autolink",
tokenize: tokenizeAutolink
};
function tokenizeAutolink(effects, ok3, nok) {
let size = 0;
return start2;
function start2(code2) {
effects.enter("autolink");
effects.enter("autolinkMarker");
effects.consume(code2);
effects.exit("autolinkMarker");
effects.enter("autolinkProtocol");
return open;
}
function open(code2) {
if (asciiAlpha(code2)) {
effects.consume(code2);
return schemeOrEmailAtext;
}
if (code2 === 64) {
return nok(code2);
}
return emailAtext(code2);
}
function schemeOrEmailAtext(code2) {
if (code2 === 43 || code2 === 45 || code2 === 46 || asciiAlphanumeric(code2)) {
size = 1;
return schemeInsideOrEmailAtext(code2);
}
return emailAtext(code2);
}
function schemeInsideOrEmailAtext(code2) {
if (code2 === 58) {
effects.consume(code2);
size = 0;
return urlInside;
}
if ((code2 === 43 || code2 === 45 || code2 === 46 || asciiAlphanumeric(code2)) && size++ < 32) {
effects.consume(code2);
return schemeInsideOrEmailAtext;
}
size = 0;
return emailAtext(code2);
}
function urlInside(code2) {
if (code2 === 62) {
effects.exit("autolinkProtocol");
effects.enter("autolinkMarker");
effects.consume(code2);
effects.exit("autolinkMarker");
effects.exit("autolink");
return ok3;
}
if (code2 === null || code2 === 32 || code2 === 60 || asciiControl(code2)) {
return nok(code2);
}
effects.consume(code2);
return urlInside;
}
function emailAtext(code2) {
if (code2 === 64) {
effects.consume(code2);
return emailAtSignOrDot;
}
if (asciiAtext(code2)) {
effects.consume(code2);
return emailAtext;
}
return nok(code2);
}
function emailAtSignOrDot(code2) {
return asciiAlphanumeric(code2) ? emailLabel(code2) : nok(code2);
}
function emailLabel(code2) {
if (code2 === 46) {
effects.consume(code2);
size = 0;
return emailAtSignOrDot;
}
if (code2 === 62) {
effects.exit("autolinkProtocol").type = "autolinkEmail";
effects.enter("autolinkMarker");
effects.consume(code2);
effects.exit("autolinkMarker");
effects.exit("autolink");
return ok3;
}
return emailValue(code2);
}
function emailValue(code2) {
if ((code2 === 45 || asciiAlphanumeric(code2)) && size++ < 63) {
const next = code2 === 45 ? emailValue : emailLabel;
effects.consume(code2);
return next;
}
return nok(code2);
}
}
// ../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/blank-line.js
var blankLine = {
partial: true,
tokenize: tokenizeBlankLine
};
function tokenizeBlankLine(effects, ok3, nok) {
return start2;
function start2(code2) {
return markdownSpace(code2) ? factorySpace(effects, after, "linePrefix")(code2) : after(code2);
}
function after(code2) {
return code2 === null || markdownLineEnding(code2) ? ok3(code2) : nok(code2);
}
}
// ../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/block-quote.js
var blockQuote = {
continuation: {
tokenize: tokenizeBlockQuoteContinuation
},
exit,
name: "blockQuote",
tokenize: tokenizeBlockQuoteStart
};
function tokenizeBlockQuoteStart(effects, ok3, nok) {
const self2 = this;
return start2;
function start2(code2) {
if (code2 === 62) {
const state = self2.containerState;
if (!state.open) {
effects.enter("blockQuote", {
_container: true
});
state.open = true;
}
effects.enter("blockQuotePrefix");
effects.enter("blockQuoteMarker");
effects.consume(code2);
effects.exit("blockQuoteMarker");
return after;
}
return nok(code2);
}
function after(code2) {
if (markdownSpace(code2)) {
effects.enter("blockQuotePrefixWhitespace");
effects.consume(code2);
effects.exit("blockQuotePrefixWhitespace");
effects.exit("blockQuotePrefix");
return ok3;
}
effects.exit("blockQuotePrefix");
return ok3(code2);
}
}
function tokenizeBlockQuoteContinuation(effects, ok3, nok) {
const self2 = this;
return contStart;
function contStart(code2) {
if (markdownSpace(code2)) {
return factorySpace(effects, contBefore, "linePrefix", self2.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4)(code2);
}
return contBefore(code2);
}
function contBefore(code2) {
return effects.attempt(blockQuote, ok3, nok)(code2);
}
}
function exit(effects) {
effects.exit("blockQuote");
}
// ../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/character-escape.js
var characterEscape = {
name: "characterEscape",
tokenize: tokenizeCharacterEscape
};
function tokenizeCharacterEscape(effects, ok3, nok) {
return start2;
function start2(code2) {
effects.enter("characterEscape");
effects.enter("escapeMarker");
effects.consume(code2);
effects.exit("escapeMarker");
return inside;
}
function inside(code2) {
if (asciiPunctuation(code2)) {
effects.enter("characterEscapeValue");
effects.consume(code2);
effects.exit("characterEscapeValue");
effects.exit("characterEscape");
return ok3;
}
return nok(code2);
}
}
// ../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/character-reference.js
var characterReference = {
name: "characterReference",
tokenize: tokenizeCharacterReference
};
function tokenizeCharacterReference(effects, ok3, nok) {
const self2 = this;
let size = 0;
let max;
let test;
return start2;
function start2(code2) {
effects.enter("characterReference");
effects.enter("characterReferenceMarker");
effects.consume(code2);
effects.exit("characterReferenceMarker");
return open;
}
function open(code2) {
if (code2 === 35) {
effects.enter("characterReferenceMarkerNumeric");
effects.consume(code2);
effects.exit("characterReferenceMarkerNumeric");
return numeric;
}
effects.enter("characterReferenceValue");
max = 31;
test = asciiAlphanumeric;
return value(code2);
}
function numeric(code2) {
if (code2 === 88 || code2 === 120) {
effects.enter("characterReferenceMarkerHexadecimal");
effects.consume(code2);
effects.exit("characterReferenceMarkerHexadecimal");
effects.enter("characterReferenceValue");
max = 6;
test = asciiHexDigit;
return value;
}
effects.enter("characterReferenceValue");
max = 7;
test = asciiDigit;
return value(code2);
}
function value(code2) {
if (code2 === 59 && size) {
const token = effects.exit("characterReferenceValue");
if (test === asciiAlphanumeric && !decodeNamedCharacterReference(self2.sliceSerialize(token))) {
return nok(code2);
}
effects.enter("characterReferenceMarker");
effects.consume(code2);
effects.exit("characterReferenceMarker");
effects.exit("characterReference");
return ok3;
}
if (test(code2) && size++ < max) {
effects.consume(code2);
return value;
}
return nok(code2);
}
}
// ../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/code-fenced.js
var nonLazyContinuation = {
partial: true,
tokenize: tokenizeNonLazyContinuation
};
var codeFenced = {
concrete: true,
name: "codeFenced",
tokenize: tokenizeCodeFenced
};
function tokenizeCodeFenced(effects, ok3, nok) {
const self2 = this;
const closeStart = {
partial: true,
tokenize: tokenizeCloseStart
};
let initialPrefix = 0;
let sizeOpen = 0;
let marker;
return start2;
function start2(code2) {
return beforeSequenceOpen(code2);
}
function beforeSequenceOpen(code2) {
const tail = self2.events[self2.events.length - 1];
initialPrefix = tail && tail[1].type === "linePrefix" ? tail[2].sliceSerialize(tail[1], true).length : 0;
marker = code2;
effects.enter("codeFenced");
effects.enter("codeFencedFence");
effects.enter("codeFencedFenceSequence");
return sequenceOpen(code2);
}
function sequenceOpen(code2) {
if (code2 === marker) {
sizeOpen++;
effects.consume(code2);
return sequenceOpen;
}
if (sizeOpen < 3) {
return nok(code2);
}
effects.exit("codeFencedFenceSequence");
return markdownSpace(code2) ? factorySpace(effects, infoBefore, "whitespace")(code2) : infoBefore(code2);
}
function infoBefore(code2) {
if (code2 === null || markdownLineEnding(code2)) {
effects.exit("codeFencedFence");
return self2.interrupt ? ok3(code2) : effects.check(nonLazyContinuation, atNonLazyBreak, after)(code2);
}
effects.enter("codeFencedFenceInfo");
effects.enter("chunkString", {
contentType: "string"
});
return info(code2);
}
function info(code2) {
if (code2 === null || markdownLineEnding(code2)) {
effects.exit("chunkString");
effects.exit("codeFencedFenceInfo");
return infoBefore(code2);
}
if (markdownSpace(code2)) {
effects.exit("chunkString");
effects.exit("codeFencedFenceInfo");
return factorySpace(effects, metaBefore, "whitespace")(code2);
}
if (code2 === 96 && code2 === marker) {
return nok(code2);
}
effects.consume(code2);
return info;
}
function metaBefore(code2) {
if (code2 === null || markdownLineEnding(code2)) {
return infoBefore(code2);
}
effects.enter("codeFencedFenceMeta");
effects.enter("chunkString", {
contentType: "string"
});
return meta(code2);
}
function meta(code2) {
if (code2 === null || markdownLineEnding(code2)) {
effects.exit("chunkString");
effects.exit("codeFencedFenceMeta");
return infoBefore(code2);
}
if (code2 === 96 && code2 === marker) {
return nok(code2);
}
effects.consume(code2);
return meta;
}
function atNonLazyBreak(code2) {
return effects.attempt(closeStart, after, contentBefore)(code2);
}
function contentBefore(code2) {
effects.enter("lineEnding");
effects.consume(code2);
effects.exit("lineEnding");
return contentStart;
}
function contentStart(code2) {
return initialPrefix > 0 && markdownSpace(code2) ? factorySpace(effects, beforeContentChunk, "linePrefix", initialPrefix + 1)(code2) : beforeContentChunk(code2);
}
function beforeContentChunk(code2) {
if (code2 === null || markdownLineEnding(code2)) {
return effects.check(nonLazyContinuation, atNonLazyBreak, after)(code2);
}
effects.enter("codeFlowValue");
return contentChunk(code2);
}
function contentChunk(code2) {
if (code2 === null || markdownLineEnding(code2)) {
effects.exit("codeFlowValue");
return beforeContentChunk(code2);
}
effects.consume(code2);
return contentChunk;
}
function after(code2) {
effects.exit("codeFenced");
return ok3(code2);
}
function tokenizeCloseStart(effects2, ok4, nok2) {
let size = 0;
return startBefore;
function startBefore(code2) {
effects2.enter("lineEnding");
effects2.consume(code2);
effects2.exit("lineEnding");
return start3;
}
function start3(code2) {
effects2.enter("codeFencedFence");
return markdownSpace(code2) ? factorySpace(effects2, beforeSequenceClose, "linePrefix", self2.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4)(code2) : beforeSequenceClose(code2);
}
function beforeSequenceClose(code2) {
if (code2 === marker) {
effects2.enter("codeFencedFenceSequence");
return sequenceClose(code2);
}
return nok2(code2);
}
function sequenceClose(code2) {
if (code2 === marker) {
size++;
effects2.consume(code2);
return sequenceClose;
}
if (size >= sizeOpen) {
effects2.exit("codeFencedFenceSequence");
return markdownSpace(code2) ? factorySpace(effects2, sequenceCloseAfter, "whitespace")(code2) : sequenceCloseAfter(code2);
}
return nok2(code2);
}
function sequenceCloseAfter(code2) {
if (code2 === null || markdownLineEnding(code2)) {
effects2.exit("codeFencedFence");
return ok4(code2);
}
return nok2(code2);
}
}
}
function tokenizeNonLazyContinuation(effects, ok3, nok) {
const self2 = this;
return start2;
function start2(code2) {
if (code2 === null) {
return nok(code2);
}
effects.enter("lineEnding");
effects.consume(code2);
effects.exit("lineEnding");
return lineStart;
}
function lineStart(code2) {
return self2.parser.lazy[self2.now().line] ? nok(code2) : ok3(code2);
}
}
// ../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/code-indented.js
var codeIndented = {
name: "codeIndented",
tokenize: tokenizeCodeIndented
};
var furtherStart = {
partial: true,
tokenize: tokenizeFurtherStart
};
function tokenizeCodeIndented(effects, ok3, nok) {
const self2 = this;
return start2;
function start2(code2) {
effects.enter("codeIndented");
return factorySpace(effects, afterPrefix, "linePrefix", 4 + 1)(code2);
}
function afterPrefix(code2) {
const tail = self2.events[self2.events.length - 1];
return tail && tail[1].type === "linePrefix" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? atBreak(code2) : nok(code2);
}
function atBreak(code2) {
if (code2 === null) {
return after(code2);
}
if (markdownLineEnding(code2)) {
return effects.attempt(furtherStart, atBreak, after)(code2);
}
effects.enter("codeFlowValue");
return inside(code2);
}
function inside(code2) {
if (code2 === null || markdownLineEnding(code2)) {
effects.exit("codeFlowValue");
return atBreak(code2);
}
effects.consume(code2);
return inside;
}
function after(code2) {
effects.exit("codeIndented");
return ok3(code2);
}
}
function tokenizeFurtherStart(effects, ok3, nok) {
const self2 = this;
return furtherStart2;
function furtherStart2(code2) {
if (self2.parser.lazy[self2.now().line]) {
return nok(code2);
}
if (markdownLineEnding(code2)) {
effects.enter("lineEnding");
effects.consume(code2);
effects.exit("lineEnding");
return furtherStart2;
}
return factorySpace(effects, afterPrefix, "linePrefix", 4 + 1)(code2);
}
function afterPrefix(code2) {
const tail = self2.events[self2.events.length - 1];
return tail && tail[1].type === "linePrefix" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? ok3(code2) : markdownLineEnding(code2) ? furtherStart2(code2) : nok(code2);
}
}
// ../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/code-text.js
var codeText = {
name: "codeText",
previous,
resolve: resolveCodeText,
tokenize: tokenizeCodeText
};
function resolveCodeText(events) {
let tailExitIndex = events.length - 4;
let headEnterIndex = 3;
let index3;
let enter;
if ((events[headEnterIndex][1].type === "lineEnding" || events[headEnterIndex][1].type === "space") && (events[tailExitIndex][1].type === "lineEnding" || events[tailExitIndex][1].type === "space")) {
index3 = headEnterIndex;
while (++index3 < tailExitIndex) {
if (events[index3][1].type === "codeTextData") {
events[headEnterIndex][1].type = "codeTextPadding";
events[tailExitIndex][1].type = "codeTextPadding";
headEnterIndex += 2;
tailExitIndex -= 2;
break;
}
}
}
index3 = headEnterIndex - 1;
tailExitIndex++;
while (++index3 <= tailExitIndex) {
if (enter === void 0) {
if (index3 !== tailExitIndex && events[index3][1].type !== "lineEnding") {
enter = index3;
}
} else if (index3 === tailExitIndex || events[index3][1].type === "lineEnding") {
events[enter][1].type = "codeTextData";
if (index3 !== enter + 2) {
events[enter][1].end = events[index3 - 1][1].end;
events.splice(enter + 2, index3 - enter - 2);
tailExitIndex -= index3 - enter - 2;
index3 = enter + 2;
}
enter = void 0;
}
}
return events;
}
function previous(code2) {
return code2 !== 96 || this.events[this.events.length - 1][1].type === "characterEscape";
}
function tokenizeCodeText(effects, ok3, nok) {
const self2 = this;
let sizeOpen = 0;
let size;
let token;
return start2;
function start2(code2) {
effects.enter("codeText");
effects.enter("codeTextSequence");
return sequenceOpen(code2);
}
function sequenceOpen(code2) {
if (code2 === 96) {
effects.consume(code2);
sizeOpen++;
return sequenceOpen;
}
effects.exit("codeTextSequence");
return between(code2);
}
function between(code2) {
if (code2 === null) {
return nok(code2);
}
if (code2 === 32) {
effects.enter("space");
effects.consume(code2);
effects.exit("space");
return between;
}
if (code2 === 96) {
token = effects.enter("codeTextSequence");
size = 0;
return sequenceClose(code2);
}
if (markdownLineEnding(code2)) {
effects.enter("lineEnding");
effects.consume(code2);
effects.exit("lineEnding");
return between;
}
effects.enter("codeTextData");
return data(code2);
}
function data(code2) {
if (code2 === null || code2 === 32 || code2 === 96 || markdownLineEnding(code2)) {
effects.exit("codeTextData");
return between(code2);
}
effects.consume(code2);
return data;
}
function sequenceClose(code2) {
if (code2 === 96) {
effects.consume(code2);
size++;
return sequenceClose;
}
if (size === sizeOpen) {
effects.exit("codeTextSequence");
effects.exit("codeText");
return ok3(code2);
}
token.type = "codeTextData";
return data(code2);
}
}
// ../../node_modules/micromark/node_modules/micromark-util-subtokenize/lib/splice-buffer.js
var SpliceBuffer = class {
/**
* @param {ReadonlyArray<T> | null | undefined} [initial]
* Initial items (optional).
* @returns
* Splice buffer.
*/
constructor(initial) {
this.left = initial ? [...initial] : [];
this.right = [];
}
/**
* Array access;
* does not move the cursor.
*
* @param {number} index
* Index.
* @return {T}
* Item.
*/
get(index3) {
if (index3 < 0 || index3 >= this.left.length + this.right.length) {
throw new RangeError("Cannot access index `" + index3 + "` in a splice buffer of size `" + (this.left.length + this.right.length) + "`");
}
if (index3 < this.left.length) return this.left[index3];
return this.right[this.right.length - index3 + this.left.length - 1];
}
/**
* The length of the splice buffer, one greater than the largest index in the
* array.
*/
get length() {
return this.left.length + this.right.length;
}
/**
* Remove and return `list[0]`;
* moves the cursor to `0`.
*
* @returns {T | undefined}
* Item, optional.
*/
shift() {
this.setCursor(0);
return this.right.pop();
}
/**
* Slice the buffer to get an array;
* does not move the cursor.
*
* @param {number} start
* Start.
* @param {number | null | undefined} [end]
* End (optional).
* @returns {Array<T>}
* Array of items.
*/
slice(start2, end) {
const stop = end === null || end === void 0 ? Number.POSITIVE_INFINITY : end;
if (stop < this.left.length) {
return this.left.slice(start2, stop);
}
if (start2 > this.left.length) {
return this.right.slice(this.right.length - stop + this.left.length, this.right.length - start2 + this.left.length).reverse();
}
return this.left.slice(start2).concat(this.right.slice(this.right.length - stop + this.left.length).reverse());
}
/**
* Mimics the behavior of Array.prototype.splice() except for the change of
* interface necessary to avoid segfaults when patching in very large arrays.
*
* This operation moves cursor is moved to `start` and results in the cursor
* placed after any inserted items.
*
* @param {number} start
* Start;
* zero-based index at which to start changing the array;
* negative numbers count backwards from the end of the array and values
* that are out-of bounds are clamped to the appropriate end of the array.
* @param {number | null | undefined} [deleteCount=0]
* Delete count (default: `0`);
* maximum number of elements to delete, starting from start.
* @param {Array<T> | null | undefined} [items=[]]
* Items to include in place of the deleted items (default: `[]`).
* @return {Array<T>}
* Any removed items.
*/
splice(start2, deleteCount, items) {
const count = deleteCount || 0;
this.setCursor(Math.trunc(start2));
const removed = this.right.splice(this.right.length - count, Number.POSITIVE_INFINITY);
if (items) chunkedPush(this.left, items);
return removed.reverse();
}
/**
* Remove and return the highest-numbered item in the array, so
* `list[list.length - 1]`;
* Moves the cursor to `length`.
*
* @returns {T | undefined}
* Item, optional.
*/
pop() {
this.setCursor(Number.POSITIVE_INFINITY);
return this.left.pop();
}
/**
* Inserts a single item to the high-numbered side of the array;
* moves the cursor to `length`.
*
* @param {T} item
* Item.
* @returns {undefined}
* Nothing.
*/
push(item) {
this.setCursor(Number.POSITIVE_INFINITY);
this.left.push(item);
}
/**
* Inserts many items to the high-numbered side of the array.
* Moves the cursor to `length`.
*
* @param {Array<T>} items
* Items.
* @returns {undefined}
* Nothing.
*/
pushMany(items) {
this.setCursor(Number.POSITIVE_INFINITY);
chunkedPush(this.left, items);
}
/**
* Inserts a single item to the low-numbered side of the array;
* Moves the cursor to `0`.
*
* @param {T} item
* Item.
* @returns {undefined}
* Nothing.
*/
unshift(item) {
this.setCursor(0);
this.right.push(item);
}
/**
* Inserts many items to the low-numbered side of the array;
* moves the cursor to `0`.
*
* @param {Array<T>} items
* Items.
* @returns {undefined}
* Nothing.
*/
unshiftMany(items) {
this.setCursor(0);
chunkedPush(this.right, items.reverse());
}
/**
* Move the cursor to a specific position in the array. Requires
* time proportional to the distance moved.
*
* If `n < 0`, the cursor will end up at the beginning.
* If `n > length`, the cursor will end up at the end.
*
* @param {number} n
* Position.
* @return {undefined}
* Nothing.
*/
setCursor(n) {
if (n === this.left.length || n > this.left.length && this.right.length === 0 || n < 0 && this.left.length === 0) return;
if (n < this.left.length) {
const removed = this.left.splice(n, Number.POSITIVE_INFINITY);
chunkedPush(this.right, removed.reverse());
} else {
const removed = this.right.splice(this.left.length + this.right.length - n, Number.POSITIVE_INFINITY);
chunkedPush(this.left, removed.reverse());
}
}
};
function chunkedPush(list3, right) {
let chunkStart = 0;
if (right.length < 1e4) {
list3.push(...right);
} else {
while (chunkStart < right.length) {
list3.push(...right.slice(chunkStart, chunkStart + 1e4));
chunkStart += 1e4;
}
}
}
// ../../node_modules/micromark/node_modules/micromark-util-subtokenize/index.js
function subtokenize(eventsArray) {
const jumps = {};
let index3 = -1;
let event;
let lineIndex;
let otherIndex;
let otherEvent;
let parameters;
let subevents;
let more;
const events = new SpliceBuffer(eventsArray);
while (++index3 < events.length) {
while (index3 in jumps) {
index3 = jumps[index3];
}
event = events.get(index3);
if (index3 && event[1].type === "chunkFlow" && events.get(index3 - 1)[1].type === "listItemPrefix") {
subevents = event[1]._tokenizer.events;
otherIndex = 0;
if (otherIndex < subevents.length && subevents[otherIndex][1].type === "lineEndingBlank") {
otherIndex += 2;
}
if (otherIndex < subevents.length && subevents[otherIndex][1].type === "content") {
while (++otherIndex < subevents.length) {
if (subevents[otherIndex][1].type === "content") {
break;
}
if (subevents[otherIndex][1].type === "chunkText") {
subevents[otherIndex][1]._isInFirstContentOfListItem = true;
otherIndex++;
}
}
}
}
if (event[0] === "enter") {
if (event[1].contentType) {
Object.assign(jumps, subcontent(events, index3));
index3 = jumps[index3];
more = true;
}
} else if (event[1]._container) {
otherIndex = index3;
lineIndex = void 0;
while (otherIndex--) {
otherEvent = events.get(otherIndex);
if (otherEvent[1].type === "lineEnding" || otherEvent[1].type === "lineEndingBlank") {
if (otherEvent[0] === "enter") {
if (lineIndex) {
events.get(lineIndex)[1].type = "lineEndingBlank";
}
otherEvent[1].type = "lineEnding";
lineIndex = otherIndex;
}
} else if (otherEvent[1].type === "linePrefix" || otherEvent[1].type === "listItemIndent") {
} else {
break;
}
}
if (lineIndex) {
event[1].end = {
...events.get(lineIndex)[1].start
};
parameters = events.slice(lineIndex, index3);
parameters.unshift(event);
events.splice(lineIndex, index3 - lineIndex + 1, parameters);
}
}
}
splice(eventsArray, 0, Number.POSITIVE_INFINITY, events.slice(0));
return !more;
}
function subcontent(events, eventIndex) {
const token = events.get(eventIndex)[1];
const context = events.get(eventIndex)[2];
let startPosition = eventIndex - 1;
const startPositions = [];
let tokenizer = token._tokenizer;
if (!tokenizer) {
tokenizer = context.parser[token.contentType](token.start);
if (token._contentTypeTextTrailing) {
tokenizer._contentTypeTextTrailing = true;
}
}
const childEvents = tokenizer.events;
const jumps = [];
const gaps = {};
let stream;
let previous2;
let index3 = -1;
let current = token;
let adjust = 0;
let start2 = 0;
const breaks = [start2];
while (current) {
while (events.get(++startPosition)[1] !== current) {
}
startPositions.push(startPosition);
if (!current._tokenizer) {
stream = context.sliceStream(current);
if (!current.next) {
stream.push(null);
}
if (previous2) {
tokenizer.defineSkip(current.start);
}
if (current._isInFirstContentOfListItem) {
tokenizer._gfmTasklistFirstContentOfListItem = true;
}
tokenizer.write(stream);
if (current._isInFirstContentOfListItem) {
tokenizer._gfmTasklistFirstContentOfListItem = void 0;
}
}
previous2 = current;
current = current.next;
}
current = token;
while (++index3 < childEvents.length) {
if (
// Find a void token that includes a break.
childEvents[index3][0] === "exit" && childEvents[index3 - 1][0] === "enter" && childEvents[index3][1].type === childEvents[index3 - 1][1].type && childEvents[index3][1].start.line !== childEvents[index3][1].end.line
) {
start2 = index3 + 1;
breaks.push(start2);
current._tokenizer = void 0;
current.previous = void 0;
current = current.next;
}
}
tokenizer.events = [];
if (current) {
current._tokenizer = void 0;
current.previous = void 0;
} else {
breaks.pop();
}
index3 = breaks.length;
while (index3--) {
const slice = childEvents.slice(breaks[index3], breaks[index3 + 1]);
const start3 = startPositions.pop();
jumps.push([start3, start3 + slice.length - 1]);
events.splice(start3, 2, slice);
}
jumps.reverse();
index3 = -1;
while (++index3 < jumps.length) {
gaps[adjust + jumps[index3][0]] = adjust + jumps[index3][1];
adjust += jumps[index3][1] - jumps[index3][0] - 1;
}
return gaps;
}
// ../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/content.js
var content2 = {
resolve: resolveContent,
tokenize: tokenizeContent
};
var continuationConstruct = {
partial: true,
tokenize: tokenizeContinuation
};
function resolveContent(events) {
subtokenize(events);
return events;
}
function tokenizeContent(effects, ok3) {
let previous2;
return chunkStart;
function chunkStart(code2) {
effects.enter("content");
previous2 = effects.enter("chunkContent", {
contentType: "content"
});
return chunkInside(code2);
}
function chunkInside(code2) {
if (code2 === null) {
return contentEnd(code2);
}
if (markdownLineEnding(code2)) {
return effects.check(continuationConstruct, contentContinue, contentEnd)(code2);
}
effects.consume(code2);
return chunkInside;
}
function contentEnd(code2) {
effects.exit("chunkContent");
effects.exit("content");
return ok3(code2);
}
function contentContinue(code2) {
effects.consume(code2);
effects.exit("chunkContent");
previous2.next = effects.enter("chunkContent", {
contentType: "content",
previous: previous2
});
previous2 = previous2.next;
return chunkInside;
}
}
function tokenizeContinuation(effects, ok3, nok) {
const self2 = this;
return startLookahead;
function startLookahead(code2) {
effects.exit("chunkContent");
effects.enter("lineEnding");
effects.consume(code2);
effects.exit("lineEnding");
return factorySpace(effects, prefixed, "linePrefix");
}
function prefixed(code2) {
if (code2 === null || markdownLineEnding(code2)) {
return nok(code2);
}
const tail = self2.events[self2.events.length - 1];
if (!self2.parser.constructs.disable.null.includes("codeIndented") && tail && tail[1].type === "linePrefix" && tail[2].sliceSerialize(tail[1], true).length >= 4) {
return ok3(code2);
}
return effects.interrupt(self2.parser.constructs.flow, nok, ok3)(code2);
}
}
// ../../node_modules/micromark/node_modules/micromark-factory-destination/index.js
function factoryDestination(effects, ok3, nok, type, literalType, literalMarkerType, rawType, stringType, max) {
const limit = max || Number.POSITIVE_INFINITY;
let balance = 0;
return start2;
function start2(code2) {
if (code2 === 60) {
effects.enter(type);
effects.enter(literalType);
effects.enter(literalMarkerType);
effects.consume(code2);
effects.exit(literalMarkerType);
return enclosedBefore;
}
if (code2 === null || code2 === 32 || code2 === 41 || asciiControl(code2)) {
return nok(code2);
}
effects.enter(type);
effects.enter(rawType);
effects.enter(stringType);
effects.enter("chunkString", {
contentType: "string"
});
return raw(code2);
}
function enclosedBefore(code2) {
if (code2 === 62) {
effects.enter(literalMarkerType);
effects.consume(code2);
effects.exit(literalMarkerType);
effects.exit(literalType);
effects.exit(type);
return ok3;
}
effects.enter(stringType);
effects.enter("chunkString", {
contentType: "string"
});
return enclosed(code2);
}
function enclosed(code2) {
if (code2 === 62) {
effects.exit("chunkString");
effects.exit(stringType);
return enclosedBefore(code2);
}
if (code2 === null || code2 === 60 || markdownLineEnding(code2)) {
return nok(code2);
}
effects.consume(code2);
return code2 === 92 ? enclosedEscape : enclosed;
}
function enclosedEscape(code2) {
if (code2 === 60 || code2 === 62 || code2 === 92) {
effects.consume(code2);
return enclosed;
}
return enclosed(code2);
}
function raw(code2) {
if (!balance && (code2 === null || code2 === 41 || markdownLineEndingOrSpace(code2))) {
effects.exit("chunkString");
effects.exit(stringType);
effects.exit(rawType);
effects.exit(type);
return ok3(code2);
}
if (balance < limit && code2 === 40) {
effects.consume(code2);
balance++;
return raw;
}
if (code2 === 41) {
effects.consume(code2);
balance--;
return raw;
}
if (code2 === null || code2 === 32 || code2 === 40 || asciiControl(code2)) {
return nok(code2);
}
effects.consume(code2);
return code2 === 92 ? rawEscape : raw;
}
function rawEscape(code2) {
if (code2 === 40 || code2 === 41 || code2 === 92) {
effects.consume(code2);
return raw;
}
return raw(code2);
}
}
// ../../node_modules/micromark/node_modules/micromark-factory-label/index.js
function factoryLabel(effects, ok3, nok, type, markerType, stringType) {
const self2 = this;
let size = 0;
let seen;
return start2;
function start2(code2) {
effects.enter(type);
effects.enter(markerType);
effects.consume(code2);
effects.exit(markerType);
effects.enter(stringType);
return atBreak;
}
function atBreak(code2) {
if (size > 999 || code2 === null || code2 === 91 || code2 === 93 && !seen || // To do: remove in the future once we’ve switched from
// `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,
// which doesn’t need this.
// Hidden footnotes hook.
/* c8 ignore next 3 */
code2 === 94 && !size && "_hiddenFootnoteSupport" in self2.parser.constructs) {
return nok(code2);
}
if (code2 === 93) {
effects.exit(stringType);
effects.enter(markerType);
effects.consume(code2);
effects.exit(markerType);
effects.exit(type);
return ok3;
}
if (markdownLineEnding(code2)) {
effects.enter("lineEnding");
effects.consume(code2);
effects.exit("lineEnding");
return atBreak;
}
effects.enter("chunkString", {
contentType: "string"
});
return labelInside(code2);
}
function labelInside(code2) {
if (code2 === null || code2 === 91 || code2 === 93 || markdownLineEnding(code2) || size++ > 999) {
effects.exit("chunkString");
return atBreak(code2);
}
effects.consume(code2);
if (!seen) seen = !markdownSpace(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);
}
}
// ../../node_modules/micromark/node_modules/micromark-factory-title/index.js
function factoryTitle(effects, ok3, nok, type, markerType, stringType) {
let marker;
return start2;
function start2(code2) {
if (code2 === 34 || code2 === 39 || code2 === 40) {
effects.enter(type);
effects.enter(markerType);
effects.consume(code2);
effects.exit(markerType);
marker = code2 === 40 ? 41 : code2;
return begin;
}
return nok(code2);
}
function begin(code2) {
if (code2 === marker) {
effects.enter(markerType);
effects.consume(code2);
effects.exit(markerType);
effects.exit(type);
return ok3;
}
effects.enter(stringType);
return atBreak(code2);
}
function atBreak(code2) {
if (code2 === marker) {
effects.exit(stringType);
return begin(marker);
}
if (code2 === null) {
return nok(code2);
}
if (markdownLineEnding(code2)) {
effects.enter("lineEnding");
effects.consume(code2);
effects.exit("lineEnding");
return factorySpace(effects, atBreak, "linePrefix");
}
effects.enter("chunkString", {
contentType: "string"
});
return inside(code2);
}
function inside(code2) {
if (code2 === marker || code2 === null || markdownLineEnding(code2)) {
effects.exit("chunkString");
return atBreak(code2);
}
effects.consume(code2);
return code2 === 92 ? escape : inside;
}
function escape(code2) {
if (code2 === marker || code2 === 92) {
effects.consume(code2);
return inside;
}
return inside(code2);
}
}
// ../../node_modules/micromark/node_modules/micromark-factory-whitespace/index.js
function factoryWhitespace(effects, ok3) {
let seen;
return start2;
function start2(code2) {
if (markdownLineEnding(code2)) {
effects.enter("lineEnding");
effects.consume(code2);
effects.exit("lineEnding");
seen = true;
return start2;
}
if (markdownSpace(code2)) {
return factorySpace(effects, start2, seen ? "linePrefix" : "lineSuffix")(code2);
}
return ok3(code2);
}
}
// ../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/definition.js
var definition = {
name: "definition",
tokenize: tokenizeDefinition
};
var titleBefore = {
partial: true,
tokenize: tokenizeTitleBefore
};
function tokenizeDefinition(effects, ok3, nok) {
const self2 = this;
let identifier;
return start2;
function start2(code2) {
effects.enter("definition");
return before(code2);
}
function before(code2) {
return factoryLabel.call(
self2,
effects,
labelAfter,
// Note: we don’t need to reset the way `markdown-rs` does.
nok,
"definitionLabel",
"definitionLabelMarker",
"definitionLabelString"
)(code2);
}
function labelAfter(code2) {
identifier = normalizeIdentifier(self2.sliceSerialize(self2.events[self2.events.length - 1][1]).slice(1, -1));
if (code2 === 58) {
effects.enter("definitionMarker");
effects.consume(code2);
effects.exit("definitionMarker");
return markerAfter;
}
return nok(code2);
}
function markerAfter(code2) {
return markdownLineEndingOrSpace(code2) ? factoryWhitespace(effects, destinationBefore)(code2) : destinationBefore(code2);
}
function destinationBefore(code2) {
return factoryDestination(
effects,
destinationAfter,
// Note: we don’t need to reset the way `markdown-rs` does.
nok,
"definitionDestination",
"definitionDestinationLiteral",
"definitionDestinationLiteralMarker",
"definitionDestinationRaw",
"definitionDestinationString"
)(code2);
}
function destinationAfter(code2) {
return effects.attempt(titleBefore, after, after)(code2);
}
function after(code2) {
return markdownSpace(code2) ? factorySpace(effects, afterWhitespace, "whitespace")(code2) : afterWhitespace(code2);
}
function afterWhitespace(code2) {
if (code2 === null || markdownLineEnding(code2)) {
effects.exit("definition");
self2.parser.defined.push(identifier);
return ok3(code2);
}
return nok(code2);
}
}
function tokenizeTitleBefore(effects, ok3, nok) {
return titleBefore2;
function titleBefore2(code2) {
return markdownLineEndingOrSpace(code2) ? factoryWhitespace(effects, beforeMarker)(code2) : nok(code2);
}
function beforeMarker(code2) {
return factoryTitle(effects, titleAfter, nok, "definitionTitle", "definitionTitleMarker", "definitionTitleString")(code2);
}
function titleAfter(code2) {
return markdownSpace(code2) ? factorySpace(effects, titleAfterOptionalWhitespace, "whitespace")(code2) : titleAfterOptionalWhitespace(code2);
}
function titleAfterOptionalWhitespace(code2) {
return code2 === null || markdownLineEnding(code2) ? ok3(code2) : nok(code2);
}
}
// ../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/hard-break-escape.js
var hardBreakEscape = {
name: "hardBreakEscape",
tokenize: tokenizeHardBreakEscape
};
function tokenizeHardBreakEscape(effects, ok3, nok) {
return start2;
function start2(code2) {
effects.enter("hardBreakEscape");
effects.consume(code2);
return after;
}
function after(code2) {
if (markdownLineEnding(code2)) {
effects.exit("hardBreakEscape");
return ok3(code2);
}
return nok(code2);
}
}
// ../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/heading-atx.js
var headingAtx = {
name: "headingAtx",
resolve: resolveHeadingAtx,
tokenize: tokenizeHeadingAtx
};
function resolveHeadingAtx(events, context) {
let contentEnd = events.length - 2;
let contentStart = 3;
let content3;
let text5;
if (events[contentStart][1].type === "whitespace") {
contentStart += 2;
}
if (contentEnd - 2 > contentStart && events[contentEnd][1].type === "whitespace") {
contentEnd -= 2;
}
if (events[contentEnd][1].type === "atxHeadingSequence" && (contentStart === contentEnd - 1 || contentEnd - 4 > contentStart && events[contentEnd - 2][1].type === "whitespace")) {
contentEnd -= contentStart + 1 === contentEnd ? 2 : 4;
}
if (contentEnd > contentStart) {
content3 = {
type: "atxHeadingText",
start: events[contentStart][1].start,
end: events[contentEnd][1].end
};
text5 = {
type: "chunkText",
start: events[contentStart][1].start,
end: events[contentEnd][1].end,
contentType: "text"
};
splice(events, contentStart, contentEnd - contentStart + 1, [["enter", content3, context], ["enter", text5, context], ["exit", text5, context], ["exit", content3, context]]);
}
return events;
}
function tokenizeHeadingAtx(effects, ok3, nok) {
let size = 0;
return start2;
function start2(code2) {
effects.enter("atxHeading");
return before(code2);
}
function before(code2) {
effects.enter("atxHeadingSequence");
return sequenceOpen(code2);
}
function sequenceOpen(code2) {
if (code2 === 35 && size++ < 6) {
effects.consume(code2);
return sequenceOpen;
}
if (code2 === null || markdownLineEndingOrSpace(code2)) {
effects.exit("atxHeadingSequence");
return atBreak(code2);
}
return nok(code2);
}
function atBreak(code2) {
if (code2 === 35) {
effects.enter("atxHeadingSequence");
return sequenceFurther(code2);
}
if (code2 === null || markdownLineEnding(code2)) {
effects.exit("atxHeading");
return ok3(code2);
}
if (markdownSpace(code2)) {
return factorySpace(effects, atBreak, "whitespace")(code2);
}
effects.enter("atxHeadingText");
return data(code2);
}
function sequenceFurther(code2) {
if (code2 === 35) {
effects.consume(code2);
return sequenceFurther;
}
effects.exit("atxHeadingSequence");
return atBreak(code2);
}
function data(code2) {
if (code2 === null || code2 === 35 || markdownLineEndingOrSpace(code2)) {
effects.exit("atxHeadingText");
return atBreak(code2);
}
effects.consume(code2);
return data;
}
}
// ../../node_modules/micromark/node_modules/micromark-util-html-tag-name/index.js
var htmlBlockNames = [
"address",
"article",
"aside",
"base",
"basefont",
"blockquote",
"body",
"caption",
"center",
"col",
"colgroup",
"dd",
"details",
"dialog",
"dir",
"div",
"dl",
"dt",
"fieldset",
"figcaption",
"figure",
"footer",
"form",
"frame",
"frameset",
"h1",
"h2",
"h3",
"h4",
"h5",
"h6",
"head",
"header",
"hr",
"html",
"iframe",
"legend",
"li",
"link",
"main",
"menu",
"menuitem",
"nav",
"noframes",
"ol",
"optgroup",
"option",
"p",
"param",
"search",
"section",
"summary",
"table",
"tbody",
"td",
"tfoot",
"th",
"thead",
"title",
"tr",
"track",
"ul"
];
var htmlRawNames = ["pre", "script", "style", "textarea"];
// ../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/html-flow.js
var htmlFlow = {
concrete: true,
name: "htmlFlow",
resolveTo: resolveToHtmlFlow,
tokenize: tokenizeHtmlFlow
};
var blankLineBefore = {
partial: true,
tokenize: tokenizeBlankLineBefore
};
var nonLazyContinuationStart = {
partial: true,
tokenize: tokenizeNonLazyContinuationStart
};
function resolveToHtmlFlow(events) {
let index3 = events.length;
while (index3--) {
if (events[index3][0] === "enter" && events[index3][1].type === "htmlFlow") {
break;
}
}
if (index3 > 1 && events[index3 - 2][1].type === "linePrefix") {
events[index3][1].start = events[index3 - 2][1].start;
events[index3 + 1][1].start = events[index3 - 2][1].start;
events.splice(index3 - 2, 2);
}
return events;
}
function tokenizeHtmlFlow(effects, ok3, nok) {
const self2 = this;
let marker;
let closingTag;
let buffer;
let index3;
let markerB;
return start2;
function start2(code2) {
return before(code2);
}
function before(code2) {
effects.enter("htmlFlow");
effects.enter("htmlFlowData");
effects.consume(code2);
return open;
}
function open(code2) {
if (code2 === 33) {
effects.consume(code2);
return declarationOpen;
}
if (code2 === 47) {
effects.consume(code2);
closingTag = true;
return tagCloseStart;
}
if (code2 === 63) {
effects.consume(code2);
marker = 3;
return self2.interrupt ? ok3 : continuationDeclarationInside;
}
if (asciiAlpha(code2)) {
effects.consume(code2);
buffer = String.fromCharCode(code2);
return tagName;
}
return nok(code2);
}
function declarationOpen(code2) {
if (code2 === 45) {
effects.consume(code2);
marker = 2;
return commentOpenInside;
}
if (code2 === 91) {
effects.consume(code2);
marker = 5;
index3 = 0;
return cdataOpenInside;
}
if (asciiAlpha(code2)) {
effects.consume(code2);
marker = 4;
return self2.interrupt ? ok3 : continuationDeclarationInside;
}
return nok(code2);
}
function commentOpenInside(code2) {
if (code2 === 45) {
effects.consume(code2);
return self2.interrupt ? ok3 : continuationDeclarationInside;
}
return nok(code2);
}
function cdataOpenInside(code2) {
const value = "CDATA[";
if (code2 === value.charCodeAt(index3++)) {
effects.consume(code2);
if (index3 === value.length) {
return self2.interrupt ? ok3 : continuation;
}
return cdataOpenInside;
}
return nok(code2);
}
function tagCloseStart(code2) {
if (asciiAlpha(code2)) {
effects.consume(code2);
buffer = String.fromCharCode(code2);
return tagName;
}
return nok(code2);
}
function tagName(code2) {
if (code2 === null || code2 === 47 || code2 === 62 || markdownLineEndingOrSpace(code2)) {
const slash = code2 === 47;
const name2 = buffer.toLowerCase();
if (!slash && !closingTag && htmlRawNames.includes(name2)) {
marker = 1;
return self2.interrupt ? ok3(code2) : continuation(code2);
}
if (htmlBlockNames.includes(buffer.toLowerCase())) {
marker = 6;
if (slash) {
effects.consume(code2);
return basicSelfClosing;
}
return self2.interrupt ? ok3(code2) : continuation(code2);
}
marker = 7;
return self2.interrupt && !self2.parser.lazy[self2.now().line] ? nok(code2) : closingTag ? completeClosingTagAfter(code2) : completeAttributeNameBefore(code2);
}
if (code2 === 45 || asciiAlphanumeric(code2)) {
effects.consume(code2);
buffer += String.fromCharCode(code2);
return tagName;
}
return nok(code2);
}
function basicSelfClosing(code2) {
if (code2 === 62) {
effects.consume(code2);
return self2.interrupt ? ok3 : continuation;
}
return nok(code2);
}
function completeClosingTagAfter(code2) {
if (markdownSpace(code2)) {
effects.consume(code2);
return completeClosingTagAfter;
}
return completeEnd(code2);
}
function completeAttributeNameBefore(code2) {
if (code2 === 47) {
effects.consume(code2);
return completeEnd;
}
if (code2 === 58 || code2 === 95 || asciiAlpha(code2)) {
effects.consume(code2);
return completeAttributeName;
}
if (markdownSpace(code2)) {
effects.consume(code2);
return completeAttributeNameBefore;
}
return completeEnd(code2);
}
function completeAttributeName(code2) {
if (code2 === 45 || code2 === 46 || code2 === 58 || code2 === 95 || asciiAlphanumeric(code2)) {
effects.consume(code2);
return completeAttributeName;
}
return completeAttributeNameAfter(code2);
}
function completeAttributeNameAfter(code2) {
if (code2 === 61) {
effects.consume(code2);
return completeAttributeValueBefore;
}
if (markdownSpace(code2)) {
effects.consume(code2);
return completeAttributeNameAfter;
}
return completeAttributeNameBefore(code2);
}
function completeAttributeValueBefore(code2) {
if (code2 === null || code2 === 60 || code2 === 61 || code2 === 62 || code2 === 96) {
return nok(code2);
}
if (code2 === 34 || code2 === 39) {
effects.consume(code2);
markerB = code2;
return completeAttributeValueQuoted;
}
if (markdownSpace(code2)) {
effects.consume(code2);
return completeAttributeValueBefore;
}
return completeAttributeValueUnquoted(code2);
}
function completeAttributeValueQuoted(code2) {
if (code2 === markerB) {
effects.consume(code2);
markerB = null;
return completeAttributeValueQuotedAfter;
}
if (code2 === null || markdownLineEnding(code2)) {
return nok(code2);
}
effects.consume(code2);
return completeAttributeValueQuoted;
}
function completeAttributeValueUnquoted(code2) {
if (code2 === null || code2 === 34 || code2 === 39 || code2 === 47 || code2 === 60 || code2 === 61 || code2 === 62 || code2 === 96 || markdownLineEndingOrSpace(code2)) {
return completeAttributeNameAfter(code2);
}
effects.consume(code2);
return completeAttributeValueUnquoted;
}
function completeAttributeValueQuotedAfter(code2) {
if (code2 === 47 || code2 === 62 || markdownSpace(code2)) {
return completeAttributeNameBefore(code2);
}
return nok(code2);
}
function completeEnd(code2) {
if (code2 === 62) {
effects.consume(code2);
return completeAfter;
}
return nok(code2);
}
function completeAfter(code2) {
if (code2 === null || markdownLineEnding(code2)) {
return continuation(code2);
}
if (markdownSpace(code2)) {
effects.consume(code2);
return completeAfter;
}
return nok(code2);
}
function continuation(code2) {
if (code2 === 45 && marker === 2) {
effects.consume(code2);
return continuationCommentInside;
}
if (code2 === 60 && marker === 1) {
effects.consume(code2);
return continuationRawTagOpen;
}
if (code2 === 62 && marker === 4) {
effects.consume(code2);
return continuationClose;
}
if (code2 === 63 && marker === 3) {
effects.consume(code2);
return continuationDeclarationInside;
}
if (code2 === 93 && marker === 5) {
effects.consume(code2);
return continuationCdataInside;
}
if (markdownLineEnding(code2) && (marker === 6 || marker === 7)) {
effects.exit("htmlFlowData");
return effects.check(blankLineBefore, continuationAfter, continuationStart)(code2);
}
if (code2 === null || markdownLineEnding(code2)) {
effects.exit("htmlFlowData");
return continuationStart(code2);
}
effects.consume(code2);
return continuation;
}
function continuationStart(code2) {
return effects.check(nonLazyContinuationStart, continuationStartNonLazy, continuationAfter)(code2);
}
function continuationStartNonLazy(code2) {
effects.enter("lineEnding");
effects.consume(code2);
effects.exit("lineEnding");
return continuationBefore;
}
function continuationBefore(code2) {
if (code2 === null || markdownLineEnding(code2)) {
return continuationStart(code2);
}
effects.enter("htmlFlowData");
return continuation(code2);
}
function continuationCommentInside(code2) {
if (code2 === 45) {
effects.consume(code2);
return continuationDeclarationInside;
}
return continuation(code2);
}
function continuationRawTagOpen(code2) {
if (code2 === 47) {
effects.consume(code2);
buffer = "";
return continuationRawEndTag;
}
return continuation(code2);
}
function continuationRawEndTag(code2) {
if (code2 === 62) {
const name2 = buffer.toLowerCase();
if (htmlRawNames.includes(name2)) {
effects.consume(code2);
return continuationClose;
}
return continuation(code2);
}
if (asciiAlpha(code2) && buffer.length < 8) {
effects.consume(code2);
buffer += String.fromCharCode(code2);
return continuationRawEndTag;
}
return continuation(code2);
}
function continuationCdataInside(code2) {
if (code2 === 93) {
effects.consume(code2);
return continuationDeclarationInside;
}
return continuation(code2);
}
function continuationDeclarationInside(code2) {
if (code2 === 62) {
effects.consume(code2);
return continuationClose;
}
if (code2 === 45 && marker === 2) {
effects.consume(code2);
return continuationDeclarationInside;
}
return continuation(code2);
}
function continuationClose(code2) {
if (code2 === null || markdownLineEnding(code2)) {
effects.exit("htmlFlowData");
return continuationAfter(code2);
}
effects.consume(code2);
return continuationClose;
}
function continuationAfter(code2) {
effects.exit("htmlFlow");
return ok3(code2);
}
}
function tokenizeNonLazyContinuationStart(effects, ok3, nok) {
const self2 = this;
return start2;
function start2(code2) {
if (markdownLineEnding(code2)) {
effects.enter("lineEnding");
effects.consume(code2);
effects.exit("lineEnding");
return after;
}
return nok(code2);
}
function after(code2) {
return self2.parser.lazy[self2.now().line] ? nok(code2) : ok3(code2);
}
}
function tokenizeBlankLineBefore(effects, ok3, nok) {
return start2;
function start2(code2) {
effects.enter("lineEnding");
effects.consume(code2);
effects.exit("lineEnding");
return effects.attempt(blankLine, ok3, nok);
}
}
// ../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/html-text.js
var htmlText = {
name: "htmlText",
tokenize: tokenizeHtmlText
};
function tokenizeHtmlText(effects, ok3, nok) {
const self2 = this;
let marker;
let index3;
let returnState;
return start2;
function start2(code2) {
effects.enter("htmlText");
effects.enter("htmlTextData");
effects.consume(code2);
return open;
}
function open(code2) {
if (code2 === 33) {
effects.consume(code2);
return declarationOpen;
}
if (code2 === 47) {
effects.consume(code2);
return tagCloseStart;
}
if (code2 === 63) {
effects.consume(code2);
return instruction;
}
if (asciiAlpha(code2)) {
effects.consume(code2);
return tagOpen;
}
return nok(code2);
}
function declarationOpen(code2) {
if (code2 === 45) {
effects.consume(code2);
return commentOpenInside;
}
if (code2 === 91) {
effects.consume(code2);
index3 = 0;
return cdataOpenInside;
}
if (asciiAlpha(code2)) {
effects.consume(code2);
return declaration;
}
return nok(code2);
}
function commentOpenInside(code2) {
if (code2 === 45) {
effects.consume(code2);
return commentEnd;
}
return nok(code2);
}
function comment(code2) {
if (code2 === null) {
return nok(code2);
}
if (code2 === 45) {
effects.consume(code2);
return commentClose;
}
if (markdownLineEnding(code2)) {
returnState = comment;
return lineEndingBefore(code2);
}
effects.consume(code2);
return comment;
}
function commentClose(code2) {
if (code2 === 45) {
effects.consume(code2);
return commentEnd;
}
return comment(code2);
}
function commentEnd(code2) {
return code2 === 62 ? end(code2) : code2 === 45 ? commentClose(code2) : comment(code2);
}
function cdataOpenInside(code2) {
const value = "CDATA[";
if (code2 === value.charCodeAt(index3++)) {
effects.consume(code2);
return index3 === value.length ? cdata : cdataOpenInside;
}
return nok(code2);
}
function cdata(code2) {
if (code2 === null) {
return nok(code2);
}
if (code2 === 93) {
effects.consume(code2);
return cdataClose;
}
if (markdownLineEnding(code2)) {
returnState = cdata;
return lineEndingBefore(code2);
}
effects.consume(code2);
return cdata;
}
function cdataClose(code2) {
if (code2 === 93) {
effects.consume(code2);
return cdataEnd;
}
return cdata(code2);
}
function cdataEnd(code2) {
if (code2 === 62) {
return end(code2);
}
if (code2 === 93) {
effects.consume(code2);
return cdataEnd;
}
return cdata(code2);
}
function declaration(code2) {
if (code2 === null || code2 === 62) {
return end(code2);
}
if (markdownLineEnding(code2)) {
returnState = declaration;
return lineEndingBefore(code2);
}
effects.consume(code2);
return declaration;
}
function instruction(code2) {
if (code2 === null) {
return nok(code2);
}
if (code2 === 63) {
effects.consume(code2);
return instructionClose;
}
if (markdownLineEnding(code2)) {
returnState = instruction;
return lineEndingBefore(code2);
}
effects.consume(code2);
return instruction;
}
function instructionClose(code2) {
return code2 === 62 ? end(code2) : instruction(code2);
}
function tagCloseStart(code2) {
if (asciiAlpha(code2)) {
effects.consume(code2);
return tagClose;
}
return nok(code2);
}
function tagClose(code2) {
if (code2 === 45 || asciiAlphanumeric(code2)) {
effects.consume(code2);
return tagClose;
}
return tagCloseBetween(code2);
}
function tagCloseBetween(code2) {
if (markdownLineEnding(code2)) {
returnState = tagCloseBetween;
return lineEndingBefore(code2);
}
if (markdownSpace(code2)) {
effects.consume(code2);
return tagCloseBetween;
}
return end(code2);
}
function tagOpen(code2) {
if (code2 === 45 || asciiAlphanumeric(code2)) {
effects.consume(code2);
return tagOpen;
}
if (code2 === 47 || code2 === 62 || markdownLineEndingOrSpace(code2)) {
return tagOpenBetween(code2);
}
return nok(code2);
}
function tagOpenBetween(code2) {
if (code2 === 47) {
effects.consume(code2);
return end;
}
if (code2 === 58 || code2 === 95 || asciiAlpha(code2)) {
effects.consume(code2);
return tagOpenAttributeName;
}
if (markdownLineEnding(code2)) {
returnState = tagOpenBetween;
return lineEndingBefore(code2);
}
if (markdownSpace(code2)) {
effects.consume(code2);
return tagOpenBetween;
}
return end(code2);
}
function tagOpenAttributeName(code2) {
if (code2 === 45 || code2 === 46 || code2 === 58 || code2 === 95 || asciiAlphanumeric(code2)) {
effects.consume(code2);
return tagOpenAttributeName;
}
return tagOpenAttributeNameAfter(code2);
}
function tagOpenAttributeNameAfter(code2) {
if (code2 === 61) {
effects.consume(code2);
return tagOpenAttributeValueBefore;
}
if (markdownLineEnding(code2)) {
returnState = tagOpenAttributeNameAfter;
return lineEndingBefore(code2);
}
if (markdownSpace(code2)) {
effects.consume(code2);
return tagOpenAttributeNameAfter;
}
return tagOpenBetween(code2);
}
function tagOpenAttributeValueBefore(code2) {
if (code2 === null || code2 === 60 || code2 === 61 || code2 === 62 || code2 === 96) {
return nok(code2);
}
if (code2 === 34 || code2 === 39) {
effects.consume(code2);
marker = code2;
return tagOpenAttributeValueQuoted;
}
if (markdownLineEnding(code2)) {
returnState = tagOpenAttributeValueBefore;
return lineEndingBefore(code2);
}
if (markdownSpace(code2)) {
effects.consume(code2);
return tagOpenAttributeValueBefore;
}
effects.consume(code2);
return tagOpenAttributeValueUnquoted;
}
function tagOpenAttributeValueQuoted(code2) {
if (code2 === marker) {
effects.consume(code2);
marker = void 0;
return tagOpenAttributeValueQuotedAfter;
}
if (code2 === null) {
return nok(code2);
}
if (markdownLineEnding(code2)) {
returnState = tagOpenAttributeValueQuoted;
return lineEndingBefore(code2);
}
effects.consume(code2);
return tagOpenAttributeValueQuoted;
}
function tagOpenAttributeValueUnquoted(code2) {
if (code2 === null || code2 === 34 || code2 === 39 || code2 === 60 || code2 === 61 || code2 === 96) {
return nok(code2);
}
if (code2 === 47 || code2 === 62 || markdownLineEndingOrSpace(code2)) {
return tagOpenBetween(code2);
}
effects.consume(code2);
return tagOpenAttributeValueUnquoted;
}
function tagOpenAttributeValueQuotedAfter(code2) {
if (code2 === 47 || code2 === 62 || markdownLineEndingOrSpace(code2)) {
return tagOpenBetween(code2);
}
return nok(code2);
}
function end(code2) {
if (code2 === 62) {
effects.consume(code2);
effects.exit("htmlTextData");
effects.exit("htmlText");
return ok3;
}
return nok(code2);
}
function lineEndingBefore(code2) {
effects.exit("htmlTextData");
effects.enter("lineEnding");
effects.consume(code2);
effects.exit("lineEnding");
return lineEndingAfter;
}
function lineEndingAfter(code2) {
return markdownSpace(code2) ? factorySpace(effects, lineEndingAfterPrefix, "linePrefix", self2.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4)(code2) : lineEndingAfterPrefix(code2);
}
function lineEndingAfterPrefix(code2) {
effects.enter("htmlTextData");
return returnState(code2);
}
}
// ../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/label-end.js
var labelEnd = {
name: "labelEnd",
resolveAll: resolveAllLabelEnd,
resolveTo: resolveToLabelEnd,
tokenize: tokenizeLabelEnd
};
var resourceConstruct = {
tokenize: tokenizeResource
};
var referenceFullConstruct = {
tokenize: tokenizeReferenceFull
};
var referenceCollapsedConstruct = {
tokenize: tokenizeReferenceCollapsed
};
function resolveAllLabelEnd(events) {
let index3 = -1;
const newEvents = [];
while (++index3 < events.length) {
const token = events[index3][1];
newEvents.push(events[index3]);
if (token.type === "labelImage" || token.type === "labelLink" || token.type === "labelEnd") {
const offset = token.type === "labelImage" ? 4 : 2;
token.type = "data";
index3 += offset;
}
}
if (events.length !== newEvents.length) {
splice(events, 0, events.length, newEvents);
}
return events;
}
function resolveToLabelEnd(events, context) {
let index3 = events.length;
let offset = 0;
let token;
let open;
let close;
let media;
while (index3--) {
token = events[index3][1];
if (open) {
if (token.type === "link" || token.type === "labelLink" && token._inactive) {
break;
}
if (events[index3][0] === "enter" && token.type === "labelLink") {
token._inactive = true;
}
} else if (close) {
if (events[index3][0] === "enter" && (token.type === "labelImage" || token.type === "labelLink") && !token._balanced) {
open = index3;
if (token.type !== "labelLink") {
offset = 2;
break;
}
}
} else if (token.type === "labelEnd") {
close = index3;
}
}
const group = {
type: events[open][1].type === "labelLink" ? "link" : "image",
start: {
...events[open][1].start
},
end: {
...events[events.length - 1][1].end
}
};
const label = {
type: "label",
start: {
...events[open][1].start
},
end: {
...events[close][1].end
}
};
const text5 = {
type: "labelText",
start: {
...events[open + offset + 2][1].end
},
end: {
...events[close - 2][1].start
}
};
media = [["enter", group, context], ["enter", label, context]];
media = push(media, events.slice(open + 1, open + offset + 3));
media = push(media, [["enter", text5, context]]);
media = push(media, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + offset + 4, close - 3), context));
media = push(media, [["exit", text5, context], events[close - 2], events[close - 1], ["exit", label, context]]);
media = push(media, events.slice(close + 1));
media = push(media, [["exit", group, context]]);
splice(events, open, events.length, media);
return events;
}
function tokenizeLabelEnd(effects, ok3, nok) {
const self2 = this;
let index3 = self2.events.length;
let labelStart;
let defined;
while (index3--) {
if ((self2.events[index3][1].type === "labelImage" || self2.events[index3][1].type === "labelLink") && !self2.events[index3][1]._balanced) {
labelStart = self2.events[index3][1];
break;
}
}
return start2;
function start2(code2) {
if (!labelStart) {
return nok(code2);
}
if (labelStart._inactive) {
return labelEndNok(code2);
}
defined = self2.parser.defined.includes(normalizeIdentifier(self2.sliceSerialize({
start: labelStart.end,
end: self2.now()
})));
effects.enter("labelEnd");
effects.enter("labelMarker");
effects.consume(code2);
effects.exit("labelMarker");
effects.exit("labelEnd");
return after;
}
function after(code2) {
if (code2 === 40) {
return effects.attempt(resourceConstruct, labelEndOk, defined ? labelEndOk : labelEndNok)(code2);
}
if (code2 === 91) {
return effects.attempt(referenceFullConstruct, labelEndOk, defined ? referenceNotFull : labelEndNok)(code2);
}
return defined ? labelEndOk(code2) : labelEndNok(code2);
}
function referenceNotFull(code2) {
return effects.attempt(referenceCollapsedConstruct, labelEndOk, labelEndNok)(code2);
}
function labelEndOk(code2) {
return ok3(code2);
}
function labelEndNok(code2) {
labelStart._balanced = true;
return nok(code2);
}
}
function tokenizeResource(effects, ok3, nok) {
return resourceStart;
function resourceStart(code2) {
effects.enter("resource");
effects.enter("resourceMarker");
effects.consume(code2);
effects.exit("resourceMarker");
return resourceBefore;
}
function resourceBefore(code2) {
return markdownLineEndingOrSpace(code2) ? factoryWhitespace(effects, resourceOpen)(code2) : resourceOpen(code2);
}
function resourceOpen(code2) {
if (code2 === 41) {
return resourceEnd(code2);
}
return factoryDestination(effects, resourceDestinationAfter, resourceDestinationMissing, "resourceDestination", "resourceDestinationLiteral", "resourceDestinationLiteralMarker", "resourceDestinationRaw", "resourceDestinationString", 32)(code2);
}
function resourceDestinationAfter(code2) {
return markdownLineEndingOrSpace(code2) ? factoryWhitespace(effects, resourceBetween)(code2) : resourceEnd(code2);
}
function resourceDestinationMissing(code2) {
return nok(code2);
}
function resourceBetween(code2) {
if (code2 === 34 || code2 === 39 || code2 === 40) {
return factoryTitle(effects, resourceTitleAfter, nok, "resourceTitle", "resourceTitleMarker", "resourceTitleString")(code2);
}
return resourceEnd(code2);
}
function resourceTitleAfter(code2) {
return markdownLineEndingOrSpace(code2) ? factoryWhitespace(effects, resourceEnd)(code2) : resourceEnd(code2);
}
function resourceEnd(code2) {
if (code2 === 41) {
effects.enter("resourceMarker");
effects.consume(code2);
effects.exit("resourceMarker");
effects.exit("resource");
return ok3;
}
return nok(code2);
}
}
function tokenizeReferenceFull(effects, ok3, nok) {
const self2 = this;
return referenceFull;
function referenceFull(code2) {
return factoryLabel.call(self2, effects, referenceFullAfter, referenceFullMissing, "reference", "referenceMarker", "referenceString")(code2);
}
function referenceFullAfter(code2) {
return self2.parser.defined.includes(normalizeIdentifier(self2.sliceSerialize(self2.events[self2.events.length - 1][1]).slice(1, -1))) ? ok3(code2) : nok(code2);
}
function referenceFullMissing(code2) {
return nok(code2);
}
}
function tokenizeReferenceCollapsed(effects, ok3, nok) {
return referenceCollapsedStart;
function referenceCollapsedStart(code2) {
effects.enter("reference");
effects.enter("referenceMarker");
effects.consume(code2);
effects.exit("referenceMarker");
return referenceCollapsedOpen;
}
function referenceCollapsedOpen(code2) {
if (code2 === 93) {
effects.enter("referenceMarker");
effects.consume(code2);
effects.exit("referenceMarker");
effects.exit("reference");
return ok3;
}
return nok(code2);
}
}
// ../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/label-start-image.js
var labelStartImage = {
name: "labelStartImage",
resolveAll: labelEnd.resolveAll,
tokenize: tokenizeLabelStartImage
};
function tokenizeLabelStartImage(effects, ok3, nok) {
const self2 = this;
return start2;
function start2(code2) {
effects.enter("labelImage");
effects.enter("labelImageMarker");
effects.consume(code2);
effects.exit("labelImageMarker");
return open;
}
function open(code2) {
if (code2 === 91) {
effects.enter("labelMarker");
effects.consume(code2);
effects.exit("labelMarker");
effects.exit("labelImage");
return after;
}
return nok(code2);
}
function after(code2) {
return code2 === 94 && "_hiddenFootnoteSupport" in self2.parser.constructs ? nok(code2) : ok3(code2);
}
}
// ../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/label-start-link.js
var labelStartLink = {
name: "labelStartLink",
resolveAll: labelEnd.resolveAll,
tokenize: tokenizeLabelStartLink
};
function tokenizeLabelStartLink(effects, ok3, nok) {
const self2 = this;
return start2;
function start2(code2) {
effects.enter("labelLink");
effects.enter("labelMarker");
effects.consume(code2);
effects.exit("labelMarker");
effects.exit("labelLink");
return after;
}
function after(code2) {
return code2 === 94 && "_hiddenFootnoteSupport" in self2.parser.constructs ? nok(code2) : ok3(code2);
}
}
// ../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/line-ending.js
var lineEnding = {
name: "lineEnding",
tokenize: tokenizeLineEnding
};
function tokenizeLineEnding(effects, ok3) {
return start2;
function start2(code2) {
effects.enter("lineEnding");
effects.consume(code2);
effects.exit("lineEnding");
return factorySpace(effects, ok3, "linePrefix");
}
}
// ../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/thematic-break.js
var thematicBreak = {
name: "thematicBreak",
tokenize: tokenizeThematicBreak
};
function tokenizeThematicBreak(effects, ok3, nok) {
let size = 0;
let marker;
return start2;
function start2(code2) {
effects.enter("thematicBreak");
return before(code2);
}
function before(code2) {
marker = code2;
return atBreak(code2);
}
function atBreak(code2) {
if (code2 === marker) {
effects.enter("thematicBreakSequence");
return sequence(code2);
}
if (size >= 3 && (code2 === null || markdownLineEnding(code2))) {
effects.exit("thematicBreak");
return ok3(code2);
}
return nok(code2);
}
function sequence(code2) {
if (code2 === marker) {
effects.consume(code2);
size++;
return sequence;
}
effects.exit("thematicBreakSequence");
return markdownSpace(code2) ? factorySpace(effects, atBreak, "whitespace")(code2) : atBreak(code2);
}
}
// ../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/list.js
var list = {
continuation: {
tokenize: tokenizeListContinuation
},
exit: tokenizeListEnd,
name: "list",
tokenize: tokenizeListStart
};
var listItemPrefixWhitespaceConstruct = {
partial: true,
tokenize: tokenizeListItemPrefixWhitespace
};
var indentConstruct = {
partial: true,
tokenize: tokenizeIndent
};
function tokenizeListStart(effects, ok3, nok) {
const self2 = this;
const tail = self2.events[self2.events.length - 1];
let initialSize = tail && tail[1].type === "linePrefix" ? tail[2].sliceSerialize(tail[1], true).length : 0;
let size = 0;
return start2;
function start2(code2) {
const kind = self2.containerState.type || (code2 === 42 || code2 === 43 || code2 === 45 ? "listUnordered" : "listOrdered");
if (kind === "listUnordered" ? !self2.containerState.marker || code2 === self2.containerState.marker : asciiDigit(code2)) {
if (!self2.containerState.type) {
self2.containerState.type = kind;
effects.enter(kind, {
_container: true
});
}
if (kind === "listUnordered") {
effects.enter("listItemPrefix");
return code2 === 42 || code2 === 45 ? effects.check(thematicBreak, nok, atMarker)(code2) : atMarker(code2);
}
if (!self2.interrupt || code2 === 49) {
effects.enter("listItemPrefix");
effects.enter("listItemValue");
return inside(code2);
}
}
return nok(code2);
}
function inside(code2) {
if (asciiDigit(code2) && ++size < 10) {
effects.consume(code2);
return inside;
}
if ((!self2.interrupt || size < 2) && (self2.containerState.marker ? code2 === self2.containerState.marker : code2 === 41 || code2 === 46)) {
effects.exit("listItemValue");
return atMarker(code2);
}
return nok(code2);
}
function atMarker(code2) {
effects.enter("listItemMarker");
effects.consume(code2);
effects.exit("listItemMarker");
self2.containerState.marker = self2.containerState.marker || code2;
return effects.check(
blankLine,
// Can’t be empty when interrupting.
self2.interrupt ? nok : onBlank,
effects.attempt(listItemPrefixWhitespaceConstruct, endOfPrefix, otherPrefix)
);
}
function onBlank(code2) {
self2.containerState.initialBlankLine = true;
initialSize++;
return endOfPrefix(code2);
}
function otherPrefix(code2) {
if (markdownSpace(code2)) {
effects.enter("listItemPrefixWhitespace");
effects.consume(code2);
effects.exit("listItemPrefixWhitespace");
return endOfPrefix;
}
return nok(code2);
}
function endOfPrefix(code2) {
self2.containerState.size = initialSize + self2.sliceSerialize(effects.exit("listItemPrefix"), true).length;
return ok3(code2);
}
}
function tokenizeListContinuation(effects, ok3, nok) {
const self2 = this;
self2.containerState._closeFlow = void 0;
return effects.check(blankLine, onBlank, notBlank);
function onBlank(code2) {
self2.containerState.furtherBlankLines = self2.containerState.furtherBlankLines || self2.containerState.initialBlankLine;
return factorySpace(effects, ok3, "listItemIndent", self2.containerState.size + 1)(code2);
}
function notBlank(code2) {
if (self2.containerState.furtherBlankLines || !markdownSpace(code2)) {
self2.containerState.furtherBlankLines = void 0;
self2.containerState.initialBlankLine = void 0;
return notInCurrentItem(code2);
}
self2.containerState.furtherBlankLines = void 0;
self2.containerState.initialBlankLine = void 0;
return effects.attempt(indentConstruct, ok3, notInCurrentItem)(code2);
}
function notInCurrentItem(code2) {
self2.containerState._closeFlow = true;
self2.interrupt = void 0;
return factorySpace(effects, effects.attempt(list, ok3, nok), "linePrefix", self2.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4)(code2);
}
}
function tokenizeIndent(effects, ok3, nok) {
const self2 = this;
return factorySpace(effects, afterPrefix, "listItemIndent", self2.containerState.size + 1);
function afterPrefix(code2) {
const tail = self2.events[self2.events.length - 1];
return tail && tail[1].type === "listItemIndent" && tail[2].sliceSerialize(tail[1], true).length === self2.containerState.size ? ok3(code2) : nok(code2);
}
}
function tokenizeListEnd(effects) {
effects.exit(this.containerState.type);
}
function tokenizeListItemPrefixWhitespace(effects, ok3, nok) {
const self2 = this;
return factorySpace(effects, afterPrefix, "listItemPrefixWhitespace", self2.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4 + 1);
function afterPrefix(code2) {
const tail = self2.events[self2.events.length - 1];
return !markdownSpace(code2) && tail && tail[1].type === "listItemPrefixWhitespace" ? ok3(code2) : nok(code2);
}
}
// ../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/setext-underline.js
var setextUnderline = {
name: "setextUnderline",
resolveTo: resolveToSetextUnderline,
tokenize: tokenizeSetextUnderline
};
function resolveToSetextUnderline(events, context) {
let index3 = events.length;
let content3;
let text5;
let definition2;
while (index3--) {
if (events[index3][0] === "enter") {
if (events[index3][1].type === "content") {
content3 = index3;
break;
}
if (events[index3][1].type === "paragraph") {
text5 = index3;
}
} else {
if (events[index3][1].type === "content") {
events.splice(index3, 1);
}
if (!definition2 && events[index3][1].type === "definition") {
definition2 = index3;
}
}
}
const heading2 = {
type: "setextHeading",
start: {
...events[content3][1].start
},
end: {
...events[events.length - 1][1].end
}
};
events[text5][1].type = "setextHeadingText";
if (definition2) {
events.splice(text5, 0, ["enter", heading2, context]);
events.splice(definition2 + 1, 0, ["exit", events[content3][1], context]);
events[content3][1].end = {
...events[definition2][1].end
};
} else {
events[content3][1] = heading2;
}
events.push(["exit", heading2, context]);
return events;
}
function tokenizeSetextUnderline(effects, ok3, nok) {
const self2 = this;
let marker;
return start2;
function start2(code2) {
let index3 = self2.events.length;
let paragraph2;
while (index3--) {
if (self2.events[index3][1].type !== "lineEnding" && self2.events[index3][1].type !== "linePrefix" && self2.events[index3][1].type !== "content") {
paragraph2 = self2.events[index3][1].type === "paragraph";
break;
}
}
if (!self2.parser.lazy[self2.now().line] && (self2.interrupt || paragraph2)) {
effects.enter("setextHeadingLine");
marker = code2;
return before(code2);
}
return nok(code2);
}
function before(code2) {
effects.enter("setextHeadingLineSequence");
return inside(code2);
}
function inside(code2) {
if (code2 === marker) {
effects.consume(code2);
return inside;
}
effects.exit("setextHeadingLineSequence");
return markdownSpace(code2) ? factorySpace(effects, after, "lineSuffix")(code2) : after(code2);
}
function after(code2) {
if (code2 === null || markdownLineEnding(code2)) {
effects.exit("setextHeadingLine");
return ok3(code2);
}
return nok(code2);
}
}
// ../../node_modules/micromark/lib/initialize/flow.js
var flow = {
tokenize: initializeFlow
};
function initializeFlow(effects) {
const self2 = this;
const initial = effects.attempt(
// Try to parse a blank line.
blankLine,
atBlankEnding,
// Try to parse initial flow (essentially, only code).
effects.attempt(this.parser.constructs.flowInitial, afterConstruct, factorySpace(effects, effects.attempt(this.parser.constructs.flow, afterConstruct, effects.attempt(content2, afterConstruct)), "linePrefix"))
);
return initial;
function atBlankEnding(code2) {
if (code2 === null) {
effects.consume(code2);
return;
}
effects.enter("lineEndingBlank");
effects.consume(code2);
effects.exit("lineEndingBlank");
self2.currentConstruct = void 0;
return initial;
}
function afterConstruct(code2) {
if (code2 === null) {
effects.consume(code2);
return;
}
effects.enter("lineEnding");
effects.consume(code2);
effects.exit("lineEnding");
self2.currentConstruct = void 0;
return initial;
}
}
// ../../node_modules/micromark/lib/initialize/text.js
var resolver = {
resolveAll: createResolver()
};
var string = initializeFactory("string");
var text2 = initializeFactory("text");
function initializeFactory(field) {
return {
resolveAll: createResolver(field === "text" ? resolveAllLineSuffixes : void 0),
tokenize: initializeText
};
function initializeText(effects) {
const self2 = this;
const constructs2 = this.parser.constructs[field];
const text5 = effects.attempt(constructs2, start2, notText);
return start2;
function start2(code2) {
return atBreak(code2) ? text5(code2) : notText(code2);
}
function notText(code2) {
if (code2 === null) {
effects.consume(code2);
return;
}
effects.enter("data");
effects.consume(code2);
return data;
}
function data(code2) {
if (atBreak(code2)) {
effects.exit("data");
return text5(code2);
}
effects.consume(code2);
return data;
}
function atBreak(code2) {
if (code2 === null) {
return true;
}
const list3 = constructs2[code2];
let index3 = -1;
if (list3) {
while (++index3 < list3.length) {
const item = list3[index3];
if (!item.previous || item.previous.call(self2, self2.previous)) {
return true;
}
}
}
return false;
}
}
}
function createResolver(extraResolver) {
return resolveAllText;
function resolveAllText(events, context) {
let index3 = -1;
let enter;
while (++index3 <= events.length) {
if (enter === void 0) {
if (events[index3] && events[index3][1].type === "data") {
enter = index3;
index3++;
}
} else if (!events[index3] || events[index3][1].type !== "data") {
if (index3 !== enter + 2) {
events[enter][1].end = events[index3 - 1][1].end;
events.splice(enter + 2, index3 - enter - 2);
index3 = enter + 2;
}
enter = void 0;
}
}
return extraResolver ? extraResolver(events, context) : events;
}
}
function resolveAllLineSuffixes(events, context) {
let eventIndex = 0;
while (++eventIndex <= events.length) {
if ((eventIndex === events.length || events[eventIndex][1].type === "lineEnding") && events[eventIndex - 1][1].type === "data") {
const data = events[eventIndex - 1][1];
const chunks = context.sliceStream(data);
let index3 = chunks.length;
let bufferIndex = -1;
let size = 0;
let tabs;
while (index3--) {
const chunk = chunks[index3];
if (typeof chunk === "string") {
bufferIndex = chunk.length;
while (chunk.charCodeAt(bufferIndex - 1) === 32) {
size++;
bufferIndex--;
}
if (bufferIndex) break;
bufferIndex = -1;
} else if (chunk === -2) {
tabs = true;
size++;
} else if (chunk === -1) {
} else {
index3++;
break;
}
}
if (context._contentTypeTextTrailing && eventIndex === events.length) {
size = 0;
}
if (size) {
const token = {
type: eventIndex === events.length || tabs || size < 2 ? "lineSuffix" : "hardBreakTrailing",
start: {
_bufferIndex: index3 ? bufferIndex : data.start._bufferIndex + bufferIndex,
_index: data.start._index + index3,
line: data.end.line,
column: data.end.column - size,
offset: data.end.offset - size
},
end: {
...data.end
}
};
data.end = {
...token.start
};
if (data.start.offset === data.end.offset) {
Object.assign(data, token);
} else {
events.splice(eventIndex, 0, ["enter", token, context], ["exit", token, context]);
eventIndex += 2;
}
}
eventIndex++;
}
}
return events;
}
// ../../node_modules/micromark/lib/constructs.js
var constructs_exports = {};
__export(constructs_exports, {
attentionMarkers: () => attentionMarkers,
contentInitial: () => contentInitial,
disable: () => disable,
document: () => document3,
flow: () => flow2,
flowInitial: () => flowInitial,
insideSpan: () => insideSpan,
string: () => string2,
text: () => text3
});
var document3 = {
[42]: list,
[43]: list,
[45]: list,
[48]: list,
[49]: list,
[50]: list,
[51]: list,
[52]: list,
[53]: list,
[54]: list,
[55]: list,
[56]: list,
[57]: list,
[62]: blockQuote
};
var contentInitial = {
[91]: definition
};
var flowInitial = {
[-2]: codeIndented,
[-1]: codeIndented,
[32]: codeIndented
};
var flow2 = {
[35]: headingAtx,
[42]: thematicBreak,
[45]: [setextUnderline, thematicBreak],
[60]: htmlFlow,
[61]: setextUnderline,
[95]: thematicBreak,
[96]: codeFenced,
[126]: codeFenced
};
var string2 = {
[38]: characterReference,
[92]: characterEscape
};
var text3 = {
[-5]: lineEnding,
[-4]: lineEnding,
[-3]: lineEnding,
[33]: labelStartImage,
[38]: characterReference,
[42]: attention,
[60]: [autolink, htmlText],
[91]: labelStartLink,
[92]: [hardBreakEscape, characterEscape],
[93]: labelEnd,
[95]: attention,
[96]: codeText
};
var insideSpan = {
null: [attention, resolver]
};
var attentionMarkers = {
null: [42, 95]
};
var disable = {
null: []
};
// ../../node_modules/micromark/lib/create-tokenizer.js
function createTokenizer(parser, initialize, from) {
let point5 = {
_bufferIndex: -1,
_index: 0,
line: from && from.line || 1,
column: from && from.column || 1,
offset: from && from.offset || 0
};
const columnStart = {};
const resolveAllConstructs = [];
let chunks = [];
let stack = [];
let consumed = true;
const effects = {
attempt: constructFactory(onsuccessfulconstruct),
check: constructFactory(onsuccessfulcheck),
consume,
enter,
exit: exit2,
interrupt: constructFactory(onsuccessfulcheck, {
interrupt: true
})
};
const context = {
code: null,
containerState: {},
defineSkip,
events: [],
now,
parser,
previous: null,
sliceSerialize,
sliceStream,
write
};
let state = initialize.tokenize.call(context, effects);
let expectedCode;
if (initialize.resolveAll) {
resolveAllConstructs.push(initialize);
}
return context;
function write(slice) {
chunks = push(chunks, slice);
main();
if (chunks[chunks.length - 1] !== null) {
return [];
}
addResult(initialize, 0);
context.events = resolveAll(resolveAllConstructs, context.events, context);
return context.events;
}
function sliceSerialize(token, expandTabs) {
return serializeChunks(sliceStream(token), expandTabs);
}
function sliceStream(token) {
return sliceChunks(chunks, token);
}
function now() {
const {
_bufferIndex,
_index,
line,
column,
offset
} = point5;
return {
_bufferIndex,
_index,
line,
column,
offset
};
}
function defineSkip(value) {
columnStart[value.line] = value.column;
accountForPotentialSkip();
}
function main() {
let chunkIndex;
while (point5._index < chunks.length) {
const chunk = chunks[point5._index];
if (typeof chunk === "string") {
chunkIndex = point5._index;
if (point5._bufferIndex < 0) {
point5._bufferIndex = 0;
}
while (point5._index === chunkIndex && point5._bufferIndex < chunk.length) {
go(chunk.charCodeAt(point5._bufferIndex));
}
} else {
go(chunk);
}
}
}
function go(code2) {
consumed = void 0;
expectedCode = code2;
state = state(code2);
}
function consume(code2) {
if (markdownLineEnding(code2)) {
point5.line++;
point5.column = 1;
point5.offset += code2 === -3 ? 2 : 1;
accountForPotentialSkip();
} else if (code2 !== -1) {
point5.column++;
point5.offset++;
}
if (point5._bufferIndex < 0) {
point5._index++;
} else {
point5._bufferIndex++;
if (point5._bufferIndex === // Points w/ non-negative `_bufferIndex` reference
// strings.
/** @type {string} */
chunks[point5._index].length) {
point5._bufferIndex = -1;
point5._index++;
}
}
context.previous = code2;
consumed = true;
}
function enter(type, fields) {
const token = fields || {};
token.type = type;
token.start = now();
context.events.push(["enter", token, context]);
stack.push(token);
return token;
}
function exit2(type) {
const token = stack.pop();
token.end = now();
context.events.push(["exit", token, context]);
return token;
}
function onsuccessfulconstruct(construct, info) {
addResult(construct, info.from);
}
function onsuccessfulcheck(_, info) {
info.restore();
}
function constructFactory(onreturn, fields) {
return hook;
function hook(constructs2, returnState, bogusState) {
let listOfConstructs;
let constructIndex;
let currentConstruct;
let info;
return Array.isArray(constructs2) ? (
/* c8 ignore next 1 */
handleListOfConstructs(constructs2)
) : "tokenize" in constructs2 ? (
// Looks like a construct.
handleListOfConstructs([
/** @type {Construct} */
constructs2
])
) : handleMapOfConstructs(constructs2);
function handleMapOfConstructs(map) {
return start2;
function start2(code2) {
const left = code2 !== null && map[code2];
const all2 = code2 !== null && map.null;
const list3 = [
// To do: add more extension tests.
/* c8 ignore next 2 */
...Array.isArray(left) ? left : left ? [left] : [],
...Array.isArray(all2) ? all2 : all2 ? [all2] : []
];
return handleListOfConstructs(list3)(code2);
}
}
function handleListOfConstructs(list3) {
listOfConstructs = list3;
constructIndex = 0;
if (list3.length === 0) {
return bogusState;
}
return handleConstruct(list3[constructIndex]);
}
function handleConstruct(construct) {
return start2;
function start2(code2) {
info = store();
currentConstruct = construct;
if (!construct.partial) {
context.currentConstruct = construct;
}
if (construct.name && context.parser.constructs.disable.null.includes(construct.name)) {
return nok(code2);
}
return construct.tokenize.call(
// If we do have fields, create an object w/ `context` as its
// prototype.
// This allows a “live binding”, which is needed for `interrupt`.
fields ? Object.assign(Object.create(context), fields) : context,
effects,
ok3,
nok
)(code2);
}
}
function ok3(code2) {
consumed = true;
onreturn(currentConstruct, info);
return returnState;
}
function nok(code2) {
consumed = true;
info.restore();
if (++constructIndex < listOfConstructs.length) {
return handleConstruct(listOfConstructs[constructIndex]);
}
return bogusState;
}
}
}
function addResult(construct, from2) {
if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {
resolveAllConstructs.push(construct);
}
if (construct.resolve) {
splice(context.events, from2, context.events.length - from2, construct.resolve(context.events.slice(from2), context));
}
if (construct.resolveTo) {
context.events = construct.resolveTo(context.events, context);
}
}
function store() {
const startPoint = now();
const startPrevious = context.previous;
const startCurrentConstruct = context.currentConstruct;
const startEventsIndex = context.events.length;
const startStack = Array.from(stack);
return {
from: startEventsIndex,
restore
};
function restore() {
point5 = startPoint;
context.previous = startPrevious;
context.currentConstruct = startCurrentConstruct;
context.events.length = startEventsIndex;
stack = startStack;
accountForPotentialSkip();
}
}
function accountForPotentialSkip() {
if (point5.line in columnStart && point5.column < 2) {
point5.column = columnStart[point5.line];
point5.offset += columnStart[point5.line] - 1;
}
}
}
function sliceChunks(chunks, token) {
const startIndex = token.start._index;
const startBufferIndex = token.start._bufferIndex;
const endIndex = token.end._index;
const endBufferIndex = token.end._bufferIndex;
let view;
if (startIndex === endIndex) {
view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)];
} else {
view = chunks.slice(startIndex, endIndex);
if (startBufferIndex > -1) {
const head = view[0];
if (typeof head === "string") {
view[0] = head.slice(startBufferIndex);
} else {
view.shift();
}
}
if (endBufferIndex > 0) {
view.push(chunks[endIndex].slice(0, endBufferIndex));
}
}
return view;
}
function serializeChunks(chunks, expandTabs) {
let index3 = -1;
const result = [];
let atTab;
while (++index3 < chunks.length) {
const chunk = chunks[index3];
let value;
if (typeof chunk === "string") {
value = chunk;
} else switch (chunk) {
case -5: {
value = "\r";
break;
}
case -4: {
value = "\n";
break;
}
case -3: {
value = "\r\n";
break;
}
case -2: {
value = expandTabs ? " " : " ";
break;
}
case -1: {
if (!expandTabs && atTab) continue;
value = " ";
break;
}
default: {
value = String.fromCharCode(chunk);
}
}
atTab = chunk === -2;
result.push(value);
}
return result.join("");
}
// ../../node_modules/micromark/lib/parse.js
function parse(options) {
const settings = options || {};
const constructs2 = (
/** @type {FullNormalizedExtension} */
combineExtensions([constructs_exports, ...settings.extensions || []])
);
const parser = {
constructs: constructs2,
content: create2(content),
defined: [],
document: create2(document2),
flow: create2(flow),
lazy: {},
string: create2(string),
text: create2(text2)
};
return parser;
function create2(initial) {
return creator;
function creator(from) {
return createTokenizer(parser, initial, from);
}
}
}
// ../../node_modules/micromark/lib/postprocess.js
function postprocess(events) {
while (!subtokenize(events)) {
}
return events;
}
// ../../node_modules/micromark/lib/preprocess.js
var search = /[\0\t\n\r]/g;
function preprocess() {
let column = 1;
let buffer = "";
let start2 = true;
let atCarriageReturn;
return preprocessor;
function preprocessor(value, encoding, end) {
const chunks = [];
let match;
let next;
let startPosition;
let endPosition;
let code2;
value = buffer + (typeof value === "string" ? value.toString() : new TextDecoder(encoding || void 0).decode(value));
startPosition = 0;
buffer = "";
if (start2) {
if (value.charCodeAt(0) === 65279) {
startPosition++;
}
start2 = void 0;
}
while (startPosition < value.length) {
search.lastIndex = startPosition;
match = search.exec(value);
endPosition = match && match.index !== void 0 ? match.index : value.length;
code2 = value.charCodeAt(endPosition);
if (!match) {
buffer = value.slice(startPosition);
break;
}
if (code2 === 10 && startPosition === endPosition && atCarriageReturn) {
chunks.push(-3);
atCarriageReturn = void 0;
} else {
if (atCarriageReturn) {
chunks.push(-5);
atCarriageReturn = void 0;
}
if (startPosition < endPosition) {
chunks.push(value.slice(startPosition, endPosition));
column += endPosition - startPosition;
}
switch (code2) {
case 0: {
chunks.push(65533);
column++;
break;
}
case 9: {
next = Math.ceil(column / 4) * 4;
chunks.push(-2);
while (column++ < next) chunks.push(-1);
break;
}
case 10: {
chunks.push(-4);
column = 1;
break;
}
default: {
atCarriageReturn = true;
column = 1;
}
}
}
startPosition = endPosition + 1;
}
if (end) {
if (atCarriageReturn) chunks.push(-5);
if (buffer) chunks.push(buffer);
chunks.push(null);
}
return chunks;
}
}
// ../../node_modules/mdast-util-from-markdown/node_modules/micromark-util-decode-numeric-character-reference/index.js
function decodeNumericCharacterReference(value, base) {
const code2 = Number.parseInt(value, base);
if (
// C0 except for HT, LF, FF, CR, space.
code2 < 9 || code2 === 11 || code2 > 13 && code2 < 32 || // Control character (DEL) of C0, and C1 controls.
code2 > 126 && code2 < 160 || // Lone high surrogates and low surrogates.
code2 > 55295 && code2 < 57344 || // Noncharacters.
code2 > 64975 && code2 < 65008 || /* eslint-disable no-bitwise */
(code2 & 65535) === 65535 || (code2 & 65535) === 65534 || /* eslint-enable no-bitwise */
// Out of range
code2 > 1114111
) {
return "\uFFFD";
}
return String.fromCodePoint(code2);
}
// ../../node_modules/mdast-util-from-markdown/node_modules/micromark-util-decode-string/index.js
var characterEscapeOrReference = /\\([!-/:-@[-`{-~])|&(#(?:\d{1,7}|x[\da-f]{1,6})|[\da-z]{1,31});/gi;
function decodeString(value) {
return value.replace(characterEscapeOrReference, decode);
}
function decode($0, $1, $2) {
if ($1) {
return $1;
}
const head = $2.charCodeAt(0);
if (head === 35) {
const head2 = $2.charCodeAt(1);
const hex = head2 === 120 || head2 === 88;
return decodeNumericCharacterReference($2.slice(hex ? 2 : 1), hex ? 16 : 10);
}
return decodeNamedCharacterReference($2) || $0;
}
// ../../node_modules/mdast-util-from-markdown/node_modules/micromark-util-normalize-identifier/index.js
function normalizeIdentifier2(value) {
return value.replace(/[\t\n\r ]+/g, " ").replace(/^ | $/g, "").toLowerCase().toUpperCase();
}
// ../../node_modules/mdast-util-from-markdown/node_modules/unist-util-stringify-position/lib/index.js
function stringifyPosition2(value) {
if (!value || typeof value !== "object") {
return "";
}
if ("position" in value || "type" in value) {
return position3(value.position);
}
if ("start" in value || "end" in value) {
return position3(value);
}
if ("line" in value || "column" in value) {
return point3(value);
}
return "";
}
function point3(point5) {
return index2(point5 && point5.line) + ":" + index2(point5 && point5.column);
}
function position3(pos) {
return point3(pos && pos.start) + "-" + point3(pos && pos.end);
}
function index2(value) {
return value && typeof value === "number" ? value : 1;
}
// ../../node_modules/mdast-util-from-markdown/lib/index.js
var own2 = {}.hasOwnProperty;
function fromMarkdown(value, encoding, options) {
if (typeof encoding !== "string") {
options = encoding;
encoding = void 0;
}
return compiler(options)(postprocess(parse(options).document().write(preprocess()(value, encoding, true))));
}
function compiler(options) {
const config = {
transforms: [],
canContainEols: ["emphasis", "fragment", "heading", "paragraph", "strong"],
enter: {
autolink: opener(link2),
autolinkProtocol: onenterdata,
autolinkEmail: onenterdata,
atxHeading: opener(heading2),
blockQuote: opener(blockQuote2),
characterEscape: onenterdata,
characterReference: onenterdata,
codeFenced: opener(codeFlow),
codeFencedFenceInfo: buffer,
codeFencedFenceMeta: buffer,
codeIndented: opener(codeFlow, buffer),
codeText: opener(codeText2, buffer),
codeTextData: onenterdata,
data: onenterdata,
codeFlowValue: onenterdata,
definition: opener(definition2),
definitionDestinationString: buffer,
definitionLabelString: buffer,
definitionTitleString: buffer,
emphasis: opener(emphasis2),
hardBreakEscape: opener(hardBreak2),
hardBreakTrailing: opener(hardBreak2),
htmlFlow: opener(html4, buffer),
htmlFlowData: onenterdata,
htmlText: opener(html4, buffer),
htmlTextData: onenterdata,
image: opener(image2),
label: buffer,
link: opener(link2),
listItem: opener(listItem2),
listItemValue: onenterlistitemvalue,
listOrdered: opener(list3, onenterlistordered),
listUnordered: opener(list3),
paragraph: opener(paragraph2),
reference: onenterreference,
referenceString: buffer,
resourceDestinationString: buffer,
resourceTitleString: buffer,
setextHeading: opener(heading2),
strong: opener(strong2),
thematicBreak: opener(thematicBreak3)
},
exit: {
atxHeading: closer(),
atxHeadingSequence: onexitatxheadingsequence,
autolink: closer(),
autolinkEmail: onexitautolinkemail,
autolinkProtocol: onexitautolinkprotocol,
blockQuote: closer(),
characterEscapeValue: onexitdata,
characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker,
characterReferenceMarkerNumeric: onexitcharacterreferencemarker,
characterReferenceValue: onexitcharacterreferencevalue,
characterReference: onexitcharacterreference,
codeFenced: closer(onexitcodefenced),
codeFencedFence: onexitcodefencedfence,
codeFencedFenceInfo: onexitcodefencedfenceinfo,
codeFencedFenceMeta: onexitcodefencedfencemeta,
codeFlowValue: onexitdata,
codeIndented: closer(onexitcodeindented),
codeText: closer(onexitcodetext),
codeTextData: onexitdata,
data: onexitdata,
definition: closer(),
definitionDestinationString: onexitdefinitiondestinationstring,
definitionLabelString: onexitdefinitionlabelstring,
definitionTitleString: onexitdefinitiontitlestring,
emphasis: closer(),
hardBreakEscape: closer(onexithardbreak),
hardBreakTrailing: closer(onexithardbreak),
htmlFlow: closer(onexithtmlflow),
htmlFlowData: onexitdata,
htmlText: closer(onexithtmltext),
htmlTextData: onexitdata,
image: closer(onexitimage),
label: onexitlabel,
labelText: onexitlabeltext,
lineEnding: onexitlineending,
link: closer(onexitlink),
listItem: closer(),
listOrdered: closer(),
listUnordered: closer(),
paragraph: closer(),
referenceString: onexitreferencestring,
resourceDestinationString: onexitresourcedestinationstring,
resourceTitleString: onexitresourcetitlestring,
resource: onexitresource,
setextHeading: closer(onexitsetextheading),
setextHeadingLineSequence: onexitsetextheadinglinesequence,
setextHeadingText: onexitsetextheadingtext,
strong: closer(),
thematicBreak: closer()
}
};
configure(config, (options || {}).mdastExtensions || []);
const data = {};
return compile;
function compile(events) {
let tree = {
type: "root",
children: []
};
const context = {
stack: [tree],
tokenStack: [],
config,
enter,
exit: exit2,
buffer,
resume,
data
};
const listStack = [];
let index3 = -1;
while (++index3 < events.length) {
if (events[index3][1].type === "listOrdered" || events[index3][1].type === "listUnordered") {
if (events[index3][0] === "enter") {
listStack.push(index3);
} else {
const tail = listStack.pop();
index3 = prepareList(events, tail, index3);
}
}
}
index3 = -1;
while (++index3 < events.length) {
const handler = config[events[index3][0]];
if (own2.call(handler, events[index3][1].type)) {
handler[events[index3][1].type].call(Object.assign({
sliceSerialize: events[index3][2].sliceSerialize
}, context), events[index3][1]);
}
}
if (context.tokenStack.length > 0) {
const tail = context.tokenStack[context.tokenStack.length - 1];
const handler = tail[1] || defaultOnError;
handler.call(context, void 0, tail[0]);
}
tree.position = {
start: point4(events.length > 0 ? events[0][1].start : {
line: 1,
column: 1,
offset: 0
}),
end: point4(events.length > 0 ? events[events.length - 2][1].end : {
line: 1,
column: 1,
offset: 0
})
};
index3 = -1;
while (++index3 < config.transforms.length) {
tree = config.transforms[index3](tree) || tree;
}
return tree;
}
function prepareList(events, start2, length) {
let index3 = start2 - 1;
let containerBalance = -1;
let listSpread = false;
let listItem3;
let lineIndex;
let firstBlankLineIndex;
let atMarker;
while (++index3 <= length) {
const event = events[index3];
switch (event[1].type) {
case "listUnordered":
case "listOrdered":
case "blockQuote": {
if (event[0] === "enter") {
containerBalance++;
} else {
containerBalance--;
}
atMarker = void 0;
break;
}
case "lineEndingBlank": {
if (event[0] === "enter") {
if (listItem3 && !atMarker && !containerBalance && !firstBlankLineIndex) {
firstBlankLineIndex = index3;
}
atMarker = void 0;
}
break;
}
case "linePrefix":
case "listItemValue":
case "listItemMarker":
case "listItemPrefix":
case "listItemPrefixWhitespace": {
break;
}
default: {
atMarker = void 0;
}
}
if (!containerBalance && event[0] === "enter" && event[1].type === "listItemPrefix" || containerBalance === -1 && event[0] === "exit" && (event[1].type === "listUnordered" || event[1].type === "listOrdered")) {
if (listItem3) {
let tailIndex = index3;
lineIndex = void 0;
while (tailIndex--) {
const tailEvent = events[tailIndex];
if (tailEvent[1].type === "lineEnding" || tailEvent[1].type === "lineEndingBlank") {
if (tailEvent[0] === "exit") continue;
if (lineIndex) {
events[lineIndex][1].type = "lineEndingBlank";
listSpread = true;
}
tailEvent[1].type = "lineEnding";
lineIndex = tailIndex;
} else if (tailEvent[1].type === "linePrefix" || tailEvent[1].type === "blockQuotePrefix" || tailEvent[1].type === "blockQuotePrefixWhitespace" || tailEvent[1].type === "blockQuoteMarker" || tailEvent[1].type === "listItemIndent") {
} else {
break;
}
}
if (firstBlankLineIndex && (!lineIndex || firstBlankLineIndex < lineIndex)) {
listItem3._spread = true;
}
listItem3.end = Object.assign({}, lineIndex ? events[lineIndex][1].start : event[1].end);
events.splice(lineIndex || index3, 0, ["exit", listItem3, event[2]]);
index3++;
length++;
}
if (event[1].type === "listItemPrefix") {
const item = {
type: "listItem",
_spread: false,
start: Object.assign({}, event[1].start),
// @ts-expect-error: we’ll add `end` in a second.
end: void 0
};
listItem3 = item;
events.splice(index3, 0, ["enter", item, event[2]]);
index3++;
length++;
firstBlankLineIndex = void 0;
atMarker = true;
}
}
}
events[start2][1]._spread = listSpread;
return length;
}
function opener(create2, and) {
return open;
function open(token) {
enter.call(this, create2(token), token);
if (and) and.call(this, token);
}
}
function buffer() {
this.stack.push({
type: "fragment",
children: []
});
}
function enter(node2, token, errorHandler) {
const parent = this.stack[this.stack.length - 1];
const siblings = parent.children;
siblings.push(node2);
this.stack.push(node2);
this.tokenStack.push([token, errorHandler || void 0]);
node2.position = {
start: point4(token.start),
// @ts-expect-error: `end` will be patched later.
end: void 0
};
}
function closer(and) {
return close;
function close(token) {
if (and) and.call(this, token);
exit2.call(this, token);
}
}
function exit2(token, onExitError) {
const node2 = this.stack.pop();
const open = this.tokenStack.pop();
if (!open) {
throw new Error("Cannot close `" + token.type + "` (" + stringifyPosition2({
start: token.start,
end: token.end
}) + "): it\u2019s not open");
} else if (open[0].type !== token.type) {
if (onExitError) {
onExitError.call(this, token, open[0]);
} else {
const handler = open[1] || defaultOnError;
handler.call(this, token, open[0]);
}
}
node2.position.end = point4(token.end);
}
function resume() {
return toString(this.stack.pop());
}
function onenterlistordered() {
this.data.expectingFirstListItemValue = true;
}
function onenterlistitemvalue(token) {
if (this.data.expectingFirstListItemValue) {
const ancestor = this.stack[this.stack.length - 2];
ancestor.start = Number.parseInt(this.sliceSerialize(token), 10);
this.data.expectingFirstListItemValue = void 0;
}
}
function onexitcodefencedfenceinfo() {
const data2 = this.resume();
const node2 = this.stack[this.stack.length - 1];
node2.lang = data2;
}
function onexitcodefencedfencemeta() {
const data2 = this.resume();
const node2 = this.stack[this.stack.length - 1];
node2.meta = data2;
}
function onexitcodefencedfence() {
if (this.data.flowCodeInside) return;
this.buffer();
this.data.flowCodeInside = true;
}
function onexitcodefenced() {
const data2 = this.resume();
const node2 = this.stack[this.stack.length - 1];
node2.value = data2.replace(/^(\r?\n|\r)|(\r?\n|\r)$/g, "");
this.data.flowCodeInside = void 0;
}
function onexitcodeindented() {
const data2 = this.resume();
const node2 = this.stack[this.stack.length - 1];
node2.value = data2.replace(/(\r?\n|\r)$/g, "");
}
function onexitdefinitionlabelstring(token) {
const label = this.resume();
const node2 = this.stack[this.stack.length - 1];
node2.label = label;
node2.identifier = normalizeIdentifier2(this.sliceSerialize(token)).toLowerCase();
}
function onexitdefinitiontitlestring() {
const data2 = this.resume();
const node2 = this.stack[this.stack.length - 1];
node2.title = data2;
}
function onexitdefinitiondestinationstring() {
const data2 = this.resume();
const node2 = this.stack[this.stack.length - 1];
node2.url = data2;
}
function onexitatxheadingsequence(token) {
const node2 = this.stack[this.stack.length - 1];
if (!node2.depth) {
const depth = this.sliceSerialize(token).length;
node2.depth = depth;
}
}
function onexitsetextheadingtext() {
this.data.setextHeadingSlurpLineEnding = true;
}
function onexitsetextheadinglinesequence(token) {
const node2 = this.stack[this.stack.length - 1];
node2.depth = this.sliceSerialize(token).codePointAt(0) === 61 ? 1 : 2;
}
function onexitsetextheading() {
this.data.setextHeadingSlurpLineEnding = void 0;
}
function onenterdata(token) {
const node2 = this.stack[this.stack.length - 1];
const siblings = node2.children;
let tail = siblings[siblings.length - 1];
if (!tail || tail.type !== "text") {
tail = text5();
tail.position = {
start: point4(token.start),
// @ts-expect-error: we’ll add `end` later.
end: void 0
};
siblings.push(tail);
}
this.stack.push(tail);
}
function onexitdata(token) {
const tail = this.stack.pop();
tail.value += this.sliceSerialize(token);
tail.position.end = point4(token.end);
}
function onexitlineending(token) {
const context = this.stack[this.stack.length - 1];
if (this.data.atHardBreak) {
const tail = context.children[context.children.length - 1];
tail.position.end = point4(token.end);
this.data.atHardBreak = void 0;
return;
}
if (!this.data.setextHeadingSlurpLineEnding && config.canContainEols.includes(context.type)) {
onenterdata.call(this, token);
onexitdata.call(this, token);
}
}
function onexithardbreak() {
this.data.atHardBreak = true;
}
function onexithtmlflow() {
const data2 = this.resume();
const node2 = this.stack[this.stack.length - 1];
node2.value = data2;
}
function onexithtmltext() {
const data2 = this.resume();
const node2 = this.stack[this.stack.length - 1];
node2.value = data2;
}
function onexitcodetext() {
const data2 = this.resume();
const node2 = this.stack[this.stack.length - 1];
node2.value = data2;
}
function onexitlink() {
const node2 = this.stack[this.stack.length - 1];
if (this.data.inReference) {
const referenceType = this.data.referenceType || "shortcut";
node2.type += "Reference";
node2.referenceType = referenceType;
delete node2.url;
delete node2.title;
} else {
delete node2.identifier;
delete node2.label;
}
this.data.referenceType = void 0;
}
function onexitimage() {
const node2 = this.stack[this.stack.length - 1];
if (this.data.inReference) {
const referenceType = this.data.referenceType || "shortcut";
node2.type += "Reference";
node2.referenceType = referenceType;
delete node2.url;
delete node2.title;
} else {
delete node2.identifier;
delete node2.label;
}
this.data.referenceType = void 0;
}
function onexitlabeltext(token) {
const string3 = this.sliceSerialize(token);
const ancestor = this.stack[this.stack.length - 2];
ancestor.label = decodeString(string3);
ancestor.identifier = normalizeIdentifier2(string3).toLowerCase();
}
function onexitlabel() {
const fragment = this.stack[this.stack.length - 1];
const value = this.resume();
const node2 = this.stack[this.stack.length - 1];
this.data.inReference = true;
if (node2.type === "link") {
const children = fragment.children;
node2.children = children;
} else {
node2.alt = value;
}
}
function onexitresourcedestinationstring() {
const data2 = this.resume();
const node2 = this.stack[this.stack.length - 1];
node2.url = data2;
}
function onexitresourcetitlestring() {
const data2 = this.resume();
const node2 = this.stack[this.stack.length - 1];
node2.title = data2;
}
function onexitresource() {
this.data.inReference = void 0;
}
function onenterreference() {
this.data.referenceType = "collapsed";
}
function onexitreferencestring(token) {
const label = this.resume();
const node2 = this.stack[this.stack.length - 1];
node2.label = label;
node2.identifier = normalizeIdentifier2(this.sliceSerialize(token)).toLowerCase();
this.data.referenceType = "full";
}
function onexitcharacterreferencemarker(token) {
this.data.characterReferenceType = token.type;
}
function onexitcharacterreferencevalue(token) {
const data2 = this.sliceSerialize(token);
const type = this.data.characterReferenceType;
let value;
if (type) {
value = decodeNumericCharacterReference(data2, type === "characterReferenceMarkerNumeric" ? 10 : 16);
this.data.characterReferenceType = void 0;
} else {
const result = decodeNamedCharacterReference(data2);
value = result;
}
const tail = this.stack[this.stack.length - 1];
tail.value += value;
}
function onexitcharacterreference(token) {
const tail = this.stack.pop();
tail.position.end = point4(token.end);
}
function onexitautolinkprotocol(token) {
onexitdata.call(this, token);
const node2 = this.stack[this.stack.length - 1];
node2.url = this.sliceSerialize(token);
}
function onexitautolinkemail(token) {
onexitdata.call(this, token);
const node2 = this.stack[this.stack.length - 1];
node2.url = "mailto:" + this.sliceSerialize(token);
}
function blockQuote2() {
return {
type: "blockquote",
children: []
};
}
function codeFlow() {
return {
type: "code",
lang: null,
meta: null,
value: ""
};
}
function codeText2() {
return {
type: "inlineCode",
value: ""
};
}
function definition2() {
return {
type: "definition",
identifier: "",
label: null,
title: null,
url: ""
};
}
function emphasis2() {
return {
type: "emphasis",
children: []
};
}
function heading2() {
return {
type: "heading",
// @ts-expect-error `depth` will be set later.
depth: 0,
children: []
};
}
function hardBreak2() {
return {
type: "break"
};
}
function html4() {
return {
type: "html",
value: ""
};
}
function image2() {
return {
type: "image",
title: null,
url: "",
alt: null
};
}
function link2() {
return {
type: "link",
title: null,
url: "",
children: []
};
}
function list3(token) {
return {
type: "list",
ordered: token.type === "listOrdered",
start: null,
spread: token._spread,
children: []
};
}
function listItem2(token) {
return {
type: "listItem",
spread: token._spread,
checked: null,
children: []
};
}
function paragraph2() {
return {
type: "paragraph",
children: []
};
}
function strong2() {
return {
type: "strong",
children: []
};
}
function text5() {
return {
type: "text",
value: ""
};
}
function thematicBreak3() {
return {
type: "thematicBreak"
};
}
}
function point4(d) {
return {
line: d.line,
column: d.column,
offset: d.offset
};
}
function configure(combined, extensions) {
let index3 = -1;
while (++index3 < extensions.length) {
const value = extensions[index3];
if (Array.isArray(value)) {
configure(combined, value);
} else {
extension(combined, value);
}
}
}
function extension(combined, extension2) {
let key;
for (key in extension2) {
if (own2.call(extension2, key)) {
switch (key) {
case "canContainEols": {
const right = extension2[key];
if (right) {
combined[key].push(...right);
}
break;
}
case "transforms": {
const right = extension2[key];
if (right) {
combined[key].push(...right);
}
break;
}
case "enter":
case "exit": {
const right = extension2[key];
if (right) {
Object.assign(combined[key], right);
}
break;
}
}
}
}
}
function defaultOnError(left, right) {
if (left) {
throw new Error("Cannot close `" + left.type + "` (" + stringifyPosition2({
start: left.start,
end: left.end
}) + "): a different token (`" + right.type + "`, " + stringifyPosition2({
start: right.start,
end: right.end
}) + ") is open");
} else {
throw new Error("Cannot close document, a token (`" + right.type + "`, " + stringifyPosition2({
start: right.start,
end: right.end
}) + ") is still open");
}
}
// ../../node_modules/remark-parse/lib/index.js
function remarkParse(options) {
const self2 = this;
self2.parser = parser;
function parser(doc) {
return fromMarkdown(doc, {
...self2.data("settings"),
...options,
// Note: these options are not in the readme.
// The goal is for them to be set by plugins on `data` instead of being
// passed by users.
extensions: self2.data("micromarkExtensions") || [],
mdastExtensions: self2.data("fromMarkdownExtensions") || []
});
}
}
// ../../node_modules/mdast-util-to-hast/lib/handlers/blockquote.js
function blockquote(state, node2) {
const result = {
type: "element",
tagName: "blockquote",
properties: {},
children: state.wrap(state.all(node2), true)
};
state.patch(node2, result);
return state.applyData(node2, result);
}
// ../../node_modules/mdast-util-to-hast/lib/handlers/break.js
function hardBreak(state, node2) {
const result = { type: "element", tagName: "br", properties: {}, children: [] };
state.patch(node2, result);
return [state.applyData(node2, result), { type: "text", value: "\n" }];
}
// ../../node_modules/mdast-util-to-hast/lib/handlers/code.js
function code(state, node2) {
const value = node2.value ? node2.value + "\n" : "";
const properties = {};
if (node2.lang) {
properties.className = ["language-" + node2.lang];
}
let result = {
type: "element",
tagName: "code",
properties,
children: [{ type: "text", value }]
};
if (node2.meta) {
result.data = { meta: node2.meta };
}
state.patch(node2, result);
result = state.applyData(node2, result);
result = { type: "element", tagName: "pre", properties: {}, children: [result] };
state.patch(node2, result);
return result;
}
// ../../node_modules/mdast-util-to-hast/lib/handlers/delete.js
function strikethrough(state, node2) {
const result = {
type: "element",
tagName: "del",
properties: {},
children: state.all(node2)
};
state.patch(node2, result);
return state.applyData(node2, result);
}
// ../../node_modules/mdast-util-to-hast/lib/handlers/emphasis.js
function emphasis(state, node2) {
const result = {
type: "element",
tagName: "em",
properties: {},
children: state.all(node2)
};
state.patch(node2, result);
return state.applyData(node2, result);
}
// ../../node_modules/mdast-util-to-hast/node_modules/micromark-util-character/index.js
var asciiAlpha2 = regexCheck2(/[A-Za-z]/);
var asciiAlphanumeric2 = regexCheck2(/[\dA-Za-z]/);
var asciiAtext2 = regexCheck2(/[#-'*+\--9=?A-Z^-~]/);
var asciiDigit2 = regexCheck2(/\d/);
var asciiHexDigit2 = regexCheck2(/[\dA-Fa-f]/);
var asciiPunctuation2 = regexCheck2(/[!-/:-@[-`{-~]/);
var unicodePunctuation2 = regexCheck2(/\p{P}|\p{S}/u);
var unicodeWhitespace2 = regexCheck2(/\s/);
function regexCheck2(regex) {
return check;
function check(code2) {
return code2 !== null && code2 > -1 && regex.test(String.fromCharCode(code2));
}
}
// ../../node_modules/mdast-util-to-hast/node_modules/micromark-util-sanitize-uri/index.js
function normalizeUri(value) {
const result = [];
let index3 = -1;
let start2 = 0;
let skip = 0;
while (++index3 < value.length) {
const code2 = value.charCodeAt(index3);
let replace = "";
if (code2 === 37 && asciiAlphanumeric2(value.charCodeAt(index3 + 1)) && asciiAlphanumeric2(value.charCodeAt(index3 + 2))) {
skip = 2;
} else if (code2 < 128) {
if (!/[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(code2))) {
replace = String.fromCharCode(code2);
}
} else if (code2 > 55295 && code2 < 57344) {
const next = value.charCodeAt(index3 + 1);
if (code2 < 56320 && next > 56319 && next < 57344) {
replace = String.fromCharCode(code2, next);
skip = 1;
} else {
replace = "\uFFFD";
}
} else {
replace = String.fromCharCode(code2);
}
if (replace) {
result.push(value.slice(start2, index3), encodeURIComponent(replace));
start2 = index3 + skip + 1;
replace = "";
}
if (skip) {
index3 += skip;
skip = 0;
}
}
return result.join("") + value.slice(start2);
}
// ../../node_modules/mdast-util-to-hast/lib/handlers/footnote-reference.js
function footnoteReference(state, node2) {
const clobberPrefix = typeof state.options.clobberPrefix === "string" ? state.options.clobberPrefix : "user-content-";
const id = String(node2.identifier).toUpperCase();
const safeId = normalizeUri(id.toLowerCase());
const index3 = state.footnoteOrder.indexOf(id);
let counter;
let reuseCounter = state.footnoteCounts.get(id);
if (reuseCounter === void 0) {
reuseCounter = 0;
state.footnoteOrder.push(id);
counter = state.footnoteOrder.length;
} else {
counter = index3 + 1;
}
reuseCounter += 1;
state.footnoteCounts.set(id, reuseCounter);
const link2 = {
type: "element",
tagName: "a",
properties: {
href: "#" + clobberPrefix + "fn-" + safeId,
id: clobberPrefix + "fnref-" + safeId + (reuseCounter > 1 ? "-" + reuseCounter : ""),
dataFootnoteRef: true,
ariaDescribedBy: ["footnote-label"]
},
children: [{ type: "text", value: String(counter) }]
};
state.patch(node2, link2);
const sup = {
type: "element",
tagName: "sup",
properties: {},
children: [link2]
};
state.patch(node2, sup);
return state.applyData(node2, sup);
}
// ../../node_modules/mdast-util-to-hast/lib/handlers/heading.js
function heading(state, node2) {
const result = {
type: "element",
tagName: "h" + node2.depth,
properties: {},
children: state.all(node2)
};
state.patch(node2, result);
return state.applyData(node2, result);
}
// ../../node_modules/mdast-util-to-hast/lib/handlers/html.js
function html3(state, node2) {
if (state.options.allowDangerousHtml) {
const result = { type: "raw", value: node2.value };
state.patch(node2, result);
return state.applyData(node2, result);
}
return void 0;
}
// ../../node_modules/mdast-util-to-hast/lib/revert.js
function revert(state, node2) {
const subtype = node2.referenceType;
let suffix = "]";
if (subtype === "collapsed") {
suffix += "[]";
} else if (subtype === "full") {
suffix += "[" + (node2.label || node2.identifier) + "]";
}
if (node2.type === "imageReference") {
return [{ type: "text", value: "![" + node2.alt + suffix }];
}
const contents = state.all(node2);
const head = contents[0];
if (head && head.type === "text") {
head.value = "[" + head.value;
} else {
contents.unshift({ type: "text", value: "[" });
}
const tail = contents[contents.length - 1];
if (tail && tail.type === "text") {
tail.value += suffix;
} else {
contents.push({ type: "text", value: suffix });
}
return contents;
}
// ../../node_modules/mdast-util-to-hast/lib/handlers/image-reference.js
function imageReference(state, node2) {
const id = String(node2.identifier).toUpperCase();
const definition2 = state.definitionById.get(id);
if (!definition2) {
return revert(state, node2);
}
const properties = { src: normalizeUri(definition2.url || ""), alt: node2.alt };
if (definition2.title !== null && definition2.title !== void 0) {
properties.title = definition2.title;
}
const result = { type: "element", tagName: "img", properties, children: [] };
state.patch(node2, result);
return state.applyData(node2, result);
}
// ../../node_modules/mdast-util-to-hast/lib/handlers/image.js
function image(state, node2) {
const properties = { src: normalizeUri(node2.url) };
if (node2.alt !== null && node2.alt !== void 0) {
properties.alt = node2.alt;
}
if (node2.title !== null && node2.title !== void 0) {
properties.title = node2.title;
}
const result = { type: "element", tagName: "img", properties, children: [] };
state.patch(node2, result);
return state.applyData(node2, result);
}
// ../../node_modules/mdast-util-to-hast/lib/handlers/inline-code.js
function inlineCode(state, node2) {
const text5 = { type: "text", value: node2.value.replace(/\r?\n|\r/g, " ") };
state.patch(node2, text5);
const result = {
type: "element",
tagName: "code",
properties: {},
children: [text5]
};
state.patch(node2, result);
return state.applyData(node2, result);
}
// ../../node_modules/mdast-util-to-hast/lib/handlers/link-reference.js
function linkReference(state, node2) {
const id = String(node2.identifier).toUpperCase();
const definition2 = state.definitionById.get(id);
if (!definition2) {
return revert(state, node2);
}
const properties = { href: normalizeUri(definition2.url || "") };
if (definition2.title !== null && definition2.title !== void 0) {
properties.title = definition2.title;
}
const result = {
type: "element",
tagName: "a",
properties,
children: state.all(node2)
};
state.patch(node2, result);
return state.applyData(node2, result);
}
// ../../node_modules/mdast-util-to-hast/lib/handlers/link.js
function link(state, node2) {
const properties = { href: normalizeUri(node2.url) };
if (node2.title !== null && node2.title !== void 0) {
properties.title = node2.title;
}
const result = {
type: "element",
tagName: "a",
properties,
children: state.all(node2)
};
state.patch(node2, result);
return state.applyData(node2, result);
}
// ../../node_modules/mdast-util-to-hast/lib/handlers/list-item.js
function listItem(state, node2, parent) {
const results = state.all(node2);
const loose = parent ? listLoose(parent) : listItemLoose(node2);
const properties = {};
const children = [];
if (typeof node2.checked === "boolean") {
const head = results[0];
let paragraph2;
if (head && head.type === "element" && head.tagName === "p") {
paragraph2 = head;
} else {
paragraph2 = { type: "element", tagName: "p", properties: {}, children: [] };
results.unshift(paragraph2);
}
if (paragraph2.children.length > 0) {
paragraph2.children.unshift({ type: "text", value: " " });
}
paragraph2.children.unshift({
type: "element",
tagName: "input",
properties: { type: "checkbox", checked: node2.checked, disabled: true },
children: []
});
properties.className = ["task-list-item"];
}
let index3 = -1;
while (++index3 < results.length) {
const child = results[index3];
if (loose || index3 !== 0 || child.type !== "element" || child.tagName !== "p") {
children.push({ type: "text", value: "\n" });
}
if (child.type === "element" && child.tagName === "p" && !loose) {
children.push(...child.children);
} else {
children.push(child);
}
}
const tail = results[results.length - 1];
if (tail && (loose || tail.type !== "element" || tail.tagName !== "p")) {
children.push({ type: "text", value: "\n" });
}
const result = { type: "element", tagName: "li", properties, children };
state.patch(node2, result);
return state.applyData(node2, result);
}
function listLoose(node2) {
let loose = false;
if (node2.type === "list") {
loose = node2.spread || false;
const children = node2.children;
let index3 = -1;
while (!loose && ++index3 < children.length) {
loose = listItemLoose(children[index3]);
}
}
return loose;
}
function listItemLoose(node2) {
const spread = node2.spread;
return spread === null || spread === void 0 ? node2.children.length > 1 : spread;
}
// ../../node_modules/mdast-util-to-hast/lib/handlers/list.js
function list2(state, node2) {
const properties = {};
const results = state.all(node2);
let index3 = -1;
if (typeof node2.start === "number" && node2.start !== 1) {
properties.start = node2.start;
}
while (++index3 < results.length) {
const child = results[index3];
if (child.type === "element" && child.tagName === "li" && child.properties && Array.isArray(child.properties.className) && child.properties.className.includes("task-list-item")) {
properties.className = ["contains-task-list"];
break;
}
}
const result = {
type: "element",
tagName: node2.ordered ? "ol" : "ul",
properties,
children: state.wrap(results, true)
};
state.patch(node2, result);
return state.applyData(node2, result);
}
// ../../node_modules/mdast-util-to-hast/lib/handlers/paragraph.js
function paragraph(state, node2) {
const result = {
type: "element",
tagName: "p",
properties: {},
children: state.all(node2)
};
state.patch(node2, result);
return state.applyData(node2, result);
}
// ../../node_modules/mdast-util-to-hast/lib/handlers/root.js
function root2(state, node2) {
const result = { type: "root", children: state.wrap(state.all(node2)) };
state.patch(node2, result);
return state.applyData(node2, result);
}
// ../../node_modules/mdast-util-to-hast/lib/handlers/strong.js
function strong(state, node2) {
const result = {
type: "element",
tagName: "strong",
properties: {},
children: state.all(node2)
};
state.patch(node2, result);
return state.applyData(node2, result);
}
// ../../node_modules/mdast-util-to-hast/lib/handlers/table.js
function table(state, node2) {
const rows = state.all(node2);
const firstRow = rows.shift();
const tableContent = [];
if (firstRow) {
const head = {
type: "element",
tagName: "thead",
properties: {},
children: state.wrap([firstRow], true)
};
state.patch(node2.children[0], head);
tableContent.push(head);
}
if (rows.length > 0) {
const body = {
type: "element",
tagName: "tbody",
properties: {},
children: state.wrap(rows, true)
};
const start2 = pointStart(node2.children[1]);
const end = pointEnd(node2.children[node2.children.length - 1]);
if (start2 && end) body.position = { start: start2, end };
tableContent.push(body);
}
const result = {
type: "element",
tagName: "table",
properties: {},
children: state.wrap(tableContent, true)
};
state.patch(node2, result);
return state.applyData(node2, result);
}
// ../../node_modules/mdast-util-to-hast/lib/handlers/table-row.js
function tableRow(state, node2, parent) {
const siblings = parent ? parent.children : void 0;
const rowIndex = siblings ? siblings.indexOf(node2) : 1;
const tagName = rowIndex === 0 ? "th" : "td";
const align = parent && parent.type === "table" ? parent.align : void 0;
const length = align ? align.length : node2.children.length;
let cellIndex = -1;
const cells = [];
while (++cellIndex < length) {
const cell = node2.children[cellIndex];
const properties = {};
const alignValue = align ? align[cellIndex] : void 0;
if (alignValue) {
properties.align = alignValue;
}
let result2 = { type: "element", tagName, properties, children: [] };
if (cell) {
result2.children = state.all(cell);
state.patch(cell, result2);
result2 = state.applyData(cell, result2);
}
cells.push(result2);
}
const result = {
type: "element",
tagName: "tr",
properties: {},
children: state.wrap(cells, true)
};
state.patch(node2, result);
return state.applyData(node2, result);
}
// ../../node_modules/mdast-util-to-hast/lib/handlers/table-cell.js
function tableCell(state, node2) {
const result = {
type: "element",
tagName: "td",
// Assume body cell.
properties: {},
children: state.all(node2)
};
state.patch(node2, result);
return state.applyData(node2, result);
}
// ../../node_modules/trim-lines/index.js
var tab = 9;
var space = 32;
function trimLines(value) {
const source = String(value);
const search2 = /\r?\n|\r/g;
let match = search2.exec(source);
let last = 0;
const lines = [];
while (match) {
lines.push(
trimLine(source.slice(last, match.index), last > 0, true),
match[0]
);
last = match.index + match[0].length;
match = search2.exec(source);
}
lines.push(trimLine(source.slice(last), last > 0, false));
return lines.join("");
}
function trimLine(value, start2, end) {
let startIndex = 0;
let endIndex = value.length;
if (start2) {
let code2 = value.codePointAt(startIndex);
while (code2 === tab || code2 === space) {
startIndex++;
code2 = value.codePointAt(startIndex);
}
}
if (end) {
let code2 = value.codePointAt(endIndex - 1);
while (code2 === tab || code2 === space) {
endIndex--;
code2 = value.codePointAt(endIndex - 1);
}
}
return endIndex > startIndex ? value.slice(startIndex, endIndex) : "";
}
// ../../node_modules/mdast-util-to-hast/lib/handlers/text.js
function text4(state, node2) {
const result = { type: "text", value: trimLines(String(node2.value)) };
state.patch(node2, result);
return state.applyData(node2, result);
}
// ../../node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js
function thematicBreak2(state, node2) {
const result = {
type: "element",
tagName: "hr",
properties: {},
children: []
};
state.patch(node2, result);
return state.applyData(node2, result);
}
// ../../node_modules/mdast-util-to-hast/lib/handlers/index.js
var handlers = {
blockquote,
break: hardBreak,
code,
delete: strikethrough,
emphasis,
footnoteReference,
heading,
html: html3,
imageReference,
image,
inlineCode,
linkReference,
link,
listItem,
list: list2,
paragraph,
// @ts-expect-error: root is different, but hard to type.
root: root2,
strong,
table,
tableCell,
tableRow,
text: text4,
thematicBreak: thematicBreak2,
toml: ignore,
yaml: ignore,
definition: ignore,
footnoteDefinition: ignore
};
function ignore() {
return void 0;
}
// ../../node_modules/@ungap/structured-clone/esm/types.js
var VOID = -1;
var PRIMITIVE = 0;
var ARRAY = 1;
var OBJECT = 2;
var DATE = 3;
var REGEXP = 4;
var MAP = 5;
var SET = 6;
var ERROR = 7;
var BIGINT = 8;
// ../../node_modules/@ungap/structured-clone/esm/deserialize.js
var env = typeof self === "object" ? self : globalThis;
var deserializer = ($, _) => {
const as = (out, index3) => {
$.set(index3, out);
return out;
};
const unpair = (index3) => {
if ($.has(index3))
return $.get(index3);
const [type, value] = _[index3];
switch (type) {
case PRIMITIVE:
case VOID:
return as(value, index3);
case ARRAY: {
const arr = as([], index3);
for (const index4 of value)
arr.push(unpair(index4));
return arr;
}
case OBJECT: {
const object = as({}, index3);
for (const [key, index4] of value)
object[unpair(key)] = unpair(index4);
return object;
}
case DATE:
return as(new Date(value), index3);
case REGEXP: {
const { source, flags } = value;
return as(new RegExp(source, flags), index3);
}
case MAP: {
const map = as(/* @__PURE__ */ new Map(), index3);
for (const [key, index4] of value)
map.set(unpair(key), unpair(index4));
return map;
}
case SET: {
const set = as(/* @__PURE__ */ new Set(), index3);
for (const index4 of value)
set.add(unpair(index4));
return set;
}
case ERROR: {
const { name: name2, message } = value;
return as(new env[name2](message), index3);
}
case BIGINT:
return as(BigInt(value), index3);
case "BigInt":
return as(Object(BigInt(value)), index3);
case "ArrayBuffer":
return as(new Uint8Array(value).buffer, value);
case "DataView": {
const { buffer } = new Uint8Array(value);
return as(new DataView(buffer), value);
}
}
return as(new env[type](value), index3);
};
return unpair;
};
var deserialize = (serialized) => deserializer(/* @__PURE__ */ new Map(), serialized)(0);
// ../../node_modules/@ungap/structured-clone/esm/serialize.js
var EMPTY = "";
var { toString: toString2 } = {};
var { keys } = Object;
var typeOf = (value) => {
const type = typeof value;
if (type !== "object" || !value)
return [PRIMITIVE, type];
const asString = toString2.call(value).slice(8, -1);
switch (asString) {
case "Array":
return [ARRAY, EMPTY];
case "Object":
return [OBJECT, EMPTY];
case "Date":
return [DATE, EMPTY];
case "RegExp":
return [REGEXP, EMPTY];
case "Map":
return [MAP, EMPTY];
case "Set":
return [SET, EMPTY];
case "DataView":
return [ARRAY, asString];
}
if (asString.includes("Array"))
return [ARRAY, asString];
if (asString.includes("Error"))
return [ERROR, asString];
return [OBJECT, asString];
};
var shouldSkip = ([TYPE, type]) => TYPE === PRIMITIVE && (type === "function" || type === "symbol");
var serializer = (strict, json, $, _) => {
const as = (out, value) => {
const index3 = _.push(out) - 1;
$.set(value, index3);
return index3;
};
const pair = (value) => {
if ($.has(value))
return $.get(value);
let [TYPE, type] = typeOf(value);
switch (TYPE) {
case PRIMITIVE: {
let entry = value;
switch (type) {
case "bigint":
TYPE = BIGINT;
entry = value.toString();
break;
case "function":
case "symbol":
if (strict)
throw new TypeError("unable to serialize " + type);
entry = null;
break;
case "undefined":
return as([VOID], value);
}
return as([TYPE, entry], value);
}
case ARRAY: {
if (type) {
let spread = value;
if (type === "DataView") {
spread = new Uint8Array(value.buffer);
} else if (type === "ArrayBuffer") {
spread = new Uint8Array(value);
}
return as([type, [...spread]], value);
}
const arr = [];
const index3 = as([TYPE, arr], value);
for (const entry of value)
arr.push(pair(entry));
return index3;
}
case OBJECT: {
if (type) {
switch (type) {
case "BigInt":
return as([type, value.toString()], value);
case "Boolean":
case "Number":
case "String":
return as([type, value.valueOf()], value);
}
}
if (json && "toJSON" in value)
return pair(value.toJSON());
const entries = [];
const index3 = as([TYPE, entries], value);
for (const key of keys(value)) {
if (strict || !shouldSkip(typeOf(value[key])))
entries.push([pair(key), pair(value[key])]);
}
return index3;
}
case DATE:
return as([TYPE, value.toISOString()], value);
case REGEXP: {
const { source, flags } = value;
return as([TYPE, { source, flags }], value);
}
case MAP: {
const entries = [];
const index3 = as([TYPE, entries], value);
for (const [key, entry] of value) {
if (strict || !(shouldSkip(typeOf(key)) || shouldSkip(typeOf(entry))))
entries.push([pair(key), pair(entry)]);
}
return index3;
}
case SET: {
const entries = [];
const index3 = as([TYPE, entries], value);
for (const entry of value) {
if (strict || !shouldSkip(typeOf(entry)))
entries.push(pair(entry));
}
return index3;
}
}
const { message } = value;
return as([TYPE, { name: type, message }], value);
};
return pair;
};
var serialize = (value, { json, lossy } = {}) => {
const _ = [];
return serializer(!(json || lossy), !!json, /* @__PURE__ */ new Map(), _)(value), _;
};
// ../../node_modules/@ungap/structured-clone/esm/index.js
var esm_default = typeof structuredClone === "function" ? (
/* c8 ignore start */
(any, options) => options && ("json" in options || "lossy" in options) ? deserialize(serialize(any, options)) : structuredClone(any)
) : (any, options) => deserialize(serialize(any, options));
// ../../node_modules/mdast-util-to-hast/lib/footer.js
function defaultFootnoteBackContent(_, rereferenceIndex) {
const result = [{ type: "text", value: "\u21A9" }];
if (rereferenceIndex > 1) {
result.push({
type: "element",
tagName: "sup",
properties: {},
children: [{ type: "text", value: String(rereferenceIndex) }]
});
}
return result;
}
function defaultFootnoteBackLabel(referenceIndex, rereferenceIndex) {
return "Back to reference " + (referenceIndex + 1) + (rereferenceIndex > 1 ? "-" + rereferenceIndex : "");
}
function footer(state) {
const clobberPrefix = typeof state.options.clobberPrefix === "string" ? state.options.clobberPrefix : "user-content-";
const footnoteBackContent = state.options.footnoteBackContent || defaultFootnoteBackContent;
const footnoteBackLabel = state.options.footnoteBackLabel || defaultFootnoteBackLabel;
const footnoteLabel = state.options.footnoteLabel || "Footnotes";
const footnoteLabelTagName = state.options.footnoteLabelTagName || "h2";
const footnoteLabelProperties = state.options.footnoteLabelProperties || {
className: ["sr-only"]
};
const listItems = [];
let referenceIndex = -1;
while (++referenceIndex < state.footnoteOrder.length) {
const definition2 = state.footnoteById.get(
state.footnoteOrder[referenceIndex]
);
if (!definition2) {
continue;
}
const content3 = state.all(definition2);
const id = String(definition2.identifier).toUpperCase();
const safeId = normalizeUri(id.toLowerCase());
let rereferenceIndex = 0;
const backReferences = [];
const counts = state.footnoteCounts.get(id);
while (counts !== void 0 && ++rereferenceIndex <= counts) {
if (backReferences.length > 0) {
backReferences.push({ type: "text", value: " " });
}
let children = typeof footnoteBackContent === "string" ? footnoteBackContent : footnoteBackContent(referenceIndex, rereferenceIndex);
if (typeof children === "string") {
children = { type: "text", value: children };
}
backReferences.push({
type: "element",
tagName: "a",
properties: {
href: "#" + clobberPrefix + "fnref-" + safeId + (rereferenceIndex > 1 ? "-" + rereferenceIndex : ""),
dataFootnoteBackref: "",
ariaLabel: typeof footnoteBackLabel === "string" ? footnoteBackLabel : footnoteBackLabel(referenceIndex, rereferenceIndex),
className: ["data-footnote-backref"]
},
children: Array.isArray(children) ? children : [children]
});
}
const tail = content3[content3.length - 1];
if (tail && tail.type === "element" && tail.tagName === "p") {
const tailTail = tail.children[tail.children.length - 1];
if (tailTail && tailTail.type === "text") {
tailTail.value += " ";
} else {
tail.children.push({ type: "text", value: " " });
}
tail.children.push(...backReferences);
} else {
content3.push(...backReferences);
}
const listItem2 = {
type: "element",
tagName: "li",
properties: { id: clobberPrefix + "fn-" + safeId },
children: state.wrap(content3, true)
};
state.patch(definition2, listItem2);
listItems.push(listItem2);
}
if (listItems.length === 0) {
return;
}
return {
type: "element",
tagName: "section",
properties: { dataFootnotes: true, className: ["footnotes"] },
children: [
{
type: "element",
tagName: footnoteLabelTagName,
properties: {
...esm_default(footnoteLabelProperties),
id: "footnote-label"
},
children: [{ type: "text", value: footnoteLabel }]
},
{ type: "text", value: "\n" },
{
type: "element",
tagName: "ol",
properties: {},
children: state.wrap(listItems, true)
},
{ type: "text", value: "\n" }
]
};
}
// ../../node_modules/unist-util-visit/node_modules/unist-util-is/lib/index.js
var 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 ok2;
}
if (typeof test === "function") {
return castFactory(test);
}
if (typeof test === "object") {
return Array.isArray(test) ? anyFactory(test) : propsFactory(test);
}
if (typeof test === "string") {
return typeFactory(test);
}
throw new Error("Expected function, string, or object as test");
}
);
function anyFactory(tests) {
const checks2 = [];
let index3 = -1;
while (++index3 < tests.length) {
checks2[index3] = convert(tests[index3]);
}
return castFactory(any);
function any(...parameters) {
let index4 = -1;
while (++index4 < checks2.length) {
if (checks2[index4].apply(this, parameters)) return true;
}
return false;
}
}
function propsFactory(check) {
const checkAsRecord = (
/** @type {Record<string, unknown>} */
check
);
return castFactory(all2);
function all2(node2) {
const nodeAsRecord = (
/** @type {Record<string, unknown>} */
/** @type {unknown} */
node2
);
let key;
for (key in check) {
if (nodeAsRecord[key] !== checkAsRecord[key]) return false;
}
return true;
}
}
function typeFactory(check) {
return castFactory(type);
function type(node2) {
return node2 && node2.type === check;
}
}
function castFactory(testFunction) {
return check;
function check(value, index3, parent) {
return Boolean(
looksLikeANode(value) && testFunction.call(
this,
value,
typeof index3 === "number" ? index3 : void 0,
parent || void 0
)
);
}
}
function ok2() {
return true;
}
function looksLikeANode(value) {
return value !== null && typeof value === "object" && "type" in value;
}
// ../../node_modules/unist-util-visit/node_modules/unist-util-visit-parents/lib/color.js
function color(d) {
return d;
}
// ../../node_modules/unist-util-visit/node_modules/unist-util-visit-parents/lib/index.js
var empty2 = [];
var CONTINUE = true;
var EXIT = false;
var SKIP = "skip";
function visitParents(tree, test, visitor, reverse) {
let check;
if (typeof test === "function" && typeof visitor !== "function") {
reverse = visitor;
visitor = test;
} else {
check = test;
}
const is2 = convert(check);
const step = reverse ? -1 : 1;
factory(tree, void 0, [])();
function factory(node2, index3, parents) {
const value = (
/** @type {Record<string, unknown>} */
node2 && typeof node2 === "object" ? node2 : {}
);
if (typeof value.type === "string") {
const name2 = (
// `hast`
typeof value.tagName === "string" ? value.tagName : (
// `xast`
typeof value.name === "string" ? value.name : void 0
)
);
Object.defineProperty(visit2, "name", {
value: "node (" + color(node2.type + (name2 ? "<" + name2 + ">" : "")) + ")"
});
}
return visit2;
function visit2() {
let result = empty2;
let subresult;
let offset;
let grandparents;
if (!test || is2(node2, index3, parents[parents.length - 1] || void 0)) {
result = toResult(visitor(node2, parents));
if (result[0] === EXIT) {
return result;
}
}
if ("children" in node2 && node2.children) {
const nodeAsParent = (
/** @type {UnistParent} */
node2
);
if (nodeAsParent.children && result[0] !== SKIP) {
offset = (reverse ? nodeAsParent.children.length : -1) + step;
grandparents = parents.concat(nodeAsParent);
while (offset > -1 && offset < nodeAsParent.children.length) {
const child = nodeAsParent.children[offset];
subresult = factory(child, offset, grandparents)();
if (subresult[0] === EXIT) {
return subresult;
}
offset = typeof subresult[1] === "number" ? subresult[1] : offset + step;
}
}
}
return result;
}
}
}
function toResult(value) {
if (Array.isArray(value)) {
return value;
}
if (typeof value === "number") {
return [CONTINUE, value];
}
return value === null || value === void 0 ? empty2 : [value];
}
// ../../node_modules/unist-util-visit/lib/index.js
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(node2, parents) {
const parent = parents[parents.length - 1];
const index3 = parent ? parent.children.indexOf(node2) : void 0;
return visitor(node2, index3, parent);
}
}
// ../../node_modules/mdast-util-to-hast/lib/state.js
var own3 = {}.hasOwnProperty;
var emptyOptions3 = {};
function createState(tree, options) {
const settings = options || emptyOptions3;
const definitionById = /* @__PURE__ */ new Map();
const footnoteById = /* @__PURE__ */ new Map();
const footnoteCounts = /* @__PURE__ */ new Map();
const handlers2 = { ...handlers, ...settings.handlers };
const state = {
all: all2,
applyData,
definitionById,
footnoteById,
footnoteCounts,
footnoteOrder: [],
handlers: handlers2,
one: one3,
options: settings,
patch,
wrap
};
visit(tree, function(node2) {
if (node2.type === "definition" || node2.type === "footnoteDefinition") {
const map = node2.type === "definition" ? definitionById : footnoteById;
const id = String(node2.identifier).toUpperCase();
if (!map.has(id)) {
map.set(id, node2);
}
}
});
return state;
function one3(node2, parent) {
const type = node2.type;
const handle = state.handlers[type];
if (own3.call(state.handlers, type) && handle) {
return handle(state, node2, parent);
}
if (state.options.passThrough && state.options.passThrough.includes(type)) {
if ("children" in node2) {
const { children, ...shallow } = node2;
const result = esm_default(shallow);
result.children = state.all(node2);
return result;
}
return esm_default(node2);
}
const unknown = state.options.unknownHandler || defaultUnknownHandler;
return unknown(state, node2, parent);
}
function all2(parent) {
const values = [];
if ("children" in parent) {
const nodes = parent.children;
let index3 = -1;
while (++index3 < nodes.length) {
const result = state.one(nodes[index3], parent);
if (result) {
if (index3 && nodes[index3 - 1].type === "break") {
if (!Array.isArray(result) && result.type === "text") {
result.value = trimMarkdownSpaceStart(result.value);
}
if (!Array.isArray(result) && result.type === "element") {
const head = result.children[0];
if (head && head.type === "text") {
head.value = trimMarkdownSpaceStart(head.value);
}
}
}
if (Array.isArray(result)) {
values.push(...result);
} else {
values.push(result);
}
}
}
}
return values;
}
}
function patch(from, to) {
if (from.position) to.position = position(from);
}
function applyData(from, to) {
let result = to;
if (from && from.data) {
const hName = from.data.hName;
const hChildren = from.data.hChildren;
const hProperties = from.data.hProperties;
if (typeof hName === "string") {
if (result.type === "element") {
result.tagName = hName;
} else {
const children = "children" in result ? result.children : [result];
result = { type: "element", tagName: hName, properties: {}, children };
}
}
if (result.type === "element" && hProperties) {
Object.assign(result.properties, esm_default(hProperties));
}
if ("children" in result && result.children && hChildren !== null && hChildren !== void 0) {
result.children = hChildren;
}
}
return result;
}
function defaultUnknownHandler(state, node2) {
const data = node2.data || {};
const result = "value" in node2 && !(own3.call(data, "hProperties") || own3.call(data, "hChildren")) ? { type: "text", value: node2.value } : {
type: "element",
tagName: "div",
properties: {},
children: state.all(node2)
};
state.patch(node2, result);
return state.applyData(node2, result);
}
function wrap(nodes, loose) {
const result = [];
let index3 = -1;
if (loose) {
result.push({ type: "text", value: "\n" });
}
while (++index3 < nodes.length) {
if (index3) result.push({ type: "text", value: "\n" });
result.push(nodes[index3]);
}
if (loose && nodes.length > 0) {
result.push({ type: "text", value: "\n" });
}
return result;
}
function trimMarkdownSpaceStart(value) {
let index3 = 0;
let code2 = value.charCodeAt(index3);
while (code2 === 9 || code2 === 32) {
index3++;
code2 = value.charCodeAt(index3);
}
return value.slice(index3);
}
// ../../node_modules/mdast-util-to-hast/lib/index.js
function toHast(tree, options) {
const state = createState(tree, options);
const node2 = state.one(tree, void 0);
const foot = footer(state);
const result = Array.isArray(node2) ? { type: "root", children: node2 } : node2 || { type: "root", children: [] };
if (foot) {
ok("children" in result);
result.children.push({ type: "text", value: "\n" }, foot);
}
return result;
}
// ../../node_modules/remark-rehype/lib/index.js
function remarkRehype(destination, options) {
if (destination && "run" in destination) {
return async function(tree, file) {
const hastTree = (
/** @type {HastRoot} */
toHast(tree, { file, ...options })
);
await destination.run(hastTree, file);
};
}
return function(tree, file) {
return (
/** @type {HastRoot} */
toHast(tree, { file, ...destination || options })
);
};
}
// ../../node_modules/bail/index.js
function bail(error) {
if (error) {
throw error;
}
}
// ../../node_modules/unified/lib/index.js
var import_extend = __toESM(require_extend(), 1);
// ../../node_modules/is-plain-obj/index.js
function isPlainObject(value) {
if (typeof value !== "object" || value === null) {
return false;
}
const prototype = Object.getPrototypeOf(value);
return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
}
// ../../node_modules/trough/lib/index.js
function trough() {
const fns = [];
const pipeline = { run, use };
return pipeline;
function run(...values) {
let middlewareIndex = -1;
const callback = values.pop();
if (typeof callback !== "function") {
throw new TypeError("Expected function as last argument, not " + callback);
}
next(null, ...values);
function next(error, ...output) {
const fn = fns[++middlewareIndex];
let index3 = -1;
if (error) {
callback(error);
return;
}
while (++index3 < values.length) {
if (output[index3] === null || output[index3] === void 0) {
output[index3] = values[index3];
}
}
values = output;
if (fn) {
wrap2(fn, next)(...output);
} else {
callback(null, ...output);
}
}
}
function use(middelware) {
if (typeof middelware !== "function") {
throw new TypeError(
"Expected `middelware` to be a function, not " + middelware
);
}
fns.push(middelware);
return pipeline;
}
}
function wrap2(middleware, callback) {
let called;
return wrapped;
function wrapped(...parameters) {
const fnExpectsCallback = middleware.length > parameters.length;
let result;
if (fnExpectsCallback) {
parameters.push(done);
}
try {
result = middleware.apply(this, parameters);
} catch (error) {
const exception = (
/** @type {Error} */
error
);
if (fnExpectsCallback && called) {
throw exception;
}
return done(exception);
}
if (!fnExpectsCallback) {
if (result && result.then && typeof result.then === "function") {
result.then(then, done);
} else if (result instanceof Error) {
done(result);
} else {
then(result);
}
}
}
function done(error, ...output) {
if (!called) {
called = true;
callback(error, ...output);
}
}
function then(value) {
done(null, value);
}
}
// ../../node_modules/vfile/lib/minpath.browser.js
var minpath = { basename, dirname, extname, join, sep: "/" };
function basename(path, extname2) {
if (extname2 !== void 0 && typeof extname2 !== "string") {
throw new TypeError('"ext" argument must be a string');
}
assertPath(path);
let start2 = 0;
let end = -1;
let index3 = path.length;
let seenNonSlash;
if (extname2 === void 0 || extname2.length === 0 || extname2.length > path.length) {
while (index3--) {
if (path.codePointAt(index3) === 47) {
if (seenNonSlash) {
start2 = index3 + 1;
break;
}
} else if (end < 0) {
seenNonSlash = true;
end = index3 + 1;
}
}
return end < 0 ? "" : path.slice(start2, end);
}
if (extname2 === path) {
return "";
}
let firstNonSlashEnd = -1;
let extnameIndex = extname2.length - 1;
while (index3--) {
if (path.codePointAt(index3) === 47) {
if (seenNonSlash) {
start2 = index3 + 1;
break;
}
} else {
if (firstNonSlashEnd < 0) {
seenNonSlash = true;
firstNonSlashEnd = index3 + 1;
}
if (extnameIndex > -1) {
if (path.codePointAt(index3) === extname2.codePointAt(extnameIndex--)) {
if (extnameIndex < 0) {
end = index3;
}
} else {
extnameIndex = -1;
end = firstNonSlashEnd;
}
}
}
}
if (start2 === end) {
end = firstNonSlashEnd;
} else if (end < 0) {
end = path.length;
}
return path.slice(start2, end);
}
function dirname(path) {
assertPath(path);
if (path.length === 0) {
return ".";
}
let end = -1;
let index3 = path.length;
let unmatchedSlash;
while (--index3) {
if (path.codePointAt(index3) === 47) {
if (unmatchedSlash) {
end = index3;
break;
}
} else if (!unmatchedSlash) {
unmatchedSlash = true;
}
}
return end < 0 ? path.codePointAt(0) === 47 ? "/" : "." : end === 1 && path.codePointAt(0) === 47 ? "//" : path.slice(0, end);
}
function extname(path) {
assertPath(path);
let index3 = path.length;
let end = -1;
let startPart = 0;
let startDot = -1;
let preDotState = 0;
let unmatchedSlash;
while (index3--) {
const code2 = path.codePointAt(index3);
if (code2 === 47) {
if (unmatchedSlash) {
startPart = index3 + 1;
break;
}
continue;
}
if (end < 0) {
unmatchedSlash = true;
end = index3 + 1;
}
if (code2 === 46) {
if (startDot < 0) {
startDot = index3;
} else if (preDotState !== 1) {
preDotState = 1;
}
} else if (startDot > -1) {
preDotState = -1;
}
}
if (startDot < 0 || end < 0 || // We saw a non-dot character immediately before the dot.
preDotState === 0 || // The (right-most) trimmed path component is exactly `..`.
preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
return "";
}
return path.slice(startDot, end);
}
function join(...segments) {
let index3 = -1;
let joined;
while (++index3 < segments.length) {
assertPath(segments[index3]);
if (segments[index3]) {
joined = joined === void 0 ? segments[index3] : joined + "/" + segments[index3];
}
}
return joined === void 0 ? "." : normalize2(joined);
}
function normalize2(path) {
assertPath(path);
const absolute = path.codePointAt(0) === 47;
let value = normalizeString(path, !absolute);
if (value.length === 0 && !absolute) {
value = ".";
}
if (value.length > 0 && path.codePointAt(path.length - 1) === 47) {
value += "/";
}
return absolute ? "/" + value : value;
}
function normalizeString(path, allowAboveRoot) {
let result = "";
let lastSegmentLength = 0;
let lastSlash = -1;
let dots = 0;
let index3 = -1;
let code2;
let lastSlashIndex;
while (++index3 <= path.length) {
if (index3 < path.length) {
code2 = path.codePointAt(index3);
} else if (code2 === 47) {
break;
} else {
code2 = 47;
}
if (code2 === 47) {
if (lastSlash === index3 - 1 || dots === 1) {
} else if (lastSlash !== index3 - 1 && dots === 2) {
if (result.length < 2 || lastSegmentLength !== 2 || result.codePointAt(result.length - 1) !== 46 || result.codePointAt(result.length - 2) !== 46) {
if (result.length > 2) {
lastSlashIndex = result.lastIndexOf("/");
if (lastSlashIndex !== result.length - 1) {
if (lastSlashIndex < 0) {
result = "";
lastSegmentLength = 0;
} else {
result = result.slice(0, lastSlashIndex);
lastSegmentLength = result.length - 1 - result.lastIndexOf("/");
}
lastSlash = index3;
dots = 0;
continue;
}
} else if (result.length > 0) {
result = "";
lastSegmentLength = 0;
lastSlash = index3;
dots = 0;
continue;
}
}
if (allowAboveRoot) {
result = result.length > 0 ? result + "/.." : "..";
lastSegmentLength = 2;
}
} else {
if (result.length > 0) {
result += "/" + path.slice(lastSlash + 1, index3);
} else {
result = path.slice(lastSlash + 1, index3);
}
lastSegmentLength = index3 - lastSlash - 1;
}
lastSlash = index3;
dots = 0;
} else if (code2 === 46 && dots > -1) {
dots++;
} else {
dots = -1;
}
}
return result;
}
function assertPath(path) {
if (typeof path !== "string") {
throw new TypeError(
"Path must be a string. Received " + JSON.stringify(path)
);
}
}
// ../../node_modules/vfile/lib/minproc.browser.js
var minproc = { cwd };
function cwd() {
return "/";
}
// ../../node_modules/vfile/lib/minurl.shared.js
function isUrl(fileUrlOrPath) {
return Boolean(
fileUrlOrPath !== null && typeof fileUrlOrPath === "object" && "href" in fileUrlOrPath && fileUrlOrPath.href && "protocol" in fileUrlOrPath && fileUrlOrPath.protocol && // @ts-expect-error: indexing is fine.
fileUrlOrPath.auth === void 0
);
}
// ../../node_modules/vfile/lib/minurl.browser.js
function urlToPath(path) {
if (typeof path === "string") {
path = new URL(path);
} else if (!isUrl(path)) {
const error = new TypeError(
'The "path" argument must be of type string or an instance of URL. Received `' + path + "`"
);
error.code = "ERR_INVALID_ARG_TYPE";
throw error;
}
if (path.protocol !== "file:") {
const error = new TypeError("The URL must be of scheme file");
error.code = "ERR_INVALID_URL_SCHEME";
throw error;
}
return getPathFromURLPosix(path);
}
function getPathFromURLPosix(url) {
if (url.hostname !== "") {
const error = new TypeError(
'File URL host must be "localhost" or empty on darwin'
);
error.code = "ERR_INVALID_FILE_URL_HOST";
throw error;
}
const pathname = url.pathname;
let index3 = -1;
while (++index3 < pathname.length) {
if (pathname.codePointAt(index3) === 37 && pathname.codePointAt(index3 + 1) === 50) {
const third = pathname.codePointAt(index3 + 2);
if (third === 70 || third === 102) {
const error = new TypeError(
"File URL path must not include encoded / characters"
);
error.code = "ERR_INVALID_FILE_URL_PATH";
throw error;
}
}
}
return decodeURIComponent(pathname);
}
// ../../node_modules/vfile/lib/index.js
var order = (
/** @type {const} */
[
"history",
"path",
"basename",
"stem",
"extname",
"dirname"
]
);
var VFile = class {
/**
* Create a new virtual file.
*
* `options` is treated as:
*
* * `string` or `Uint8Array` — `{value: options}`
* * `URL` — `{path: options}`
* * `VFile` — shallow copies its data over to the new file
* * `object` — all fields are shallow copied over to the new file
*
* Path related fields are set in the following order (least specific to
* most specific): `history`, `path`, `basename`, `stem`, `extname`,
* `dirname`.
*
* You cannot set `dirname` or `extname` without setting either `history`,
* `path`, `basename`, or `stem` too.
*
* @param {Compatible | null | undefined} [value]
* File value.
* @returns
* New instance.
*/
constructor(value) {
let options;
if (!value) {
options = {};
} else if (isUrl(value)) {
options = { path: value };
} else if (typeof value === "string" || isUint8Array(value)) {
options = { value };
} else {
options = value;
}
this.cwd = "cwd" in options ? "" : minproc.cwd();
this.data = {};
this.history = [];
this.messages = [];
this.value;
this.map;
this.result;
this.stored;
let index3 = -1;
while (++index3 < order.length) {
const field2 = order[index3];
if (field2 in options && options[field2] !== void 0 && options[field2] !== null) {
this[field2] = field2 === "history" ? [...options[field2]] : options[field2];
}
}
let field;
for (field in options) {
if (!order.includes(field)) {
this[field] = options[field];
}
}
}
/**
* Get the basename (including extname) (example: `'index.min.js'`).
*
* @returns {string | undefined}
* Basename.
*/
get basename() {
return typeof this.path === "string" ? minpath.basename(this.path) : void 0;
}
/**
* Set basename (including extname) (`'index.min.js'`).
*
* Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
* on windows).
* Cannot be nullified (use `file.path = file.dirname` instead).
*
* @param {string} basename
* Basename.
* @returns {undefined}
* Nothing.
*/
set basename(basename2) {
assertNonEmpty(basename2, "basename");
assertPart(basename2, "basename");
this.path = minpath.join(this.dirname || "", basename2);
}
/**
* Get the parent path (example: `'~'`).
*
* @returns {string | undefined}
* Dirname.
*/
get dirname() {
return typeof this.path === "string" ? minpath.dirname(this.path) : void 0;
}
/**
* Set the parent path (example: `'~'`).
*
* Cannot be set if there’s no `path` yet.
*
* @param {string | undefined} dirname
* Dirname.
* @returns {undefined}
* Nothing.
*/
set dirname(dirname2) {
assertPath2(this.basename, "dirname");
this.path = minpath.join(dirname2 || "", this.basename);
}
/**
* Get the extname (including dot) (example: `'.js'`).
*
* @returns {string | undefined}
* Extname.
*/
get extname() {
return typeof this.path === "string" ? minpath.extname(this.path) : void 0;
}
/**
* Set the extname (including dot) (example: `'.js'`).
*
* Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
* on windows).
* Cannot be set if there’s no `path` yet.
*
* @param {string | undefined} extname
* Extname.
* @returns {undefined}
* Nothing.
*/
set extname(extname2) {
assertPart(extname2, "extname");
assertPath2(this.dirname, "extname");
if (extname2) {
if (extname2.codePointAt(0) !== 46) {
throw new Error("`extname` must start with `.`");
}
if (extname2.includes(".", 1)) {
throw new Error("`extname` cannot contain multiple dots");
}
}
this.path = minpath.join(this.dirname, this.stem + (extname2 || ""));
}
/**
* Get the full path (example: `'~/index.min.js'`).
*
* @returns {string}
* Path.
*/
get path() {
return this.history[this.history.length - 1];
}
/**
* Set the full path (example: `'~/index.min.js'`).
*
* Cannot be nullified.
* You can set a file URL (a `URL` object with a `file:` protocol) which will
* be turned into a path with `url.fileURLToPath`.
*
* @param {URL | string} path
* Path.
* @returns {undefined}
* Nothing.
*/
set path(path) {
if (isUrl(path)) {
path = urlToPath(path);
}
assertNonEmpty(path, "path");
if (this.path !== path) {
this.history.push(path);
}
}
/**
* Get the stem (basename w/o extname) (example: `'index.min'`).
*
* @returns {string | undefined}
* Stem.
*/
get stem() {
return typeof this.path === "string" ? minpath.basename(this.path, this.extname) : void 0;
}
/**
* Set the stem (basename w/o extname) (example: `'index.min'`).
*
* Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
* on windows).
* Cannot be nullified (use `file.path = file.dirname` instead).
*
* @param {string} stem
* Stem.
* @returns {undefined}
* Nothing.
*/
set stem(stem) {
assertNonEmpty(stem, "stem");
assertPart(stem, "stem");
this.path = minpath.join(this.dirname || "", stem + (this.extname || ""));
}
// Normal prototypal methods.
/**
* Create a fatal message for `reason` associated with the file.
*
* The `fatal` field of the message is set to `true` (error; file not usable)
* and the `file` field is set to the current file path.
* The message is added to the `messages` field on `file`.
*
* > 🪦 **Note**: also has obsolete signatures.
*
* @overload
* @param {string} reason
* @param {MessageOptions | null | undefined} [options]
* @returns {never}
*
* @overload
* @param {string} reason
* @param {Node | NodeLike | null | undefined} parent
* @param {string | null | undefined} [origin]
* @returns {never}
*
* @overload
* @param {string} reason
* @param {Point | Position | null | undefined} place
* @param {string | null | undefined} [origin]
* @returns {never}
*
* @overload
* @param {string} reason
* @param {string | null | undefined} [origin]
* @returns {never}
*
* @overload
* @param {Error | VFileMessage} cause
* @param {Node | NodeLike | null | undefined} parent
* @param {string | null | undefined} [origin]
* @returns {never}
*
* @overload
* @param {Error | VFileMessage} cause
* @param {Point | Position | null | undefined} place
* @param {string | null | undefined} [origin]
* @returns {never}
*
* @overload
* @param {Error | VFileMessage} cause
* @param {string | null | undefined} [origin]
* @returns {never}
*
* @param {Error | VFileMessage | string} causeOrReason
* Reason for message, should use markdown.
* @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
* Configuration (optional).
* @param {string | null | undefined} [origin]
* Place in code where the message originates (example:
* `'my-package:my-rule'` or `'my-rule'`).
* @returns {never}
* Never.
* @throws {VFileMessage}
* Message.
*/
fail(causeOrReason, optionsOrParentOrPlace, origin) {
const message = this.message(causeOrReason, optionsOrParentOrPlace, origin);
message.fatal = true;
throw message;
}
/**
* Create an info message for `reason` associated with the file.
*
* The `fatal` field of the message is set to `undefined` (info; change
* likely not needed) and the `file` field is set to the current file path.
* The message is added to the `messages` field on `file`.
*
* > 🪦 **Note**: also has obsolete signatures.
*
* @overload
* @param {string} reason
* @param {MessageOptions | null | undefined} [options]
* @returns {VFileMessage}
*
* @overload
* @param {string} reason
* @param {Node | NodeLike | null | undefined} parent
* @param {string | null | undefined} [origin]
* @returns {VFileMessage}
*
* @overload
* @param {string} reason
* @param {Point | Position | null | undefined} place
* @param {string | null | undefined} [origin]
* @returns {VFileMessage}
*
* @overload
* @param {string} reason
* @param {string | null | undefined} [origin]
* @returns {VFileMessage}
*
* @overload
* @param {Error | VFileMessage} cause
* @param {Node | NodeLike | null | undefined} parent
* @param {string | null | undefined} [origin]
* @returns {VFileMessage}
*
* @overload
* @param {Error | VFileMessage} cause
* @param {Point | Position | null | undefined} place
* @param {string | null | undefined} [origin]
* @returns {VFileMessage}
*
* @overload
* @param {Error | VFileMessage} cause
* @param {string | null | undefined} [origin]
* @returns {VFileMessage}
*
* @param {Error | VFileMessage | string} causeOrReason
* Reason for message, should use markdown.
* @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
* Configuration (optional).
* @param {string | null | undefined} [origin]
* Place in code where the message originates (example:
* `'my-package:my-rule'` or `'my-rule'`).
* @returns {VFileMessage}
* Message.
*/
info(causeOrReason, optionsOrParentOrPlace, origin) {
const message = this.message(causeOrReason, optionsOrParentOrPlace, origin);
message.fatal = void 0;
return message;
}
/**
* Create a message for `reason` associated with the file.
*
* The `fatal` field of the message is set to `false` (warning; change may be
* needed) and the `file` field is set to the current file path.
* The message is added to the `messages` field on `file`.
*
* > 🪦 **Note**: also has obsolete signatures.
*
* @overload
* @param {string} reason
* @param {MessageOptions | null | undefined} [options]
* @returns {VFileMessage}
*
* @overload
* @param {string} reason
* @param {Node | NodeLike | null | undefined} parent
* @param {string | null | undefined} [origin]
* @returns {VFileMessage}
*
* @overload
* @param {string} reason
* @param {Point | Position | null | undefined} place
* @param {string | null | undefined} [origin]
* @returns {VFileMessage}
*
* @overload
* @param {string} reason
* @param {string | null | undefined} [origin]
* @returns {VFileMessage}
*
* @overload
* @param {Error | VFileMessage} cause
* @param {Node | NodeLike | null | undefined} parent
* @param {string | null | undefined} [origin]
* @returns {VFileMessage}
*
* @overload
* @param {Error | VFileMessage} cause
* @param {Point | Position | null | undefined} place
* @param {string | null | undefined} [origin]
* @returns {VFileMessage}
*
* @overload
* @param {Error | VFileMessage} cause
* @param {string | null | undefined} [origin]
* @returns {VFileMessage}
*
* @param {Error | VFileMessage | string} causeOrReason
* Reason for message, should use markdown.
* @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
* Configuration (optional).
* @param {string | null | undefined} [origin]
* Place in code where the message originates (example:
* `'my-package:my-rule'` or `'my-rule'`).
* @returns {VFileMessage}
* Message.
*/
message(causeOrReason, optionsOrParentOrPlace, origin) {
const message = new VFileMessage(
// @ts-expect-error: the overloads are fine.
causeOrReason,
optionsOrParentOrPlace,
origin
);
if (this.path) {
message.name = this.path + ":" + message.name;
message.file = this.path;
}
message.fatal = false;
this.messages.push(message);
return message;
}
/**
* Serialize the file.
*
* > **Note**: which encodings are supported depends on the engine.
* > For info on Node.js, see:
* > <https://nodejs.org/api/util.html#whatwg-supported-encodings>.
*
* @param {string | null | undefined} [encoding='utf8']
* Character encoding to understand `value` as when it’s a `Uint8Array`
* (default: `'utf-8'`).
* @returns {string}
* Serialized file.
*/
toString(encoding) {
if (this.value === void 0) {
return "";
}
if (typeof this.value === "string") {
return this.value;
}
const decoder = new TextDecoder(encoding || void 0);
return decoder.decode(this.value);
}
};
function assertPart(part, name2) {
if (part && part.includes(minpath.sep)) {
throw new Error(
"`" + name2 + "` cannot be a path: did not expect `" + minpath.sep + "`"
);
}
}
function assertNonEmpty(part, name2) {
if (!part) {
throw new Error("`" + name2 + "` cannot be empty");
}
}
function assertPath2(path, name2) {
if (!path) {
throw new Error("Setting `" + name2 + "` requires `path` to be set too");
}
}
function isUint8Array(value) {
return Boolean(
value && typeof value === "object" && "byteLength" in value && "byteOffset" in value
);
}
// ../../node_modules/unified/lib/callable-instance.js
var CallableInstance = (
/**
* @type {new <Parameters extends Array<unknown>, Result>(property: string | symbol) => (...parameters: Parameters) => Result}
*/
/** @type {unknown} */
/**
* @this {Function}
* @param {string | symbol} property
* @returns {(...parameters: Array<unknown>) => unknown}
*/
function(property) {
const self2 = this;
const constr = self2.constructor;
const proto = (
/** @type {Record<string | symbol, Function>} */
// Prototypes do exist.
// type-coverage:ignore-next-line
constr.prototype
);
const value = proto[property];
const apply = function() {
return value.apply(apply, arguments);
};
Object.setPrototypeOf(apply, proto);
return apply;
}
);
// ../../node_modules/unified/lib/index.js
var own4 = {}.hasOwnProperty;
var Processor = class _Processor extends CallableInstance {
/**
* Create a processor.
*/
constructor() {
super("copy");
this.Compiler = void 0;
this.Parser = void 0;
this.attachers = [];
this.compiler = void 0;
this.freezeIndex = -1;
this.frozen = void 0;
this.namespace = {};
this.parser = void 0;
this.transformers = trough();
}
/**
* Copy a processor.
*
* @deprecated
* This is a private internal method and should not be used.
* @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
* New *unfrozen* processor ({@linkcode Processor}) that is
* configured to work the same as its ancestor.
* When the descendant processor is configured in the future it does not
* affect the ancestral processor.
*/
copy() {
const destination = (
/** @type {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>} */
new _Processor()
);
let index3 = -1;
while (++index3 < this.attachers.length) {
const attacher = this.attachers[index3];
destination.use(...attacher);
}
destination.data((0, import_extend.default)(true, {}, this.namespace));
return destination;
}
/**
* Configure the processor with info available to all plugins.
* Information is stored in an object.
*
* Typically, options can be given to a specific plugin, but sometimes it
* makes sense to have information shared with several plugins.
* For example, a list of HTML elements that are self-closing, which is
* needed during all phases.
*
* > **Note**: setting information cannot occur on *frozen* processors.
* > Call the processor first to create a new unfrozen processor.
*
* > **Note**: to register custom data in TypeScript, augment the
* > {@linkcode Data} interface.
*
* @example
* This example show how to get and set info:
*
* ```js
* import {unified} from 'unified'
*
* const processor = unified().data('alpha', 'bravo')
*
* processor.data('alpha') // => 'bravo'
*
* processor.data() // => {alpha: 'bravo'}
*
* processor.data({charlie: 'delta'})
*
* processor.data() // => {charlie: 'delta'}
* ```
*
* @template {keyof Data} Key
*
* @overload
* @returns {Data}
*
* @overload
* @param {Data} dataset
* @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
*
* @overload
* @param {Key} key
* @returns {Data[Key]}
*
* @overload
* @param {Key} key
* @param {Data[Key]} value
* @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
*
* @param {Data | Key} [key]
* Key to get or set, or entire dataset to set, or nothing to get the
* entire dataset (optional).
* @param {Data[Key]} [value]
* Value to set (optional).
* @returns {unknown}
* The current processor when setting, the value at `key` when getting, or
* the entire dataset when getting without key.
*/
data(key, value) {
if (typeof key === "string") {
if (arguments.length === 2) {
assertUnfrozen("data", this.frozen);
this.namespace[key] = value;
return this;
}
return own4.call(this.namespace, key) && this.namespace[key] || void 0;
}
if (key) {
assertUnfrozen("data", this.frozen);
this.namespace = key;
return this;
}
return this.namespace;
}
/**
* Freeze a processor.
*
* Frozen processors are meant to be extended and not to be configured
* directly.
*
* When a processor is frozen it cannot be unfrozen.
* New processors working the same way can be created by calling the
* processor.
*
* It’s possible to freeze processors explicitly by calling `.freeze()`.
* Processors freeze automatically when `.parse()`, `.run()`, `.runSync()`,
* `.stringify()`, `.process()`, or `.processSync()` are called.
*
* @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
* The current processor.
*/
freeze() {
if (this.frozen) {
return this;
}
const self2 = (
/** @type {Processor} */
/** @type {unknown} */
this
);
while (++this.freezeIndex < this.attachers.length) {
const [attacher, ...options] = this.attachers[this.freezeIndex];
if (options[0] === false) {
continue;
}
if (options[0] === true) {
options[0] = void 0;
}
const transformer = attacher.call(self2, ...options);
if (typeof transformer === "function") {
this.transformers.use(transformer);
}
}
this.frozen = true;
this.freezeIndex = Number.POSITIVE_INFINITY;
return this;
}
/**
* Parse text to a syntax tree.
*
* > **Note**: `parse` freezes the processor if not already *frozen*.
*
* > **Note**: `parse` performs the parse phase, not the run phase or other
* > phases.
*
* @param {Compatible | undefined} [file]
* file to parse (optional); typically `string` or `VFile`; any value
* accepted as `x` in `new VFile(x)`.
* @returns {ParseTree extends undefined ? Node : ParseTree}
* Syntax tree representing `file`.
*/
parse(file) {
this.freeze();
const realFile = vfile(file);
const parser = this.parser || this.Parser;
assertParser("parse", parser);
return parser(String(realFile), realFile);
}
/**
* Process the given file as configured on the processor.
*
* > **Note**: `process` freezes the processor if not already *frozen*.
*
* > **Note**: `process` performs the parse, run, and stringify phases.
*
* @overload
* @param {Compatible | undefined} file
* @param {ProcessCallback<VFileWithOutput<CompileResult>>} done
* @returns {undefined}
*
* @overload
* @param {Compatible | undefined} [file]
* @returns {Promise<VFileWithOutput<CompileResult>>}
*
* @param {Compatible | undefined} [file]
* File (optional); typically `string` or `VFile`]; any value accepted as
* `x` in `new VFile(x)`.
* @param {ProcessCallback<VFileWithOutput<CompileResult>> | undefined} [done]
* Callback (optional).
* @returns {Promise<VFile> | undefined}
* Nothing if `done` is given.
* Otherwise a promise, rejected with a fatal error or resolved with the
* processed file.
*
* The parsed, transformed, and compiled value is available at
* `file.value` (see note).
*
* > **Note**: unified typically compiles by serializing: most
* > compilers return `string` (or `Uint8Array`).
* > Some compilers, such as the one configured with
* > [`rehype-react`][rehype-react], return other values (in this case, a
* > React tree).
* > If you’re using a compiler that doesn’t serialize, expect different
* > result values.
* >
* > To register custom results in TypeScript, add them to
* > {@linkcode CompileResultMap}.
*
* [rehype-react]: https://github.com/rehypejs/rehype-react
*/
process(file, done) {
const self2 = this;
this.freeze();
assertParser("process", this.parser || this.Parser);
assertCompiler("process", this.compiler || this.Compiler);
return done ? executor(void 0, done) : new Promise(executor);
function executor(resolve, reject) {
const realFile = vfile(file);
const parseTree = (
/** @type {HeadTree extends undefined ? Node : HeadTree} */
/** @type {unknown} */
self2.parse(realFile)
);
self2.run(parseTree, realFile, function(error, tree, file2) {
if (error || !tree || !file2) {
return realDone(error);
}
const compileTree = (
/** @type {CompileTree extends undefined ? Node : CompileTree} */
/** @type {unknown} */
tree
);
const compileResult = self2.stringify(compileTree, file2);
if (looksLikeAValue(compileResult)) {
file2.value = compileResult;
} else {
file2.result = compileResult;
}
realDone(
error,
/** @type {VFileWithOutput<CompileResult>} */
file2
);
});
function realDone(error, file2) {
if (error || !file2) {
reject(error);
} else if (resolve) {
resolve(file2);
} else {
ok(done, "`done` is defined if `resolve` is not");
done(void 0, file2);
}
}
}
}
/**
* Process the given file as configured on the processor.
*
* An error is thrown if asynchronous transforms are configured.
*
* > **Note**: `processSync` freezes the processor if not already *frozen*.
*
* > **Note**: `processSync` performs the parse, run, and stringify phases.
*
* @param {Compatible | undefined} [file]
* File (optional); typically `string` or `VFile`; any value accepted as
* `x` in `new VFile(x)`.
* @returns {VFileWithOutput<CompileResult>}
* The processed file.
*
* The parsed, transformed, and compiled value is available at
* `file.value` (see note).
*
* > **Note**: unified typically compiles by serializing: most
* > compilers return `string` (or `Uint8Array`).
* > Some compilers, such as the one configured with
* > [`rehype-react`][rehype-react], return other values (in this case, a
* > React tree).
* > If you’re using a compiler that doesn’t serialize, expect different
* > result values.
* >
* > To register custom results in TypeScript, add them to
* > {@linkcode CompileResultMap}.
*
* [rehype-react]: https://github.com/rehypejs/rehype-react
*/
processSync(file) {
let complete = false;
let result;
this.freeze();
assertParser("processSync", this.parser || this.Parser);
assertCompiler("processSync", this.compiler || this.Compiler);
this.process(file, realDone);
assertDone("processSync", "process", complete);
ok(result, "we either bailed on an error or have a tree");
return result;
function realDone(error, file2) {
complete = true;
bail(error);
result = file2;
}
}
/**
* Run *transformers* on a syntax tree.
*
* > **Note**: `run` freezes the processor if not already *frozen*.
*
* > **Note**: `run` performs the run phase, not other phases.
*
* @overload
* @param {HeadTree extends undefined ? Node : HeadTree} tree
* @param {RunCallback<TailTree extends undefined ? Node : TailTree>} done
* @returns {undefined}
*
* @overload
* @param {HeadTree extends undefined ? Node : HeadTree} tree
* @param {Compatible | undefined} file
* @param {RunCallback<TailTree extends undefined ? Node : TailTree>} done
* @returns {undefined}
*
* @overload
* @param {HeadTree extends undefined ? Node : HeadTree} tree
* @param {Compatible | undefined} [file]
* @returns {Promise<TailTree extends undefined ? Node : TailTree>}
*
* @param {HeadTree extends undefined ? Node : HeadTree} tree
* Tree to transform and inspect.
* @param {(
* RunCallback<TailTree extends undefined ? Node : TailTree> |
* Compatible
* )} [file]
* File associated with `node` (optional); any value accepted as `x` in
* `new VFile(x)`.
* @param {RunCallback<TailTree extends undefined ? Node : TailTree>} [done]
* Callback (optional).
* @returns {Promise<TailTree extends undefined ? Node : TailTree> | undefined}
* Nothing if `done` is given.
* Otherwise, a promise rejected with a fatal error or resolved with the
* transformed tree.
*/
run(tree, file, done) {
assertNode(tree);
this.freeze();
const transformers = this.transformers;
if (!done && typeof file === "function") {
done = file;
file = void 0;
}
return done ? executor(void 0, done) : new Promise(executor);
function executor(resolve, reject) {
ok(
typeof file !== "function",
"`file` can\u2019t be a `done` anymore, we checked"
);
const realFile = vfile(file);
transformers.run(tree, realFile, realDone);
function realDone(error, outputTree, file2) {
const resultingTree = (
/** @type {TailTree extends undefined ? Node : TailTree} */
outputTree || tree
);
if (error) {
reject(error);
} else if (resolve) {
resolve(resultingTree);
} else {
ok(done, "`done` is defined if `resolve` is not");
done(void 0, resultingTree, file2);
}
}
}
}
/**
* Run *transformers* on a syntax tree.
*
* An error is thrown if asynchronous transforms are configured.
*
* > **Note**: `runSync` freezes the processor if not already *frozen*.
*
* > **Note**: `runSync` performs the run phase, not other phases.
*
* @param {HeadTree extends undefined ? Node : HeadTree} tree
* Tree to transform and inspect.
* @param {Compatible | undefined} [file]
* File associated with `node` (optional); any value accepted as `x` in
* `new VFile(x)`.
* @returns {TailTree extends undefined ? Node : TailTree}
* Transformed tree.
*/
runSync(tree, file) {
let complete = false;
let result;
this.run(tree, file, realDone);
assertDone("runSync", "run", complete);
ok(result, "we either bailed on an error or have a tree");
return result;
function realDone(error, tree2) {
bail(error);
result = tree2;
complete = true;
}
}
/**
* Compile a syntax tree.
*
* > **Note**: `stringify` freezes the processor if not already *frozen*.
*
* > **Note**: `stringify` performs the stringify phase, not the run phase
* > or other phases.
*
* @param {CompileTree extends undefined ? Node : CompileTree} tree
* Tree to compile.
* @param {Compatible | undefined} [file]
* File associated with `node` (optional); any value accepted as `x` in
* `new VFile(x)`.
* @returns {CompileResult extends undefined ? Value : CompileResult}
* Textual representation of the tree (see note).
*
* > **Note**: unified typically compiles by serializing: most compilers
* > return `string` (or `Uint8Array`).
* > Some compilers, such as the one configured with
* > [`rehype-react`][rehype-react], return other values (in this case, a
* > React tree).
* > If you’re using a compiler that doesn’t serialize, expect different
* > result values.
* >
* > To register custom results in TypeScript, add them to
* > {@linkcode CompileResultMap}.
*
* [rehype-react]: https://github.com/rehypejs/rehype-react
*/
stringify(tree, file) {
this.freeze();
const realFile = vfile(file);
const compiler2 = this.compiler || this.Compiler;
assertCompiler("stringify", compiler2);
assertNode(tree);
return compiler2(tree, realFile);
}
/**
* Configure the processor to use a plugin, a list of usable values, or a
* preset.
*
* If the processor is already using a plugin, the previous plugin
* configuration is changed based on the options that are passed in.
* In other words, the plugin is not added a second time.
*
* > **Note**: `use` cannot be called on *frozen* processors.
* > Call the processor first to create a new unfrozen processor.
*
* @example
* There are many ways to pass plugins to `.use()`.
* This example gives an overview:
*
* ```js
* import {unified} from 'unified'
*
* unified()
* // Plugin with options:
* .use(pluginA, {x: true, y: true})
* // Passing the same plugin again merges configuration (to `{x: true, y: false, z: true}`):
* .use(pluginA, {y: false, z: true})
* // Plugins:
* .use([pluginB, pluginC])
* // Two plugins, the second with options:
* .use([pluginD, [pluginE, {}]])
* // Preset with plugins and settings:
* .use({plugins: [pluginF, [pluginG, {}]], settings: {position: false}})
* // Settings only:
* .use({settings: {position: false}})
* ```
*
* @template {Array<unknown>} [Parameters=[]]
* @template {Node | string | undefined} [Input=undefined]
* @template [Output=Input]
*
* @overload
* @param {Preset | null | undefined} [preset]
* @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
*
* @overload
* @param {PluggableList} list
* @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
*
* @overload
* @param {Plugin<Parameters, Input, Output>} plugin
* @param {...(Parameters | [boolean])} parameters
* @returns {UsePlugin<ParseTree, HeadTree, TailTree, CompileTree, CompileResult, Input, Output>}
*
* @param {PluggableList | Plugin | Preset | null | undefined} value
* Usable value.
* @param {...unknown} parameters
* Parameters, when a plugin is given as a usable value.
* @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
* Current processor.
*/
use(value, ...parameters) {
const attachers = this.attachers;
const namespace = this.namespace;
assertUnfrozen("use", this.frozen);
if (value === null || value === void 0) {
} else if (typeof value === "function") {
addPlugin(value, parameters);
} else if (typeof value === "object") {
if (Array.isArray(value)) {
addList(value);
} else {
addPreset(value);
}
} else {
throw new TypeError("Expected usable value, not `" + value + "`");
}
return this;
function add(value2) {
if (typeof value2 === "function") {
addPlugin(value2, []);
} else if (typeof value2 === "object") {
if (Array.isArray(value2)) {
const [plugin, ...parameters2] = (
/** @type {PluginTuple<Array<unknown>>} */
value2
);
addPlugin(plugin, parameters2);
} else {
addPreset(value2);
}
} else {
throw new TypeError("Expected usable value, not `" + value2 + "`");
}
}
function addPreset(result) {
if (!("plugins" in result) && !("settings" in result)) {
throw new Error(
"Expected usable value but received an empty preset, which is probably a mistake: presets typically come with `plugins` and sometimes with `settings`, but this has neither"
);
}
addList(result.plugins);
if (result.settings) {
namespace.settings = (0, import_extend.default)(true, namespace.settings, result.settings);
}
}
function addList(plugins) {
let index3 = -1;
if (plugins === null || plugins === void 0) {
} else if (Array.isArray(plugins)) {
while (++index3 < plugins.length) {
const thing = plugins[index3];
add(thing);
}
} else {
throw new TypeError("Expected a list of plugins, not `" + plugins + "`");
}
}
function addPlugin(plugin, parameters2) {
let index3 = -1;
let entryIndex = -1;
while (++index3 < attachers.length) {
if (attachers[index3][0] === plugin) {
entryIndex = index3;
break;
}
}
if (entryIndex === -1) {
attachers.push([plugin, ...parameters2]);
} else if (parameters2.length > 0) {
let [primary, ...rest] = parameters2;
const currentPrimary = attachers[entryIndex][1];
if (isPlainObject(currentPrimary) && isPlainObject(primary)) {
primary = (0, import_extend.default)(true, currentPrimary, primary);
}
attachers[entryIndex] = [plugin, primary, ...rest];
}
}
}
};
var unified = new Processor().freeze();
function assertParser(name2, value) {
if (typeof value !== "function") {
throw new TypeError("Cannot `" + name2 + "` without `parser`");
}
}
function assertCompiler(name2, value) {
if (typeof value !== "function") {
throw new TypeError("Cannot `" + name2 + "` without `compiler`");
}
}
function assertUnfrozen(name2, frozen) {
if (frozen) {
throw new Error(
"Cannot call `" + name2 + "` on a frozen processor.\nCreate a new processor first, by calling it: use `processor()` instead of `processor`."
);
}
}
function assertNode(node2) {
if (!isPlainObject(node2) || typeof node2.type !== "string") {
throw new TypeError("Expected node, got `" + node2 + "`");
}
}
function assertDone(name2, asyncName, complete) {
if (!complete) {
throw new Error(
"`" + name2 + "` finished async. Use `" + asyncName + "` instead"
);
}
}
function vfile(value) {
return looksLikeAVFile(value) ? value : new VFile(value);
}
function looksLikeAVFile(value) {
return Boolean(
value && typeof value === "object" && "message" in value && "messages" in value
);
}
function looksLikeAValue(value) {
return typeof value === "string" || isUint8Array2(value);
}
function isUint8Array2(value) {
return Boolean(
value && typeof value === "object" && "byteLength" in value && "byteOffset" in value
);
}
// ../../node_modules/react-markdown/lib/index.js
var changelog = "https://github.com/remarkjs/react-markdown/blob/main/changelog.md";
var emptyPlugins = [];
var emptyRemarkRehypeOptions = { allowDangerousHtml: true };
var safeProtocol = /^(https?|ircs?|mailto|xmpp)$/i;
var deprecations = [
{ from: "astPlugins", id: "remove-buggy-html-in-markdown-parser" },
{ from: "allowDangerousHtml", id: "remove-buggy-html-in-markdown-parser" },
{
from: "allowNode",
id: "replace-allownode-allowedtypes-and-disallowedtypes",
to: "allowElement"
},
{
from: "allowedTypes",
id: "replace-allownode-allowedtypes-and-disallowedtypes",
to: "allowedElements"
},
{
from: "disallowedTypes",
id: "replace-allownode-allowedtypes-and-disallowedtypes",
to: "disallowedElements"
},
{ from: "escapeHtml", id: "remove-buggy-html-in-markdown-parser" },
{ from: "includeElementIndex", id: "#remove-includeelementindex" },
{
from: "includeNodeIndex",
id: "change-includenodeindex-to-includeelementindex"
},
{ from: "linkTarget", id: "remove-linktarget" },
{ from: "plugins", id: "change-plugins-to-remarkplugins", to: "remarkPlugins" },
{ from: "rawSourcePos", id: "#remove-rawsourcepos" },
{ from: "renderers", id: "change-renderers-to-components", to: "components" },
{ from: "source", id: "change-source-to-children", to: "children" },
{ from: "sourcePos", id: "#remove-sourcepos" },
{ from: "transformImageUri", id: "#add-urltransform", to: "urlTransform" },
{ from: "transformLinkUri", id: "#add-urltransform", to: "urlTransform" }
];
function Markdown(options) {
const processor = createProcessor(options);
const file = createFile(options);
return post(processor.runSync(processor.parse(file), file), options);
}
async function MarkdownAsync(options) {
const processor = createProcessor(options);
const file = createFile(options);
const tree = await processor.run(processor.parse(file), file);
return post(tree, options);
}
function MarkdownHooks(options) {
const processor = createProcessor(options);
const [error, setError] = useState(
/** @type {Error | undefined} */
void 0
);
const [tree, setTree] = useState(
/** @type {Root | undefined} */
void 0
);
useEffect(
/* c8 ignore next 7 -- hooks are client-only. */
function() {
const file = createFile(options);
processor.run(processor.parse(file), file, function(error2, tree2) {
setError(error2);
setTree(tree2);
});
},
[
options.children,
options.rehypePlugins,
options.remarkPlugins,
options.remarkRehypeOptions
]
);
if (error) throw error;
return tree ? post(tree, options) : createElement(Fragment);
}
function createProcessor(options) {
const rehypePlugins = options.rehypePlugins || emptyPlugins;
const remarkPlugins = options.remarkPlugins || emptyPlugins;
const remarkRehypeOptions = options.remarkRehypeOptions ? { ...options.remarkRehypeOptions, ...emptyRemarkRehypeOptions } : emptyRemarkRehypeOptions;
const processor = unified().use(remarkParse).use(remarkPlugins).use(remarkRehype, remarkRehypeOptions).use(rehypePlugins);
return processor;
}
function createFile(options) {
const children = options.children || "";
const file = new VFile();
if (typeof children === "string") {
file.value = children;
} else {
unreachable(
"Unexpected value `" + children + "` for `children` prop, expected `string`"
);
}
return file;
}
function post(tree, options) {
const allowedElements = options.allowedElements;
const allowElement = options.allowElement;
const components = options.components;
const disallowedElements = options.disallowedElements;
const skipHtml = options.skipHtml;
const unwrapDisallowed = options.unwrapDisallowed;
const urlTransform = options.urlTransform || defaultUrlTransform;
for (const deprecation of deprecations) {
if (Object.hasOwn(options, deprecation.from)) {
unreachable(
"Unexpected `" + deprecation.from + "` prop, " + (deprecation.to ? "use `" + deprecation.to + "` instead" : "remove it") + " (see <" + changelog + "#" + deprecation.id + "> for more info)"
);
}
}
if (allowedElements && disallowedElements) {
unreachable(
"Unexpected combined `allowedElements` and `disallowedElements`, expected one or the other"
);
}
if (options.className) {
tree = {
type: "element",
tagName: "div",
properties: { className: options.className },
// Assume no doctypes.
children: (
/** @type {Array<ElementContent>} */
tree.type === "root" ? tree.children : [tree]
)
};
}
visit(tree, transform);
return toJsxRuntime(tree, {
Fragment,
// @ts-expect-error
// React components are allowed to return numbers,
// but not according to the types in hast-util-to-jsx-runtime
components,
ignoreInvalidStyle: true,
jsx,
jsxs,
passKeys: true,
passNode: true
});
function transform(node2, index3, parent) {
if (node2.type === "raw" && parent && typeof index3 === "number") {
if (skipHtml) {
parent.children.splice(index3, 1);
} else {
parent.children[index3] = { type: "text", value: node2.value };
}
return index3;
}
if (node2.type === "element") {
let key;
for (key in urlAttributes) {
if (Object.hasOwn(urlAttributes, key) && Object.hasOwn(node2.properties, key)) {
const value = node2.properties[key];
const test = urlAttributes[key];
if (test === null || test.includes(node2.tagName)) {
node2.properties[key] = urlTransform(String(value || ""), key, node2);
}
}
}
}
if (node2.type === "element") {
let remove = allowedElements ? !allowedElements.includes(node2.tagName) : disallowedElements ? disallowedElements.includes(node2.tagName) : false;
if (!remove && allowElement && typeof index3 === "number") {
remove = !allowElement(node2, index3, parent);
}
if (remove && parent && typeof index3 === "number") {
if (unwrapDisallowed && node2.children) {
parent.children.splice(index3, 1, ...node2.children);
} else {
parent.children.splice(index3, 1);
}
return index3;
}
}
}
}
function defaultUrlTransform(value) {
const colon = value.indexOf(":");
const questionMark = value.indexOf("?");
const numberSign = value.indexOf("#");
const slash = value.indexOf("/");
if (
// If there is no protocol, it’s relative.
colon === -1 || // If the first colon is after a `?`, `#`, or `/`, it’s not a protocol.
slash !== -1 && colon > slash || questionMark !== -1 && colon > questionMark || numberSign !== -1 && colon > numberSign || // It is a protocol, it should be allowed.
safeProtocol.test(value.slice(0, colon))
) {
return value;
}
return "";
}
export {
MarkdownAsync,
MarkdownHooks,
Markdown as default,
defaultUrlTransform
};
//# sourceMappingURL=react-markdown-AKQ45PHK.js.map