@coderminer/vue-markdown 0.0.0-stage → 1.0.0

package/dist/chunks/lib-LwqA_W3J.js

@@ -0,0 +1,127 @@
+import { t as e } from "./objectSpread2-CtBNx0TF.js";
+import t from "node:path";
+import n from "node:process";
+import { fileURLToPath as r } from "node:url";
+// node_modules/unist-util-stringify-position/lib/index.js
+function i(e) {
+	return !e || typeof e != "object" ? "" : "position" in e || "type" in e ? o(e.position) : "start" in e || "end" in e ? o(e) : "line" in e || "column" in e ? a(e) : "";
+}
+function a(e) {
+	return s(e && e.line) + ":" + s(e && e.column);
+}
+function o(e) {
+	return a(e && e.start) + "-" + a(e && e.end);
+}
+function s(e) {
+	return e && typeof e == "number" ? e : 1;
+}
+// node_modules/vfile-message/lib/index.js
+var c = class extends Error {
+	constructor(t, n, r) {
+		super(), typeof n == "string" && (r = n, n = void 0);
+		let a = "", o = {}, s = !1;
+		if (n && (o = "line" in n && "column" in n || "start" in n && "end" in n ? { place: n } : "type" in n ? {
+			ancestors: [n],
+			place: n.position
+		} : e({}, n)), typeof t == "string" ? a = t : !o.cause && t && (s = !0, a = t.message, o.cause = t), !o.ruleId && !o.source && typeof r == "string") {
+			let e = r.indexOf(":");
+			e === -1 ? o.ruleId = r : (o.source = r.slice(0, e), o.ruleId = r.slice(e + 1));
+		}
+		if (!o.place && o.ancestors && o.ancestors) {
+			let e = o.ancestors[o.ancestors.length - 1];
+			e && (o.place = e.position);
+		}
+		let c = o.place && "start" in o.place ? o.place.start : o.place;
+		this.ancestors = o.ancestors || void 0, this.cause = o.cause || void 0, this.column = c ? c.column : void 0, this.fatal = void 0, this.file = "", this.message = a, this.line = c ? c.line : void 0, this.name = i(o.place) || "1:1", this.place = o.place || void 0, this.reason = this.message, this.ruleId = o.ruleId || void 0, this.source = o.source || void 0, this.stack = s && o.cause && typeof o.cause.stack == "string" ? o.cause.stack : "", this.actual = void 0, this.expected = void 0, this.note = void 0, this.url = void 0;
+	}
+};
+c.prototype.file = "", c.prototype.name = "", c.prototype.reason = "", c.prototype.message = "", c.prototype.stack = "", c.prototype.column = void 0, c.prototype.line = void 0, c.prototype.ancestors = void 0, c.prototype.cause = void 0, c.prototype.fatal = void 0, c.prototype.place = void 0, c.prototype.ruleId = void 0, c.prototype.source = void 0;
+// node_modules/vfile/lib/minurl.shared.js
+function l(e) {
+	return !!(typeof e == "object" && e && "href" in e && e.href && "protocol" in e && e.protocol && e.auth === void 0);
+}
+// node_modules/vfile/lib/index.js
+var u = [
+	"history",
+	"path",
+	"basename",
+	"stem",
+	"extname",
+	"dirname"
+], d = class {
+	constructor(e) {
+		let t;
+		t = e ? l(e) ? { path: e } : typeof e == "string" || h(e) ? { value: e } : e : {}, this.cwd = "cwd" in t ? "" : n.cwd(), this.data = {}, this.history = [], this.messages = [], this.value, this.map, this.result, this.stored;
+		let r = -1;
+		for (; ++r < u.length;) {
+			let e = u[r];
+			e in t && t[e] !== void 0 && t[e] !== null && (this[e] = e === "history" ? [...t[e]] : t[e]);
+		}
+		let i;
+		for (i in t) u.includes(i) || (this[i] = t[i]);
+	}
+	get basename() {
+		return typeof this.path == "string" ? t.basename(this.path) : void 0;
+	}
+	set basename(e) {
+		p(e, "basename"), f(e, "basename"), this.path = t.join(this.dirname || "", e);
+	}
+	get dirname() {
+		return typeof this.path == "string" ? t.dirname(this.path) : void 0;
+	}
+	set dirname(e) {
+		m(this.basename, "dirname"), this.path = t.join(e || "", this.basename);
+	}
+	get extname() {
+		return typeof this.path == "string" ? t.extname(this.path) : void 0;
+	}
+	set extname(e) {
+		if (f(e, "extname"), m(this.dirname, "extname"), e) {
+			if (e.codePointAt(0) !== 46) throw Error("`extname` must start with `.`");
+			if (e.includes(".", 1)) throw Error("`extname` cannot contain multiple dots");
+		}
+		this.path = t.join(this.dirname, this.stem + (e || ""));
+	}
+	get path() {
+		return this.history[this.history.length - 1];
+	}
+	set path(e) {
+		l(e) && (e = r(e)), p(e, "path"), this.path !== e && this.history.push(e);
+	}
+	get stem() {
+		return typeof this.path == "string" ? t.basename(this.path, this.extname) : void 0;
+	}
+	set stem(e) {
+		p(e, "stem"), f(e, "stem"), this.path = t.join(this.dirname || "", e + (this.extname || ""));
+	}
+	fail(e, t, n) {
+		let r = this.message(e, t, n);
+		throw r.fatal = !0, r;
+	}
+	info(e, t, n) {
+		let r = this.message(e, t, n);
+		return r.fatal = void 0, r;
+	}
+	message(e, t, n) {
+		let r = new c(e, t, n);
+		return this.path && (r.name = this.path + ":" + r.name, r.file = this.path), r.fatal = !1, this.messages.push(r), r;
+	}
+	toString(e) {
+		return this.value === void 0 ? "" : typeof this.value == "string" ? this.value : new TextDecoder(e || void 0).decode(this.value);
+	}
+};
+function f(e, n) {
+	if (e && e.includes(t.sep)) throw Error("`" + n + "` cannot be a path: did not expect `" + t.sep + "`");
+}
+function p(e, t) {
+	if (!e) throw Error("`" + t + "` cannot be empty");
+}
+function m(e, t) {
+	if (!e) throw Error("Setting `" + t + "` requires `path` to be set too");
+}
+function h(e) {
+	return !!(e && typeof e == "object" && "byteLength" in e && "byteOffset" in e);
+}
+export { c as n, i as r, d as t };
+
+//# sourceMappingURL=lib-LwqA_W3J.js.map

