@loopstack/loopstack-studio 0.20.3 → 0.21.0-rc.0

package/dist/node_modules/mdast-util-find-and-replace/lib/index.js

@@ -0,0 +1,59 @@
+import { convert } from "../../unist-util-is/lib/index.js";
+import { visitParents } from "../../unist-util-visit-parents/lib/index.js";
+import escapeStringRegexp from "../node_modules/escape-string-regexp/index.js";
+function findAndReplace(n, r, a) {
+	let o = convert((a || {}).ignore || []), s = toPairs(r), c = -1;
+	for (; ++c < s.length;) visitParents(n, "text", l);
+	function l(e, t) {
+		let n = -1, r;
+		for (; ++n < t.length;) {
+			let e = t[n], i = r ? r.children : void 0;
+			if (o(e, i ? i.indexOf(e) : void 0, r)) return;
+			r = e;
+		}
+		if (r) return u(e, t);
+	}
+	function u(e, t) {
+		let n = t[t.length - 1], r = s[c][0], i = s[c][1], a = 0, o = n.children.indexOf(e), l = !1, u = [];
+		r.lastIndex = 0;
+		let d = r.exec(e.value);
+		for (; d;) {
+			let n = d.index, o = {
+				index: d.index,
+				input: d.input,
+				stack: [...t, e]
+			}, s = i(...d, o);
+			if (typeof s == "string" && (s = s.length > 0 ? {
+				type: "text",
+				value: s
+			} : void 0), s === !1 ? r.lastIndex = n + 1 : (a !== n && u.push({
+				type: "text",
+				value: e.value.slice(a, n)
+			}), Array.isArray(s) ? u.push(...s) : s && u.push(s), a = n + d[0].length, l = !0), !r.global) break;
+			d = r.exec(e.value);
+		}
+		return l ? (a < e.value.length && u.push({
+			type: "text",
+			value: e.value.slice(a)
+		}), n.children.splice(o, 1, ...u)) : u = [e], o + u.length;
+	}
+}
+function toPairs(e) {
+	let t = [];
+	if (!Array.isArray(e)) throw TypeError("Expected find and replace tuple or list of tuples");
+	let n = !e[0] || Array.isArray(e[0]) ? e : [e], r = -1;
+	for (; ++r < n.length;) {
+		let e = n[r];
+		t.push([toExpression(e[0]), toFunction(e[1])]);
+	}
+	return t;
+}
+function toExpression(e) {
+	return typeof e == "string" ? new RegExp(escapeStringRegexp(e), "g") : e;
+}
+function toFunction(e) {
+	return typeof e == "function" ? e : function() {
+		return e;
+	};
+}
+export { findAndReplace };

package/dist/node_modules/mdast-util-find-and-replace/node_modules/escape-string-regexp/index.js

@@ -0,0 +1,5 @@
+function escapeStringRegexp(e) {
+	if (typeof e != "string") throw TypeError("Expected a string");
+	return e.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
+}
+export { escapeStringRegexp as default };

package/dist/node_modules/mdast-util-gfm/lib/index.js

@@ -0,0 +1,24 @@
+import { gfmAutolinkLiteralFromMarkdown, gfmAutolinkLiteralToMarkdown } from "../../mdast-util-gfm-autolink-literal/lib/index.js";
+import { gfmFootnoteFromMarkdown, gfmFootnoteToMarkdown } from "../../mdast-util-gfm-footnote/lib/index.js";
+import { gfmStrikethroughFromMarkdown, gfmStrikethroughToMarkdown } from "../../mdast-util-gfm-strikethrough/lib/index.js";
+import { gfmTableFromMarkdown, gfmTableToMarkdown } from "../../mdast-util-gfm-table/lib/index.js";
+import { gfmTaskListItemFromMarkdown, gfmTaskListItemToMarkdown } from "../../mdast-util-gfm-task-list-item/lib/index.js";
+function gfmFromMarkdown() {
+	return [
+		gfmAutolinkLiteralFromMarkdown(),
+		gfmFootnoteFromMarkdown(),
+		gfmStrikethroughFromMarkdown(),
+		gfmTableFromMarkdown(),
+		gfmTaskListItemFromMarkdown()
+	];
+}
+function gfmToMarkdown(e) {
+	return { extensions: [
+		gfmAutolinkLiteralToMarkdown(),
+		gfmFootnoteToMarkdown(e),
+		gfmStrikethroughToMarkdown(),
+		gfmTableToMarkdown(e),
+		gfmTaskListItemToMarkdown()
+	] };
+}
+export { gfmFromMarkdown, gfmToMarkdown };

