ya-bbcode 5.1.2 → 6.0.0

package/dist/ya-bbcode.mjs

@@ -1,44 +1,59 @@
 // src/ya-bbcode.ts
 const PLACEHOLDER_START = "\0";
 const PLACEHOLDER_END = ";";
+const PARAGRAPH_BREAK = "</p><p>";
+const newlines = /\r\n|\r|\n/g;
+const placeholders = /\0(\d+);/g;
+const whitespace = /\s/;
+const escapable = /["&'<>]/g;
+const tabOrNewline = /[\t\n\r]/;
+const relativeUrl = /^\.{0,2}\//;
+const schemeName = /^[a-z][\d+.a-z-]*$/;
+const dangerousKeys = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
 function placeholder(index) {
 	return PLACEHOLDER_START + index + PLACEHOLDER_END;
 }
-function replaceFirst(content, search, replacement) {
-	const index = content.indexOf(search);
-	if (index === -1) return content;
-	return content.slice(0, index) + replacement + content.slice(index + search.length);
-}
-const sanitizedEntities = {
-	"&amp;": "&",
-	"&lt;": "<",
-	"&gt;": ">",
-	"&quot;": "\"",
-	"&#39;": "'"
-};
-function unescapeSanitized(value) {
-	return value.replaceAll(/&(?:amp|lt|gt|quot|#39);/g, (entity) => sanitizedEntities[entity]);
+function entityFor(character) {
+	switch (character) {
+		case "&": return "&amp;";
+		case "<": return "&lt;";
+		case ">": return "&gt;";
+		case "\"": return "&quot;";
+		default: return "&#39;";
+	}
 }
 /**
-* Escapes HTML attribute values to prevent XSS
-* Encodes quotes, angle brackets, and other special characters
+* Escapes text for use in HTML content or attribute values to prevent XSS
+* Encodes quotes, angle brackets, and ampersands
 */
-function escapeHtmlAttr(value) {
-	const attrEntities = {
-		"&": "&amp;",
-		"<": "&lt;",
-		">": "&gt;",
-		"\"": "&quot;",
-		"'": "&#39;"
-	};
-	return String(value).replaceAll(/["&'<>]/g, (char) => attrEntities[char] || char);
+function escapeHtml(value) {
+	escapable.lastIndex = 0;
+	if (!escapable.test(value)) return value;
+	let escaped = "";
+	let copied = 0;
+	do {
+		const index = escapable.lastIndex - 1;
+		escaped += value.slice(copied, index) + entityFor(value.charAt(index));
+		copied = index + 1;
+	} while (escapable.test(value));
+	return escaped + value.slice(copied);
+}
+function unescapeSanitized(value) {
+	if (!value.includes("&")) return value;
+	return value.replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&quot;", "\"").replaceAll("&#39;", "'").replaceAll("&amp;", "&");
 }
 function normalizeUrl(url) {
 	let start = 0;
 	let end = url.length;
 	while (start < end && url.charAt(start) <= " ") start++;
 	while (end > start && url.charAt(end - 1) <= " ") end--;
-	return url.slice(start, end).replaceAll(/[\t\n\r]/g, "");
+	const trimmed = url.slice(start, end);
+	if (!tabOrNewline.test(trimmed)) return trimmed;
+	return trimmed.replaceAll(/[\t\n\r]/g, "");
 }
 const defaultAllowedSchemes = [
 	"http",
@@ -55,66 +70,361 @@ const defaultAllowedSchemes = [
 function sanitizeUrl(url, allowedSchemes) {
 	const trimmed = normalizeUrl(String(url));
 	if (!trimmed) return;
-	if (/^\.{0,2}\//.test(trimmed)) return trimmed;
+	if (relativeUrl.test(trimmed)) return trimmed;
 	if (trimmed.startsWith("#")) return trimmed;
-	const schemeMatch = /^([a-z][\d+.a-z-]*):/.exec(trimmed.toLowerCase());
-	if (schemeMatch) {
-		const scheme = schemeMatch[1] ?? "";
-		if (!allowedSchemes.includes(scheme)) return;
+	const colon = trimmed.indexOf(":");
+	if (colon > 0) {
+		const scheme = trimmed.slice(0, colon).toLowerCase();
+		if (!allowedSchemes.includes(scheme) && schemeName.test(scheme)) return;
 	}
 	return trimmed;
 }
+function tagName(content) {
+	const firstEquals = content.indexOf("=");
+	const firstSpace = content.indexOf(" ");
+	if (firstSpace === -1 || firstEquals !== -1 && firstEquals < firstSpace) {
+		if (firstEquals === -1) return content.toLowerCase();
+		return content.slice(0, firstEquals).toLowerCase();
+	}
+	return content.slice(0, content.search(whitespace)).toLowerCase();
+}
 /**
-* Parse tag attributes from a tag string
+* Parse a tag's attributes from the text between its brackets
 * Supports both formats:
-* - [tag=value] → { attr: 'value', attrs: {} }
-* - [tag key=value flag] → { attr: 'value', attrs: { key: 'value', flag: true } }
+* - [tag=value] → attr: 'value', attrs: {}
+* - [tag key=value flag] → attr: 'value', attrs: { key: 'value', flag: true }
 */
-function parseTagAttributes(tagContent) {
-	const firstSpace = tagContent.indexOf(" ");
-	const firstEquals = tagContent.indexOf("=");
-	if (firstSpace === -1 || firstEquals !== -1 && firstEquals < firstSpace) return {
-		attr: tagContent.split("=").slice(1).join("="),
-		attrs: {}
-	};
-	const parts = tagContent.split(/\s+/);
+function attributesOf(tag) {
+	if (tag.attrs !== void 0) return tag.attrs;
+	const content = tag.content;
+	const firstSpace = content.indexOf(" ");
+	const firstEquals = content.indexOf("=");
+	if (firstSpace === -1 || firstEquals !== -1 && firstEquals < firstSpace) {
+		if (firstEquals !== -1) tag.attr = content.slice(firstEquals + 1);
+		tag.attrs = {};
+		return tag.attrs;
+	}
+	const parts = content.split(/\s+/);
 	const attrs = Object.create(null);
-	let firstValue = "";
-	const dangerousKeys = /* @__PURE__ */ new Set([
-		"__proto__",
-		"constructor",
-		"prototype"
-	]);
 	for (let i = 1; i < parts.length; i++) {
 		const part = parts[i];
 		if (!part) continue;
-		if (part.includes("=")) {
-			const eqIndex = part.indexOf("=");
-			const key = part.slice(0, eqIndex);
-			const value = part.slice(eqIndex + 1);
-			if (dangerousKeys.has(key.toLowerCase())) continue;
-			attrs[key] = value;
-			if (!firstValue && value) firstValue = value;
-		} else {
-			if (dangerousKeys.has(part.toLowerCase())) continue;
-			attrs[part] = true;
+		const eqIndex = part.indexOf("=");
+		if (eqIndex === -1) {
+			if (!dangerousKeys.has(part.toLowerCase())) attrs[part] = true;
+			continue;
+		}
+		const key = part.slice(0, eqIndex);
+		if (dangerousKeys.has(key.toLowerCase())) continue;
+		const value = part.slice(eqIndex + 1);
+		attrs[key] = value;
+		if (!tag.attr && value) tag.attr = value;
+	}
+	tag.attrs = attrs;
+	return attrs;
+}
+function breakLines(text, lineBreak) {
+	if (lineBreak === PARAGRAPH_BREAK) return text.replaceAll(newlines, "</p><p>");
+	return text.replaceAll(newlines, "<br/>");
+}
+const maxSplicedNewlines = 8;
+function indexOrEnd(input, character, from) {
+	const index = input.indexOf(character, from);
+	if (index === -1) return Infinity;
+	return index;
+}
+function textBetween(doc, start, end) {
+	if (start === end) return "";
+	const { input, lineBreak } = doc;
+	if (lineBreak === void 0) return input.slice(start, end);
+	let text = "";
+	let from = start;
+	for (let spliced = 0;; spliced++) {
+		if (doc.nextLf < from) doc.nextLf = indexOrEnd(input, "\n", from);
+		if (doc.nextCr < from) doc.nextCr = indexOrEnd(input, "\r", from);
+		const newline = Math.min(doc.nextLf, doc.nextCr);
+		if (newline >= end) break;
+		if (spliced === maxSplicedNewlines) return text + breakLines(input.slice(from, end), lineBreak);
+		text += input.slice(from, newline) + lineBreak;
+		from = newline + 1;
+		if (doc.nextCr === newline && doc.nextLf === from) from++;
+	}
+	if (from === start) return input.slice(start, end);
+	return text + input.slice(from, end);
+}
+function tagText(doc, slot, escape = false) {
+	let text = doc.input.slice(doc.bounds[slot * 2], doc.bounds[slot * 2 + 1]);
+	if (escape) text = escapeHtml(text);
+	const { lineBreak } = doc;
+	if (lineBreak === void 0 || !(text.includes("\n") || text.includes("\r"))) return text;
+	return breakLines(text, lineBreak);
+}
+function adopt(parent, orphans) {
+	let first = orphans.length;
+	while (first > 0 && orphans[first - 1].slot > parent.slot) first--;
+	if (first === orphans.length) return;
+	parent.firstChild = orphans[first];
+	for (let i = first; i < orphans.length; i++) {
+		const child = orphans[i];
+		child.parent = parent;
+		child.nextSibling = orphans[i + 1];
+	}
+	orphans.length = first;
+}
+/**
+* Looks up the kind for the text between a tag's brackets, creating it the first time a name is seen.
+*/
+function kindOf(kinds, tags, content) {
+	const name = tagName(content);
+	let kind = kinds.get(name);
+	if (kind === void 0) {
+		let definition;
+		if (Object.hasOwn(tags, name)) definition = tags[name];
+		kind = {
+			name,
+			definition,
+			lastOpen: void 0
+		};
+		kinds.set(name, kind);
+	}
+	return kind;
+}
+function spells(text, input, start, length) {
+	if (text.length !== length) return false;
+	for (let i = 0; i < length; i++) if (text.codePointAt(i) !== input.codePointAt(start + i)) return false;
+	return true;
+}
+const recentSize = 64;
+const recentMaxLength = 16;
+/**
+* Finds every tag in one pass, pairs opening and closing tags and links them into a tree.
+* Returns the first top-level tag, or undefined when the input has no opening tag.
+*/
+function buildTree(doc, tags) {
+	const { input, parts, bounds } = doc;
+	const kinds = /* @__PURE__ */ new Map();
+	const recent = [];
+	const orphans = [];
+	let unclosed = 0;
+	let ignoring;
+	let textStart = 0;
+	let from = 0;
+	let close = -1;
+	let caret = -1;
+	for (;;) {
+		const open = input.indexOf("[", from);
+		if (open === -1) break;
+		if (close <= open) {
+			close = input.indexOf("]", open + 1);
+			if (close === -1) break;
+		}
+		if (caret <= open) caret = indexOrEnd(input, "^", open + 1);
+		if (caret < close) {
+			from = caret + 1;
+			continue;
+		}
+		from = close + 1;
+		if (close === open + 1) continue;
+		let nameStart = open + 1;
+		const isClosing = input.charAt(nameStart) === "/";
+		if (isClosing) nameStart++;
+		if (ignoring !== void 0 && !isClosing) continue;
+		const length = close - nameStart;
+		const hash = ((input.codePointAt(nameStart) ?? 0) + (input.codePointAt(close - 1) ?? 0) * 3 + length * 7) % recentSize;
+		let spelling = recent[hash];
+		if (spelling === void 0 || !spells(spelling.content, input, nameStart, length)) {
+			const content = input.slice(nameStart, close);
+			spelling = {
+				content,
+				kind: kindOf(kinds, tags, content)
+			};
+			if (length <= recentMaxLength) recent[hash] = spelling;
+		}
+		const { content, kind } = spelling;
+		if (ignoring !== void 0) {
+			if (kind !== ignoring) continue;
+			ignoring = void 0;
+		}
+		const slot = bounds.length / 2;
+		parts.push(textBetween(doc, textStart, open), void 0);
+		bounds.push(open, close + 1);
+		textStart = close + 1;
+		if (isClosing) {
+			const opener = kind.lastOpen;
+			if (opener !== void 0) {
+				kind.lastOpen = opener.previousOpen;
+				opener.closeSlot = slot;
+				unclosed--;
+				adopt(opener, orphans);
+			}
+			continue;
+		}
+		const tag = {
+			slot,
+			closeSlot: -1,
+			kind,
+			content,
+			parent: void 0,
+			firstChild: void 0,
+			nextSibling: void 0,
+			previousOpen: kind.lastOpen,
+			attr: "",
+			attrs: void 0
+		};
+		kind.lastOpen = tag;
+		unclosed++;
+		orphans.push(tag);
+		if (kind.definition?.type === "ignore") ignoring = kind;
+	}
+	parts.push(textBetween(doc, textStart, input.length));
+	if (unclosed > 0) {
+		let firstUnclosed;
+		for (const kind of kinds.values()) for (let tag = kind.lastOpen; tag !== void 0; tag = tag.previousOpen) if (firstUnclosed === void 0 || tag.slot < firstUnclosed.slot) firstUnclosed = tag;
+		if (firstUnclosed !== void 0) adopt(firstUnclosed, orphans);
+	}
+	for (let i = 0; i < orphans.length; i++) orphans[i].nextSibling = orphans[i + 1];
+	return orphans[0];
+}
+function resolve(doc, slot, value) {
+	if (doc.dead?.has(slot)) return;
+	doc.parts[slot * 2 + 1] = value;
+}
+function tagHtml(tag, html) {
+	if (typeof html !== "function") return html;
+	const attrs = attributesOf(tag);
+	return html(tag.attr, attrs);
+}
+function enter(doc, tag) {
+	const definition = tag.kind.definition;
+	if (!definition) {
+		resolve(doc, tag.slot, tagText(doc, tag.slot));
+		return;
+	}
+	const type = definition.type;
+	if (type === "replace") {
+		const open = tagHtml(tag, definition.open);
+		if (open) resolve(doc, tag.slot, open);
+	} else if (type === "ignore") {
+		if (doc.dead?.has(tag.slot) || doc.dead?.has(tag.closeSlot)) return;
+		doc.parts[tag.slot * 2 + 1] = "";
+		if (tag.closeSlot !== -1) doc.parts[tag.closeSlot * 2 + 1] = "";
+	} else if (type !== "content") throw new Error("Cannot parse content block. Invalid block type [" + type + "] provided for tag [" + tag.kind.name + "]");
+}
+function autoClose(doc, tag, definition) {
+	const html = tagHtml(tag, definition.autoClose);
+	let before;
+	for (let sibling = tag.nextSibling; sibling !== void 0; sibling = sibling.nextSibling) if (sibling.kind === tag.kind) {
+		before = sibling.slot;
+		break;
+	}
+	if (before === void 0 && tag.parent !== void 0 && tag.parent.closeSlot !== -1) before = tag.parent.closeSlot;
+	if (before === void 0 || !html || doc.dead?.has(before)) return;
+	doc.parts[before * 2] += html;
+}
+/**
+* Writes a content tag's output back when it was given placeholders for slots that were still unresolved.
+* Each placeholder it kept goes back to its own slot with the output before it as that slot's text, so the
+* slot can still be resolved later exactly as if the content tag had never wrapped it.
+*/
+function reseat(doc, tag, html, pending, skips) {
+	const { parts } = doc;
+	doc.dead ??= /* @__PURE__ */ new Set();
+	const positions = /* @__PURE__ */ new Map();
+	for (const [index, slot] of pending.entries()) positions.set(slot, index);
+	let anchor = tag.slot;
+	let next = 0;
+	let written = 0;
+	for (const match of html.matchAll(placeholders)) {
+		const slot = Number(match[1]);
+		const found = positions.get(slot);
+		if (found === void 0 || found < next) continue;
+		for (; next < found; next++) doc.dead.add(pending[next]);
+		next = found + 1;
+		parts[slot * 2] = html.slice(written, match.index);
+		parts[slot * 2 + 1] = void 0;
+		skips.set(anchor, slot - 1);
+		anchor = slot;
+		written = match.index + match[0].length;
+	}
+	for (; next < pending.length; next++) doc.dead.add(pending[next]);
+	parts[tag.slot * 2 + 1] = "";
+	parts[tag.closeSlot * 2 + 1] = html.slice(written);
+	skips.set(anchor, tag.closeSlot - 1);
+}
+function replaceContent(doc, tag, definition) {
+	const { parts } = doc;
+	const { slot: openSlot, closeSlot } = tag;
+	if (doc.dead?.has(openSlot) || doc.dead?.has(closeSlot)) return;
+	let inner = "";
+	let pending;
+	for (let slot = (doc.skips?.get(openSlot) ?? openSlot) + 1; slot <= closeSlot; slot++) {
+		inner += parts[slot * 2];
+		parts[slot * 2] = "";
+		if (slot === closeSlot) break;
+		const value = parts[slot * 2 + 1];
+		if (value === void 0) {
+			inner += placeholder(slot);
+			pending ??= [];
+			pending.push(slot);
+		} else inner += value;
+		parts[slot * 2 + 1] = "";
+		slot = doc.skips?.get(slot) ?? slot;
+	}
+	let replace = definition.replace;
+	if (typeof replace === "function") {
+		const attrs = attributesOf(tag);
+		replace = replace(tag.attr, inner, attrs);
+	}
+	doc.skips ??= /* @__PURE__ */ new Map();
+	if (pending !== void 0) {
+		reseat(doc, tag, String(replace), pending, doc.skips);
+		return;
+	}
+	parts[openSlot * 2 + 1] = String(replace);
+	parts[closeSlot * 2 + 1] = "";
+	doc.skips.set(openSlot, doc.skips.get(closeSlot) ?? closeSlot);
+}
+function leave(doc, tag) {
+	const definition = tag.kind.definition;
+	if (!definition) {
+		if (tag.closeSlot !== -1) resolve(doc, tag.closeSlot, tagText(doc, tag.closeSlot));
+		return;
+	}
+	if (definition.type === "replace") {
+		if (definition.autoClose && tag.closeSlot === -1) autoClose(doc, tag, definition);
+		const close = tagHtml(tag, definition.close);
+		if (close && tag.closeSlot !== -1) resolve(doc, tag.closeSlot, close);
+	} else if (definition.type === "content" && tag.closeSlot !== -1) replaceContent(doc, tag, definition);
+}
+function renderTree(doc, root) {
+	let tag = root;
+	while (tag !== void 0) {
+		enter(doc, tag);
+		if (tag.firstChild !== void 0) {
+			tag = tag.firstChild;
+			continue;
+		}
+		for (;;) {
+			leave(doc, tag);
+			if (tag.nextSibling !== void 0) {
+				tag = tag.nextSibling;
+				break;
+			}
+			tag = tag.parent;
+			if (tag === void 0) return;
 		}
 	}
-	return {
-		attr: firstValue,
-		attrs
-	};
 }
 var yabbcode = class {
 	tags = {
 		"url": {
 			type: "replace",
-			open: (attr) => `<a href="${escapeHtmlAttr(sanitizeUrl(this.#unsanitize(attr), this.config.allowedSchemes ?? defaultAllowedSchemes) ?? "#")}">`,
+			open: (attr) => `<a href="${escapeHtml(sanitizeUrl(this.#unsanitize(attr), this.config.allowedSchemes ?? defaultAllowedSchemes) ?? "#")}">`,
 			close: "</a>"
 		},
 		"quote": {
 			type: "replace",
-			open: (attr) => `<blockquote author="${escapeHtmlAttr(this.#unsanitize(attr))}">`,
+			open: (attr) => `<blockquote author="${escapeHtml(this.#unsanitize(attr))}">`,
 			close: "</blockquote>"
 		},
 		"b": {
@@ -201,57 +511,18 @@ var yabbcode = class {
 		"img": {
 			type: "content",
 			replace: (attr, content) => {
-				const src = sanitizeUrl(this.#unsanitize(content.replaceAll(this.regex.placeholders, "")), this.config.allowedSchemes ?? defaultAllowedSchemes);
+				let url = content;
+				if (url.includes(PLACEHOLDER_START)) url = url.replaceAll(this.regex.placeholders, "");
+				url = this.#unsanitize(url);
+				const src = sanitizeUrl(url, this.config.allowedSchemes ?? defaultAllowedSchemes);
 				if (src === void 0) return "";
-				return `<img src="${escapeHtmlAttr(src)}" alt="${escapeHtmlAttr(this.#unsanitize(attr))}"/>`;
+				return `<img src="${escapeHtml(src)}" alt="${escapeHtml(this.#unsanitize(attr))}"/>`;
 			}
 		},
 		"noparse": { type: "ignore" }
 	};
-	regex = {
-		tags: /(\[[^\]^]+\])/g,
-		newline: /\r\n|\r|\n/g,
-		placeholders: /\0(\d+);/g
-	};
+	regex = { placeholders: /\0(\d+);/g };
 	config;
-	contentModules = {
-		replace: (tag, module, content) => {
-			let open = module.open;
-			let close = module.close;
-			if (typeof open === "function") open = open(tag.attr, tag.attrs);
-			if (typeof close === "function") close = close(tag.attr, tag.attrs);
-			if (open && !tag.isClosing) content = replaceFirst(content, placeholder(tag.index), open);
-			if (close && tag.closing) content = replaceFirst(content, placeholder(tag.closing.index), close);
-			return content;
-		},
-		content: (tag, module, content) => {
-			if (!tag.closing) return content;
-			const openTag = placeholder(tag.index);
-			const closeTag = placeholder(tag.closing.index);
-			const start = content.indexOf(openTag);
-			const end = content.indexOf(closeTag);
-			let replace = module.replace;
-			const innerContent = content.slice(start + openTag.length, end);
-			if (typeof replace === "function") replace = replace(tag.attr, innerContent, tag.attrs);
-			const contentStart = content.slice(0, Math.max(0, start));
-			const contentEnd = content.slice(end + closeTag.length);
-			return contentStart + replace + contentEnd;
-		},
-		ignore: (tag, _module, content) => {
-			const openTag = placeholder(tag.index);
-			const start = content.indexOf(openTag);
-			let closeTag = "";
-			let end = content.length;
-			if (tag.closing) {
-				closeTag = placeholder(tag.closing.index);
-				end = content.indexOf(closeTag);
-			}
-			const innerContent = content.slice(start + openTag.length, end);
-			const contentStart = content.slice(0, Math.max(0, start));
-			const contentEnd = content.slice(end + closeTag.length);
-			return contentStart + innerContent + contentEnd;
-		}
-	};
 	constructor(config = {}) {
 		this.config = {
 			newline: true,
@@ -266,162 +537,13 @@ var yabbcode = class {
 		if (config.sanitizeHtml !== void 0) this.config.sanitizeHtml = config.sanitizeHtml;
 		if (config.allowedSchemes !== void 0) this.config.allowedSchemes = config.allowedSchemes;
 	}
-	#getTag(name) {
-		if (!Object.hasOwn(this.tags, name)) return;
-		return this.tags[name];
-	}
-	#convertNewlines(input) {
-		if (!this.config.newline) return input;
-		if (this.config.paragraph) return input.replace(this.regex.newline, "</p><p>");
-		return input.replace(this.regex.newline, "<br/>");
-	}
-	#applyLayout(input) {
-		input = this.#convertNewlines(input);
-		if (this.config.paragraph) input = "<p>" + input + "</p>";
-		return input;
-	}
 	#unsanitize(value) {
 		if (!this.config.sanitizeHtml) return value;
 		return unescapeSanitized(value);
 	}
-	#findIgnoredTags(tagsMap) {
-		const ignored = /* @__PURE__ */ new Set();
-		let ignoreModule;
-		for (const tag of tagsMap) if (ignoreModule === void 0) {
-			if (!tag.isClosing && this.#getTag(tag.module)?.type === "ignore") ignoreModule = tag.module;
-		} else if (tag.isClosing && tag.module === ignoreModule) ignoreModule = void 0;
-		else ignored.add(tag.index);
-		return ignored;
-	}
-	#contentLoop(tagsMap, content, parentClosingTagIndex) {
-		if (tagsMap.length > 50) {
-			const hasSpecialType = (tag) => {
-				const module = this.#getTag(tag.module);
-				if (module) {
-					if (module.type === "content" || module.type === "ignore") return true;
-					if (module.type === "replace" && module.autoClose) return true;
-				}
-				return tag.children.some((child) => hasSpecialType(child));
-			};
-			if (!tagsMap.some((tag) => hasSpecialType(tag))) return this.#contentLoopOptimized(tagsMap, content);
-		}
-		for (let i = 0; i < tagsMap.length; i++) {
-			const tag = tagsMap[i];
-			if (!tag) continue;
-			let module = this.#getTag(tag.module);
-			if (!module) module = {
-				type: "replace",
-				open: tag.raw,
-				close: tag.closing ? tag.closing.raw : ""
-			};
-			if (!this.contentModules[module.type]) throw new Error("Cannot parse content block. Invalid block type [" + module.type + "] provided for tag [" + tag.module + "]");
-			if (module.type === "replace") {
-				const replaceModule = module;
-				let open = replaceModule.open;
-				if (typeof open === "function") open = open(tag.attr, tag.attrs);
-				if (open && !tag.isClosing) content = replaceFirst(content, placeholder(tag.index), open);
-				if (tag.children.length > 0) {
-					const closingIndex = tag.closing?.index;
-					content = this.#contentLoop(tag.children, content, closingIndex);
-				}
-				if (replaceModule.autoClose && !tag.closing) {
-					let autoClose = replaceModule.autoClose;
-					if (typeof autoClose === "function") autoClose = autoClose(tag.attr, tag.attrs);
-					let insertBefore;
-					for (let siblingIndex = i + 1; siblingIndex < tagsMap.length; siblingIndex++) {
-						const sibling = tagsMap[siblingIndex];
-						if (sibling?.module === tag.module) {
-							insertBefore = placeholder(sibling.index);
-							break;
-						}
-					}
-					if (insertBefore === void 0 && parentClosingTagIndex !== void 0) insertBefore = placeholder(parentClosingTagIndex);
-					if (insertBefore && autoClose) content = replaceFirst(content, insertBefore, autoClose + insertBefore);
-				}
-				let close = replaceModule.close;
-				if (typeof close === "function") close = close(tag.attr, tag.attrs);
-				if (close && tag.closing) content = replaceFirst(content, placeholder(tag.closing.index), close);
-			} else if (module.type === "content") {
-				if (tag.children.length > 0) content = this.#contentLoop(tag.children, content, tag.closing?.index);
-				content = this.contentModules.content(tag, module, content);
-			} else if (module.type === "ignore") content = this.contentModules.ignore(tag, module, content);
-		}
-		return content;
-	}
-	#contentLoopOptimized(tagsMap, content) {
-		const replacements = /* @__PURE__ */ new Map();
-		const processTag = (tag) => {
-			let module = this.#getTag(tag.module);
-			if (!module) module = {
-				type: "replace",
-				open: tag.raw,
-				close: tag.closing ? tag.closing.raw : ""
-			};
-			if (module.type !== "replace") return;
-			let open = module.open;
-			let close = module.close;
-			if (typeof open === "function") open = open(tag.attr, tag.attrs);
-			if (typeof close === "function") close = close(tag.attr, tag.attrs);
-			if (open && !tag.isClosing) replacements.set(placeholder(tag.index), open);
-			if (close && tag.closing) replacements.set(placeholder(tag.closing.index), close);
-			for (const child of tag.children) processTag(child);
-		};
-		for (const tag of tagsMap) processTag(tag);
-		return content.replaceAll(this.regex.placeholders, (match) => replacements.get(match) ?? match);
-	}
-	#tagLoop(tagsMap, parent) {
-		const stack = [];
-		const processed = /* @__PURE__ */ new Set();
-		for (let i = 0; i < tagsMap.length; i++) {
-			const tag = tagsMap[i];
-			if (!tag) continue;
-			if (tag.isClosing) for (let stackIndex = stack.length - 1; stackIndex >= 0; stackIndex--) {
-				const openTag = stack[stackIndex];
-				if (!openTag) continue;
-				if (openTag.module === tag.module && !processed.has(openTag.index)) {
-					openTag.matchTag = tag.index;
-					openTag.closing = tag;
-					tag.matchTag = openTag.index;
-					processed.add(openTag.index);
-					const childStart = (openTag.stackIndex ?? 0) + 1;
-					if (childStart < i) {
-						openTag.children = [];
-						for (let childIndex = childStart; childIndex < i; childIndex++) {
-							const childTag = tagsMap[childIndex];
-							if (!(childTag && !childTag.isClosing && childTag.parent === null)) continue;
-							childTag.parent = openTag.index;
-							openTag.children.push(childTag);
-						}
-					}
-					stack.splice(stackIndex, 1);
-					break;
-				}
-			}
-			else {
-				tag.stackIndex = i;
-				stack.push(tag);
-			}
-		}
-		for (const tag of stack) {
-			tag.matchTag = false;
-			const childStart = (tag.stackIndex ?? 0) + 1;
-			if (!(childStart < tagsMap.length)) continue;
-			tag.children = [];
-			for (let childIndex = childStart; childIndex < tagsMap.length; childIndex++) {
-				const childTag = tagsMap[childIndex];
-				if (!(childTag && !childTag.isClosing && childTag.parent === null)) continue;
-				childTag.parent = tag.index;
-				tag.children.push(childTag);
-			}
-		}
-		const result = [];
-		for (const tag of tagsMap) {
-			if (tag.isClosing) continue;
-			if (!(parent === void 0 && tag.parent === null || parent !== void 0 && tag.parent === parent)) continue;
-			if (tag.children.length > 0) tag.children = this.#tagLoop(tag.children, tag.index);
-			result.push(tag);
-		}
-		return result;
+	#leftover(doc, slot) {
+		if (this.config.cleanUnmatchable || slot * 2 >= doc.bounds.length) return "";
+		return tagText(doc, slot, !this.config.sanitizeHtml);
 	}
 	clearTags() {
 		this.tags = {};
@@ -429,88 +551,43 @@ var yabbcode = class {
 	}
 	registerTag(tag, options) {
 		const tagName = String(tag).toLowerCase();
-		if ([
-			"__proto__",
-			"constructor",
-			"prototype"
-		].includes(tagName)) throw new Error(`Cannot register tag with dangerous name: ${tagName}`);
+		if (dangerousKeys.has(tagName)) throw new Error(`Cannot register tag with dangerous name: ${tagName}`);
 		this.tags[tagName] = options;
 		return this;
 	}
 	parse(bbcInput) {
 		if (typeof bbcInput === "boolean" || typeof bbcInput !== "string" && Number.isNaN(Number(bbcInput))) return "";
-		let input = String(bbcInput).replaceAll(PLACEHOLDER_START, "");
-		if (this.config.sanitizeHtml) {
-			const htmlEntities = {
-				"&": "&amp;",
-				"<": "&lt;",
-				">": "&gt;",
-				"\"": "&quot;",
-				"'": "&#39;"
-			};
-			input = input.replaceAll(/["&'<>]/g, (char) => htmlEntities[char]);
+		let input = String(bbcInput);
+		if (input.includes(PLACEHOLDER_START)) input = input.replaceAll(PLACEHOLDER_START, "");
+		if (this.config.sanitizeHtml) input = escapeHtml(input);
+		let lineBreak;
+		if (this.config.newline) {
+			lineBreak = "<br/>";
+			if (this.config.paragraph) lineBreak = PARAGRAPH_BREAK;
 		}
-		let tagsMap = [];
-		const tags = String(input).match(this.regex.tags);
-		if (!tags || tags.length === 0) return this.#applyLayout(input);
-		for (const [i, tag] of tags.entries()) {
-			const tagContent = tag.slice(1, -1);
-			const isClosing = tagContent.startsWith("/");
-			const contentToParse = isClosing ? tagContent.slice(1) : tagContent;
-			const spaceIndex = contentToParse.indexOf(" ");
-			const equalsIndex = contentToParse.indexOf("=");
-			let moduleName;
-			let parsedAttrs;
-			if (spaceIndex === -1 && equalsIndex === -1) {
-				moduleName = contentToParse.toLowerCase();
-				parsedAttrs = {
-					attr: "",
-					attrs: {}
-				};
-			} else if (spaceIndex === -1 || equalsIndex !== -1 && equalsIndex < spaceIndex) {
-				moduleName = (contentToParse.split("=", 1)[0] ?? "").toLowerCase();
-				parsedAttrs = parseTagAttributes(contentToParse);
-			} else {
-				moduleName = (contentToParse.split(/\s+/, 1)[0] ?? "").toLowerCase();
-				parsedAttrs = parseTagAttributes(contentToParse);
-			}
-			const item = {
-				index: i,
-				module: moduleName,
-				isClosing,
-				raw: this.#convertNewlines(tag),
-				attr: parsedAttrs.attr,
-				attrs: parsedAttrs.attrs,
-				children: [],
-				parent: null,
-				matchTag: null
-			};
-			tagsMap.push(item);
+		const doc = {
+			input,
+			lineBreak,
+			parts: [],
+			bounds: [],
+			nextLf: -1,
+			nextCr: -1,
+			skips: void 0,
+			dead: void 0
+		};
+		const { parts } = doc;
+		const root = buildTree(doc, this.tags);
+		if (this.config.paragraph) {
+			parts[0] = "<p>" + parts[0];
+			parts[parts.length - 1] += "</p>";
 		}
-		const ignored = this.#findIgnoredTags(tagsMap);
-		tagsMap = tagsMap.filter((tag) => !ignored.has(tag.index));
-		const parts = [];
-		let searchFrom = 0;
-		let copiedUpTo = 0;
-		for (const [i, tag] of tags.entries()) {
-			const pos = input.indexOf(tag, searchFrom);
-			if (pos === -1) continue;
-			searchFrom = pos + tag.length;
-			if (ignored.has(i)) continue;
-			parts.push(input.slice(copiedUpTo, pos), placeholder(i));
-			copiedUpTo = searchFrom;
+		renderTree(doc, root);
+		if (!this.config.cleanUnmatchable) {
+			for (let index = 1; index < parts.length; index += 2) if (parts[index] === void 0) parts[index] = this.#leftover(doc, (index - 1) / 2);
 		}
-		parts.push(input.slice(copiedUpTo));
-		input = parts.join("");
-		input = this.#applyLayout(input);
-		tagsMap = this.#tagLoop(tagsMap);
-		input = this.#contentLoop(tagsMap, input);
-		if (this.config.cleanUnmatchable) return input.replaceAll(this.regex.placeholders, "");
-		return input.replaceAll(this.regex.placeholders, (_match, index) => {
-			let raw = tags[Number(index)] ?? "";
-			if (!this.config.sanitizeHtml) raw = escapeHtmlAttr(raw);
-			return this.#convertNewlines(raw);
-		});
+		const output = parts.join("");
+		if (!output.includes(PLACEHOLDER_START)) return output;
+		return output.replaceAll(placeholders, (_match, index) => this.#leftover(doc, Number(index)));
 	}
 };