@loopstack/loopstack-studio 0.21.0 → 0.21.1

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

@@ -0,0 +1,175 @@
+import { markdownLineEnding } from "../../micromark-util-character/index.js";
+import { push, splice } from "../../micromark-util-chunked/index.js";
+import { resolveAll } from "../../micromark-util-resolve-all/index.js";
+function createTokenizer(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 _(e) {
+		return f = push(f, e), S(), f[f.length - 1] === null ? (A(s, 0), h.events = resolveAll(d, h.events, h), h.events) : [];
+	}
+	function v(e, t) {
+		return serializeChunks(y(e), t);
+	}
+	function y(e) {
+		return sliceChunks(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(t) {
+		markdownLineEnding(t) ? (l.line++, l.column = 1, l.offset += t === -3 ? 2 : 1, M()) : t !== -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 = t;
+	}
+	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, t) {
+		e.resolveAll && !d.includes(e) && d.push(e), e.resolve && splice(h.events, t, h.events.length - t, e.resolve(h.events.slice(t), 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 sliceChunks(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 serializeChunks(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("");
+}
+export { createTokenizer };

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

@@ -0,0 +1,32 @@
+import { markdownLineEnding } from "../../../micromark-util-character/index.js";
+import { factorySpace } from "../../../micromark-factory-space/index.js";
+const content = { tokenize: initializeContent };
+function initializeContent(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"), factorySpace(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 markdownLineEnding(t) ? (n.consume(t), n.exit("chunkText"), s) : (n.consume(t), c);
+	}
+}
+export { content };

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

@@ -0,0 +1,101 @@
+import { markdownLineEnding } from "../../../micromark-util-character/index.js";
+import { splice } from "../../../micromark-util-chunked/index.js";
+import { factorySpace } from "../../../micromark-factory-space/index.js";
+const document = { tokenize: initializeDocument };
+var containerConstruct = { tokenize: tokenizeContainer };
+function initializeDocument(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(e) {
+		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 splice(r.events, i + 1, 0, r.events.slice(n)), r.events.length = c, f(e);
+		}
+		return u(e);
+	}
+	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(containerConstruct, 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(containerConstruct, 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(t) {
+		if (t === null) {
+			y(n.exit("chunkFlow"), !0), b(0), n.consume(t);
+			return;
+		}
+		return markdownLineEnding(t) ? (n.consume(t), y(n.exit("chunkFlow")), o = 0, r.interrupt = void 0, u) : (n.consume(t), v);
+	}
+	function y(e, n) {
+		let i = r.sliceStream(e);
+		if (n && i.push(null), e.previous = c, c && (c.next = e), c = e, s.defineSkip(e.start), s.write(i), r.parser.lazy[e.start.line]) {
+			let e = s.events.length;
+			for (; e--;) if (s.events[e][1].start.offset < l && (!s.events[e][1].end || s.events[e][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), e = n; e < r.events.length;) r.events[e][1].end = { ...c }, e++;
+			splice(r.events, i + 1, 0, r.events.slice(n)), r.events.length = e;
+		}
+	}
+	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 tokenizeContainer(e, t, r) {
+	return factorySpace(e, e.attempt(this.parser.constructs.document, t, r), "linePrefix", this.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4);
+}
+export { document };

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

@@ -0,0 +1,23 @@
+import { factorySpace } from "../../../micromark-factory-space/index.js";
+import { blankLine } from "../../../micromark-core-commonmark/lib/blank-line.js";
+import { content } from "../../../micromark-core-commonmark/lib/content.js";
+const flow = { tokenize: initializeFlow };
+function initializeFlow(r) {
+	let i = this, a = r.attempt(blankLine, o, r.attempt(this.parser.constructs.flowInitial, s, factorySpace(r, r.attempt(this.parser.constructs.flow, s, r.attempt(content, 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;
+	}
+}
+export { flow };

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

@@ -0,0 +1,84 @@
+const resolver = { resolveAll: createResolver() }, string = initializeFactory("string"), text = initializeFactory("text");
+function initializeFactory(e) {
+	return {
+		resolveAll: createResolver(e === "text" ? resolveAllLineSuffixes : 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 createResolver(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 resolveAllLineSuffixes(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;
+}
+export { resolver, string, text };

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

@@ -0,0 +1,27 @@
+import { combineExtensions } from "../../micromark-util-combine-extensions/index.js";
+import { content } from "./initialize/content.js";
+import { document } from "./initialize/document.js";
+import { flow } from "./initialize/flow.js";
+import { string, text } from "./initialize/text.js";
+import { constructs_exports } from "./constructs.js";
+import { createTokenizer } from "./create-tokenizer.js";
+function parse(c) {
+	let l = {
+		constructs: combineExtensions([constructs_exports, ...(c || {}).extensions || []]),
+		content: u(content),
+		defined: [],
+		document: u(document),
+		flow: u(flow),
+		lazy: {},
+		string: u(string),
+		text: u(text)
+	};
+	return l;
+	function u(e) {
+		return s;
+		function s(s) {
+			return createTokenizer(l, e, s);
+		}
+	}
+}
+export { parse };

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

@@ -0,0 +1,6 @@
+import { subtokenize } from "../../micromark-util-subtokenize/index.js";
+function postprocess(t) {
+	for (; !subtokenize(t););
+	return t;
+}
+export { postprocess };

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

@@ -0,0 +1,30 @@
+var search = /[\0\t\n\r]/g;
+function preprocess() {
+	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 (search.lastIndex = d, l = search.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;
+	}
+}
+export { preprocess };

package/dist/node_modules/micromark-core-commonmark/lib/attention.js

@@ -0,0 +1,112 @@
+import { classifyCharacter } from "../../micromark-util-classify-character/index.js";
+import { push, splice } from "../../micromark-util-chunked/index.js";
+import { resolveAll } from "../../micromark-util-resolve-all/index.js";
+const attention = {
+	name: "attention",
+	resolveAll: resolveAllAttention,
+	tokenize: tokenizeAttention
+};
+function resolveAllAttention(e, i) {
+	let a = -1, o, c, l, u, d, f, p, m;
+	for (; ++a < e.length;) if (e[a][0] === "enter" && e[a][1].type === "attentionSequence" && e[a][1]._close) {
+		for (o = a; o--;) if (e[o][0] === "exit" && e[o][1].type === "attentionSequence" && e[o][1]._open && i.sliceSerialize(e[o][1]).charCodeAt(0) === i.sliceSerialize(e[a][1]).charCodeAt(0)) {
+			if ((e[o][1]._close || e[a][1]._open) && (e[a][1].end.offset - e[a][1].start.offset) % 3 && !((e[o][1].end.offset - e[o][1].start.offset + e[a][1].end.offset - e[a][1].start.offset) % 3)) continue;
+			f = e[o][1].end.offset - e[o][1].start.offset > 1 && e[a][1].end.offset - e[a][1].start.offset > 1 ? 2 : 1;
+			let h = { ...e[o][1].end }, g = { ...e[a][1].start };
+			movePoint(h, -f), movePoint(g, f), u = {
+				type: f > 1 ? "strongSequence" : "emphasisSequence",
+				start: h,
+				end: { ...e[o][1].end }
+			}, d = {
+				type: f > 1 ? "strongSequence" : "emphasisSequence",
+				start: { ...e[a][1].start },
+				end: g
+			}, l = {
+				type: f > 1 ? "strongText" : "emphasisText",
+				start: { ...e[o][1].end },
+				end: { ...e[a][1].start }
+			}, c = {
+				type: f > 1 ? "strong" : "emphasis",
+				start: { ...u.start },
+				end: { ...d.end }
+			}, e[o][1].end = { ...u.start }, e[a][1].start = { ...d.end }, p = [], e[o][1].end.offset - e[o][1].start.offset && (p = push(p, [[
+				"enter",
+				e[o][1],
+				i
+			], [
+				"exit",
+				e[o][1],
+				i
+			]])), p = push(p, [
+				[
+					"enter",
+					c,
+					i
+				],
+				[
+					"enter",
+					u,
+					i
+				],
+				[
+					"exit",
+					u,
+					i
+				],
+				[
+					"enter",
+					l,
+					i
+				]
+			]), p = push(p, resolveAll(i.parser.constructs.insideSpan.null, e.slice(o + 1, a), i)), p = push(p, [
+				[
+					"exit",
+					l,
+					i
+				],
+				[
+					"enter",
+					d,
+					i
+				],
+				[
+					"exit",
+					d,
+					i
+				],
+				[
+					"exit",
+					c,
+					i
+				]
+			]), e[a][1].end.offset - e[a][1].start.offset ? (m = 2, p = push(p, [[
+				"enter",
+				e[a][1],
+				i
+			], [
+				"exit",
+				e[a][1],
+				i
+			]])) : m = 0, splice(e, o - 1, a - o + 3, p), a = o + p.length - m - 2;
+			break;
+		}
+	}
+	for (a = -1; ++a < e.length;) e[a][1].type === "attentionSequence" && (e[a][1].type = "data");
+	return e;
+}
+function tokenizeAttention(t, n) {
+	let r = this.parser.constructs.attentionMarkers.null, i = this.previous, a = classifyCharacter(i), o;
+	return s;
+	function s(e) {
+		return o = e, t.enter("attentionSequence"), c(e);
+	}
+	function c(s) {
+		if (s === o) return t.consume(s), c;
+		let l = t.exit("attentionSequence"), u = classifyCharacter(s), d = !u || u === 2 && a || r.includes(s), f = !a || a === 2 && u || r.includes(i);
+		return l._open = !!(o === 42 ? d : d && (a || !f)), l._close = !!(o === 42 ? f : f && (u || !d)), n(s);
+	}
+}
+function movePoint(e, t) {
+	e.column += t, e.offset += t, e._bufferIndex += t;
+}
+export { attention };

package/dist/node_modules/micromark-core-commonmark/lib/autolink.js

@@ -0,0 +1,41 @@
+import { asciiAlpha, asciiAlphanumeric, asciiAtext, asciiControl } from "../../micromark-util-character/index.js";
+const autolink = {
+	name: "autolink",
+	tokenize: tokenizeAutolink
+};
+function tokenizeAutolink(i, a, o) {
+	let s = 0;
+	return c;
+	function c(e) {
+		return i.enter("autolink"), i.enter("autolinkMarker"), i.consume(e), i.exit("autolinkMarker"), i.enter("autolinkProtocol"), l;
+	}
+	function l(r) {
+		return asciiAlpha(r) ? (i.consume(r), u) : r === 64 ? o(r) : p(r);
+	}
+	function u(e) {
+		return e === 43 || e === 45 || e === 46 || asciiAlphanumeric(e) ? (s = 1, d(e)) : p(e);
+	}
+	function d(e) {
+		return e === 58 ? (i.consume(e), s = 0, f) : (e === 43 || e === 45 || e === 46 || asciiAlphanumeric(e)) && s++ < 32 ? (i.consume(e), d) : (s = 0, p(e));
+	}
+	function f(e) {
+		return e === 62 ? (i.exit("autolinkProtocol"), i.enter("autolinkMarker"), i.consume(e), i.exit("autolinkMarker"), i.exit("autolink"), a) : e === null || e === 32 || e === 60 || asciiControl(e) ? o(e) : (i.consume(e), f);
+	}
+	function p(e) {
+		return e === 64 ? (i.consume(e), m) : asciiAtext(e) ? (i.consume(e), p) : o(e);
+	}
+	function m(e) {
+		return asciiAlphanumeric(e) ? h(e) : o(e);
+	}
+	function h(e) {
+		return e === 46 ? (i.consume(e), s = 0, m) : e === 62 ? (i.exit("autolinkProtocol").type = "autolinkEmail", i.enter("autolinkMarker"), i.consume(e), i.exit("autolinkMarker"), i.exit("autolink"), a) : g(e);
+	}
+	function g(e) {
+		if ((e === 45 || asciiAlphanumeric(e)) && s++ < 63) {
+			let r = e === 45 ? g : h;
+			return i.consume(e), r;
+		}
+		return o(e);
+	}
+}
+export { autolink };

package/dist/node_modules/micromark-core-commonmark/lib/block-quote.js

@@ -0,0 +1,36 @@
+import { markdownSpace } from "../../micromark-util-character/index.js";
+import { factorySpace } from "../../micromark-factory-space/index.js";
+const blockQuote = {
+	continuation: { tokenize: tokenizeBlockQuoteContinuation },
+	exit,
+	name: "blockQuote",
+	tokenize: tokenizeBlockQuoteStart
+};
+function tokenizeBlockQuoteStart(t, n, r) {
+	let i = this;
+	return a;
+	function a(e) {
+		if (e === 62) {
+			let n = i.containerState;
+			return n.open ||= (t.enter("blockQuote", { _container: !0 }), !0), t.enter("blockQuotePrefix"), t.enter("blockQuoteMarker"), t.consume(e), t.exit("blockQuoteMarker"), o;
+		}
+		return r(e);
+	}
+	function o(r) {
+		return markdownSpace(r) ? (t.enter("blockQuotePrefixWhitespace"), t.consume(r), t.exit("blockQuotePrefixWhitespace"), t.exit("blockQuotePrefix"), n) : (t.exit("blockQuotePrefix"), n(r));
+	}
+}
+function tokenizeBlockQuoteContinuation(r, i, a) {
+	let o = this;
+	return s;
+	function s(n) {
+		return markdownSpace(n) ? factorySpace(r, c, "linePrefix", o.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4)(n) : c(n);
+	}
+	function c(e) {
+		return r.attempt(blockQuote, i, a)(e);
+	}
+}
+function exit(e) {
+	e.exit("blockQuote");
+}
+export { blockQuote };

package/dist/node_modules/micromark-core-commonmark/lib/character-escape.js

@@ -0,0 +1,15 @@
+import { asciiPunctuation } from "../../micromark-util-character/index.js";
+const characterEscape = {
+	name: "characterEscape",
+	tokenize: tokenizeCharacterEscape
+};
+function tokenizeCharacterEscape(t, n, r) {
+	return i;
+	function i(e) {
+		return t.enter("characterEscape"), t.enter("escapeMarker"), t.consume(e), t.exit("escapeMarker"), a;
+	}
+	function a(i) {
+		return asciiPunctuation(i) ? (t.enter("characterEscapeValue"), t.consume(i), t.exit("characterEscapeValue"), t.exit("characterEscape"), n) : r(i);
+	}
+}
+export { characterEscape };