package/dist/node_modules/mdast-util-gfm-autolink-literal/lib/index.js

@@ -0,0 +1,127 @@
+import { ccount } from "../../ccount/index.js";
+import { ok } from "../../devlop/lib/default.js";
+import { unicodePunctuation, unicodeWhitespace } from "../../micromark-util-character/index.js";
+import { findAndReplace } from "../../mdast-util-find-and-replace/lib/index.js";
+var inConstruct = "phrasing", notInConstruct = [
+	"autolink",
+	"link",
+	"image",
+	"label"
+];
+function gfmAutolinkLiteralFromMarkdown() {
+	return {
+		transforms: [transformGfmAutolinkLiterals],
+		enter: {
+			literalAutolink: enterLiteralAutolink,
+			literalAutolinkEmail: enterLiteralAutolinkValue,
+			literalAutolinkHttp: enterLiteralAutolinkValue,
+			literalAutolinkWww: enterLiteralAutolinkValue
+		},
+		exit: {
+			literalAutolink: exitLiteralAutolink,
+			literalAutolinkEmail: exitLiteralAutolinkEmail,
+			literalAutolinkHttp: exitLiteralAutolinkHttp,
+			literalAutolinkWww: exitLiteralAutolinkWww
+		}
+	};
+}
+function gfmAutolinkLiteralToMarkdown() {
+	return { unsafe: [
+		{
+			character: "@",
+			before: "[+\\-.\\w]",
+			after: "[\\-.\\w]",
+			inConstruct,
+			notInConstruct
+		},
+		{
+			character: ".",
+			before: "[Ww]",
+			after: "[\\-.\\w]",
+			inConstruct,
+			notInConstruct
+		},
+		{
+			character: ":",
+			before: "[ps]",
+			after: "\\/",
+			inConstruct,
+			notInConstruct
+		}
+	] };
+}
+function enterLiteralAutolink(t) {
+	this.enter({
+		type: "link",
+		title: null,
+		url: "",
+		children: []
+	}, t);
+}
+function enterLiteralAutolinkValue(t) {
+	this.config.enter.autolinkProtocol.call(this, t);
+}
+function exitLiteralAutolinkHttp(t) {
+	this.config.exit.autolinkProtocol.call(this, t);
+}
+function exitLiteralAutolinkWww(t) {
+	this.config.exit.data.call(this, t);
+	let m = this.stack[this.stack.length - 1];
+	m.type, m.url = "http://" + this.sliceSerialize(t);
+}
+function exitLiteralAutolinkEmail(t) {
+	this.config.exit.autolinkEmail.call(this, t);
+}
+function exitLiteralAutolink(t) {
+	this.exit(t);
+}
+function transformGfmAutolinkLiterals(t) {
+	findAndReplace(t, [[/(https?:\/\/|www(?=\.))([-.\w]+)([^ \t\r\n]*)/gi, findUrl], [RegExp("(?<=^|\\s|\\p{P}|\\p{S})([-.\\w+]+)@([-\\w]+(?:\\.[-\\w]+)+)", "gu"), findEmail]], { ignore: ["link", "linkReference"] });
+}
+function findUrl(t, m, h, g, _) {
+	let v = "";
+	if (!previous(_) || (/^w/i.test(m) && (h = m + h, m = "", v = "http://"), !isCorrectDomain(h))) return !1;
+	let y = splitUrl(h + g);
+	if (!y[0]) return !1;
+	let b = {
+		type: "link",
+		title: null,
+		url: v + m + y[0],
+		children: [{
+			type: "text",
+			value: m + y[0]
+		}]
+	};
+	return y[1] ? [b, {
+		type: "text",
+		value: y[1]
+	}] : b;
+}
+function findEmail(t, m, h, g) {
+	return !previous(g, !0) || /[-\d_]$/.test(h) ? !1 : {
+		type: "link",
+		title: null,
+		url: "mailto:" + m + "@" + h,
+		children: [{
+			type: "text",
+			value: m + "@" + h
+		}]
+	};
+}
+function isCorrectDomain(t) {
+	let m = t.split(".");
+	return !(m.length < 2 || m[m.length - 1] && (/_/.test(m[m.length - 1]) || !/[a-zA-Z\d]/.test(m[m.length - 1])) || m[m.length - 2] && (/_/.test(m[m.length - 2]) || !/[a-zA-Z\d]/.test(m[m.length - 2])));
+}
+function splitUrl(m) {
+	let h = /[!"&'),.:;<>?\]}]+$/.exec(m);
+	if (!h) return [m, void 0];
+	m = m.slice(0, h.index);
+	let g = h[0], _ = g.indexOf(")"), v = ccount(m, "("), y = ccount(m, ")");
+	for (; _ !== -1 && v > y;) m += g.slice(0, _ + 1), g = g.slice(_ + 1), _ = g.indexOf(")"), y++;
+	return [m, g];
+}
+function previous(t, m) {
+	let _ = t.input.charCodeAt(t.index - 1);
+	return (t.index === 0 || unicodeWhitespace(_) || unicodePunctuation(_)) && (!m || _ !== 47);
+}
+export { gfmAutolinkLiteralFromMarkdown, gfmAutolinkLiteralToMarkdown };

package/dist/node_modules/mdast-util-gfm-footnote/lib/index.js

@@ -0,0 +1,95 @@
+import { ok } from "../../devlop/lib/default.js";
+import { normalizeIdentifier } from "../../micromark-util-normalize-identifier/index.js";
+footnoteReference.peek = footnoteReferencePeek;
+function enterFootnoteCallString() {
+	this.buffer();
+}
+function enterFootnoteCall(e) {
+	this.enter({
+		type: "footnoteReference",
+		identifier: "",
+		label: ""
+	}, e);
+}
+function enterFootnoteDefinitionLabelString() {
+	this.buffer();
+}
+function enterFootnoteDefinition(e) {
+	this.enter({
+		type: "footnoteDefinition",
+		identifier: "",
+		label: "",
+		children: []
+	}, e);
+}
+function exitFootnoteCallString(e) {
+	let l = this.resume(), u = this.stack[this.stack.length - 1];
+	u.type, u.identifier = normalizeIdentifier(this.sliceSerialize(e)).toLowerCase(), u.label = l;
+}
+function exitFootnoteCall(e) {
+	this.exit(e);
+}
+function exitFootnoteDefinitionLabelString(e) {
+	let l = this.resume(), u = this.stack[this.stack.length - 1];
+	u.type, u.identifier = normalizeIdentifier(this.sliceSerialize(e)).toLowerCase(), u.label = l;
+}
+function exitFootnoteDefinition(e) {
+	this.exit(e);
+}
+function footnoteReferencePeek() {
+	return "[";
+}
+function footnoteReference(e, c, l, u) {
+	let d = l.createTracker(u), f = d.move("[^"), p = l.enter("footnoteReference"), m = l.enter("reference");
+	return f += d.move(l.safe(l.associationId(e), {
+		after: "]",
+		before: f
+	})), m(), p(), f += d.move("]"), f;
+}
+function gfmFootnoteFromMarkdown() {
+	return {
+		enter: {
+			gfmFootnoteCallString: enterFootnoteCallString,
+			gfmFootnoteCall: enterFootnoteCall,
+			gfmFootnoteDefinitionLabelString: enterFootnoteDefinitionLabelString,
+			gfmFootnoteDefinition: enterFootnoteDefinition
+		},
+		exit: {
+			gfmFootnoteCallString: exitFootnoteCallString,
+			gfmFootnoteCall: exitFootnoteCall,
+			gfmFootnoteDefinitionLabelString: exitFootnoteDefinitionLabelString,
+			gfmFootnoteDefinition: exitFootnoteDefinition
+		}
+	};
+}
+function gfmFootnoteToMarkdown(e) {
+	let c = !1;
+	return e && e.firstLineBlank && (c = !0), {
+		handlers: {
+			footnoteDefinition: l,
+			footnoteReference
+		},
+		unsafe: [{
+			character: "[",
+			inConstruct: [
+				"label",
+				"phrasing",
+				"reference"
+			]
+		}]
+	};
+	function l(e, l, u, d) {
+		let f = u.createTracker(d), p = f.move("[^"), m = u.enter("footnoteDefinition"), h = u.enter("label");
+		return p += f.move(u.safe(u.associationId(e), {
+			before: p,
+			after: "]"
+		})), h(), p += f.move("]:"), e.children && e.children.length > 0 && (f.shift(4), p += f.move((c ? "\n" : " ") + u.indentLines(u.containerFlow(e, f.current()), c ? mapAll : mapExceptFirst))), m(), p;
+	}
+}
+function mapExceptFirst(e, c, l) {
+	return c === 0 ? e : mapAll(e, c, l);
+}
+function mapAll(e, c, l) {
+	return (l ? "" : "    ") + e;
+}
+export { gfmFootnoteFromMarkdown, gfmFootnoteToMarkdown };

package/dist/node_modules/mdast-util-gfm-strikethrough/lib/index.js

@@ -0,0 +1,47 @@
+var constructsWithoutStrikethrough = [
+	"autolink",
+	"destinationLiteral",
+	"destinationRaw",
+	"reference",
+	"titleQuote",
+	"titleApostrophe"
+];
+handleDelete.peek = peekDelete;
+function gfmStrikethroughFromMarkdown() {
+	return {
+		canContainEols: ["delete"],
+		enter: { strikethrough: enterStrikethrough },
+		exit: { strikethrough: exitStrikethrough }
+	};
+}
+function gfmStrikethroughToMarkdown() {
+	return {
+		unsafe: [{
+			character: "~",
+			inConstruct: "phrasing",
+			notInConstruct: constructsWithoutStrikethrough
+		}],
+		handlers: { delete: handleDelete }
+	};
+}
+function enterStrikethrough(e) {
+	this.enter({
+		type: "delete",
+		children: []
+	}, e);
+}
+function exitStrikethrough(e) {
+	this.exit(e);
+}
+function handleDelete(e, t, n, r) {
+	let i = n.createTracker(r), a = n.enter("strikethrough"), o = i.move("~~");
+	return o += n.containerPhrasing(e, {
+		...i.current(),
+		before: o,
+		after: "~"
+	}), o += i.move("~~"), a(), o;
+}
+function peekDelete() {
+	return "~";
+}
+export { gfmStrikethroughFromMarkdown, gfmStrikethroughToMarkdown };

package/dist/node_modules/mdast-util-gfm-table/lib/index.js

@@ -0,0 +1,135 @@
+import { ok } from "../../devlop/lib/default.js";
+import { markdownTable } from "../../markdown-table/index.js";
+import { handle } from "../../mdast-util-to-markdown/lib/handle/index.js";
+function gfmTableFromMarkdown() {
+	return {
+		enter: {
+			table: enterTable,
+			tableData: enterCell,
+			tableHeader: enterCell,
+			tableRow: enterRow
+		},
+		exit: {
+			codeText: exitCodeText,
+			table: exitTable,
+			tableData: exit,
+			tableHeader: exit,
+			tableRow: exit
+		}
+	};
+}
+function enterTable(e) {
+	let t = e._align;
+	this.enter({
+		type: "table",
+		align: t.map(function(e) {
+			return e === "none" ? null : e;
+		}),
+		children: []
+	}, e), this.data.inTable = !0;
+}
+function exitTable(e) {
+	this.exit(e), this.data.inTable = void 0;
+}
+function enterRow(e) {
+	this.enter({
+		type: "tableRow",
+		children: []
+	}, e);
+}
+function exit(e) {
+	this.exit(e);
+}
+function enterCell(e) {
+	this.enter({
+		type: "tableCell",
+		children: []
+	}, e);
+}
+function exitCodeText(e) {
+	let t = this.resume();
+	this.data.inTable && (t = t.replace(/\\([\\|])/g, replace));
+	let n = this.stack[this.stack.length - 1];
+	n.type, n.value = t, this.exit(e);
+}
+function replace(e, t) {
+	return t === "|" ? t : e;
+}
+function gfmTableToMarkdown(e) {
+	let r = e || {}, i = r.tableCellPadding, a = r.tablePipeAlign, o = r.stringLength, s = i ? " " : "|";
+	return {
+		unsafe: [
+			{
+				character: "\r",
+				inConstruct: "tableCell"
+			},
+			{
+				character: "\n",
+				inConstruct: "tableCell"
+			},
+			{
+				atBreak: !0,
+				character: "|",
+				after: "[	 :-]"
+			},
+			{
+				character: "|",
+				inConstruct: "tableCell"
+			},
+			{
+				atBreak: !0,
+				character: ":",
+				after: "-"
+			},
+			{
+				atBreak: !0,
+				character: "-",
+				after: "[:|-]"
+			}
+		],
+		handlers: {
+			inlineCode: m,
+			table: c,
+			tableCell: u,
+			tableRow: l
+		}
+	};
+	function c(e, t, n, r) {
+		return d(f(e, n, r), e.align);
+	}
+	function l(e, t, n, r) {
+		let i = d([p(e, n, r)]);
+		return i.slice(0, i.indexOf("\n"));
+	}
+	function u(e, t, n, r) {
+		let i = n.enter("tableCell"), a = n.enter("phrasing"), o = n.containerPhrasing(e, {
+			...r,
+			before: s,
+			after: s
+		});
+		return a(), i(), o;
+	}
+	function d(e, n) {
+		return markdownTable(e, {
+			align: n,
+			alignDelimiters: a,
+			padding: i,
+			stringLength: o
+		});
+	}
+	function f(e, t, n) {
+		let r = e.children, i = -1, a = [], o = t.enter("table");
+		for (; ++i < r.length;) a[i] = p(r[i], t, n);
+		return o(), a;
+	}
+	function p(e, t, n) {
+		let r = e.children, i = -1, a = [], o = t.enter("tableRow");
+		for (; ++i < r.length;) a[i] = u(r[i], e, t, n);
+		return o(), a;
+	}
+	function m(e, t, r) {
+		let i = handle.inlineCode(e, t, r);
+		return r.stack.includes("tableCell") && (i = i.replace(/\|/g, "\\$&")), i;
+	}
+}
+export { gfmTableFromMarkdown, gfmTableToMarkdown };

package/dist/node_modules/mdast-util-gfm-task-list-item/lib/index.js

@@ -0,0 +1,56 @@
+import { ok } from "../../devlop/lib/default.js";
+import { handle } from "../../mdast-util-to-markdown/lib/handle/index.js";
+function gfmTaskListItemFromMarkdown() {
+	return { exit: {
+		taskListCheckValueChecked: exitCheck,
+		taskListCheckValueUnchecked: exitCheck,
+		paragraph: exitParagraphWithTaskListItem
+	} };
+}
+function gfmTaskListItemToMarkdown() {
+	return {
+		unsafe: [{
+			atBreak: !0,
+			character: "-",
+			after: "[:|-]"
+		}],
+		handlers: { listItem: listItemWithTaskListItem }
+	};
+}
+function exitCheck(e) {
+	let t = this.stack[this.stack.length - 2];
+	t.type, t.checked = e.type === "taskListCheckValueChecked";
+}
+function exitParagraphWithTaskListItem(e) {
+	let t = this.stack[this.stack.length - 2];
+	if (t && t.type === "listItem" && typeof t.checked == "boolean") {
+		let e = this.stack[this.stack.length - 1];
+		e.type;
+		let n = e.children[0];
+		if (n && n.type === "text") {
+			let r = t.children, i = -1, a;
+			for (; ++i < r.length;) {
+				let e = r[i];
+				if (e.type === "paragraph") {
+					a = e;
+					break;
+				}
+			}
+			a === e && (n.value = n.value.slice(1), n.value.length === 0 ? e.children.shift() : e.position && n.position && typeof n.position.start.offset == "number" && (n.position.start.column++, n.position.start.offset++, e.position.start = Object.assign({}, n.position.start)));
+		}
+	}
+	this.exit(e);
+}
+function listItemWithTaskListItem(e, n, r, i) {
+	let a = e.children[0], o = typeof e.checked == "boolean" && a && a.type === "paragraph", s = "[" + (e.checked ? "x" : " ") + "] ", c = r.createTracker(i);
+	o && c.move(s);
+	let l = handle.listItem(e, n, r, {
+		...i,
+		...c.current()
+	});
+	return o && (l = l.replace(/^(?:[*+-]|\d+\.)([\r\n]| {1,3})/, u)), l;
+	function u(e) {
+		return e + s;
+	}
+}
+export { gfmTaskListItemFromMarkdown, gfmTaskListItemToMarkdown };

package/dist/node_modules/mdast-util-math/lib/index.js

@@ -0,0 +1,142 @@
+import { ok } from "../../devlop/lib/default.js";
+import { longestStreak } from "../../longest-streak/index.js";
+function mathFromMarkdown() {
+	return {
+		enter: {
+			mathFlow: e,
+			mathFlowFenceMeta: t,
+			mathText: a
+		},
+		exit: {
+			mathFlow: i,
+			mathFlowFence: r,
+			mathFlowFenceMeta: n,
+			mathFlowValue: s,
+			mathText: o,
+			mathTextData: s
+		}
+	};
+	function e(e) {
+		this.enter({
+			type: "math",
+			meta: null,
+			value: "",
+			data: {
+				hName: "pre",
+				hChildren: [{
+					type: "element",
+					tagName: "code",
+					properties: { className: ["language-math", "math-display"] },
+					children: []
+				}]
+			}
+		}, e);
+	}
+	function t() {
+		this.buffer();
+	}
+	function n() {
+		let e = this.resume(), t = this.stack[this.stack.length - 1];
+		t.type, t.meta = e;
+	}
+	function r() {
+		this.data.mathFlowInside || (this.buffer(), this.data.mathFlowInside = !0);
+	}
+	function i(e) {
+		let t = this.resume().replace(/^(\r?\n|\r)|(\r?\n|\r)$/g, ""), n = this.stack[this.stack.length - 1];
+		n.type, this.exit(e), n.value = t;
+		let r = n.data.hChildren[0];
+		r.type, r.tagName, r.children.push({
+			type: "text",
+			value: t
+		}), this.data.mathFlowInside = void 0;
+	}
+	function a(e) {
+		this.enter({
+			type: "inlineMath",
+			value: "",
+			data: {
+				hName: "code",
+				hProperties: { className: ["language-math", "math-inline"] },
+				hChildren: []
+			}
+		}, e), this.buffer();
+	}
+	function o(e) {
+		let t = this.resume(), n = this.stack[this.stack.length - 1];
+		n.type, this.exit(e), n.value = t, n.data.hChildren.push({
+			type: "text",
+			value: t
+		});
+	}
+	function s(e) {
+		this.config.enter.data.call(this, e), this.config.exit.data.call(this, e);
+	}
+}
+function mathToMarkdown(e) {
+	let n = (e || {}).singleDollarTextMath;
+	return n ??= !0, i.peek = a, {
+		unsafe: [
+			{
+				character: "\r",
+				inConstruct: "mathFlowMeta"
+			},
+			{
+				character: "\n",
+				inConstruct: "mathFlowMeta"
+			},
+			{
+				character: "$",
+				after: n ? void 0 : "\\$",
+				inConstruct: "phrasing"
+			},
+			{
+				character: "$",
+				inConstruct: "mathFlowMeta"
+			},
+			{
+				atBreak: !0,
+				character: "$",
+				after: "\\$"
+			}
+		],
+		handlers: {
+			math: r,
+			inlineMath: i
+		}
+	};
+	function r(e, n, r, i) {
+		let a = e.value || "", o = r.createTracker(i), s = "$".repeat(Math.max(longestStreak(a, "$") + 1, 2)), c = r.enter("mathFlow"), l = o.move(s);
+		if (e.meta) {
+			let t = r.enter("mathFlowMeta");
+			l += o.move(r.safe(e.meta, {
+				after: "\n",
+				before: l,
+				encode: ["$"],
+				...o.current()
+			})), t();
+		}
+		return l += o.move("\n"), a && (l += o.move(a + "\n")), l += o.move(s), c(), l;
+	}
+	function i(e, t, r) {
+		let i = e.value || "", a = 1;
+		for (n || a++; (/* @__PURE__ */ RegExp("(^|[^$])" + "\\$".repeat(a) + "([^$]|$)")).test(i);) a++;
+		let o = "$".repeat(a);
+		/[^ \r\n]/.test(i) && (/^[ \r\n]/.test(i) && /[ \r\n]$/.test(i) || /^\$|\$$/.test(i)) && (i = " " + i + " ");
+		let s = -1;
+		for (; ++s < r.unsafe.length;) {
+			let e = r.unsafe[s];
+			if (!e.atBreak) continue;
+			let t = r.compilePattern(e), n;
+			for (; n = t.exec(i);) {
+				let e = n.index;
+				i.codePointAt(e) === 10 && i.codePointAt(e - 1) === 13 && e--, i = i.slice(0, e) + " " + i.slice(n.index + 1);
+			}
+		}
+		return o + i + o;
+	}
+	function a() {
+		return "$";
+	}
+}
+export { mathFromMarkdown, mathToMarkdown };