ya-bbcode 4.0.0 → 5.1.0

package/dist/ya-bbcode.d.cts

@@ -0,0 +1,64 @@
+interface Config {
+  newline?: boolean;
+  paragraph?: boolean;
+  cleanUnmatchable?: boolean;
+  sanitizeHtml?: boolean;
+  allowedSchemes?: string[];
+}
+interface TagAttributes {
+  [key: string]: string | boolean;
+}
+interface ReplaceTag {
+  type: 'replace';
+  open: ((attr: string, attrs: TagAttributes) => string) | string;
+  close: ((attr: string, attrs: TagAttributes) => string) | string | null;
+  /**
+   * HTML to insert when the tag implicitly closes (e.g., before next sibling or parent close).
+   * Useful for tags like [*] that don't have explicit closing tags in BBCode.
+   */
+  autoClose?: ((attr: string, attrs: TagAttributes) => string) | string;
+}
+interface ContentTag {
+  type: 'content';
+  replace: ((attr: string, content: string, attrs: TagAttributes) => string) | string;
+}
+interface IgnoreTag {
+  type: 'ignore';
+}
+type TagDefinition = ReplaceTag | ContentTag | IgnoreTag;
+interface TagsMap {
+  [key: string]: TagDefinition;
+}
+interface TagItem {
+  index: number;
+  module: string;
+  raw: string;
+  attr: string;
+  attrs: TagAttributes;
+  isClosing: boolean;
+  matchTag: number | false | null;
+  closing?: TagItem;
+  children: TagItem[];
+  parent: number | null;
+  stackIndex?: number;
+}
+declare class yabbcode {
+  #private;
+  tags: TagsMap;
+  regex: {
+    tags: RegExp;
+    newline: RegExp;
+    placeholders: RegExp;
+  };
+  config: Config;
+  contentModules: {
+    replace: (tag: TagItem, module: ReplaceTag, content: string) => string;
+    content: (tag: TagItem, module: ContentTag, content: string) => string;
+    ignore: (tag: TagItem, _module: IgnoreTag, content: string) => string;
+  };
+  constructor(config?: Config);
+  clearTags(): this;
+  registerTag(tag: string, options: TagDefinition): this;
+  parse(bbcInput: string | number | boolean): string;
+}
+export { type Config, type ContentTag, type IgnoreTag, type ReplaceTag, type TagAttributes, type TagDefinition, yabbcode as default };

package/dist/ya-bbcode.d.mts

@@ -0,0 +1,64 @@
+interface Config {
+  newline?: boolean;
+  paragraph?: boolean;
+  cleanUnmatchable?: boolean;
+  sanitizeHtml?: boolean;
+  allowedSchemes?: string[];
+}
+interface TagAttributes {
+  [key: string]: string | boolean;
+}
+interface ReplaceTag {
+  type: 'replace';
+  open: ((attr: string, attrs: TagAttributes) => string) | string;
+  close: ((attr: string, attrs: TagAttributes) => string) | string | null;
+  /**
+   * HTML to insert when the tag implicitly closes (e.g., before next sibling or parent close).
+   * Useful for tags like [*] that don't have explicit closing tags in BBCode.
+   */
+  autoClose?: ((attr: string, attrs: TagAttributes) => string) | string;
+}
+interface ContentTag {
+  type: 'content';
+  replace: ((attr: string, content: string, attrs: TagAttributes) => string) | string;
+}
+interface IgnoreTag {
+  type: 'ignore';
+}
+type TagDefinition = ReplaceTag | ContentTag | IgnoreTag;
+interface TagsMap {
+  [key: string]: TagDefinition;
+}
+interface TagItem {
+  index: number;
+  module: string;
+  raw: string;
+  attr: string;
+  attrs: TagAttributes;
+  isClosing: boolean;
+  matchTag: number | false | null;
+  closing?: TagItem;
+  children: TagItem[];
+  parent: number | null;
+  stackIndex?: number;
+}
+declare class yabbcode {
+  #private;
+  tags: TagsMap;
+  regex: {
+    tags: RegExp;
+    newline: RegExp;
+    placeholders: RegExp;
+  };
+  config: Config;
+  contentModules: {
+    replace: (tag: TagItem, module: ReplaceTag, content: string) => string;
+    content: (tag: TagItem, module: ContentTag, content: string) => string;
+    ignore: (tag: TagItem, _module: IgnoreTag, content: string) => string;
+  };
+  constructor(config?: Config);
+  clearTags(): this;
+  registerTag(tag: string, options: TagDefinition): this;
+  parse(bbcInput: string | number | boolean): string;
+}
+export { type Config, type ContentTag, type IgnoreTag, type ReplaceTag, type TagAttributes, type TagDefinition, yabbcode as default };

package/dist/ya-bbcode.mjs