package/dist/chunks/lib-LwqA_W3J.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lib-LwqA_W3J.js","names":["_objectSpread2","minpath","minproc","urlToPath","stringifyPosition","value","position","point","index","pos","VFileMessage","optionsOrParentOrPlace","reason","options","legacyCause","causeOrReason","origin","parent","start","isUrl","fileUrlOrPath","order","VFile","isUint8Array","field","assertNonEmpty","basename","assertPart","assertPath","dirname","extname","path","stem","message","encoding","part","name"],"sources":["../../node_modules/unist-util-stringify-position/lib/index.js","../../node_modules/vfile-message/lib/index.js","../../node_modules/vfile/lib/minurl.shared.js","../../node_modules/vfile/lib/index.js"],"sourcesContent":["/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Position} Position\n */\n\n/**\n * @typedef NodeLike\n * @property {string} type\n * @property {PositionLike | null | undefined} [position]\n *\n * @typedef PointLike\n * @property {number | null | undefined} [line]\n * @property {number | null | undefined} [column]\n * @property {number | null | undefined} [offset]\n *\n * @typedef PositionLike\n * @property {PointLike | null | undefined} [start]\n * @property {PointLike | null | undefined} [end]\n */\n\n/**\n * Serialize the positional info of a point, position (start and end points),\n * or node.\n *\n * @param {Node | NodeLike | Point | PointLike | Position | PositionLike | null | undefined} [value]\n *   Node, position, or point.\n * @returns {string}\n *   Pretty printed positional info of a node (`string`).\n *\n *   In the format of a range `ls:cs-le:ce` (when given `node` or `position`)\n *   or a point `l:c` (when given `point`), where `l` stands for line, `c` for\n *   column, `s` for `start`, and `e` for end.\n *   An empty string (`''`) is returned if the given value is neither `node`,\n *   `position`, nor `point`.\n */\nexport function stringifyPosition(value) {\n  // Nothing.\n  if (!value || typeof value !== 'object') {\n    return ''\n  }\n\n  // Node.\n  if ('position' in value || 'type' in value) {\n    return position(value.position)\n  }\n\n  // Position.\n  if ('start' in value || 'end' in value) {\n    return position(value)\n  }\n\n  // Point.\n  if ('line' in value || 'column' in value) {\n    return point(value)\n  }\n\n  // ?\n  return ''\n}\n\n/**\n * @param {Point | PointLike | null | undefined} point\n * @returns {string}\n */\nfunction point(point) {\n  return index(point && point.line) + ':' + index(point && point.column)\n}\n\n/**\n * @param {Position | PositionLike | null | undefined} pos\n * @returns {string}\n */\nfunction position(pos) {\n  return point(pos && pos.start) + '-' + point(pos && pos.end)\n}\n\n/**\n * @param {number | null | undefined} value\n * @returns {number}\n */\nfunction index(value) {\n  return value && typeof value === 'number' ? value : 1\n}\n","/**\n * @import {Node, Point, Position} from 'unist'\n */\n\n/**\n * @typedef {object & {type: string, position?: Position | undefined}} NodeLike\n *\n * @typedef Options\n *   Configuration.\n * @property {Array<Node> | null | undefined} [ancestors]\n *   Stack of (inclusive) ancestor nodes surrounding the message (optional).\n * @property {Error | null | undefined} [cause]\n *   Original error cause of the message (optional).\n * @property {Point | Position | null | undefined} [place]\n *   Place of message (optional).\n * @property {string | null | undefined} [ruleId]\n *   Category of message (optional, example: `'my-rule'`).\n * @property {string | null | undefined} [source]\n *   Namespace of who sent the message (optional, example: `'my-package'`).\n */\n\nimport {stringifyPosition} from 'unist-util-stringify-position'\n\n/**\n * Message.\n */\nexport class VFileMessage extends Error {\n  /**\n   * Create a message for `reason`.\n   *\n   * > 🪦 **Note**: also has obsolete signatures.\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Options | null | undefined} [options]\n   * @returns\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {string} reason\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @param {Error | VFileMessage | string} causeOrReason\n   *   Reason for message, should use markdown.\n   * @param {Node | NodeLike | Options | Point | Position | string | null | undefined} [optionsOrParentOrPlace]\n   *   Configuration (optional).\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns\n   *   Instance of `VFileMessage`.\n   */\n  // eslint-disable-next-line complexity\n  constructor(causeOrReason, optionsOrParentOrPlace, origin) {\n    super()\n\n    if (typeof optionsOrParentOrPlace === 'string') {\n      origin = optionsOrParentOrPlace\n      optionsOrParentOrPlace = undefined\n    }\n\n    /** @type {string} */\n    let reason = ''\n    /** @type {Options} */\n    let options = {}\n    let legacyCause = false\n\n    if (optionsOrParentOrPlace) {\n      // Point.\n      if (\n        'line' in optionsOrParentOrPlace &&\n        'column' in optionsOrParentOrPlace\n      ) {\n        options = {place: optionsOrParentOrPlace}\n      }\n      // Position.\n      else if (\n        'start' in optionsOrParentOrPlace &&\n        'end' in optionsOrParentOrPlace\n      ) {\n        options = {place: optionsOrParentOrPlace}\n      }\n      // Node.\n      else if ('type' in optionsOrParentOrPlace) {\n        options = {\n          ancestors: [optionsOrParentOrPlace],\n          place: optionsOrParentOrPlace.position\n        }\n      }\n      // Options.\n      else {\n        options = {...optionsOrParentOrPlace}\n      }\n    }\n\n    if (typeof causeOrReason === 'string') {\n      reason = causeOrReason\n    }\n    // Error.\n    else if (!options.cause && causeOrReason) {\n      legacyCause = true\n      reason = causeOrReason.message\n      options.cause = causeOrReason\n    }\n\n    if (!options.ruleId && !options.source && typeof origin === 'string') {\n      const index = origin.indexOf(':')\n\n      if (index === -1) {\n        options.ruleId = origin\n      } else {\n        options.source = origin.slice(0, index)\n        options.ruleId = origin.slice(index + 1)\n      }\n    }\n\n    if (!options.place && options.ancestors && options.ancestors) {\n      const parent = options.ancestors[options.ancestors.length - 1]\n\n      if (parent) {\n        options.place = parent.position\n      }\n    }\n\n    const start =\n      options.place && 'start' in options.place\n        ? options.place.start\n        : options.place\n\n    /**\n     * Stack of ancestor nodes surrounding the message.\n     *\n     * @type {Array<Node> | undefined}\n     */\n    this.ancestors = options.ancestors || undefined\n\n    /**\n     * Original error cause of the message.\n     *\n     * @type {Error | undefined}\n     */\n    this.cause = options.cause || undefined\n\n    /**\n     * Starting column of message.\n     *\n     * @type {number | undefined}\n     */\n    this.column = start ? start.column : undefined\n\n    /**\n     * State of problem.\n     *\n     * * `true` — error, file not usable\n     * * `false` — warning, change may be needed\n     * * `undefined` — change likely not needed\n     *\n     * @type {boolean | null | undefined}\n     */\n    this.fatal = undefined\n\n    /**\n     * Path of a file (used throughout the `VFile` ecosystem).\n     *\n     * @type {string | undefined}\n     */\n    this.file = ''\n\n    // Field from `Error`.\n    /**\n     * Reason for message.\n     *\n     * @type {string}\n     */\n    this.message = reason\n\n    /**\n     * Starting line of error.\n     *\n     * @type {number | undefined}\n     */\n    this.line = start ? start.line : undefined\n\n    // Field from `Error`.\n    /**\n     * Serialized positional info of message.\n     *\n     * On normal errors, this would be something like `ParseError`, buit in\n     * `VFile` messages we use this space to show where an error happened.\n     */\n    this.name = stringifyPosition(options.place) || '1:1'\n\n    /**\n     * Place of message.\n     *\n     * @type {Point | Position | undefined}\n     */\n    this.place = options.place || undefined\n\n    /**\n     * Reason for message, should use markdown.\n     *\n     * @type {string}\n     */\n    this.reason = this.message\n\n    /**\n     * Category of message (example: `'my-rule'`).\n     *\n     * @type {string | undefined}\n     */\n    this.ruleId = options.ruleId || undefined\n\n    /**\n     * Namespace of message (example: `'my-package'`).\n     *\n     * @type {string | undefined}\n     */\n    this.source = options.source || undefined\n\n    // Field from `Error`.\n    /**\n     * Stack of message.\n     *\n     * This is used by normal errors to show where something happened in\n     * programming code, irrelevant for `VFile` messages,\n     *\n     * @type {string}\n     */\n    this.stack =\n      legacyCause && options.cause && typeof options.cause.stack === 'string'\n        ? options.cause.stack\n        : ''\n\n    // The following fields are “well known”.\n    // Not standard.\n    // Feel free to add other non-standard fields to your messages.\n\n    /**\n     * Specify the source value that’s being reported, which is deemed\n     * incorrect.\n     *\n     * @type {string | undefined}\n     */\n    this.actual = undefined\n\n    /**\n     * Suggest acceptable values that can be used instead of `actual`.\n     *\n     * @type {Array<string> | undefined}\n     */\n    this.expected = undefined\n\n    /**\n     * Long form description of the message (you should use markdown).\n     *\n     * @type {string | undefined}\n     */\n    this.note = undefined\n\n    /**\n     * Link to docs for the message.\n     *\n     * > 👉 **Note**: this must be an absolute URL that can be passed as `x`\n     * > to `new URL(x)`.\n     *\n     * @type {string | undefined}\n     */\n    this.url = undefined\n  }\n}\n\nVFileMessage.prototype.file = ''\nVFileMessage.prototype.name = ''\nVFileMessage.prototype.reason = ''\nVFileMessage.prototype.message = ''\nVFileMessage.prototype.stack = ''\nVFileMessage.prototype.column = undefined\nVFileMessage.prototype.line = undefined\nVFileMessage.prototype.ancestors = undefined\nVFileMessage.prototype.cause = undefined\nVFileMessage.prototype.fatal = undefined\nVFileMessage.prototype.place = undefined\nVFileMessage.prototype.ruleId = undefined\nVFileMessage.prototype.source = undefined\n","/**\n * Checks if a value has the shape of a WHATWG URL object.\n *\n * Using a symbol or instanceof would not be able to recognize URL objects\n * coming from other implementations (e.g. in Electron), so instead we are\n * checking some well known properties for a lack of a better test.\n *\n * We use `href` and `protocol` as they are the only properties that are\n * easy to retrieve and calculate due to the lazy nature of the getters.\n *\n * We check for auth attribute to distinguish legacy url instance with\n * WHATWG URL instance.\n *\n * @param {unknown} fileUrlOrPath\n *   File path or URL.\n * @returns {fileUrlOrPath is URL}\n *   Whether it’s a URL.\n */\n// From: <https://github.com/nodejs/node/blob/6a3403c/lib/internal/url.js#L720>\nexport function isUrl(fileUrlOrPath) {\n  return Boolean(\n    fileUrlOrPath !== null &&\n      typeof fileUrlOrPath === 'object' &&\n      'href' in fileUrlOrPath &&\n      fileUrlOrPath.href &&\n      'protocol' in fileUrlOrPath &&\n      fileUrlOrPath.protocol &&\n      // @ts-expect-error: indexing is fine.\n      fileUrlOrPath.auth === undefined\n  )\n}\n","/**\n * @import {Node, Point, Position} from 'unist'\n * @import {Options as MessageOptions} from 'vfile-message'\n * @import {Compatible, Data, Map, Options, Value} from 'vfile'\n */\n\n/**\n * @typedef {object & {type: string, position?: Position | undefined}} NodeLike\n */\n\nimport {VFileMessage} from 'vfile-message'\nimport {minpath} from '#minpath'\nimport {minproc} from '#minproc'\nimport {urlToPath, isUrl} from '#minurl'\n\n/**\n * Order of setting (least specific to most), we need this because otherwise\n * `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a\n * stem can be set.\n */\nconst order = /** @type {const} */ ([\n  'history',\n  'path',\n  'basename',\n  'stem',\n  'extname',\n  'dirname'\n])\n\nexport class VFile {\n  /**\n   * Create a new virtual file.\n   *\n   * `options` is treated as:\n   *\n   * *   `string` or `Uint8Array` — `{value: options}`\n   * *   `URL` — `{path: options}`\n   * *   `VFile` — shallow copies its data over to the new file\n   * *   `object` — all fields are shallow copied over to the new file\n   *\n   * Path related fields are set in the following order (least specific to\n   * most specific): `history`, `path`, `basename`, `stem`, `extname`,\n   * `dirname`.\n   *\n   * You cannot set `dirname` or `extname` without setting either `history`,\n   * `path`, `basename`, or `stem` too.\n   *\n   * @param {Compatible | null | undefined} [value]\n   *   File value.\n   * @returns\n   *   New instance.\n   */\n  constructor(value) {\n    /** @type {Options | VFile} */\n    let options\n\n    if (!value) {\n      options = {}\n    } else if (isUrl(value)) {\n      options = {path: value}\n    } else if (typeof value === 'string' || isUint8Array(value)) {\n      options = {value}\n    } else {\n      options = value\n    }\n\n    /* eslint-disable no-unused-expressions */\n\n    /**\n     * Base of `path` (default: `process.cwd()` or `'/'` in browsers).\n     *\n     * @type {string}\n     */\n    // Prevent calling `cwd` (which could be expensive) if it’s not needed;\n    // the empty string will be overridden in the next block.\n    this.cwd = 'cwd' in options ? '' : minproc.cwd()\n\n    /**\n     * Place to store custom info (default: `{}`).\n     *\n     * It’s OK to store custom data directly on the file but moving it to\n     * `data` is recommended.\n     *\n     * @type {Data}\n     */\n    this.data = {}\n\n    /**\n     * List of file paths the file moved between.\n     *\n     * The first is the original path and the last is the current path.\n     *\n     * @type {Array<string>}\n     */\n    this.history = []\n\n    /**\n     * List of messages associated with the file.\n     *\n     * @type {Array<VFileMessage>}\n     */\n    this.messages = []\n\n    /**\n     * Raw value.\n     *\n     * @type {Value}\n     */\n    this.value\n\n    // The below are non-standard, they are “well-known”.\n    // As in, used in several tools.\n    /**\n     * Source map.\n     *\n     * This type is equivalent to the `RawSourceMap` type from the `source-map`\n     * module.\n     *\n     * @type {Map | null | undefined}\n     */\n    this.map\n\n    /**\n     * Custom, non-string, compiled, representation.\n     *\n     * This is used by unified to store non-string results.\n     * One example is when turning markdown into React nodes.\n     *\n     * @type {unknown}\n     */\n    this.result\n\n    /**\n     * Whether a file was saved to disk.\n     *\n     * This is used by vfile reporters.\n     *\n     * @type {boolean}\n     */\n    this.stored\n    /* eslint-enable no-unused-expressions */\n\n    // Set path related properties in the correct order.\n    let index = -1\n\n    while (++index < order.length) {\n      const field = order[index]\n\n      // Note: we specifically use `in` instead of `hasOwnProperty` to accept\n      // `vfile`s too.\n      if (\n        field in options &&\n        options[field] !== undefined &&\n        options[field] !== null\n      ) {\n        // @ts-expect-error: TS doesn’t understand basic reality.\n        this[field] = field === 'history' ? [...options[field]] : options[field]\n      }\n    }\n\n    /** @type {string} */\n    let field\n\n    // Set non-path related properties.\n    for (field in options) {\n      // @ts-expect-error: fine to set other things.\n      if (!order.includes(field)) {\n        // @ts-expect-error: fine to set other things.\n        this[field] = options[field]\n      }\n    }\n  }\n\n  /**\n   * Get the basename (including extname) (example: `'index.min.js'`).\n   *\n   * @returns {string | undefined}\n   *   Basename.\n   */\n  get basename() {\n    return typeof this.path === 'string'\n      ? minpath.basename(this.path)\n      : undefined\n  }\n\n  /**\n   * Set basename (including extname) (`'index.min.js'`).\n   *\n   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n   * on windows).\n   * Cannot be nullified (use `file.path = file.dirname` instead).\n   *\n   * @param {string} basename\n   *   Basename.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set basename(basename) {\n    assertNonEmpty(basename, 'basename')\n    assertPart(basename, 'basename')\n    this.path = minpath.join(this.dirname || '', basename)\n  }\n\n  /**\n   * Get the parent path (example: `'~'`).\n   *\n   * @returns {string | undefined}\n   *   Dirname.\n   */\n  get dirname() {\n    return typeof this.path === 'string'\n      ? minpath.dirname(this.path)\n      : undefined\n  }\n\n  /**\n   * Set the parent path (example: `'~'`).\n   *\n   * Cannot be set if there’s no `path` yet.\n   *\n   * @param {string | undefined} dirname\n   *   Dirname.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set dirname(dirname) {\n    assertPath(this.basename, 'dirname')\n    this.path = minpath.join(dirname || '', this.basename)\n  }\n\n  /**\n   * Get the extname (including dot) (example: `'.js'`).\n   *\n   * @returns {string | undefined}\n   *   Extname.\n   */\n  get extname() {\n    return typeof this.path === 'string'\n      ? minpath.extname(this.path)\n      : undefined\n  }\n\n  /**\n   * Set the extname (including dot) (example: `'.js'`).\n   *\n   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n   * on windows).\n   * Cannot be set if there’s no `path` yet.\n   *\n   * @param {string | undefined} extname\n   *   Extname.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set extname(extname) {\n    assertPart(extname, 'extname')\n    assertPath(this.dirname, 'extname')\n\n    if (extname) {\n      if (extname.codePointAt(0) !== 46 /* `.` */) {\n        throw new Error('`extname` must start with `.`')\n      }\n\n      if (extname.includes('.', 1)) {\n        throw new Error('`extname` cannot contain multiple dots')\n      }\n    }\n\n    this.path = minpath.join(this.dirname, this.stem + (extname || ''))\n  }\n\n  /**\n   * Get the full path (example: `'~/index.min.js'`).\n   *\n   * @returns {string}\n   *   Path.\n   */\n  get path() {\n    return this.history[this.history.length - 1]\n  }\n\n  /**\n   * Set the full path (example: `'~/index.min.js'`).\n   *\n   * Cannot be nullified.\n   * You can set a file URL (a `URL` object with a `file:` protocol) which will\n   * be turned into a path with `url.fileURLToPath`.\n   *\n   * @param {URL | string} path\n   *   Path.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set path(path) {\n    if (isUrl(path)) {\n      path = urlToPath(path)\n    }\n\n    assertNonEmpty(path, 'path')\n\n    if (this.path !== path) {\n      this.history.push(path)\n    }\n  }\n\n  /**\n   * Get the stem (basename w/o extname) (example: `'index.min'`).\n   *\n   * @returns {string | undefined}\n   *   Stem.\n   */\n  get stem() {\n    return typeof this.path === 'string'\n      ? minpath.basename(this.path, this.extname)\n      : undefined\n  }\n\n  /**\n   * Set the stem (basename w/o extname) (example: `'index.min'`).\n   *\n   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n   * on windows).\n   * Cannot be nullified (use `file.path = file.dirname` instead).\n   *\n   * @param {string} stem\n   *   Stem.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set stem(stem) {\n    assertNonEmpty(stem, 'stem')\n    assertPart(stem, 'stem')\n    this.path = minpath.join(this.dirname || '', stem + (this.extname || ''))\n  }\n\n  // Normal prototypal methods.\n  /**\n   * Create a fatal message for `reason` associated with the file.\n   *\n   * The `fatal` field of the message is set to `true` (error; file not usable)\n   * and the `file` field is set to the current file path.\n   * The message is added to the `messages` field on `file`.\n   *\n   * > 🪦 **Note**: also has obsolete signatures.\n   *\n   * @overload\n   * @param {string} reason\n   * @param {MessageOptions | null | undefined} [options]\n   * @returns {never}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @param {Error | VFileMessage | string} causeOrReason\n   *   Reason for message, should use markdown.\n   * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]\n   *   Configuration (optional).\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns {never}\n   *   Never.\n   * @throws {VFileMessage}\n   *   Message.\n   */\n  fail(causeOrReason, optionsOrParentOrPlace, origin) {\n    // @ts-expect-error: the overloads are fine.\n    const message = this.message(causeOrReason, optionsOrParentOrPlace, origin)\n\n    message.fatal = true\n\n    throw message\n  }\n\n  /**\n   * Create an info message for `reason` associated with the file.\n   *\n   * The `fatal` field of the message is set to `undefined` (info; change\n   * likely not needed) and the `file` field is set to the current file path.\n   * The message is added to the `messages` field on `file`.\n   *\n   * > 🪦 **Note**: also has obsolete signatures.\n   *\n   * @overload\n   * @param {string} reason\n   * @param {MessageOptions | null | undefined} [options]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @param {Error | VFileMessage | string} causeOrReason\n   *   Reason for message, should use markdown.\n   * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]\n   *   Configuration (optional).\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns {VFileMessage}\n   *   Message.\n   */\n  info(causeOrReason, optionsOrParentOrPlace, origin) {\n    // @ts-expect-error: the overloads are fine.\n    const message = this.message(causeOrReason, optionsOrParentOrPlace, origin)\n\n    message.fatal = undefined\n\n    return message\n  }\n\n  /**\n   * Create a message for `reason` associated with the file.\n   *\n   * The `fatal` field of the message is set to `false` (warning; change may be\n   * needed) and the `file` field is set to the current file path.\n   * The message is added to the `messages` field on `file`.\n   *\n   * > 🪦 **Note**: also has obsolete signatures.\n   *\n   * @overload\n   * @param {string} reason\n   * @param {MessageOptions | null | undefined} [options]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @param {Error | VFileMessage | string} causeOrReason\n   *   Reason for message, should use markdown.\n   * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]\n   *   Configuration (optional).\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns {VFileMessage}\n   *   Message.\n   */\n  message(causeOrReason, optionsOrParentOrPlace, origin) {\n    const message = new VFileMessage(\n      // @ts-expect-error: the overloads are fine.\n      causeOrReason,\n      optionsOrParentOrPlace,\n      origin\n    )\n\n    if (this.path) {\n      message.name = this.path + ':' + message.name\n      message.file = this.path\n    }\n\n    message.fatal = false\n\n    this.messages.push(message)\n\n    return message\n  }\n\n  /**\n   * Serialize the file.\n   *\n   * > **Note**: which encodings are supported depends on the engine.\n   * > For info on Node.js, see:\n   * > <https://nodejs.org/api/util.html#whatwg-supported-encodings>.\n   *\n   * @param {string | null | undefined} [encoding='utf8']\n   *   Character encoding to understand `value` as when it’s a `Uint8Array`\n   *   (default: `'utf-8'`).\n   * @returns {string}\n   *   Serialized file.\n   */\n  toString(encoding) {\n    if (this.value === undefined) {\n      return ''\n    }\n\n    if (typeof this.value === 'string') {\n      return this.value\n    }\n\n    const decoder = new TextDecoder(encoding || undefined)\n    return decoder.decode(this.value)\n  }\n}\n\n/**\n * Assert that `part` is not a path (as in, does not contain `path.sep`).\n *\n * @param {string | null | undefined} part\n *   File path part.\n * @param {string} name\n *   Part name.\n * @returns {undefined}\n *   Nothing.\n */\nfunction assertPart(part, name) {\n  if (part && part.includes(minpath.sep)) {\n    throw new Error(\n      '`' + name + '` cannot be a path: did not expect `' + minpath.sep + '`'\n    )\n  }\n}\n\n/**\n * Assert that `part` is not empty.\n *\n * @param {string | undefined} part\n *   Thing.\n * @param {string} name\n *   Part name.\n * @returns {asserts part is string}\n *   Nothing.\n */\nfunction assertNonEmpty(part, name) {\n  if (!part) {\n    throw new Error('`' + name + '` cannot be empty')\n  }\n}\n\n/**\n * Assert `path` exists.\n *\n * @param {string | undefined} path\n *   Path.\n * @param {string} name\n *   Dependency name.\n * @returns {asserts path is string}\n *   Nothing.\n */\nfunction assertPath(path, name) {\n  if (!path) {\n    throw new Error('Setting `' + name + '` requires `path` to be set too')\n  }\n}\n\n/**\n * Assert `value` is an `Uint8Array`.\n *\n * @param {unknown} value\n *   thing.\n * @returns {value is Uint8Array}\n *   Whether `value` is an `Uint8Array`.\n */\nfunction isUint8Array(value) {\n  return Boolean(\n    value &&\n      typeof value === 'object' &&\n      'byteLength' in value &&\n      'byteOffset' in value\n  )\n}\n"],"ignoreList":[0,1,2,3],"mappings":"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"}

package/dist/chunks/longest-streak-DZE_EqsU.js

@@ -0,0 +1,10 @@
+// node_modules/longest-streak/index.js
+function e(e, t) {
+	let n = String(e), r = n.indexOf(t), i = r, a = 0, o = 0;
+	if (typeof t != "string") throw TypeError("Expected substring");
+	for (; r !== -1;) r === i ? ++a > o && (o = a) : a = 1, i = r + t.length, r = n.indexOf(t, i);
+	return o;
+}
+export { e as t };
+
+//# sourceMappingURL=longest-streak-DZE_EqsU.js.map

package/dist/chunks/longest-streak-DZE_EqsU.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"longest-streak-DZE_EqsU.js","names":["longestStreak","source","value","index","substring","expected","count","max"],"sources":["../../node_modules/longest-streak/index.js"],"sourcesContent":["/**\n * Get the count of the longest repeating streak of `substring` in `value`.\n *\n * @param {string} value\n *   Content to search in.\n * @param {string} substring\n *   Substring to look for, typically one character.\n * @returns {number}\n *   Count of most frequent adjacent `substring`s in `value`.\n */\nexport function longestStreak(value, substring) {\n  const source = String(value)\n  let index = source.indexOf(substring)\n  let expected = index\n  let count = 0\n  let max = 0\n\n  if (typeof substring !== 'string') {\n    throw new TypeError('Expected substring')\n  }\n\n  while (index !== -1) {\n    if (index === expected) {\n      if (++count > max) {\n        max = count\n      }\n    } else {\n      count = 1\n    }\n\n    expected = index + substring.length\n    index = source.indexOf(substring, expected)\n  }\n\n  return max\n}\n"],"ignoreList":[0],"mappings":";AAUA,SAAgBA,EAAc,GAAO,GAAW;CAC9C,IAAMC,IAAS,OAAOC,CAAK,GACvBC,IAAQF,EAAO,QAAQG,CAAS,GAChCC,IAAWF,GACXG,IAAQ,GACRC,IAAM;CAEV,IAAI,OAAOH,KAAc,UACvB,MAAU,UAAU,oBAAoB;CAG1C,OAAOD,MAAU,KAUf,AATIA,MAAUE,IACR,EAAEC,IAAQC,MACZ,IAAMD,KAGR,IAAQ,GAGV,IAAWH,IAAQC,EAAU,QAC7B,IAAQH,EAAO,QAAQG,GAAWC,CAAQ;CAG5C,OAAOE;AACT"}

