@burdenoff/microfe-store 2026.720.2 → 2026.720.4

package/dist/node_modules/micromark/lib/create-tokenizer.js

@@ -0,0 +1,179 @@
+import { push as e, splice as t } from "../../micromark-util-chunked/index.js";
+import { markdownLineEnding as n } from "../../micromark-util-character/index.js";
+import { resolveAll as r } from "../../micromark-util-resolve-all/index.js";
+//#region node_modules/micromark/lib/create-tokenizer.js
+function i(i, s, c) {
+	let l = {
+		_bufferIndex: -1,
+		_index: 0,
+		line: c && c.line || 1,
+		column: c && c.column || 1,
+		offset: c && c.offset || 0
+	}, u = {}, d = [], f = [], p = [], m = {
+		attempt: k(D),
+		check: k(O),
+		consume: w,
+		enter: T,
+		exit: E,
+		interrupt: k(O, { interrupt: !0 })
+	}, h = {
+		code: null,
+		containerState: {},
+		defineSkip: x,
+		events: [],
+		now: b,
+		parser: i,
+		previous: null,
+		sliceSerialize: v,
+		sliceStream: y,
+		write: _
+	}, g = s.tokenize.call(h, m);
+	return s.resolveAll && d.push(s), h;
+	function _(t) {
+		return f = e(f, t), S(), f[f.length - 1] === null ? (A(s, 0), h.events = r(d, h.events, h), h.events) : [];
+	}
+	function v(e, t) {
+		return o(y(e), t);
+	}
+	function y(e) {
+		return a(f, e);
+	}
+	function b() {
+		let { _bufferIndex: e, _index: t, line: n, column: r, offset: i } = l;
+		return {
+			_bufferIndex: e,
+			_index: t,
+			line: n,
+			column: r,
+			offset: i
+		};
+	}
+	function x(e) {
+		u[e.line] = e.column, M();
+	}
+	function S() {
+		let e;
+		for (; l._index < f.length;) {
+			let t = f[l._index];
+			if (typeof t == "string") for (e = l._index, l._bufferIndex < 0 && (l._bufferIndex = 0); l._index === e && l._bufferIndex < t.length;) C(t.charCodeAt(l._bufferIndex));
+			else C(t);
+		}
+	}
+	function C(e) {
+		g = g(e);
+	}
+	function w(e) {
+		n(e) ? (l.line++, l.column = 1, l.offset += e === -3 ? 2 : 1, M()) : e !== -1 && (l.column++, l.offset++), l._bufferIndex < 0 ? l._index++ : (l._bufferIndex++, l._bufferIndex === f[l._index].length && (l._bufferIndex = -1, l._index++)), h.previous = e;
+	}
+	function T(e, t) {
+		let n = t || {};
+		return n.type = e, n.start = b(), h.events.push([
+			"enter",
+			n,
+			h
+		]), p.push(n), n;
+	}
+	function E(e) {
+		let t = p.pop();
+		return t.end = b(), h.events.push([
+			"exit",
+			t,
+			h
+		]), t;
+	}
+	function D(e, t) {
+		A(e, t.from);
+	}
+	function O(e, t) {
+		t.restore();
+	}
+	function k(e, t) {
+		return n;
+		function n(n, r, i) {
+			let a, o, s, c;
+			return Array.isArray(n) ? u(n) : "tokenize" in n ? u([n]) : l(n);
+			function l(e) {
+				return t;
+				function t(t) {
+					let n = t !== null && e[t], r = t !== null && e.null;
+					return u([...Array.isArray(n) ? n : n ? [n] : [], ...Array.isArray(r) ? r : r ? [r] : []])(t);
+				}
+			}
+			function u(e) {
+				return a = e, o = 0, e.length === 0 ? i : d(e[o]);
+			}
+			function d(e) {
+				return n;
+				function n(n) {
+					return c = j(), s = e, e.partial || (h.currentConstruct = e), e.name && h.parser.constructs.disable.null.includes(e.name) ? p(n) : e.tokenize.call(t ? Object.assign(Object.create(h), t) : h, m, f, p)(n);
+				}
+			}
+			function f(t) {
+				return e(s, c), r;
+			}
+			function p(e) {
+				return c.restore(), ++o < a.length ? d(a[o]) : i;
+			}
+		}
+	}
+	function A(e, n) {
+		e.resolveAll && !d.includes(e) && d.push(e), e.resolve && t(h.events, n, h.events.length - n, e.resolve(h.events.slice(n), h)), e.resolveTo && (h.events = e.resolveTo(h.events, h));
+	}
+	function j() {
+		let e = b(), t = h.previous, n = h.currentConstruct, r = h.events.length, i = Array.from(p);
+		return {
+			from: r,
+			restore: a
+		};
+		function a() {
+			l = e, h.previous = t, h.currentConstruct = n, h.events.length = r, p = i, M();
+		}
+	}
+	function M() {
+		l.line in u && l.column < 2 && (l.column = u[l.line], l.offset += u[l.line] - 1);
+	}
+}
+function a(e, t) {
+	let n = t.start._index, r = t.start._bufferIndex, i = t.end._index, a = t.end._bufferIndex, o;
+	if (n === i) o = [e[n].slice(r, a)];
+	else {
+		if (o = e.slice(n, i), r > -1) {
+			let e = o[0];
+			typeof e == "string" ? o[0] = e.slice(r) : o.shift();
+		}
+		a > 0 && o.push(e[i].slice(0, a));
+	}
+	return o;
+}
+function o(e, t) {
+	let n = -1, r = [], i;
+	for (; ++n < e.length;) {
+		let a = e[n], o;
+		if (typeof a == "string") o = a;
+		else switch (a) {
+			case -5:
+				o = "\r";
+				break;
+			case -4:
+				o = "\n";
+				break;
+			case -3:
+				o = "\r\n";
+				break;
+			case -2:
+				o = t ? " " : "	";
+				break;
+			case -1:
+				if (!t && i) continue;
+				o = " ";
+				break;
+			default: o = String.fromCharCode(a);
+		}
+		i = a === -2, r.push(o);
+	}
+	return r.join("");
+}
+//#endregion
+export { i as createTokenizer };
+
+//# sourceMappingURL=create-tokenizer.js.map