@@ -0,0 +1,487 @@
+// src/ya-bbcode.ts
+/**
+* Escapes HTML attribute values to prevent XSS
+* Encodes quotes, angle brackets, and other special characters
+*/
+function escapeHtmlAttr(value) {
+	const attrEntities = {
+		"&": "&",
+		"<": "&lt;",
+		">": "&gt;",
+		"\"": "&quot;",
+		"'": "&#39;"
+	};
+	return String(value).replaceAll(/["&'<>]/g, (char) => attrEntities[char] || char);
+}
+/**
+* Validates and sanitizes URLs to prevent javascript: and data: URL attacks
+* Only allows safe URL schemes based on the allowedSchemes list
+*/
+function sanitizeUrl(url, allowedSchemes) {
+	const trimmed = String(url).trim();
+	if (!trimmed) return "#";
+	if (/^\.{0,2}\//.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 "#";
+	}
+	return trimmed;
+}
+/**
+* Parse tag attributes from a tag string
+* Supports both formats:
+* - [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+/);
+	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;
+		}
+	}
+	return {
+		attr: firstValue,
+		attrs
+	};
+}
+var yabbcode = class {
+	tags = {
+		"url": {
+			type: "replace",
+			open: (attr) => `<a href="${escapeHtmlAttr(sanitizeUrl(attr, this.config.allowedSchemes ?? [
+				"http",
+				"https",
+				"mailto",
+				"ftp",
+				"ftps"
+			]))}">`,
+			close: "</a>"
+		},
+		"quote": {
+			type: "replace",
+			open: (attr) => `<blockquote author="${escapeHtmlAttr(attr)}">`,
+			close: "</blockquote>"
+		},
+		"b": {
+			type: "replace",
+			open: "<strong>",
+			close: "</strong>"
+		},
+		"u": {
+			type: "replace",
+			open: "<u>",
+			close: "</u>"
+		},
+		"i": {
+			type: "replace",
+			open: "<i>",
+			close: "</i>"
+		},
+		"h1": {
+			type: "replace",
+			open: "<h1>",
+			close: "</h1>"
+		},
+		"h2": {
+			type: "replace",
+			open: "<h2>",
+			close: "</h2>"
+		},
+		"h3": {
+			type: "replace",
+			open: "<h3>",
+			close: "</h3>"
+		},
+		"h4": {
+			type: "replace",
+			open: "<h4>",
+			close: "</h4>"
+		},
+		"h5": {
+			type: "replace",
+			open: "<h5>",
+			close: "</h5>"
+		},
+		"h6": {
+			type: "replace",
+			open: "<h6>",
+			close: "</h6>"
+		},
+		"code": {
+			type: "replace",
+			open: "<code>",
+			close: "</code>"
+		},
+		"hr": {
+			type: "replace",
+			open: "<hr/>",
+			close: null
+		},
+		"strike": {
+			type: "replace",
+			open: "<span class=\"yabbcode-strike\">",
+			close: "</span>"
+		},
+		"spoiler": {
+			type: "replace",
+			open: "<span class=\"yabbcode-spoiler\">",
+			close: "</span>"
+		},
+		"list": {
+			type: "replace",
+			open: "<ul>",
+			close: "</ul>"
+		},
+		"olist": {
+			type: "replace",
+			open: "<ol>",
+			close: "</ol>"
+		},
+		"*": {
+			type: "replace",
+			open: "<li>",
+			close: "</li>",
+			autoClose: "</li>"
+		},
+		"img": {
+			type: "content",
+			replace: (attr, content) => {
+				if (!content) return "";
+				return `<img src="${escapeHtmlAttr(content)}" alt="${escapeHtmlAttr(attr)}"/>`;
+			}
+		},
+		"noparse": { type: "ignore" }
+	};
+	regex = {
+		tags: /(\[[^\]^]+\])/g,
+		newline: /\r\n|\r|\n/g,
+		placeholders: /\[TAG-[1-9]+\]/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 = content.replace("[TAG-" + tag.index + "]", open);
+			if (close && tag.closing) content = content.replace("[TAG-" + tag.closing.index + "]", close);
+			return content;
+		},
+		content: (tag, module, content) => {
+			if (!tag.closing) return content;
+			const openTag = "[TAG-" + tag.index + "]";
+			const closeTag = "[TAG-" + 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 = "[TAG-" + tag.index + "]";
+			const start = content.indexOf(openTag);
+			let closeTag = "";
+			let end = content.length;
+			if (tag.closing) {
+				closeTag = "[TAG-" + tag.closing.index + "]";
+				end = content.indexOf(closeTag);
+			}
+			let innerContent = content.slice(start + openTag.length, end);
+			innerContent = this.#ignoreLoop(tag.children, innerContent);
+			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,
+			paragraph: false,
+			cleanUnmatchable: true,
+			sanitizeHtml: true,
+			allowedSchemes: [
+				"http",
+				"https",
+				"mailto",
+				"ftp",
+				"ftps"
+			]
+		};
+		if (config.newline !== void 0) this.config.newline = config.newline;
+		if (config.paragraph !== void 0) this.config.paragraph = config.paragraph;
+		if (config.cleanUnmatchable !== void 0) this.config.cleanUnmatchable = config.cleanUnmatchable;
+		if (config.sanitizeHtml !== void 0) this.config.sanitizeHtml = config.sanitizeHtml;
+		if (config.allowedSchemes !== void 0) this.config.allowedSchemes = config.allowedSchemes;
+	}
+	#ignoreLoop(tagsMap, content) {
+		for (const tag of tagsMap) {
+			content = content.replace("[TAG-" + tag.index + "]", tag.raw);
+			if (tag.closing) content = content.replace("[TAG-" + tag.closing.index + "]", tag.closing.raw);
+			if (tag.children.length > 0) content = this.#ignoreLoop(tag.children, content);
+		}
+		return content;
+	}
+	#contentLoop(tagsMap, content, parentClosingTagIndex) {
+		if (tagsMap.length > 50) {
+			const hasSpecialType = (tag) => {
+				const module = this.tags[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.tags[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 = content.replace("[TAG-" + 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 = "[TAG-" + sibling.index + "]";
+							break;
+						}
+					}
+					if (insertBefore === void 0 && parentClosingTagIndex !== void 0) insertBefore = "[TAG-" + parentClosingTagIndex + "]";
+					if (insertBefore && autoClose) content = content.replace(insertBefore, autoClose + insertBefore);
+				}
+				let close = replaceModule.close;
+				if (typeof close === "function") close = close(tag.attr, tag.attrs);
+				if (close && tag.closing) content = content.replace("[TAG-" + 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.tags[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("[TAG-" + tag.index + "]", open);
+			if (close && tag.closing) replacements.set("[TAG-" + tag.closing.index + "]", close);
+			for (const child of tag.children) processTag(child);
+		};
+		for (const tag of tagsMap) processTag(tag);
+		return content.replaceAll(/\[TAG-(\d+)\]/g, (match) => replacements.get(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;
+	}
+	clearTags() {
+		this.tags = {};
+		return this;
+	}
+	registerTag(tag, options) {
+		const tagName = String(tag).toLowerCase();
+		if ([
+			"__proto__",
+			"constructor",
+			"prototype"
+		].includes(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);
+		if (this.config.sanitizeHtml) {
+			const htmlEntities = {
+				"&": "&amp;",
+				"<": "&lt;",
+				">": "&gt;",
+				"\"": "&quot;",
+				"'": "&#39;"
+			};
+			input = input.replaceAll(/["&'<>]/g, (char) => htmlEntities[char]);
+		}
+		let tagsMap = [];
+		const tags = String(input).match(this.regex.tags);
+		if (this.config.newline) {
+			if (this.config.paragraph) input = input.replace(this.regex.newline, "</p><p>");
+			else input = input.replace(this.regex.newline, "<br/>");
+		}
+		if (this.config.paragraph) input = "<p>" + input + "</p>";
+		if (!tags || tags.length === 0) return 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: tag,
+				attr: parsedAttrs.attr,
+				attrs: parsedAttrs.attrs,
+				children: [],
+				parent: null,
+				matchTag: null
+			};
+			tagsMap.push(item);
+		}
+		if (tags.length <= 3) for (const [i, tag] of tags.entries()) input = input.replace(tag, "[TAG-" + i + "]");
+		else {
+			const tagPositions = [];
+			let lastIndex = 0;
+			for (const [i, tag] of tags.entries()) {
+				const pos = input.indexOf(tag, lastIndex);
+				if (pos === -1) continue;
+				tagPositions.push({
+					pos,
+					tag,
+					placeholder: "[TAG-" + i + "]"
+				});
+				lastIndex = pos + tag.length;
+			}
+			if (tagPositions.length > 0) {
+				const parts = [];
+				let lastPos = 0;
+				for (const { pos, tag, placeholder } of tagPositions) {
+					parts.push(input.slice(lastPos, pos));
+					parts.push(placeholder);
+					lastPos = pos + tag.length;
+				}
+				parts.push(input.slice(lastPos));
+				input = parts.join("");
+			}
+		}
+		tagsMap = this.#tagLoop(tagsMap);
+		input = this.#contentLoop(tagsMap, input);
+		if (this.config.cleanUnmatchable) input = input.replace(this.regex.placeholders, "");
+		return input;
+	}
+};
+
+export { yabbcode as default };
+//# sourceMappingURL=ya-bbcode.mjs.map