package/dist/chunks/micromark-factory-space-Db040TnW.js

@@ -0,0 +1,139 @@
+// node_modules/micromark-util-character/index.js
+var e = f(/[A-Za-z]/), t = f(/[\dA-Za-z]/), n = f(/[#-'*+\--9=?A-Z^-~]/);
+function r(e) {
+	return e !== null && (e < 32 || e === 127);
+}
+var i = f(/\d/), a = f(/[\dA-Fa-f]/), o = f(/[!-/:-@[-`{-~]/);
+function s(e) {
+	return e !== null && e < -2;
+}
+function c(e) {
+	return e !== null && (e < 0 || e === 32);
+}
+function l(e) {
+	return e === -2 || e === -1 || e === 32;
+}
+var u = f(RegExp("\\p{P}|\\p{S}", "u")), d = f(/\s/);
+function f(e) {
+	return t;
+	function t(t) {
+		return t !== null && t > -1 && e.test(String.fromCharCode(t));
+	}
+}
+// node_modules/unist-util-is/lib/index.js
+var p = (function(e) {
+	if (e == null) return v;
+	if (typeof e == "function") return _(e);
+	if (typeof e == "object") return Array.isArray(e) ? m(e) : h(e);
+	if (typeof e == "string") return g(e);
+	throw Error("Expected function, string, or object as test");
+});
+function m(e) {
+	let t = [], n = -1;
+	for (; ++n < e.length;) t[n] = p(e[n]);
+	return _(r);
+	function r(...e) {
+		let n = -1;
+		for (; ++n < t.length;) if (t[n].apply(this, e)) return !0;
+		return !1;
+	}
+}
+function h(e) {
+	let t = e;
+	return _(n);
+	function n(n) {
+		let r = n, i;
+		for (i in e) if (r[i] !== t[i]) return !1;
+		return !0;
+	}
+}
+function g(e) {
+	return _(t);
+	function t(t) {
+		return t && t.type === e;
+	}
+}
+function _(e) {
+	return t;
+	function t(t, n, r) {
+		return !!(y(t) && e.call(this, t, typeof n == "number" ? n : void 0, r || void 0));
+	}
+}
+function v() {
+	return !0;
+}
+function y(e) {
+	return typeof e == "object" && !!e && "type" in e;
+}
+// node_modules/unist-util-visit-parents/lib/color.node.js
+function b(e) {
+	return "\x1B[33m" + e + "\x1B[39m";
+}
+// node_modules/unist-util-visit-parents/lib/index.js
+var x = [], S = "skip";
+function C(e, t, n, r) {
+	let i;
+	typeof t == "function" && typeof n != "function" ? (r = n, n = t) : i = t;
+	let a = p(i), o = r ? -1 : 1;
+	s(e, void 0, [])();
+	function s(e, i, c) {
+		let l = e && typeof e == "object" ? e : {};
+		if (typeof l.type == "string") {
+			let t = typeof l.tagName == "string" ? l.tagName : typeof l.name == "string" ? l.name : void 0;
+			Object.defineProperty(u, "name", { value: "node (" + b(e.type + (t ? "<" + t + ">" : "")) + ")" });
+		}
+		return u;
+		function u() {
+			let l = x, u, d, f;
+			if ((!t || a(e, i, c[c.length - 1] || void 0)) && (l = w(n(e, c)), l[0] === !1)) return l;
+			if ("children" in e && e.children) {
+				let t = e;
+				if (t.children && l[0] !== "skip") for (d = (r ? t.children.length : -1) + o, f = c.concat(t); d > -1 && d < t.children.length;) {
+					let e = t.children[d];
+					if (u = s(e, d, f)(), u[0] === !1) return u;
+					d = typeof u[1] == "number" ? u[1] : d + o;
+				}
+			}
+			return l;
+		}
+	}
+}
+function w(e) {
+	return Array.isArray(e) ? e : typeof e == "number" ? [!0, e] : e == null ? x : [e];
+}
+// node_modules/unist-util-visit/lib/index.js
+function T(e, t, n, r) {
+	let i, a, o;
+	typeof t == "function" && typeof n != "function" ? (a = void 0, o = t, i = n) : (a = t, o = n, i = r), C(e, a, s, i);
+	function s(e, t) {
+		let n = t[t.length - 1], r = n ? n.children.indexOf(e) : void 0;
+		return o(e, r, n);
+	}
+}
+// node_modules/micromark-factory-space/index.js
+function E(e, t, n, r) {
+	let i = r ? r - 1 : Infinity, a = 0;
+	return o;
+	function o(r) {
+		return l(r) ? (e.enter(n), s(r)) : t(r);
+	}
+	function s(r) {
+		return l(r) && a++ < i ? (e.consume(r), s) : (e.exit(n), t(r));
+	}
+}
+function D(e, t, n, r, i, a) {
+	let o = 0;
+	return s;
+	function s(t) {
+		return a > 0 && l(t) ? (e.enter(r), c(t)) : u(t);
+	}
+	function c(t) {
+		return l(t) && o < a ? (e.consume(t), o++, c) : (e.exit(r), u(t));
+	}
+	function u(e) {
+		return o >= i ? t(e) : n(e);
+	}
+}
+export { u as _, C as a, t as c, i as d, a as f, l as g, c as h, S as i, n as l, s as m, D as n, p as o, o as p, T as r, e as s, E as t, r as u, d as v };
+
+//# sourceMappingURL=micromark-factory-space-Db040TnW.js.map

package/dist/chunks/micromark-factory-space-Db040TnW.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"micromark-factory-space-Db040TnW.js","names":["asciiAlpha","regexCheck","asciiAlphanumeric","asciiAtext","asciiControl","code","asciiDigit","asciiHexDigit","asciiPunctuation","markdownLineEnding","markdownLineEndingOrSpace","markdownSpace","unicodePunctuation","unicodeWhitespace","check","regex","convert","test","ok","castFactory","anyFactory","propertiesFactory","typeFactory","checks","index","tests","any","parameters","checkAsRecord","all","nodeAsRecord","node","key","type","looksLikeANode","value","testFunction","parent","color","d","empty","SKIP","visitParents","visitor","is","step","reverse","tree","factory","name","visit","result","subresult","offset","grandparents","parents","toResult","nodeAsParent","child","testOrVisitor","visitorOrReverse","maybeReverse","overload","factorySpace","limit","max","size","start","effects","prefix","factorySpaceMinMax","after","min","nok"],"sources":["../../node_modules/micromark-util-character/index.js","../../node_modules/unist-util-is/lib/index.js","../../node_modules/unist-util-visit-parents/lib/color.node.js","../../node_modules/unist-util-visit-parents/lib/index.js","../../node_modules/unist-util-visit/lib/index.js","../../node_modules/micromark-factory-space/index.js"],"sourcesContent":["/**\n * @import {Code} from 'micromark-util-types'\n */\n\n/**\n * Check whether the character code represents an ASCII alpha (`a` through `z`,\n * case insensitive).\n *\n * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.\n *\n * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)\n * to U+005A (`Z`).\n *\n * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)\n * to U+007A (`z`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAlpha = regexCheck(/[A-Za-z]/);\n\n/**\n * Check whether the character code represents an ASCII alphanumeric (`a`\n * through `z`, case insensitive, or `0` through `9`).\n *\n * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha\n * (see `asciiAlpha`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/);\n\n/**\n * Check whether the character code represents an ASCII atext.\n *\n * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in\n * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),\n * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F\n * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E\n * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE\n * (`{`) to U+007E TILDE (`~`).\n *\n * See:\n * **\\[RFC5322]**:\n * [Internet Message Format](https://tools.ietf.org/html/rfc5322).\n * P. Resnick.\n * IETF.\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/);\n\n/**\n * Check whether a character code is an ASCII control character.\n *\n * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)\n * to U+001F (US), or U+007F (DEL).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function asciiControl(code) {\n  return (\n    // Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code !== null && (code < 32 || code === 127)\n  );\n}\n\n/**\n * Check whether the character code represents an ASCII digit (`0` through `9`).\n *\n * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to\n * U+0039 (`9`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiDigit = regexCheck(/\\d/);\n\n/**\n * Check whether the character code represents an ASCII hex digit (`a` through\n * `f`, case insensitive, or `0` through `9`).\n *\n * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex\n * digit, or an ASCII lower hex digit.\n *\n * An **ASCII upper hex digit** is a character in the inclusive range U+0041\n * (`A`) to U+0046 (`F`).\n *\n * An **ASCII lower hex digit** is a character in the inclusive range U+0061\n * (`a`) to U+0066 (`f`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiHexDigit = regexCheck(/[\\dA-Fa-f]/);\n\n/**\n * Check whether the character code represents ASCII punctuation.\n *\n * An **ASCII punctuation** is a character in the inclusive ranges U+0021\n * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT\n * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT\n * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);\n\n/**\n * Check whether a character code is a markdown line ending.\n *\n * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN\n * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).\n *\n * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE\n * RETURN (CR) are replaced by these virtual characters depending on whether\n * they occurred together.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEnding(code) {\n  return code !== null && code < -2;\n}\n\n/**\n * Check whether a character code is a markdown line ending (see\n * `markdownLineEnding`) or markdown space (see `markdownSpace`).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEndingOrSpace(code) {\n  return code !== null && (code < 0 || code === 32);\n}\n\n/**\n * Check whether a character code is a markdown space.\n *\n * A **markdown space** is the concrete character U+0020 SPACE (SP) and the\n * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).\n *\n * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is\n * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL\n * SPACE (VS) characters, depending on the column at which the tab occurred.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32;\n}\n\n// Size note: removing ASCII from the regex and using `asciiPunctuation` here\n// In fact adds to the bundle size.\n/**\n * Check whether the character code represents Unicode punctuation.\n *\n * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,\n * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`\n * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`\n * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII\n * punctuation (see `asciiPunctuation`).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodePunctuation = regexCheck(/\\p{P}|\\p{S}/u);\n\n/**\n * Check whether the character code represents Unicode whitespace.\n *\n * Note that this does handle micromark specific markdown whitespace characters.\n * See `markdownLineEndingOrSpace` to check that.\n *\n * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,\n * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),\n * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\\[UNICODE]**).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodeWhitespace = regexCheck(/\\s/);\n\n/**\n * Create a code check from a regex.\n *\n * @param {RegExp} regex\n *   Expression.\n * @returns {(code: Code) => boolean}\n *   Check.\n */\nfunction regexCheck(regex) {\n  return check;\n\n  /**\n   * Check whether a code matches the bound regex.\n   *\n   * @param {Code} code\n   *   Character code.\n   * @returns {boolean}\n   *   Whether the character code matches the bound regex.\n   */\n  function check(code) {\n    return code !== null && code > -1 && regex.test(String.fromCharCode(code));\n  }\n}","/**\n * @import {Node, Parent} from 'unist'\n */\n\n/**\n * @template Fn\n * @template Fallback\n * @typedef {Fn extends (value: any) => value is infer Thing ? Thing : Fallback} Predicate\n */\n\n/**\n * @callback Check\n *   Check that an arbitrary value is a node.\n * @param {unknown} this\n *   The given context.\n * @param {unknown} [node]\n *   Anything (typically a node).\n * @param {number | null | undefined} [index]\n *   The node’s position in its parent.\n * @param {Parent | null | undefined} [parent]\n *   The node’s parent.\n * @returns {boolean}\n *   Whether this is a node and passes a test.\n *\n * @typedef {Record<string, unknown> | Node} Props\n *   Object to check for equivalence.\n *\n *   Note: `Node` is included as it is common but is not indexable.\n *\n * @typedef {Array<Props | TestFunction | string> | ReadonlyArray<Props | TestFunction | string> | Props | TestFunction | string | null | undefined} Test\n *   Check for an arbitrary node.\n *\n * @callback TestFunction\n *   Check if a node passes a test.\n * @param {unknown} this\n *   The given context.\n * @param {Node} node\n *   A node.\n * @param {number | undefined} [index]\n *   The node’s position in its parent.\n * @param {Parent | undefined} [parent]\n *   The node’s parent.\n * @returns {boolean | undefined | void}\n *   Whether this node passes the test.\n *\n *   Note: `void` is included until TS sees no return as `undefined`.\n */\n\n/**\n * Check if `node` is a `Node` and whether it passes the given test.\n *\n * @param {unknown} node\n *   Thing to check, typically `Node`.\n * @param {Test} test\n *   A check for a specific node.\n * @param {number | null | undefined} index\n *   The node’s position in its parent.\n * @param {Parent | null | undefined} parent\n *   The node’s parent.\n * @param {unknown} context\n *   Context object (`this`) to pass to `test` functions.\n * @returns {boolean}\n *   Whether `node` is a node and passes a test.\n */\nexport const is =\n  // Note: overloads in JSDoc can’t yet use different `@template`s.\n  /**\n   * @type {(\n   *   (<Condition extends ReadonlyArray<string>>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition[number]}) &\n   *   (<Condition extends Array<string>>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition[number]}) &\n   *   (<Condition extends string>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &\n   *   (<Condition extends Props>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &\n   *   (<Condition extends TestFunction>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &\n   *   ((node?: null | undefined) => false) &\n   *   ((node: unknown, test?: null | undefined, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &\n   *   ((node: unknown, test?: Test, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => boolean)\n   * )}\n   */\n  (\n    /**\n     * @param {unknown} [node]\n     * @param {Test} [test]\n     * @param {number | null | undefined} [index]\n     * @param {Parent | null | undefined} [parent]\n     * @param {unknown} [context]\n     * @returns {boolean}\n     */\n    // eslint-disable-next-line max-params\n    function (node, test, index, parent, context) {\n      const check = convert(test)\n\n      if (\n        index !== undefined &&\n        index !== null &&\n        (typeof index !== 'number' ||\n          index < 0 ||\n          index === Number.POSITIVE_INFINITY)\n      ) {\n        throw new Error('Expected positive finite index')\n      }\n\n      if (\n        parent !== undefined &&\n        parent !== null &&\n        (!is(parent) || !parent.children)\n      ) {\n        throw new Error('Expected parent node')\n      }\n\n      if (\n        (parent === undefined || parent === null) !==\n        (index === undefined || index === null)\n      ) {\n        throw new Error('Expected both parent and index')\n      }\n\n      return looksLikeANode(node)\n        ? check.call(context, node, index, parent)\n        : false\n    }\n  )\n\n/**\n * Generate an assertion from a test.\n *\n * Useful if you’re going to test many nodes, for example when creating a\n * utility where something else passes a compatible test.\n *\n * The created function is a bit faster because it expects valid input only:\n * a `node`, `index`, and `parent`.\n *\n * @param {Test} test\n *   *   when nullish, checks if `node` is a `Node`.\n *   *   when `string`, works like passing `(node) => node.type === test`.\n *   *   when `function` checks if function passed the node is true.\n *   *   when `object`, checks that all keys in test are in node, and that they have (strictly) equal values.\n *   *   when `array`, checks if any one of the subtests pass.\n * @returns {Check}\n *   An assertion.\n */\nexport const convert =\n  // Note: overloads in JSDoc can’t yet use different `@template`s.\n  /**\n   * @type {(\n   *   (<Condition extends string>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &\n   *   (<Condition extends Props>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &\n   *   (<Condition extends TestFunction>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &\n   *   ((test?: null | undefined) => (node?: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &\n   *   ((test?: Test) => Check)\n   * )}\n   */\n  (\n    /**\n     * @param {Test} [test]\n     * @returns {Check}\n     */\n    function (test) {\n      if (test === null || test === undefined) {\n        return ok\n      }\n\n      if (typeof test === 'function') {\n        return castFactory(test)\n      }\n\n      if (typeof test === 'object') {\n        return Array.isArray(test)\n          ? anyFactory(test)\n          : // Cast because `ReadonlyArray` goes into the above but `isArray`\n            // narrows to `Array`.\n            propertiesFactory(/** @type {Props} */ (test))\n      }\n\n      if (typeof test === 'string') {\n        return typeFactory(test)\n      }\n\n      throw new Error('Expected function, string, or object as test')\n    }\n  )\n\n/**\n * @param {Array<Props | TestFunction | string>} tests\n * @returns {Check}\n */\nfunction anyFactory(tests) {\n  /** @type {Array<Check>} */\n  const checks = []\n  let index = -1\n\n  while (++index < tests.length) {\n    checks[index] = convert(tests[index])\n  }\n\n  return castFactory(any)\n\n  /**\n   * @this {unknown}\n   * @type {TestFunction}\n   */\n  function any(...parameters) {\n    let index = -1\n\n    while (++index < checks.length) {\n      if (checks[index].apply(this, parameters)) return true\n    }\n\n    return false\n  }\n}\n\n/**\n * Turn an object into a test for a node with a certain fields.\n *\n * @param {Props} check\n * @returns {Check}\n */\nfunction propertiesFactory(check) {\n  const checkAsRecord = /** @type {Record<string, unknown>} */ (check)\n\n  return castFactory(all)\n\n  /**\n   * @param {Node} node\n   * @returns {boolean}\n   */\n  function all(node) {\n    const nodeAsRecord = /** @type {Record<string, unknown>} */ (\n      /** @type {unknown} */ (node)\n    )\n\n    /** @type {string} */\n    let key\n\n    for (key in check) {\n      if (nodeAsRecord[key] !== checkAsRecord[key]) return false\n    }\n\n    return true\n  }\n}\n\n/**\n * Turn a string into a test for a node with a certain type.\n *\n * @param {string} check\n * @returns {Check}\n */\nfunction typeFactory(check) {\n  return castFactory(type)\n\n  /**\n   * @param {Node} node\n   */\n  function type(node) {\n    return node && node.type === check\n  }\n}\n\n/**\n * Turn a custom test into a test for a node that passes that test.\n *\n * @param {TestFunction} testFunction\n * @returns {Check}\n */\nfunction castFactory(testFunction) {\n  return check\n\n  /**\n   * @this {unknown}\n   * @type {Check}\n   */\n  function check(value, index, parent) {\n    return Boolean(\n      looksLikeANode(value) &&\n        testFunction.call(\n          this,\n          value,\n          typeof index === 'number' ? index : undefined,\n          parent || undefined\n        )\n    )\n  }\n}\n\nfunction ok() {\n  return true\n}\n\n/**\n * @param {unknown} value\n * @returns {value is Node}\n */\nfunction looksLikeANode(value) {\n  return value !== null && typeof value === 'object' && 'type' in value\n}\n","/**\n * @param {string} d\n * @returns {string}\n */\nexport function color(d) {\n  return '\\u001B[33m' + d + '\\u001B[39m'\n}\n","/**\n * @import {Node as UnistNode, Parent as UnistParent} from 'unist'\n */\n\n/**\n * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test\n *   Test from `unist-util-is`.\n *\n *   Note: we have remove and add `undefined`, because otherwise when generating\n *   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,\n *   which doesn’t work when publishing on npm.\n */\n\n/**\n * @typedef {(\n *   Fn extends (value: any) => value is infer Thing\n *   ? Thing\n *   : Fallback\n * )} Predicate\n *   Get the value of a type guard `Fn`.\n * @template Fn\n *   Value; typically function that is a type guard (such as `(x): x is Y`).\n * @template Fallback\n *   Value to yield if `Fn` is not a type guard.\n */\n\n/**\n * @typedef {(\n *   Check extends null | undefined // No test.\n *   ? Value\n *   : Value extends {type: Check} // String (type) test.\n *   ? Value\n *   : Value extends Check // Partial test.\n *   ? Value\n *   : Check extends Function // Function test.\n *   ? Predicate<Check, Value> extends Value\n *     ? Predicate<Check, Value>\n *     : never\n *   : never // Some other test?\n * )} MatchesOne\n *   Check whether a node matches a primitive check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test, but not arrays.\n */\n\n/**\n * @typedef {(\n *   Check extends ReadonlyArray<infer T>\n *   ? MatchesOne<Value, T>\n *   : Check extends Array<infer T>\n *   ? MatchesOne<Value, T>\n *   : MatchesOne<Value, Check>\n * )} Matches\n *   Check whether a node matches a check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test.\n */\n\n/**\n * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint\n *   Number; capped reasonably.\n */\n\n/**\n * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment\n *   Increment a number in the type system.\n * @template {Uint} [I=0]\n *   Index.\n */\n\n/**\n * @typedef {(\n *   Node extends UnistParent\n *   ? Node extends {children: Array<infer Children>}\n *     ? Child extends Children ? Node : never\n *     : never\n *   : never\n * )} InternalParent\n *   Collect nodes that can be parents of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent\n *   Collect nodes in `Tree` that can be parents of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Depth extends Max\n *   ? never\n *   :\n *     | InternalParent<Node, Child>\n *     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>\n * )} InternalAncestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {InternalAncestor<InclusiveDescendant<Tree>, Child>} Ancestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Tree extends UnistParent\n *     ? Depth extends Max\n *       ? Tree\n *       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>\n *     : Tree\n * )} InclusiveDescendant\n *   Collect all (inclusive) descendants of `Tree`.\n *\n *   > 👉 **Note**: for performance reasons, this seems to be the fastest way to\n *   > recurse without actually running into an infinite loop, which the\n *   > previous version did.\n *   >\n *   > Practically, a max of `2` is typically enough assuming a `Root` is\n *   > passed, but it doesn’t improve performance.\n *   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.\n *   > Using up to `10` doesn’t hurt or help either.\n * @template {UnistNode} Tree\n *   Tree type.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {'skip' | boolean} Action\n *   Union of the action types.\n *\n * @typedef {number} Index\n *   Move to the sibling at `index` next (after node itself is completely\n *   traversed).\n *\n *   Useful if mutating the tree, such as removing the node the visitor is\n *   currently on, or any of its previous siblings.\n *   Results less than 0 or greater than or equal to `children.length` stop\n *   traversing the parent.\n *\n * @typedef {[(Action | null | undefined | void)?, (Index | null | undefined)?]} ActionTuple\n *   List with one or two values, the first an action, the second an index.\n *\n * @typedef {Action | ActionTuple | Index | null | undefined | void} VisitorResult\n *   Any value that can be returned from a visitor.\n */\n\n/**\n * @callback Visitor\n *   Handle a node (matching `test`, if given).\n *\n *   Visitors are free to transform `node`.\n *   They can also transform the parent of node (the last of `ancestors`).\n *\n *   Replacing `node` itself, if `SKIP` is not returned, still causes its\n *   descendants to be walked (which is a bug).\n *\n *   When adding or removing previous siblings of `node` (or next siblings, in\n *   case of reverse), the `Visitor` should return a new `Index` to specify the\n *   sibling to traverse after `node` is traversed.\n *   Adding or removing next siblings of `node` (or previous siblings, in case\n *   of reverse) is handled as expected without needing to return a new `Index`.\n *\n *   Removing the children property of an ancestor still results in them being\n *   traversed.\n * @param {Visited} node\n *   Found node.\n * @param {Array<VisitedParents>} ancestors\n *   Ancestors of `node`.\n * @returns {VisitorResult}\n *   What to do next.\n *\n *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.\n *   An `Action` is treated as a tuple of `[Action]`.\n *\n *   Passing a tuple back only makes sense if the `Action` is `SKIP`.\n *   When the `Action` is `EXIT`, that action can be returned.\n *   When the `Action` is `CONTINUE`, `Index` can be returned.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [VisitedParents=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @typedef {Visitor<Matches<InclusiveDescendant<Tree>, Check>, Ancestor<Tree, Matches<InclusiveDescendant<Tree>, Check>>>} BuildVisitor\n *   Build a typed `Visitor` function from a tree and a test.\n *\n *   It will infer which values are passed as `node` and which as `parents`.\n * @template {UnistNode} [Tree=UnistNode]\n *   Tree type.\n * @template {Test} [Check=Test]\n *   Test type.\n */\n\nimport {convert} from 'unist-util-is'\nimport {color} from 'unist-util-visit-parents/do-not-use-color'\n\n/** @type {Readonly<ActionTuple>} */\nconst empty = []\n\n/**\n * Continue traversing as normal.\n */\nexport const CONTINUE = true\n\n/**\n * Stop traversing immediately.\n */\nexport const EXIT = false\n\n/**\n * Do not traverse this node’s children.\n */\nexport const SKIP = 'skip'\n\n/**\n * Visit nodes, with ancestral information.\n *\n * This algorithm performs *depth-first* *tree traversal* in *preorder*\n * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).\n *\n * You can choose for which nodes `visitor` is called by passing a `test`.\n * For complex tests, you should test yourself in `visitor`, as it will be\n * faster and will have improved type information.\n *\n * Walking the tree is an intensive task.\n * Make use of the return values of the visitor when possible.\n * Instead of walking a tree multiple times, walk it once, use `unist-util-is`\n * to check if a node matches, and then perform different operations.\n *\n * You can change the tree.\n * See `Visitor` for more info.\n *\n * @overload\n * @param {Tree} tree\n * @param {Check} check\n * @param {BuildVisitor<Tree, Check>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @overload\n * @param {Tree} tree\n * @param {BuildVisitor<Tree>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @param {UnistNode} tree\n *   Tree to traverse.\n * @param {Visitor | Test} test\n *   `unist-util-is`-compatible test\n * @param {Visitor | boolean | null | undefined} [visitor]\n *   Handle each node.\n * @param {boolean | null | undefined} [reverse]\n *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).\n * @returns {undefined}\n *   Nothing.\n *\n * @template {UnistNode} Tree\n *   Node type.\n * @template {Test} Check\n *   `unist-util-is`-compatible test.\n */\nexport function visitParents(tree, test, visitor, reverse) {\n  /** @type {Test} */\n  let check\n\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor\n    // @ts-expect-error no visitor given, so `visitor` is test.\n    visitor = test\n  } else {\n    // @ts-expect-error visitor given, so `test` isn’t a visitor.\n    check = test\n  }\n\n  const is = convert(check)\n  const step = reverse ? -1 : 1\n\n  factory(tree, undefined, [])()\n\n  /**\n   * @param {UnistNode} node\n   * @param {number | undefined} index\n   * @param {Array<UnistParent>} parents\n   */\n  function factory(node, index, parents) {\n    const value = /** @type {Record<string, unknown>} */ (\n      node && typeof node === 'object' ? node : {}\n    )\n\n    if (typeof value.type === 'string') {\n      const name =\n        // `hast`\n        typeof value.tagName === 'string'\n          ? value.tagName\n          : // `xast`\n            typeof value.name === 'string'\n            ? value.name\n            : undefined\n\n      Object.defineProperty(visit, 'name', {\n        value:\n          'node (' + color(node.type + (name ? '<' + name + '>' : '')) + ')'\n      })\n    }\n\n    return visit\n\n    function visit() {\n      /** @type {Readonly<ActionTuple>} */\n      let result = empty\n      /** @type {Readonly<ActionTuple>} */\n      let subresult\n      /** @type {number} */\n      let offset\n      /** @type {Array<UnistParent>} */\n      let grandparents\n\n      if (!test || is(node, index, parents[parents.length - 1] || undefined)) {\n        // @ts-expect-error: `visitor` is now a visitor.\n        result = toResult(visitor(node, parents))\n\n        if (result[0] === EXIT) {\n          return result\n        }\n      }\n\n      if ('children' in node && node.children) {\n        const nodeAsParent = /** @type {UnistParent} */ (node)\n\n        if (nodeAsParent.children && result[0] !== SKIP) {\n          offset = (reverse ? nodeAsParent.children.length : -1) + step\n          grandparents = parents.concat(nodeAsParent)\n\n          while (offset > -1 && offset < nodeAsParent.children.length) {\n            const child = nodeAsParent.children[offset]\n\n            subresult = factory(child, offset, grandparents)()\n\n            if (subresult[0] === EXIT) {\n              return subresult\n            }\n\n            offset =\n              typeof subresult[1] === 'number' ? subresult[1] : offset + step\n          }\n        }\n      }\n\n      return result\n    }\n  }\n}\n\n/**\n * Turn a return value into a clean result.\n *\n * @param {VisitorResult} value\n *   Valid return values from visitors.\n * @returns {Readonly<ActionTuple>}\n *   Clean result.\n */\nfunction toResult(value) {\n  if (Array.isArray(value)) {\n    return value\n  }\n\n  if (typeof value === 'number') {\n    return [CONTINUE, value]\n  }\n\n  return value === null || value === undefined ? empty : [value]\n}\n","/**\n * @import {Node as UnistNode, Parent as UnistParent} from 'unist'\n * @import {VisitorResult} from 'unist-util-visit-parents'\n */\n\n/**\n * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test\n *   Test from `unist-util-is`.\n *\n *   Note: we have remove and add `undefined`, because otherwise when generating\n *   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,\n *   which doesn’t work when publishing on npm.\n */\n\n// To do: use types from `unist-util-visit-parents` when it’s released.\n\n/**\n * @typedef {(\n *   Fn extends (value: any) => value is infer Thing\n *   ? Thing\n *   : Fallback\n * )} Predicate\n *   Get the value of a type guard `Fn`.\n * @template Fn\n *   Value; typically function that is a type guard (such as `(x): x is Y`).\n * @template Fallback\n *   Value to yield if `Fn` is not a type guard.\n */\n\n/**\n * @typedef {(\n *   Check extends null | undefined // No test.\n *   ? Value\n *   : Value extends {type: Check} // String (type) test.\n *   ? Value\n *   : Value extends Check // Partial test.\n *   ? Value\n *   : Check extends Function // Function test.\n *   ? Predicate<Check, Value> extends Value\n *     ? Predicate<Check, Value>\n *     : never\n *   : never // Some other test?\n * )} MatchesOne\n *   Check whether a node matches a primitive check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test, but not arrays.\n */\n\n/**\n * @typedef {(\n *   Check extends ReadonlyArray<any>\n *   ? MatchesOne<Value, Check[number]>\n *   : MatchesOne<Value, Check>\n * )} Matches\n *   Check whether a node matches a check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test.\n */\n\n/**\n * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint\n *   Number; capped reasonably.\n */\n\n/**\n * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment\n *   Increment a number in the type system.\n * @template {Uint} [I=0]\n *   Index.\n */\n\n/**\n * @typedef {(\n *   Node extends UnistParent\n *   ? Node extends {children: Array<infer Children>}\n *     ? Child extends Children ? Node : never\n *     : never\n *   : never\n * )} InternalParent\n *   Collect nodes that can be parents of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent\n *   Collect nodes in `Tree` that can be parents of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Depth extends Max\n *   ? never\n *   :\n *     | InternalParent<Node, Child>\n *     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>\n * )} InternalAncestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {(\n *   Tree extends UnistParent\n *     ? Depth extends Max\n *       ? Tree\n *       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>\n *     : Tree\n * )} InclusiveDescendant\n *   Collect all (inclusive) descendants of `Tree`.\n *\n *   > 👉 **Note**: for performance reasons, this seems to be the fastest way to\n *   > recurse without actually running into an infinite loop, which the\n *   > previous version did.\n *   >\n *   > Practically, a max of `2` is typically enough assuming a `Root` is\n *   > passed, but it doesn’t improve performance.\n *   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.\n *   > Using up to `10` doesn’t hurt or help either.\n * @template {UnistNode} Tree\n *   Tree type.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @callback Visitor\n *   Handle a node (matching `test`, if given).\n *\n *   Visitors are free to transform `node`.\n *   They can also transform `parent`.\n *\n *   Replacing `node` itself, if `SKIP` is not returned, still causes its\n *   descendants to be walked (which is a bug).\n *\n *   When adding or removing previous siblings of `node` (or next siblings, in\n *   case of reverse), the `Visitor` should return a new `Index` to specify the\n *   sibling to traverse after `node` is traversed.\n *   Adding or removing next siblings of `node` (or previous siblings, in case\n *   of reverse) is handled as expected without needing to return a new `Index`.\n *\n *   Removing the children property of `parent` still results in them being\n *   traversed.\n * @param {Visited} node\n *   Found node.\n * @param {Visited extends UnistNode ? number | undefined : never} index\n *   Index of `node` in `parent`.\n * @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent\n *   Parent of `node`.\n * @returns {VisitorResult}\n *   What to do next.\n *\n *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.\n *   An `Action` is treated as a tuple of `[Action]`.\n *\n *   Passing a tuple back only makes sense if the `Action` is `SKIP`.\n *   When the `Action` is `EXIT`, that action can be returned.\n *   When the `Action` is `CONTINUE`, `Index` can be returned.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [Ancestor=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @typedef {Visitor<Visited, Parent<Ancestor, Visited>>} BuildVisitorFromMatch\n *   Build a typed `Visitor` function from a node and all possible parents.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} Visited\n *   Node type.\n * @template {UnistParent} Ancestor\n *   Parent type.\n */\n\n/**\n * @typedef {(\n *   BuildVisitorFromMatch<\n *     Matches<Descendant, Check>,\n *     Extract<Descendant, UnistParent>\n *   >\n * )} BuildVisitorFromDescendants\n *   Build a typed `Visitor` function from a list of descendants and a test.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} Descendant\n *   Node type.\n * @template {Test} Check\n *   Test type.\n */\n\n/**\n * @typedef {(\n *   BuildVisitorFromDescendants<\n *     InclusiveDescendant<Tree>,\n *     Check\n *   >\n * )} BuildVisitor\n *   Build a typed `Visitor` function from a tree and a test.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} [Tree=UnistNode]\n *   Node type.\n * @template {Test} [Check=Test]\n *   Test type.\n */\n\nimport {visitParents} from 'unist-util-visit-parents'\n\nexport {CONTINUE, EXIT, SKIP} from 'unist-util-visit-parents'\n\n/**\n * Visit nodes.\n *\n * This algorithm performs *depth-first* *tree traversal* in *preorder*\n * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).\n *\n * You can choose for which nodes `visitor` is called by passing a `test`.\n * For complex tests, you should test yourself in `visitor`, as it will be\n * faster and will have improved type information.\n *\n * Walking the tree is an intensive task.\n * Make use of the return values of the visitor when possible.\n * Instead of walking a tree multiple times, walk it once, use `unist-util-is`\n * to check if a node matches, and then perform different operations.\n *\n * You can change the tree.\n * See `Visitor` for more info.\n *\n * @overload\n * @param {Tree} tree\n * @param {Check} check\n * @param {BuildVisitor<Tree, Check>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @overload\n * @param {Tree} tree\n * @param {BuildVisitor<Tree>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @param {UnistNode} tree\n *   Tree to traverse.\n * @param {Visitor | Test} testOrVisitor\n *   `unist-util-is`-compatible test (optional, omit to pass a visitor).\n * @param {Visitor | boolean | null | undefined} [visitorOrReverse]\n *   Handle each node (when test is omitted, pass `reverse`).\n * @param {boolean | null | undefined} [maybeReverse=false]\n *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).\n * @returns {undefined}\n *   Nothing.\n *\n * @template {UnistNode} Tree\n *   Node type.\n * @template {Test} Check\n *   `unist-util-is`-compatible test.\n */\nexport function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {\n  /** @type {boolean | null | undefined} */\n  let reverse\n  /** @type {Test} */\n  let test\n  /** @type {Visitor} */\n  let visitor\n\n  if (\n    typeof testOrVisitor === 'function' &&\n    typeof visitorOrReverse !== 'function'\n  ) {\n    test = undefined\n    visitor = testOrVisitor\n    reverse = visitorOrReverse\n  } else {\n    // @ts-expect-error: assume the overload with test was given.\n    test = testOrVisitor\n    // @ts-expect-error: assume the overload with test was given.\n    visitor = visitorOrReverse\n    reverse = maybeReverse\n  }\n\n  visitParents(tree, test, overload, reverse)\n\n  /**\n   * @param {UnistNode} node\n   * @param {Array<UnistParent>} parents\n   */\n  function overload(node, parents) {\n    const parent = parents[parents.length - 1]\n    const index = parent ? parent.children.indexOf(node) : undefined\n    return visitor(node, index, parent)\n  }\n}\n","/**\n * @import {Effects, State, TokenType} from 'micromark-util-types'\n */\n\nimport { markdownSpace } from 'micromark-util-character';\n\n// To do: implement `spaceOrTabWithOptions` (`connect`, `content`).\n\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   spaces in markdown are often optional, in which case this factory can be\n *     used and `ok` will be switched to whether spaces were found or not\n * *   one line ending or space can be detected with `markdownSpace(code)` right\n *     before using `factorySpace`\n *\n * ###### Examples\n *\n * Where `␉` represents a tab (plus how much it expands) and `␠` represents a\n * single space.\n *\n * ```markdown\n * ␉\n * ␠␠␠␠\n * ␉␠\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {TokenType} type\n *   Type of the whole whitespace.\n * @param {number | undefined} [max=Infinity]\n *   Max (exclusive).\n * @returns {State}\n *   Start state.\n */\nexport function factorySpace(effects, ok, type, max) {\n  const limit = max ? max - 1 : Infinity;\n  let size = 0;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type);\n      return prefix(code);\n    }\n    return ok(code);\n  }\n\n  /** @type {State} */\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code);\n      return prefix;\n    }\n    effects.exit(type);\n    return ok(code);\n  }\n}\n\n/**\n * Parse spaces and tabs, with a required minimum and maximum, matching\n * `markdown-rs`’s `space_or_tab_min_max`.\n *\n * Unlike `factorySpace`, this can fail: `nok` is used when fewer than\n * `min` spaces or tabs are found.\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type of the whole whitespace.\n * @param {number} min\n *   Minimum allowed characters (inclusive).\n * @param {number} max\n *   Maximum allowed characters (inclusive).\n * @returns {State}\n *   Start state.\n */\nexport function factorySpaceMinMax(effects, ok, nok, type, min, max) {\n  let size = 0;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    if (max > 0 && markdownSpace(code)) {\n      effects.enter(type);\n      return prefix(code);\n    }\n    return after(code);\n  }\n\n  /** @type {State} */\n  function prefix(code) {\n    if (markdownSpace(code) && size < max) {\n      effects.consume(code);\n      size++;\n      return prefix;\n    }\n    effects.exit(type);\n    return after(code);\n  }\n\n  /** @type {State} */\n  function after(code) {\n    return size >= min ? ok(code) : nok(code);\n  }\n}"],"ignoreList":[0,1,2,3,4,5],"mappings":"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"}