package/dist/node_modules/micromark/lib/create-tokenizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-tokenizer.js","names":[],"sources":["../../../../node_modules/micromark/lib/create-tokenizer.js"],"sourcesContent":["/**\n * @import {\n *   Chunk,\n *   Code,\n *   ConstructRecord,\n *   Construct,\n *   Effects,\n *   InitialConstruct,\n *   ParseContext,\n *   Point,\n *   State,\n *   TokenizeContext,\n *   Token\n * } from 'micromark-util-types'\n */\n\n/**\n * @callback Restore\n *   Restore the state.\n * @returns {undefined}\n *   Nothing.\n *\n * @typedef Info\n *   Info.\n * @property {Restore} restore\n *   Restore.\n * @property {number} from\n *   From.\n *\n * @callback ReturnHandle\n *   Handle a successful run.\n * @param {Construct} construct\n *   Construct.\n * @param {Info} info\n *   Info.\n * @returns {undefined}\n *   Nothing.\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { push, splice } from 'micromark-util-chunked';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/**\n * Create a tokenizer.\n * Tokenizers deal with one type of data (e.g., containers, flow, text).\n * The parser is the object dealing with it all.\n * `initialize` works like other constructs, except that only its `tokenize`\n * function is used, in which case it doesn’t receive an `ok` or `nok`.\n * `from` can be given to set the point before the first character, although\n * when further lines are indented, they must be set with `defineSkip`.\n *\n * @param {ParseContext} parser\n *   Parser.\n * @param {InitialConstruct} initialize\n *   Construct.\n * @param {Omit<Point, '_bufferIndex' | '_index'> | undefined} [from]\n *   Point (optional).\n * @returns {TokenizeContext}\n *   Context.\n */\nexport function createTokenizer(parser, initialize, from) {\n  /** @type {Point} */\n  let point = {\n    _bufferIndex: -1,\n    _index: 0,\n    line: from && from.line || 1,\n    column: from && from.column || 1,\n    offset: from && from.offset || 0\n  };\n  /** @type {Record<string, number>} */\n  const columnStart = {};\n  /** @type {Array<Construct>} */\n  const resolveAllConstructs = [];\n  /** @type {Array<Chunk>} */\n  let chunks = [];\n  /** @type {Array<Token>} */\n  let stack = [];\n  /** @type {boolean | undefined} */\n  let consumed = true;\n\n  /**\n   * Tools used for tokenizing.\n   *\n   * @type {Effects}\n   */\n  const effects = {\n    attempt: constructFactory(onsuccessfulconstruct),\n    check: constructFactory(onsuccessfulcheck),\n    consume,\n    enter,\n    exit,\n    interrupt: constructFactory(onsuccessfulcheck, {\n      interrupt: true\n    })\n  };\n\n  /**\n   * State and tools for resolving and serializing.\n   *\n   * @type {TokenizeContext}\n   */\n  const context = {\n    code: null,\n    containerState: {},\n    defineSkip,\n    events: [],\n    now,\n    parser,\n    previous: null,\n    sliceSerialize,\n    sliceStream,\n    write\n  };\n\n  /**\n   * The state function.\n   *\n   * @type {State | undefined}\n   */\n  let state = initialize.tokenize.call(context, effects);\n\n  /**\n   * Track which character we expect to be consumed, to catch bugs.\n   *\n   * @type {Code}\n   */\n  let expectedCode;\n  if (initialize.resolveAll) {\n    resolveAllConstructs.push(initialize);\n  }\n  return context;\n\n  /** @type {TokenizeContext['write']} */\n  function write(slice) {\n    chunks = push(chunks, slice);\n    main();\n\n    // Exit if we’re not done, resolve might change stuff.\n    if (chunks[chunks.length - 1] !== null) {\n      return [];\n    }\n    addResult(initialize, 0);\n\n    // Otherwise, resolve, and exit.\n    context.events = resolveAll(resolveAllConstructs, context.events, context);\n    return context.events;\n  }\n\n  //\n  // Tools.\n  //\n\n  /** @type {TokenizeContext['sliceSerialize']} */\n  function sliceSerialize(token, expandTabs) {\n    return serializeChunks(sliceStream(token), expandTabs);\n  }\n\n  /** @type {TokenizeContext['sliceStream']} */\n  function sliceStream(token) {\n    return sliceChunks(chunks, token);\n  }\n\n  /** @type {TokenizeContext['now']} */\n  function now() {\n    // This is a hot path, so we clone manually instead of `Object.assign({}, point)`\n    const {\n      _bufferIndex,\n      _index,\n      line,\n      column,\n      offset\n    } = point;\n    return {\n      _bufferIndex,\n      _index,\n      line,\n      column,\n      offset\n    };\n  }\n\n  /** @type {TokenizeContext['defineSkip']} */\n  function defineSkip(value) {\n    columnStart[value.line] = value.column;\n    accountForPotentialSkip();\n  }\n\n  //\n  // State management.\n  //\n\n  /**\n   * Main loop (note that `_index` and `_bufferIndex` in `point` are modified by\n   * `consume`).\n   * Here is where we walk through the chunks, which either include strings of\n   * several characters, or numerical character codes.\n   * The reason to do this in a loop instead of a call is so the stack can\n   * drain.\n   *\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function main() {\n    /** @type {number} */\n    let chunkIndex;\n    while (point._index < chunks.length) {\n      const chunk = chunks[point._index];\n\n      // If we’re in a buffer chunk, loop through it.\n      if (typeof chunk === 'string') {\n        chunkIndex = point._index;\n        if (point._bufferIndex < 0) {\n          point._bufferIndex = 0;\n        }\n        while (point._index === chunkIndex && point._bufferIndex < chunk.length) {\n          go(chunk.charCodeAt(point._bufferIndex));\n        }\n      } else {\n        go(chunk);\n      }\n    }\n  }\n\n  /**\n   * Deal with one code.\n   *\n   * @param {Code} code\n   *   Code.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function go(code) {\n    consumed = undefined;\n    expectedCode = code;\n    state = state(code);\n  }\n\n  /** @type {Effects['consume']} */\n  function consume(code) {\n    if (markdownLineEnding(code)) {\n      point.line++;\n      point.column = 1;\n      point.offset += code === -3 ? 2 : 1;\n      accountForPotentialSkip();\n    } else if (code !== -1) {\n      point.column++;\n      point.offset++;\n    }\n\n    // Not in a string chunk.\n    if (point._bufferIndex < 0) {\n      point._index++;\n    } else {\n      point._bufferIndex++;\n\n      // At end of string chunk.\n      if (point._bufferIndex ===\n      // Points w/ non-negative `_bufferIndex` reference\n      // strings.\n      /** @type {string} */\n      chunks[point._index].length) {\n        point._bufferIndex = -1;\n        point._index++;\n      }\n    }\n\n    // Expose the previous character.\n    context.previous = code;\n\n    // Mark as consumed.\n    consumed = true;\n  }\n\n  /** @type {Effects['enter']} */\n  function enter(type, fields) {\n    /** @type {Token} */\n    // @ts-expect-error Patch instead of assign required fields to help GC.\n    const token = fields || {};\n    token.type = type;\n    token.start = now();\n    context.events.push(['enter', token, context]);\n    stack.push(token);\n    return token;\n  }\n\n  /** @type {Effects['exit']} */\n  function exit(type) {\n    const token = stack.pop();\n    token.end = now();\n    context.events.push(['exit', token, context]);\n    return token;\n  }\n\n  /**\n   * Use results.\n   *\n   * @type {ReturnHandle}\n   */\n  function onsuccessfulconstruct(construct, info) {\n    addResult(construct, info.from);\n  }\n\n  /**\n   * Discard results.\n   *\n   * @type {ReturnHandle}\n   */\n  function onsuccessfulcheck(_, info) {\n    info.restore();\n  }\n\n  /**\n   * Factory to attempt/check/interrupt.\n   *\n   * @param {ReturnHandle} onreturn\n   *   Callback.\n   * @param {{interrupt?: boolean | undefined} | undefined} [fields]\n   *   Fields.\n   */\n  function constructFactory(onreturn, fields) {\n    return hook;\n\n    /**\n     * Handle either an object mapping codes to constructs, a list of\n     * constructs, or a single construct.\n     *\n     * @param {Array<Construct> | ConstructRecord | Construct} constructs\n     *   Constructs.\n     * @param {State} returnState\n     *   State.\n     * @param {State | undefined} [bogusState]\n     *   State.\n     * @returns {State}\n     *   State.\n     */\n    function hook(constructs, returnState, bogusState) {\n      /** @type {ReadonlyArray<Construct>} */\n      let listOfConstructs;\n      /** @type {number} */\n      let constructIndex;\n      /** @type {Construct} */\n      let currentConstruct;\n      /** @type {Info} */\n      let info;\n      return Array.isArray(constructs) ? /* c8 ignore next 1 */\n      handleListOfConstructs(constructs) : 'tokenize' in constructs ?\n      // Looks like a construct.\n      handleListOfConstructs([(/** @type {Construct} */constructs)]) : handleMapOfConstructs(constructs);\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ConstructRecord} map\n       *   Constructs.\n       * @returns {State}\n       *   State.\n       */\n      function handleMapOfConstructs(map) {\n        return start;\n\n        /** @type {State} */\n        function start(code) {\n          const left = code !== null && map[code];\n          const all = code !== null && map.null;\n          const list = [\n          // To do: add more extension tests.\n          /* c8 ignore next 2 */\n          ...(Array.isArray(left) ? left : left ? [left] : []), ...(Array.isArray(all) ? all : all ? [all] : [])];\n          return handleListOfConstructs(list)(code);\n        }\n      }\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ReadonlyArray<Construct>} list\n       *   Constructs.\n       * @returns {State}\n       *   State.\n       */\n      function handleListOfConstructs(list) {\n        listOfConstructs = list;\n        constructIndex = 0;\n        if (list.length === 0) {\n          return bogusState;\n        }\n        return handleConstruct(list[constructIndex]);\n      }\n\n      /**\n       * Handle a single construct.\n       *\n       * @param {Construct} construct\n       *   Construct.\n       * @returns {State}\n       *   State.\n       */\n      function handleConstruct(construct) {\n        return start;\n\n        /** @type {State} */\n        function start(code) {\n          // To do: not needed to store if there is no bogus state, probably?\n          // Currently doesn’t work because `inspect` in document does a check\n          // w/o a bogus, which doesn’t make sense. But it does seem to help perf\n          // by not storing.\n          info = store();\n          currentConstruct = construct;\n          if (!construct.partial) {\n            context.currentConstruct = construct;\n          }\n\n          // Always populated by defaults.\n\n          if (construct.name && context.parser.constructs.disable.null.includes(construct.name)) {\n            return nok(code);\n          }\n          return construct.tokenize.call(\n          // If we do have fields, create an object w/ `context` as its\n          // prototype.\n          // This allows a “live binding”, which is needed for `interrupt`.\n          fields ? Object.assign(Object.create(context), fields) : context, effects, ok, nok)(code);\n        }\n      }\n\n      /** @type {State} */\n      function ok(code) {\n        consumed = true;\n        onreturn(currentConstruct, info);\n        return returnState;\n      }\n\n      /** @type {State} */\n      function nok(code) {\n        consumed = true;\n        info.restore();\n        if (++constructIndex < listOfConstructs.length) {\n          return handleConstruct(listOfConstructs[constructIndex]);\n        }\n        return bogusState;\n      }\n    }\n  }\n\n  /**\n   * @param {Construct} construct\n   *   Construct.\n   * @param {number} from\n   *   From.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function addResult(construct, from) {\n    if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {\n      resolveAllConstructs.push(construct);\n    }\n    if (construct.resolve) {\n      splice(context.events, from, context.events.length - from, construct.resolve(context.events.slice(from), context));\n    }\n    if (construct.resolveTo) {\n      context.events = construct.resolveTo(context.events, context);\n    }\n  }\n\n  /**\n   * Store state.\n   *\n   * @returns {Info}\n   *   Info.\n   */\n  function store() {\n    const startPoint = now();\n    const startPrevious = context.previous;\n    const startCurrentConstruct = context.currentConstruct;\n    const startEventsIndex = context.events.length;\n    const startStack = Array.from(stack);\n    return {\n      from: startEventsIndex,\n      restore\n    };\n\n    /**\n     * Restore state.\n     *\n     * @returns {undefined}\n     *   Nothing.\n     */\n    function restore() {\n      point = startPoint;\n      context.previous = startPrevious;\n      context.currentConstruct = startCurrentConstruct;\n      context.events.length = startEventsIndex;\n      stack = startStack;\n      accountForPotentialSkip();\n    }\n  }\n\n  /**\n   * Move the current point a bit forward in the line when it’s on a column\n   * skip.\n   *\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function accountForPotentialSkip() {\n    if (point.line in columnStart && point.column < 2) {\n      point.column = columnStart[point.line];\n      point.offset += columnStart[point.line] - 1;\n    }\n  }\n}\n\n/**\n * Get the chunks from a slice of chunks in the range of a token.\n *\n * @param {ReadonlyArray<Chunk>} chunks\n *   Chunks.\n * @param {Pick<Token, 'end' | 'start'>} token\n *   Token.\n * @returns {Array<Chunk>}\n *   Chunks.\n */\nfunction sliceChunks(chunks, token) {\n  const startIndex = token.start._index;\n  const startBufferIndex = token.start._bufferIndex;\n  const endIndex = token.end._index;\n  const endBufferIndex = token.end._bufferIndex;\n  /** @type {Array<Chunk>} */\n  let view;\n  if (startIndex === endIndex) {\n    // @ts-expect-error `_bufferIndex` is used on string chunks.\n    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)];\n  } else {\n    view = chunks.slice(startIndex, endIndex);\n    if (startBufferIndex > -1) {\n      const head = view[0];\n      if (typeof head === 'string') {\n        view[0] = head.slice(startBufferIndex);\n        /* c8 ignore next 4 -- used to be used, no longer */\n      } else {\n        view.shift();\n      }\n    }\n    if (endBufferIndex > 0) {\n      // @ts-expect-error `_bufferIndex` is used on string chunks.\n      view.push(chunks[endIndex].slice(0, endBufferIndex));\n    }\n  }\n  return view;\n}\n\n/**\n * Get the string value of a slice of chunks.\n *\n * @param {ReadonlyArray<Chunk>} chunks\n *   Chunks.\n * @param {boolean | undefined} [expandTabs=false]\n *   Whether to expand tabs (default: `false`).\n * @returns {string}\n *   Result.\n */\nfunction serializeChunks(chunks, expandTabs) {\n  let index = -1;\n  /** @type {Array<string>} */\n  const result = [];\n  /** @type {boolean | undefined} */\n  let atTab;\n  while (++index < chunks.length) {\n    const chunk = chunks[index];\n    /** @type {string} */\n    let value;\n    if (typeof chunk === 'string') {\n      value = chunk;\n    } else switch (chunk) {\n      case -5:\n        {\n          value = \"\\r\";\n          break;\n        }\n      case -4:\n        {\n          value = \"\\n\";\n          break;\n        }\n      case -3:\n        {\n          value = \"\\r\" + \"\\n\";\n          break;\n        }\n      case -2:\n        {\n          value = expandTabs ? \" \" : \"\\t\";\n          break;\n        }\n      case -1:\n        {\n          if (!expandTabs && atTab) continue;\n          value = \" \";\n          break;\n        }\n      default:\n        {\n          // Currently only replacement character.\n          value = String.fromCharCode(chunk);\n        }\n    }\n    atTab = chunk === -2;\n    result.push(value);\n  }\n  return result.join('');\n}"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node_modules/micromark/lib/initialize/content.js

@@ -0,0 +1,36 @@
+import { markdownLineEnding as e } from "../../../micromark-util-character/index.js";
+import { factorySpace as t } from "../../../micromark-factory-space/index.js";
+//#region node_modules/micromark/lib/initialize/content.js
+var n = { tokenize: r };
+function r(n) {
+	let r = n.attempt(this.parser.constructs.contentInitial, a, o), i;
+	return r;
+	function a(e) {
+		if (e === null) {
+			n.consume(e);
+			return;
+		}
+		return n.enter("lineEnding"), n.consume(e), n.exit("lineEnding"), t(n, r, "linePrefix");
+	}
+	function o(e) {
+		return n.enter("paragraph"), s(e);
+	}
+	function s(e) {
+		let t = n.enter("chunkText", {
+			contentType: "text",
+			previous: i
+		});
+		return i && (i.next = t), i = t, c(e);
+	}
+	function c(t) {
+		if (t === null) {
+			n.exit("chunkText"), n.exit("paragraph"), n.consume(t);
+			return;
+		}
+		return e(t) ? (n.consume(t), n.exit("chunkText"), s) : (n.consume(t), c);
+	}
+}
+//#endregion
+export { n as content };
+
+//# sourceMappingURL=content.js.map

package/dist/node_modules/micromark/lib/initialize/content.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.js","names":[],"sources":["../../../../../node_modules/micromark/lib/initialize/content.js"],"sourcesContent":["/**\n * @import {\n *   InitialConstruct,\n *   Initializer,\n *   State,\n *   TokenizeContext,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {InitialConstruct} */\nexport const content = {\n  tokenize: initializeContent\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Initializer}\n *   Content.\n */\nfunction initializeContent(effects) {\n  const contentStart = effects.attempt(this.parser.constructs.contentInitial, afterContentStartConstruct, paragraphInitial);\n  /** @type {Token} */\n  let previous;\n  return contentStart;\n\n  /** @type {State} */\n  function afterContentStartConstruct(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return factorySpace(effects, contentStart, \"linePrefix\");\n  }\n\n  /** @type {State} */\n  function paragraphInitial(code) {\n    effects.enter(\"paragraph\");\n    return lineStart(code);\n  }\n\n  /** @type {State} */\n  function lineStart(code) {\n    const token = effects.enter(\"chunkText\", {\n      contentType: \"text\",\n      previous\n    });\n    if (previous) {\n      previous.next = token;\n    }\n    previous = token;\n    return data(code);\n  }\n\n  /** @type {State} */\n  function data(code) {\n    if (code === null) {\n      effects.exit(\"chunkText\");\n      effects.exit(\"paragraph\");\n      effects.consume(code);\n      return;\n    }\n    if (markdownLineEnding(code)) {\n      effects.consume(code);\n      effects.exit(\"chunkText\");\n      return lineStart;\n    }\n\n    // Data.\n    effects.consume(code);\n    return data;\n  }\n}"],"x_google_ignoreList":[0],"mappings":";;;AAaA,IAAa,IAAU,EACrB,UAAU,GACX;AAQD,SAAS,EAAkB,GAAS;CAClC,IAAM,IAAe,EAAQ,QAAQ,KAAK,OAAO,WAAW,gBAAgB,GAA4B,EAAiB,EAErH;AACJ,QAAO;CAGP,SAAS,EAA2B,GAAM;AACxC,MAAI,MAAS,MAAM;AACjB,KAAQ,QAAQ,EAAK;AACrB;;AAKF,SAHA,EAAQ,MAAM,aAAa,EAC3B,EAAQ,QAAQ,EAAK,EACrB,EAAQ,KAAK,aAAa,EACnB,EAAa,GAAS,GAAc,aAAa;;CAI1D,SAAS,EAAiB,GAAM;AAE9B,SADA,EAAQ,MAAM,YAAY,EACnB,EAAU,EAAK;;CAIxB,SAAS,EAAU,GAAM;EACvB,IAAM,IAAQ,EAAQ,MAAM,aAAa;GACvC,aAAa;GACb;GACD,CAAC;AAKF,SAJI,MACF,EAAS,OAAO,IAElB,IAAW,GACJ,EAAK,EAAK;;CAInB,SAAS,EAAK,GAAM;AAClB,MAAI,MAAS,MAAM;AAGjB,GAFA,EAAQ,KAAK,YAAY,EACzB,EAAQ,KAAK,YAAY,EACzB,EAAQ,QAAQ,EAAK;AACrB;;AAUF,SARI,EAAmB,EAAK,IAC1B,EAAQ,QAAQ,EAAK,EACrB,EAAQ,KAAK,YAAY,EAClB,MAIT,EAAQ,QAAQ,EAAK,EACd"}

package/dist/node_modules/micromark/lib/initialize/document.js

@@ -0,0 +1,104 @@
+import { splice as e } from "../../../micromark-util-chunked/index.js";
+import { markdownLineEnding as t } from "../../../micromark-util-character/index.js";
+import { factorySpace as n } from "../../../micromark-factory-space/index.js";
+//#region node_modules/micromark/lib/initialize/document.js
+var r = { tokenize: a }, i = { tokenize: o };
+function a(n) {
+	let r = this, a = [], o = 0, s, c, l;
+	return u;
+	function u(e) {
+		if (o < a.length) {
+			let t = a[o];
+			return r.containerState = t[1], n.attempt(t[0].continuation, d, f)(e);
+		}
+		return f(e);
+	}
+	function d(t) {
+		if (o++, r.containerState._closeFlow) {
+			r.containerState._closeFlow = void 0, s && x();
+			let n = r.events.length, i = n, a;
+			for (; i--;) if (r.events[i][0] === "exit" && r.events[i][1].type === "chunkFlow") {
+				a = r.events[i][1].end;
+				break;
+			}
+			b(o);
+			let c = n;
+			for (; c < r.events.length;) r.events[c][1].end = { ...a }, c++;
+			return e(r.events, i + 1, 0, r.events.slice(n)), r.events.length = c, f(t);
+		}
+		return u(t);
+	}
+	function f(e) {
+		if (o === a.length) {
+			if (!s) return h(e);
+			if (s.currentConstruct && s.currentConstruct.concrete) return _(e);
+			r.interrupt = !!(s.currentConstruct && !s._gfmTableDynamicInterruptHack);
+		}
+		return r.containerState = {}, n.check(i, p, m)(e);
+	}
+	function p(e) {
+		return s && x(), b(o), h(e);
+	}
+	function m(e) {
+		return r.parser.lazy[r.now().line] = o !== a.length, l = r.now().offset, _(e);
+	}
+	function h(e) {
+		return r.containerState = {}, n.attempt(i, g, _)(e);
+	}
+	function g(e) {
+		return o++, a.push([r.currentConstruct, r.containerState]), h(e);
+	}
+	function _(e) {
+		if (e === null) {
+			s && x(), b(0), n.consume(e);
+			return;
+		}
+		return s ||= r.parser.flow(r.now()), n.enter("chunkFlow", {
+			_tokenizer: s,
+			contentType: "flow",
+			previous: c
+		}), v(e);
+	}
+	function v(e) {
+		if (e === null) {
+			y(n.exit("chunkFlow"), !0), b(0), n.consume(e);
+			return;
+		}
+		return t(e) ? (n.consume(e), y(n.exit("chunkFlow")), o = 0, r.interrupt = void 0, u) : (n.consume(e), v);
+	}
+	function y(t, n) {
+		let i = r.sliceStream(t);
+		if (n && i.push(null), t.previous = c, c && (c.next = t), c = t, s.defineSkip(t.start), s.write(i), r.parser.lazy[t.start.line]) {
+			let t = s.events.length;
+			for (; t--;) if (s.events[t][1].start.offset < l && (!s.events[t][1].end || s.events[t][1].end.offset > l)) return;
+			let n = r.events.length, i = n, a, c;
+			for (; i--;) if (r.events[i][0] === "exit" && r.events[i][1].type === "chunkFlow") {
+				if (a) {
+					c = r.events[i][1].end;
+					break;
+				}
+				a = !0;
+			}
+			for (b(o), t = n; t < r.events.length;) r.events[t][1].end = { ...c }, t++;
+			e(r.events, i + 1, 0, r.events.slice(n)), r.events.length = t;
+		}
+	}
+	function b(e) {
+		let t = a.length;
+		for (; t-- > e;) {
+			let e = a[t];
+			r.containerState = e[1], e[0].exit.call(r, n);
+		}
+		a.length = e;
+	}
+	function x() {
+		s.write([null]), c = void 0, s = void 0, r.containerState._closeFlow = void 0;
+	}
+}
+function o(e, t, r) {
+	return n(e, e.attempt(this.parser.constructs.document, t, r), "linePrefix", this.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4);
+}
+//#endregion
+export { r as document };
+
+//# sourceMappingURL=document.js.map

package/dist/node_modules/micromark/lib/initialize/document.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"document.js","names":[],"sources":["../../../../../node_modules/micromark/lib/initialize/document.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   ContainerState,\n *   InitialConstruct,\n *   Initializer,\n *   Point,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\n/**\n * @typedef {[Construct, ContainerState]} StackItem\n *   Construct and its state.\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { splice } from 'micromark-util-chunked';\n/** @type {InitialConstruct} */\nexport const document = {\n  tokenize: initializeDocument\n};\n\n/** @type {Construct} */\nconst containerConstruct = {\n  tokenize: tokenizeContainer\n};\n\n/**\n * @this {TokenizeContext}\n *   Self.\n * @type {Initializer}\n *   Initializer.\n */\nfunction initializeDocument(effects) {\n  const self = this;\n  /** @type {Array<StackItem>} */\n  const stack = [];\n  let continued = 0;\n  /** @type {TokenizeContext | undefined} */\n  let childFlow;\n  /** @type {Token | undefined} */\n  let childToken;\n  /** @type {number} */\n  let lineStartOffset;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    // First we iterate through the open blocks, starting with the root\n    // document, and descending through last children down to the last open\n    // block.\n    // Each block imposes a condition that the line must satisfy if the block is\n    // to remain open.\n    // For example, a block quote requires a `>` character.\n    // A paragraph requires a non-blank line.\n    // In this phase we may match all or just some of the open blocks.\n    // But we cannot close unmatched blocks yet, because we may have a lazy\n    // continuation line.\n    if (continued < stack.length) {\n      const item = stack[continued];\n      self.containerState = item[1];\n      return effects.attempt(item[0].continuation, documentContinue, checkNewContainers)(code);\n    }\n\n    // Done.\n    return checkNewContainers(code);\n  }\n\n  /** @type {State} */\n  function documentContinue(code) {\n    continued++;\n\n    // Note: this field is called `_closeFlow` but it also closes containers.\n    // Perhaps a good idea to rename it but it’s already used in the wild by\n    // extensions.\n    if (self.containerState._closeFlow) {\n      self.containerState._closeFlow = undefined;\n      if (childFlow) {\n        closeFlow();\n      }\n\n      // Note: this algorithm for moving events around is similar to the\n      // algorithm when dealing with lazy lines in `writeToChild`.\n      const indexBeforeExits = self.events.length;\n      let indexBeforeFlow = indexBeforeExits;\n      /** @type {Point | undefined} */\n      let point;\n\n      // Find the flow chunk.\n      while (indexBeforeFlow--) {\n        if (self.events[indexBeforeFlow][0] === 'exit' && self.events[indexBeforeFlow][1].type === \"chunkFlow\") {\n          point = self.events[indexBeforeFlow][1].end;\n          break;\n        }\n      }\n      exitContainers(continued);\n\n      // Fix positions.\n      let index = indexBeforeExits;\n      while (index < self.events.length) {\n        self.events[index][1].end = {\n          ...point\n        };\n        index++;\n      }\n\n      // Inject the exits earlier (they’re still also at the end).\n      splice(self.events, indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits));\n\n      // Discard the duplicate exits.\n      self.events.length = index;\n      return checkNewContainers(code);\n    }\n    return start(code);\n  }\n\n  /** @type {State} */\n  function checkNewContainers(code) {\n    // Next, after consuming the continuation markers for existing blocks, we\n    // look for new block starts (e.g. `>` for a block quote).\n    // If we encounter a new block start, we close any blocks unmatched in\n    // step 1 before creating the new block as a child of the last matched\n    // block.\n    if (continued === stack.length) {\n      // No need to `check` whether there’s a container, of `exitContainers`\n      // would be moot.\n      // We can instead immediately `attempt` to parse one.\n      if (!childFlow) {\n        return documentContinued(code);\n      }\n\n      // If we have concrete content, such as block HTML or fenced code,\n      // we can’t have containers “pierce” into them, so we can immediately\n      // start.\n      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {\n        return flowStart(code);\n      }\n\n      // If we do have flow, it could still be a blank line,\n      // but we’d be interrupting it w/ a new container if there’s a current\n      // construct.\n      // To do: next major: remove `_gfmTableDynamicInterruptHack` (no longer\n      // needed in micromark-extension-gfm-table@1.0.6).\n      self.interrupt = Boolean(childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack);\n    }\n\n    // Check if there is a new container.\n    self.containerState = {};\n    return effects.check(containerConstruct, thereIsANewContainer, thereIsNoNewContainer)(code);\n  }\n\n  /** @type {State} */\n  function thereIsANewContainer(code) {\n    if (childFlow) closeFlow();\n    exitContainers(continued);\n    return documentContinued(code);\n  }\n\n  /** @type {State} */\n  function thereIsNoNewContainer(code) {\n    self.parser.lazy[self.now().line] = continued !== stack.length;\n    lineStartOffset = self.now().offset;\n    return flowStart(code);\n  }\n\n  /** @type {State} */\n  function documentContinued(code) {\n    // Try new containers.\n    self.containerState = {};\n    return effects.attempt(containerConstruct, containerContinue, flowStart)(code);\n  }\n\n  /** @type {State} */\n  function containerContinue(code) {\n    continued++;\n    stack.push([self.currentConstruct, self.containerState]);\n    // Try another.\n    return documentContinued(code);\n  }\n\n  /** @type {State} */\n  function flowStart(code) {\n    if (code === null) {\n      if (childFlow) closeFlow();\n      exitContainers(0);\n      effects.consume(code);\n      return;\n    }\n    childFlow = childFlow || self.parser.flow(self.now());\n    effects.enter(\"chunkFlow\", {\n      _tokenizer: childFlow,\n      contentType: \"flow\",\n      previous: childToken\n    });\n    return flowContinue(code);\n  }\n\n  /** @type {State} */\n  function flowContinue(code) {\n    if (code === null) {\n      writeToChild(effects.exit(\"chunkFlow\"), true);\n      exitContainers(0);\n      effects.consume(code);\n      return;\n    }\n    if (markdownLineEnding(code)) {\n      effects.consume(code);\n      writeToChild(effects.exit(\"chunkFlow\"));\n      // Get ready for the next line.\n      continued = 0;\n      self.interrupt = undefined;\n      return start;\n    }\n    effects.consume(code);\n    return flowContinue;\n  }\n\n  /**\n   * @param {Token} token\n   *   Token.\n   * @param {boolean | undefined} [endOfFile]\n   *   Whether the token is at the end of the file (default: `false`).\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function writeToChild(token, endOfFile) {\n    const stream = self.sliceStream(token);\n    if (endOfFile) stream.push(null);\n    token.previous = childToken;\n    if (childToken) childToken.next = token;\n    childToken = token;\n    childFlow.defineSkip(token.start);\n    childFlow.write(stream);\n\n    // Alright, so we just added a lazy line:\n    //\n    // ```markdown\n    // > a\n    // b.\n    //\n    // Or:\n    //\n    // > ~~~c\n    // d\n    //\n    // Or:\n    //\n    // > | e |\n    // f\n    // ```\n    //\n    // The construct in the second example (fenced code) does not accept lazy\n    // lines, so it marked itself as done at the end of its first line, and\n    // then the content construct parses `d`.\n    // Most constructs in markdown match on the first line: if the first line\n    // forms a construct, a non-lazy line can’t “unmake” it.\n    //\n    // The construct in the third example is potentially a GFM table, and\n    // those are *weird*.\n    // It *could* be a table, from the first line, if the following line\n    // matches a condition.\n    // In this case, that second line is lazy, which “unmakes” the first line\n    // and turns the whole into one content block.\n    //\n    // We’ve now parsed the non-lazy and the lazy line, and can figure out\n    // whether the lazy line started a new flow block.\n    // If it did, we exit the current containers between the two flow blocks.\n    if (self.parser.lazy[token.start.line]) {\n      let index = childFlow.events.length;\n      while (index--) {\n        if (\n        // The token starts before the line ending…\n        childFlow.events[index][1].start.offset < lineStartOffset && (\n        // …and either is not ended yet…\n        !childFlow.events[index][1].end ||\n        // …or ends after it.\n        childFlow.events[index][1].end.offset > lineStartOffset)) {\n          // Exit: there’s still something open, which means it’s a lazy line\n          // part of something.\n          return;\n        }\n      }\n\n      // Note: this algorithm for moving events around is similar to the\n      // algorithm when closing flow in `documentContinue`.\n      const indexBeforeExits = self.events.length;\n      let indexBeforeFlow = indexBeforeExits;\n      /** @type {boolean | undefined} */\n      let seen;\n      /** @type {Point | undefined} */\n      let point;\n\n      // Find the previous chunk (the one before the lazy line).\n      while (indexBeforeFlow--) {\n        if (self.events[indexBeforeFlow][0] === 'exit' && self.events[indexBeforeFlow][1].type === \"chunkFlow\") {\n          if (seen) {\n            point = self.events[indexBeforeFlow][1].end;\n            break;\n          }\n          seen = true;\n        }\n      }\n      exitContainers(continued);\n\n      // Fix positions.\n      index = indexBeforeExits;\n      while (index < self.events.length) {\n        self.events[index][1].end = {\n          ...point\n        };\n        index++;\n      }\n\n      // Inject the exits earlier (they’re still also at the end).\n      splice(self.events, indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits));\n\n      // Discard the duplicate exits.\n      self.events.length = index;\n    }\n  }\n\n  /**\n   * @param {number} size\n   *   Size.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function exitContainers(size) {\n    let index = stack.length;\n\n    // Exit open containers.\n    while (index-- > size) {\n      const entry = stack[index];\n      self.containerState = entry[1];\n      entry[0].exit.call(self, effects);\n    }\n    stack.length = size;\n  }\n  function closeFlow() {\n    childFlow.write([null]);\n    childToken = undefined;\n    childFlow = undefined;\n    self.containerState._closeFlow = undefined;\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n *   Tokenizer.\n */\nfunction tokenizeContainer(effects, ok, nok) {\n  // Always populated by defaults.\n\n  return factorySpace(effects, effects.attempt(this.parser.constructs.document, ok, nok), \"linePrefix\", this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4);\n}"],"x_google_ignoreList":[0],"mappings":";;;;AAuBA,IAAa,IAAW,EACtB,UAAU,GACX,EAGK,IAAqB,EACzB,UAAU,GACX;AAQD,SAAS,EAAmB,GAAS;CACnC,IAAM,IAAO,MAEP,IAAQ,EAAE,EACZ,IAAY,GAEZ,GAEA,GAEA;AACJ,QAAO;CAGP,SAAS,EAAM,GAAM;AAWnB,MAAI,IAAY,EAAM,QAAQ;GAC5B,IAAM,IAAO,EAAM;AAEnB,UADA,EAAK,iBAAiB,EAAK,IACpB,EAAQ,QAAQ,EAAK,GAAG,cAAc,GAAkB,EAAmB,CAAC,EAAK;;AAI1F,SAAO,EAAmB,EAAK;;CAIjC,SAAS,EAAiB,GAAM;AAM9B,MALA,KAKI,EAAK,eAAe,YAAY;AAElC,GADA,EAAK,eAAe,aAAa,KAAA,GAC7B,KACF,GAAW;GAKb,IAAM,IAAmB,EAAK,OAAO,QACjC,IAAkB,GAElB;AAGJ,UAAO,KACL,KAAI,EAAK,OAAO,GAAiB,OAAO,UAAU,EAAK,OAAO,GAAiB,GAAG,SAAS,aAAa;AACtG,QAAQ,EAAK,OAAO,GAAiB,GAAG;AACxC;;AAGJ,KAAe,EAAU;GAGzB,IAAI,IAAQ;AACZ,UAAO,IAAQ,EAAK,OAAO,QAIzB,CAHA,EAAK,OAAO,GAAO,GAAG,MAAM,EAC1B,GAAG,GACJ,EACD;AAQF,UAJA,EAAO,EAAK,QAAQ,IAAkB,GAAG,GAAG,EAAK,OAAO,MAAM,EAAiB,CAAC,EAGhF,EAAK,OAAO,SAAS,GACd,EAAmB,EAAK;;AAEjC,SAAO,EAAM,EAAK;;CAIpB,SAAS,EAAmB,GAAM;AAMhC,MAAI,MAAc,EAAM,QAAQ;AAI9B,OAAI,CAAC,EACH,QAAO,EAAkB,EAAK;AAMhC,OAAI,EAAU,oBAAoB,EAAU,iBAAiB,SAC3D,QAAO,EAAU,EAAK;AAQxB,KAAK,YAAY,GAAQ,EAAU,oBAAoB,CAAC,EAAU;;AAKpE,SADA,EAAK,iBAAiB,EAAE,EACjB,EAAQ,MAAM,GAAoB,GAAsB,EAAsB,CAAC,EAAK;;CAI7F,SAAS,EAAqB,GAAM;AAGlC,SAFI,KAAW,GAAW,EAC1B,EAAe,EAAU,EAClB,EAAkB,EAAK;;CAIhC,SAAS,EAAsB,GAAM;AAGnC,SAFA,EAAK,OAAO,KAAK,EAAK,KAAK,CAAC,QAAQ,MAAc,EAAM,QACxD,IAAkB,EAAK,KAAK,CAAC,QACtB,EAAU,EAAK;;CAIxB,SAAS,EAAkB,GAAM;AAG/B,SADA,EAAK,iBAAiB,EAAE,EACjB,EAAQ,QAAQ,GAAoB,GAAmB,EAAU,CAAC,EAAK;;CAIhF,SAAS,EAAkB,GAAM;AAI/B,SAHA,KACA,EAAM,KAAK,CAAC,EAAK,kBAAkB,EAAK,eAAe,CAAC,EAEjD,EAAkB,EAAK;;CAIhC,SAAS,EAAU,GAAM;AACvB,MAAI,MAAS,MAAM;AAGjB,GAFI,KAAW,GAAW,EAC1B,EAAe,EAAE,EACjB,EAAQ,QAAQ,EAAK;AACrB;;AAQF,SANA,MAAyB,EAAK,OAAO,KAAK,EAAK,KAAK,CAAC,EACrD,EAAQ,MAAM,aAAa;GACzB,YAAY;GACZ,aAAa;GACb,UAAU;GACX,CAAC,EACK,EAAa,EAAK;;CAI3B,SAAS,EAAa,GAAM;AAC1B,MAAI,MAAS,MAAM;AAGjB,GAFA,EAAa,EAAQ,KAAK,YAAY,EAAE,GAAK,EAC7C,EAAe,EAAE,EACjB,EAAQ,QAAQ,EAAK;AACrB;;AAWF,SATI,EAAmB,EAAK,IAC1B,EAAQ,QAAQ,EAAK,EACrB,EAAa,EAAQ,KAAK,YAAY,CAAC,EAEvC,IAAY,GACZ,EAAK,YAAY,KAAA,GACV,MAET,EAAQ,QAAQ,EAAK,EACd;;CAWT,SAAS,EAAa,GAAO,GAAW;EACtC,IAAM,IAAS,EAAK,YAAY,EAAM;AAyCtC,MAxCI,KAAW,EAAO,KAAK,KAAK,EAChC,EAAM,WAAW,GACb,MAAY,EAAW,OAAO,IAClC,IAAa,GACb,EAAU,WAAW,EAAM,MAAM,EACjC,EAAU,MAAM,EAAO,EAmCnB,EAAK,OAAO,KAAK,EAAM,MAAM,OAAO;GACtC,IAAI,IAAQ,EAAU,OAAO;AAC7B,UAAO,KACL,KAEA,EAAU,OAAO,GAAO,GAAG,MAAM,SAAS,MAE1C,CAAC,EAAU,OAAO,GAAO,GAAG,OAE5B,EAAU,OAAO,GAAO,GAAG,IAAI,SAAS,GAGtC;GAMJ,IAAM,IAAmB,EAAK,OAAO,QACjC,IAAkB,GAElB,GAEA;AAGJ,UAAO,KACL,KAAI,EAAK,OAAO,GAAiB,OAAO,UAAU,EAAK,OAAO,GAAiB,GAAG,SAAS,aAAa;AACtG,QAAI,GAAM;AACR,SAAQ,EAAK,OAAO,GAAiB,GAAG;AACxC;;AAEF,QAAO;;AAOX,QAJA,EAAe,EAAU,EAGzB,IAAQ,GACD,IAAQ,EAAK,OAAO,QAIzB,CAHA,EAAK,OAAO,GAAO,GAAG,MAAM,EAC1B,GAAG,GACJ,EACD;AAOF,GAHA,EAAO,EAAK,QAAQ,IAAkB,GAAG,GAAG,EAAK,OAAO,MAAM,EAAiB,CAAC,EAGhF,EAAK,OAAO,SAAS;;;CAUzB,SAAS,EAAe,GAAM;EAC5B,IAAI,IAAQ,EAAM;AAGlB,SAAO,MAAU,IAAM;GACrB,IAAM,IAAQ,EAAM;AAEpB,GADA,EAAK,iBAAiB,EAAM,IAC5B,EAAM,GAAG,KAAK,KAAK,GAAM,EAAQ;;AAEnC,IAAM,SAAS;;CAEjB,SAAS,IAAY;AAInB,EAHA,EAAU,MAAM,CAAC,KAAK,CAAC,EACvB,IAAa,KAAA,GACb,IAAY,KAAA,GACZ,EAAK,eAAe,aAAa,KAAA;;;AAUrC,SAAS,EAAkB,GAAS,GAAI,GAAK;AAG3C,QAAO,EAAa,GAAS,EAAQ,QAAQ,KAAK,OAAO,WAAW,UAAU,GAAI,EAAI,EAAE,cAAc,KAAK,OAAO,WAAW,QAAQ,KAAK,SAAS,eAAe,GAAG,KAAA,IAAY,EAAE"}

package/dist/node_modules/micromark/lib/initialize/flow.js

@@ -0,0 +1,27 @@
+import { factorySpace as e } from "../../../micromark-factory-space/index.js";
+import { blankLine as t } from "../../../micromark-core-commonmark/lib/blank-line.js";
+import { content as n } from "../../../micromark-core-commonmark/lib/content.js";
+//#region node_modules/micromark/lib/initialize/flow.js
+var r = { tokenize: i };
+function i(r) {
+	let i = this, a = r.attempt(t, o, r.attempt(this.parser.constructs.flowInitial, s, e(r, r.attempt(this.parser.constructs.flow, s, r.attempt(n, s)), "linePrefix")));
+	return a;
+	function o(e) {
+		if (e === null) {
+			r.consume(e);
+			return;
+		}
+		return r.enter("lineEndingBlank"), r.consume(e), r.exit("lineEndingBlank"), i.currentConstruct = void 0, a;
+	}
+	function s(e) {
+		if (e === null) {
+			r.consume(e);
+			return;
+		}
+		return r.enter("lineEnding"), r.consume(e), r.exit("lineEnding"), i.currentConstruct = void 0, a;
+	}
+}
+//#endregion
+export { r as flow };
+
+//# sourceMappingURL=flow.js.map

package/dist/node_modules/micromark/lib/initialize/flow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow.js","names":[],"sources":["../../../../../node_modules/micromark/lib/initialize/flow.js"],"sourcesContent":["/**\n * @import {\n *   InitialConstruct,\n *   Initializer,\n *   State,\n *   TokenizeContext\n * } from 'micromark-util-types'\n */\n\nimport { blankLine, content } from 'micromark-core-commonmark';\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {InitialConstruct} */\nexport const flow = {\n  tokenize: initializeFlow\n};\n\n/**\n * @this {TokenizeContext}\n *   Self.\n * @type {Initializer}\n *   Initializer.\n */\nfunction initializeFlow(effects) {\n  const self = this;\n  const initial = effects.attempt(\n  // Try to parse a blank line.\n  blankLine, atBlankEnding,\n  // Try to parse initial flow (essentially, only code).\n  effects.attempt(this.parser.constructs.flowInitial, afterConstruct, factorySpace(effects, effects.attempt(this.parser.constructs.flow, afterConstruct, effects.attempt(content, afterConstruct)), \"linePrefix\")));\n  return initial;\n\n  /** @type {State} */\n  function atBlankEnding(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n    effects.enter(\"lineEndingBlank\");\n    effects.consume(code);\n    effects.exit(\"lineEndingBlank\");\n    self.currentConstruct = undefined;\n    return initial;\n  }\n\n  /** @type {State} */\n  function afterConstruct(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    self.currentConstruct = undefined;\n    return initial;\n  }\n}"],"x_google_ignoreList":[0],"mappings":";;;;AAaA,IAAa,IAAO,EAClB,UAAU,GACX;AAQD,SAAS,EAAe,GAAS;CAC/B,IAAM,IAAO,MACP,IAAU,EAAQ,QAExB,GAAW,GAEX,EAAQ,QAAQ,KAAK,OAAO,WAAW,aAAa,GAAgB,EAAa,GAAS,EAAQ,QAAQ,KAAK,OAAO,WAAW,MAAM,GAAgB,EAAQ,QAAQ,GAAS,EAAe,CAAC,EAAE,aAAa,CAAC,CAAC;AACjN,QAAO;CAGP,SAAS,EAAc,GAAM;AAC3B,MAAI,MAAS,MAAM;AACjB,KAAQ,QAAQ,EAAK;AACrB;;AAMF,SAJA,EAAQ,MAAM,kBAAkB,EAChC,EAAQ,QAAQ,EAAK,EACrB,EAAQ,KAAK,kBAAkB,EAC/B,EAAK,mBAAmB,KAAA,GACjB;;CAIT,SAAS,EAAe,GAAM;AAC5B,MAAI,MAAS,MAAM;AACjB,KAAQ,QAAQ,EAAK;AACrB;;AAMF,SAJA,EAAQ,MAAM,aAAa,EAC3B,EAAQ,QAAQ,EAAK,EACrB,EAAQ,KAAK,aAAa,EAC1B,EAAK,mBAAmB,KAAA,GACjB"}

package/dist/node_modules/micromark/lib/initialize/text.js

@@ -0,0 +1,88 @@
+//#region node_modules/micromark/lib/initialize/text.js
+var e = { resolveAll: i() }, t = r("string"), n = r("text");
+function r(e) {
+	return {
+		resolveAll: i(e === "text" ? a : void 0),
+		tokenize: t
+	};
+	function t(t) {
+		let n = this, r = this.parser.constructs[e], i = t.attempt(r, a, o);
+		return a;
+		function a(e) {
+			return c(e) ? i(e) : o(e);
+		}
+		function o(e) {
+			if (e === null) {
+				t.consume(e);
+				return;
+			}
+			return t.enter("data"), t.consume(e), s;
+		}
+		function s(e) {
+			return c(e) ? (t.exit("data"), i(e)) : (t.consume(e), s);
+		}
+		function c(e) {
+			if (e === null) return !0;
+			let t = r[e], i = -1;
+			if (t) for (; ++i < t.length;) {
+				let e = t[i];
+				if (!e.previous || e.previous.call(n, n.previous)) return !0;
+			}
+			return !1;
+		}
+	}
+}
+function i(e) {
+	return t;
+	function t(t, n) {
+		let r = -1, i;
+		for (; ++r <= t.length;) i === void 0 ? t[r] && t[r][1].type === "data" && (i = r, r++) : (!t[r] || t[r][1].type !== "data") && (r !== i + 2 && (t[i][1].end = t[r - 1][1].end, t.splice(i + 2, r - i - 2), r = i + 2), i = void 0);
+		return e ? e(t, n) : t;
+	}
+}
+function a(e, t) {
+	let n = 0;
+	for (; ++n <= e.length;) if ((n === e.length || e[n][1].type === "lineEnding") && e[n - 1][1].type === "data") {
+		let r = e[n - 1][1], i = t.sliceStream(r), a = i.length, o = -1, s = 0, c;
+		for (; a--;) {
+			let e = i[a];
+			if (typeof e == "string") {
+				for (o = e.length; e.charCodeAt(o - 1) === 32;) s++, o--;
+				if (o) break;
+				o = -1;
+			} else if (e === -2) c = !0, s++;
+			else if (e !== -1) {
+				a++;
+				break;
+			}
+		}
+		if (t._contentTypeTextTrailing && n === e.length && (s = 0), s) {
+			let i = {
+				type: n === e.length || c || s < 2 ? "lineSuffix" : "hardBreakTrailing",
+				start: {
+					_bufferIndex: a ? o : r.start._bufferIndex + o,
+					_index: r.start._index + a,
+					line: r.end.line,
+					column: r.end.column - s,
+					offset: r.end.offset - s
+				},
+				end: { ...r.end }
+			};
+			r.end = { ...i.start }, r.start.offset === r.end.offset ? Object.assign(r, i) : (e.splice(n, 0, [
+				"enter",
+				i,
+				t
+			], [
+				"exit",
+				i,
+				t
+			]), n += 2);
+		}
+		n++;
+	}
+	return e;
+}
+//#endregion
+export { e as resolver, t as string, n as text };
+
+//# sourceMappingURL=text.js.map

package/dist/node_modules/micromark/lib/initialize/text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.js","names":[],"sources":["../../../../../node_modules/micromark/lib/initialize/text.js"],"sourcesContent":["/**\n * @import {\n *   Code,\n *   InitialConstruct,\n *   Initializer,\n *   Resolver,\n *   State,\n *   TokenizeContext\n * } from 'micromark-util-types'\n */\n\nexport const resolver = {\n  resolveAll: createResolver()\n};\nexport const string = initializeFactory('string');\nexport const text = initializeFactory('text');\n\n/**\n * @param {'string' | 'text'} field\n *   Field.\n * @returns {InitialConstruct}\n *   Construct.\n */\nfunction initializeFactory(field) {\n  return {\n    resolveAll: createResolver(field === 'text' ? resolveAllLineSuffixes : undefined),\n    tokenize: initializeText\n  };\n\n  /**\n   * @this {TokenizeContext}\n   *   Context.\n   * @type {Initializer}\n   */\n  function initializeText(effects) {\n    const self = this;\n    const constructs = this.parser.constructs[field];\n    const text = effects.attempt(constructs, start, notText);\n    return start;\n\n    /** @type {State} */\n    function start(code) {\n      return atBreak(code) ? text(code) : notText(code);\n    }\n\n    /** @type {State} */\n    function notText(code) {\n      if (code === null) {\n        effects.consume(code);\n        return;\n      }\n      effects.enter(\"data\");\n      effects.consume(code);\n      return data;\n    }\n\n    /** @type {State} */\n    function data(code) {\n      if (atBreak(code)) {\n        effects.exit(\"data\");\n        return text(code);\n      }\n\n      // Data.\n      effects.consume(code);\n      return data;\n    }\n\n    /**\n     * @param {Code} code\n     *   Code.\n     * @returns {boolean}\n     *   Whether the code is a break.\n     */\n    function atBreak(code) {\n      if (code === null) {\n        return true;\n      }\n      const list = constructs[code];\n      let index = -1;\n      if (list) {\n        // Always populated by defaults.\n\n        while (++index < list.length) {\n          const item = list[index];\n          if (!item.previous || item.previous.call(self, self.previous)) {\n            return true;\n          }\n        }\n      }\n      return false;\n    }\n  }\n}\n\n/**\n * @param {Resolver | undefined} [extraResolver]\n *   Resolver.\n * @returns {Resolver}\n *   Resolver.\n */\nfunction createResolver(extraResolver) {\n  return resolveAllText;\n\n  /** @type {Resolver} */\n  function resolveAllText(events, context) {\n    let index = -1;\n    /** @type {number | undefined} */\n    let enter;\n\n    // A rather boring computation (to merge adjacent `data` events) which\n    // improves mm performance by 29%.\n    while (++index <= events.length) {\n      if (enter === undefined) {\n        if (events[index] && events[index][1].type === \"data\") {\n          enter = index;\n          index++;\n        }\n      } else if (!events[index] || events[index][1].type !== \"data\") {\n        // Don’t do anything if there is one data token.\n        if (index !== enter + 2) {\n          events[enter][1].end = events[index - 1][1].end;\n          events.splice(enter + 2, index - enter - 2);\n          index = enter + 2;\n        }\n        enter = undefined;\n      }\n    }\n    return extraResolver ? extraResolver(events, context) : events;\n  }\n}\n\n/**\n * A rather ugly set of instructions which again looks at chunks in the input\n * stream.\n * The reason to do this here is that it is *much* faster to parse in reverse.\n * And that we can’t hook into `null` to split the line suffix before an EOF.\n * To do: figure out if we can make this into a clean utility, or even in core.\n * As it will be useful for GFMs literal autolink extension (and maybe even\n * tables?)\n *\n * @type {Resolver}\n */\nfunction resolveAllLineSuffixes(events, context) {\n  let eventIndex = 0; // Skip first.\n\n  while (++eventIndex <= events.length) {\n    if ((eventIndex === events.length || events[eventIndex][1].type === \"lineEnding\") && events[eventIndex - 1][1].type === \"data\") {\n      const data = events[eventIndex - 1][1];\n      const chunks = context.sliceStream(data);\n      let index = chunks.length;\n      let bufferIndex = -1;\n      let size = 0;\n      /** @type {boolean | undefined} */\n      let tabs;\n      while (index--) {\n        const chunk = chunks[index];\n        if (typeof chunk === 'string') {\n          bufferIndex = chunk.length;\n          while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n            size++;\n            bufferIndex--;\n          }\n          if (bufferIndex) break;\n          bufferIndex = -1;\n        }\n        // Number\n        else if (chunk === -2) {\n          tabs = true;\n          size++;\n        } else if (chunk === -1) {\n          // Empty\n        } else {\n          // Replacement character, exit.\n          index++;\n          break;\n        }\n      }\n\n      // Allow final trailing whitespace.\n      if (context._contentTypeTextTrailing && eventIndex === events.length) {\n        size = 0;\n      }\n      if (size) {\n        const token = {\n          type: eventIndex === events.length || tabs || size < 2 ? \"lineSuffix\" : \"hardBreakTrailing\",\n          start: {\n            _bufferIndex: index ? bufferIndex : data.start._bufferIndex + bufferIndex,\n            _index: data.start._index + index,\n            line: data.end.line,\n            column: data.end.column - size,\n            offset: data.end.offset - size\n          },\n          end: {\n            ...data.end\n          }\n        };\n        data.end = {\n          ...token.start\n        };\n        if (data.start.offset === data.end.offset) {\n          Object.assign(data, token);\n        } else {\n          events.splice(eventIndex, 0, ['enter', token, context], ['exit', token, context]);\n          eventIndex += 2;\n        }\n      }\n      eventIndex++;\n    }\n  }\n  return events;\n}"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node_modules/micromark/lib/parse.js

@@ -0,0 +1,31 @@
+import { combineExtensions as e } from "../../micromark-util-combine-extensions/index.js";
+import { content as t } from "./initialize/content.js";
+import { document as n } from "./initialize/document.js";
+import { flow as r } from "./initialize/flow.js";
+import { string as i, text as a } from "./initialize/text.js";
+import { constructs_exports as o } from "./constructs.js";
+import { createTokenizer as s } from "./create-tokenizer.js";
+//#region node_modules/micromark/lib/parse.js
+function c(c) {
+	let l = {
+		constructs: e([o, ...(c || {}).extensions || []]),
+		content: u(t),
+		defined: [],
+		document: u(n),
+		flow: u(r),
+		lazy: {},
+		string: u(i),
+		text: u(a)
+	};
+	return l;
+	function u(e) {
+		return t;
+		function t(t) {
+			return s(l, e, t);
+		}
+	}
+}
+//#endregion
+export { c as parse };
+
+//# sourceMappingURL=parse.js.map

package/dist/node_modules/micromark/lib/parse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.js","names":["defaultConstructs"],"sources":["../../../../node_modules/micromark/lib/parse.js"],"sourcesContent":["/**\n * @import {\n *   Create,\n *   FullNormalizedExtension,\n *   InitialConstruct,\n *   ParseContext,\n *   ParseOptions\n * } from 'micromark-util-types'\n */\n\nimport { combineExtensions } from 'micromark-util-combine-extensions';\nimport { content } from './initialize/content.js';\nimport { document } from './initialize/document.js';\nimport { flow } from './initialize/flow.js';\nimport { string, text } from './initialize/text.js';\nimport * as defaultConstructs from './constructs.js';\nimport { createTokenizer } from './create-tokenizer.js';\n\n/**\n * @param {ParseOptions | null | undefined} [options]\n *   Configuration (optional).\n * @returns {ParseContext}\n *   Parser.\n */\nexport function parse(options) {\n  const settings = options || {};\n  const constructs = /** @type {FullNormalizedExtension} */\n  combineExtensions([defaultConstructs, ...(settings.extensions || [])]);\n\n  /** @type {ParseContext} */\n  const parser = {\n    constructs,\n    content: create(content),\n    defined: [],\n    document: create(document),\n    flow: create(flow),\n    lazy: {},\n    string: create(string),\n    text: create(text)\n  };\n  return parser;\n\n  /**\n   * @param {InitialConstruct} initial\n   *   Construct to start with.\n   * @returns {Create}\n   *   Create a tokenizer.\n   */\n  function create(initial) {\n    return creator;\n    /** @type {Create} */\n    function creator(from) {\n      return createTokenizer(parser, initial, from);\n    }\n  }\n}"],"x_google_ignoreList":[0],"mappings":";;;;;;;;AAwBA,SAAgB,EAAM,GAAS;CAM7B,IAAM,IAAS;EACb,YAJF,EAAkB,CAACA,GAAmB,IAFrB,KAAW,EAAE,EAEqB,cAAc,EAAE,CAAE,CAAC;EAKpE,SAAS,EAAO,EAAQ;EACxB,SAAS,EAAE;EACX,UAAU,EAAO,EAAS;EAC1B,MAAM,EAAO,EAAK;EAClB,MAAM,EAAE;EACR,QAAQ,EAAO,EAAO;EACtB,MAAM,EAAO,EAAK;EACnB;AACD,QAAO;CAQP,SAAS,EAAO,GAAS;AACvB,SAAO;EAEP,SAAS,EAAQ,GAAM;AACrB,UAAO,EAAgB,GAAQ,GAAS,EAAK"}

package/dist/node_modules/micromark/lib/postprocess.js

@@ -0,0 +1,10 @@
+import { subtokenize as e } from "../../micromark-util-subtokenize/index.js";
+//#region node_modules/micromark/lib/postprocess.js
+function t(t) {
+	for (; !e(t););
+	return t;
+}
+//#endregion
+export { t as postprocess };
+
+//# sourceMappingURL=postprocess.js.map

package/dist/node_modules/micromark/lib/postprocess.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"postprocess.js","names":[],"sources":["../../../../node_modules/micromark/lib/postprocess.js"],"sourcesContent":["/**\n * @import {Event} from 'micromark-util-types'\n */\n\nimport { subtokenize } from 'micromark-util-subtokenize';\n\n/**\n * @param {Array<Event>} events\n *   Events.\n * @returns {Array<Event>}\n *   Events.\n */\nexport function postprocess(events) {\n  while (!subtokenize(events)) {\n    // Empty\n  }\n  return events;\n}"],"x_google_ignoreList":[0],"mappings":";;AAYA,SAAgB,EAAY,GAAQ;AAClC,QAAO,CAAC,EAAY,EAAO;AAG3B,QAAO"}

package/dist/node_modules/micromark/lib/preprocess.js

@@ -0,0 +1,34 @@
+//#region node_modules/micromark/lib/preprocess.js
+var e = /[\0\t\n\r]/g;
+function t() {
+	let t = 1, n = "", r = !0, i;
+	return a;
+	function a(a, o, s) {
+		let c = [], l, u, d, f, p;
+		for (a = n + (typeof a == "string" ? a.toString() : new TextDecoder(o || void 0).decode(a)), d = 0, n = "", r &&= (a.charCodeAt(0) === 65279 && d++, void 0); d < a.length;) {
+			if (e.lastIndex = d, l = e.exec(a), f = l && l.index !== void 0 ? l.index : a.length, p = a.charCodeAt(f), !l) {
+				n = a.slice(d);
+				break;
+			}
+			if (p === 10 && d === f && i) c.push(-3), i = void 0;
+			else switch (i &&= (c.push(-5), void 0), d < f && (c.push(a.slice(d, f)), t += f - d), p) {
+				case 0:
+					c.push(65533), t++;
+					break;
+				case 9:
+					for (u = Math.ceil(t / 4) * 4, c.push(-2); t++ < u;) c.push(-1);
+					break;
+				case 10:
+					c.push(-4), t = 1;
+					break;
+				default: i = !0, t = 1;
+			}
+			d = f + 1;
+		}
+		return s && (i && c.push(-5), n && c.push(n), c.push(null)), c;
+	}
+}
+//#endregion
+export { t as preprocess };
+
+//# sourceMappingURL=preprocess.js.map