bbcode-compiler 0.1.9 → 0.1.11

package/dist/index.js

@@ -1,1061 +1,889 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+//#region src/parser/nodeIsType.ts
 function nodeIsType(node, nodeType) {
-  return node.nodeType === nodeType;
+	return node.nodeType === nodeType;
 }
-var AstNodeType = /* @__PURE__ */ ((AstNodeType2) => {
-  AstNodeType2["RootNode"] = "RootNode";
-  AstNodeType2["TextNode"] = "TextNode";
-  AstNodeType2["LinebreakNode"] = "LinebreakNode";
-  AstNodeType2["TagNode"] = "TagNode";
-  AstNodeType2["StartTagNode"] = "StartTagNode";
-  AstNodeType2["EndTagNode"] = "EndTagNode";
-  AstNodeType2["AttrNode"] = "AttrNode";
-  return AstNodeType2;
-})(AstNodeType || {});
-class AstNode {
-  constructor(children = []) {
-    this.children = children;
-  }
-  addChild(node) {
-    this.children.push(node);
-  }
-  isValid() {
-    for (const child of this.children) {
-      if (!child.isValid()) {
-        return false;
-      }
-    }
-    return true;
-  }
-  toShortString() {
-    return this.nodeType;
-  }
-  // For debugging purposes only
-  // Pretty-prints AST
-  toString(depth = 0) {
-    let s = " ".repeat(depth * 2) + this.toShortString();
-    for (const child of this.children) {
-      s += "\n" + child.toString(depth + 1);
-    }
-    return s;
-  }
-  toJSON() {
-    const json = {
-      type: this.nodeType
-    };
-    if (this.children.length > 0) {
-      json.children = this.children.map((child) => child.toJSON());
-    }
-    return json;
-  }
-}
-class RootNode extends AstNode {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "nodeType", "RootNode");
-  }
-  isValid() {
-    for (const child of this.children) {
-      if (child.nodeType !== "TagNode" && child.nodeType !== "TextNode" && child.nodeType !== "LinebreakNode") {
-        return false;
-      }
-    }
-    return super.isValid() && this.children.length > 0;
-  }
-}
-class TextNode extends AstNode {
-  constructor(str) {
-    super();
-    __publicField(this, "nodeType", "TextNode");
-    __publicField(this, "str");
-    this.str = str;
-  }
-  isValid() {
-    return super.isValid() && this.children.length === 0;
-  }
-  toShortString() {
-    return `${super.toShortString()} "${this.str}"`;
-  }
-  toJSON() {
-    const json = super.toJSON();
-    json.data = {
-      str: this.str
-    };
-    return json;
-  }
-}
-class LinebreakNode extends AstNode {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "nodeType", "LinebreakNode");
-  }
-  toShortString() {
-    return `${super.toShortString()} "\\n"`;
-  }
-}
-const _AttrNode = class _AttrNode extends AstNode {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "nodeType", "AttrNode");
-  }
-  get key() {
-    switch (this.children.length) {
-      case 1: {
-        return _AttrNode.DEFAULT_KEY;
-      }
-      case 2: {
-        if (!nodeIsType(
-          this.children[0],
-          "TextNode"
-          /* TextNode */
-        )) {
-          throw new Error("Invalid TextNode");
-        }
-        return this.children[0].str.trim();
-      }
-    }
-    throw new Error("Invalid AttrNode");
-  }
-  get val() {
-    switch (this.children.length) {
-      case 1: {
-        if (!nodeIsType(
-          this.children[0],
-          "TextNode"
-          /* TextNode */
-        )) {
-          throw new Error("Invalid TextNode");
-        }
-        return this.children[0].str.trim();
-      }
-      case 2: {
-        if (!nodeIsType(
-          this.children[1],
-          "TextNode"
-          /* TextNode */
-        )) {
-          throw new Error("Invalid TextNode");
-        }
-        return this.children[1].str.trim();
-      }
-    }
-    throw new Error("Invalid AttrNode");
-  }
-  isValid() {
-    return super.isValid() && (this.children.length >= 1 && this.children.length <= 2);
-  }
-  toShortString() {
-    let s = super.toShortString();
-    switch (this.children.length) {
-      case 1: {
-        s += ` VAL="${this.val}"`;
-        break;
-      }
-      case 2: {
-        s += ` KEY="${this.key}" VAL="${this.val}"`;
-        break;
-      }
-    }
-    return s;
-  }
-  toJSON() {
-    const json = {
-      type: this.nodeType
-    };
-    switch (this.children.length) {
-      case 1: {
-        json.data = {
-          key: this.key
-        };
-        break;
-      }
-      case 2: {
-        json.data = {
-          key: this.key,
-          val: this.val
-        };
-        break;
-      }
-    }
-    return json;
-  }
+//#endregion
+//#region src/parser/AstNode.ts
+/**
+
+Haven't formally verified this grammar but it should be LL(2)
+
+The root's intermediate state has StartTag/EndTag because it's easier to first parse them as independant nodes
+than to parse a StartTag and find the matching EndTag since we can only lookahead by 1 token
+
+Trying to lookahead by 4 tokens after each advancement to determine the end of the sub-root will greatly affect performance
+1 "["
+2 "/"
+3 "LABEL"
+4 "]"
+
+---
+
+Root <- (Text | Linebreak | Tag)*
+
+Text <-
+| {XSS Characters}.
+| STR.
+
+Linebreak <-
+| LINEBREAK.
+
+Tag      <- StartTag Root EndTag
+StartTag <- L_BRACKET           Text Attr* R_BRACKET
+EndTag   <- L_BRACKET BACKSLASH Text       R_BRACKET
+
+Attr <-
+| STR EQUALS STR
+| EQUALS STR
+| STR
+
+*/
+var AstNode = class {
+	children;
+	constructor(children = new Array()) {
+		this.children = children;
+	}
+	addChild(node) {
+		this.children.push(node);
+	}
+	isValid() {
+		for (const child of this.children) if (!child.isValid()) return false;
+		return true;
+	}
+	toShortString() {
+		return this.nodeType;
+	}
+	toString(depth = 0) {
+		let s = " ".repeat(depth * 2) + this.toShortString();
+		for (const child of this.children) s += "\n" + child.toString(depth + 1);
+		return s;
+	}
+	toJSON() {
+		const json = { type: this.nodeType };
+		if (this.children.length > 0) json.children = this.children.map((child) => child.toJSON());
+		return json;
+	}
 };
-__publicField(_AttrNode, "DEFAULT_KEY", "default");
-let AttrNode = _AttrNode;
-class StartTagNode extends AstNode {
-  constructor(tagName, ogTag, attrNodes = []) {
-    super(attrNodes);
-    __publicField(this, "nodeType", "StartTagNode");
-    __publicField(this, "tagName");
-    __publicField(this, "ogTag");
-    this.tagName = tagName.toLowerCase();
-    this.ogTag = ogTag;
-  }
-  isValid() {
-    for (const child of this.children) {
-      if (child.nodeType !== "AttrNode") {
-        return false;
-      }
-    }
-    return super.isValid();
-  }
-  toShortString() {
-    return `${super.toShortString()} ${this.ogTag}`;
-  }
-  toJSON() {
-    const json = super.toJSON();
-    json.data = {
-      tag: this.tagName
-    };
-    return json;
-  }
-}
-class EndTagNode extends AstNode {
-  constructor(tagName, ogTag) {
-    super();
-    __publicField(this, "nodeType", "EndTagNode");
-    __publicField(this, "tagName");
-    __publicField(this, "ogTag");
-    this.tagName = tagName;
-    this.ogTag = ogTag;
-  }
-  isValid() {
-    return super.isValid() && this.children.length === 0;
-  }
-  toShortString() {
-    return `${super.toShortString()} ${this.ogTag}`;
-  }
-  toJSON() {
-    const json = super.toJSON();
-    json.data = {
-      tag: this.tagName
-    };
-    return json;
-  }
-}
-class TagNode extends AstNode {
-  constructor(startTag, endTag) {
-    super();
-    __publicField(this, "nodeType", "TagNode");
-    __publicField(this, "_startTag");
-    __publicField(this, "_endTag");
-    this._startTag = startTag;
-    this._endTag = endTag;
-  }
-  get tagName() {
-    return this._startTag.tagName;
-  }
-  get attributes() {
-    return this._startTag.children;
-  }
-  get ogStartTag() {
-    return this._startTag.ogTag;
-  }
-  get ogEndTag() {
-    if (!this._endTag) {
-      return "";
-    }
-    if (nodeIsType(
-      this._endTag,
-      "LinebreakNode"
-      /* LinebreakNode */
-    )) {
-      return "\n";
-    } else {
-      return this._endTag.ogTag;
-    }
-  }
-  isValid() {
-    var _a;
-    if (this._endTag && nodeIsType(
-      this._endTag,
-      "EndTagNode"
-      /* EndTagNode */
-    ) && this._startTag.tagName !== this._endTag.tagName) {
-      return false;
-    }
-    if (this.children.length === 1 && this.children[0].nodeType !== "RootNode") {
-      return false;
-    }
-    if (this.children.length > 2) {
-      return false;
-    }
-    return super.isValid() && this._startTag.isValid() && (((_a = this._endTag) == null ? void 0 : _a.isValid()) ?? true);
-  }
-  toString(depth = 0) {
-    let s = " ".repeat(depth * 2) + this.toShortString() + ` [${this.tagName}]`;
-    for (const attrNode of this._startTag.children) {
-      s += "\n" + attrNode.toString(depth + 1);
-    }
-    for (const child of this.children) {
-      s += "\n" + child.toString(depth + 1);
-    }
-    return s;
-  }
-  toJSON() {
-    const json = super.toJSON();
-    json.data = {
-      startTag: this._startTag.toJSON()
-    };
-    if (this._endTag) {
-      json.data.endTag = this._endTag.toJSON();
-    }
-    return json;
-  }
-}
+var RootNode = class extends AstNode {
+	nodeType = "RootNode";
+	isValid() {
+		for (const child of this.children) if (child.nodeType !== "TagNode" && child.nodeType !== "TextNode" && child.nodeType !== "LinebreakNode") return false;
+		return super.isValid() && this.children.length > 0;
+	}
+};
+var TextNode = class extends AstNode {
+	nodeType = "TextNode";
+	str;
+	constructor(str) {
+		super();
+		this.str = str;
+	}
+	isValid() {
+		return super.isValid() && this.children.length === 0;
+	}
+	toShortString() {
+		return `${super.toShortString()} "${this.str}"`;
+	}
+	toJSON() {
+		const json = super.toJSON();
+		json.data = { str: this.str };
+		return json;
+	}
+};
+var LinebreakNode = class extends AstNode {
+	nodeType = "LinebreakNode";
+	toShortString() {
+		return `${super.toShortString()} "\\n"`;
+	}
+};
+var AttrNode = class AttrNode extends AstNode {
+	nodeType = "AttrNode";
+	static DEFAULT_KEY = "default";
+	get key() {
+		switch (this.children.length) {
+			case 1: return AttrNode.DEFAULT_KEY;
+			case 2:
+				if (!nodeIsType(this.children[0], "TextNode")) throw new Error("Invalid TextNode");
+				return this.children[0].str.trim();
+		}
+		throw new Error("Invalid AttrNode");
+	}
+	get val() {
+		switch (this.children.length) {
+			case 1:
+				if (!nodeIsType(this.children[0], "TextNode")) throw new Error("Invalid TextNode");
+				return this.children[0].str.trim();
+			case 2:
+				if (!nodeIsType(this.children[1], "TextNode")) throw new Error("Invalid TextNode");
+				return this.children[1].str.trim();
+		}
+		throw new Error("Invalid AttrNode");
+	}
+	isValid() {
+		return super.isValid() && this.children.length >= 1 && this.children.length <= 2;
+	}
+	toShortString() {
+		let s = super.toShortString();
+		switch (this.children.length) {
+			case 1:
+				s += ` VAL="${this.val}"`;
+				break;
+			case 2:
+				s += ` KEY="${this.key}" VAL="${this.val}"`;
+				break;
+		}
+		return s;
+	}
+	toJSON() {
+		const json = { type: this.nodeType };
+		switch (this.children.length) {
+			case 1:
+				json.data = { key: this.key };
+				break;
+			case 2:
+				json.data = {
+					key: this.key,
+					val: this.val
+				};
+				break;
+		}
+		return json;
+	}
+};
+var StartTagNode = class extends AstNode {
+	nodeType = "StartTagNode";
+	tagName;
+	ogTag;
+	constructor(tagName, ogTag, attrNodes = []) {
+		super(attrNodes);
+		this.tagName = tagName.toLowerCase();
+		this.ogTag = ogTag;
+	}
+	isValid() {
+		for (const child of this.children) if (child.nodeType !== "AttrNode") return false;
+		return super.isValid();
+	}
+	toShortString() {
+		return `${super.toShortString()} ${this.ogTag}`;
+	}
+	toJSON() {
+		const json = super.toJSON();
+		json.data = { tag: this.tagName };
+		return json;
+	}
+};
+var EndTagNode = class extends AstNode {
+	nodeType = "EndTagNode";
+	tagName;
+	ogTag;
+	constructor(tagName, ogTag) {
+		super();
+		this.tagName = tagName;
+		this.ogTag = ogTag;
+	}
+	isValid() {
+		return super.isValid() && this.children.length === 0;
+	}
+	toShortString() {
+		return `${super.toShortString()} ${this.ogTag}`;
+	}
+	toJSON() {
+		const json = super.toJSON();
+		json.data = { tag: this.tagName };
+		return json;
+	}
+};
+var TagNode = class extends AstNode {
+	nodeType = "TagNode";
+	_startTag;
+	_endTag;
+	constructor(startTag, endTag) {
+		super();
+		this._startTag = startTag;
+		this._endTag = endTag;
+	}
+	get tagName() {
+		return this._startTag.tagName;
+	}
+	get attributes() {
+		return this._startTag.children;
+	}
+	get ogStartTag() {
+		return this._startTag.ogTag;
+	}
+	get ogEndTag() {
+		if (!this._endTag) return "";
+		if (nodeIsType(this._endTag, "LinebreakNode")) return "\n";
+		else return this._endTag.ogTag;
+	}
+	isValid() {
+		if (this._endTag && nodeIsType(this._endTag, "EndTagNode") && this._startTag.tagName !== this._endTag.tagName) return false;
+		if (this.children.length === 1 && this.children[0].nodeType !== "RootNode") return false;
+		if (this.children.length > 2) return false;
+		return super.isValid() && this._startTag.isValid() && (this._endTag?.isValid() ?? true);
+	}
+	toString(depth = 0) {
+		let s = " ".repeat(depth * 2) + this.toShortString() + ` [${this.tagName}]`;
+		for (const attrNode of this._startTag.children) s += "\n" + attrNode.toString(depth + 1);
+		for (const child of this.children) s += "\n" + child.toString(depth + 1);
+		return s;
+	}
+	toJSON() {
+		const json = super.toJSON();
+		json.data = { startTag: this._startTag.toJSON() };
+		if (this._endTag) json.data.endTag = this._endTag.toJSON();
+		return json;
+	}
+};
+//#endregion
+//#region src/generator/utils/getTagImmediateAttrVal.ts
+/**
+* Gets the text of the immediate attribute of the current TagNode
+*
+*      [url=https://en.wikipedia.org]English Wikipedia[/url]
+*
+*      TagNode [url]
+*        AttrNode VAL="https://en.wikipedia.org" (returns this string)
+*          TextNode "https://en.wikipedia.org"
+*        RootNode
+*          TextNode "English Wikipedia"
+*/
 function getTagImmediateAttrVal(tagNode) {
-  if (tagNode.attributes.length !== 1) {
-    return void 0;
-  }
-  const attrNode = tagNode.attributes[0];
-  return attrNode.val;
+	if (tagNode.attributes.length !== 1) return;
+	return tagNode.attributes[0].val;
 }
+//#endregion
+//#region src/generator/utils/getTagImmediateText.ts
+/**
+* Gets the text of the immediate descendant of the current TagNode
+*
+*      [url]https://en.wikipedia.org[/url]
+*
+*      TagNode [url]
+*        RootNode
+*          TextNode "https://en.wikipedia.org" (returns this string)
+*/
 function getTagImmediateText(tagNode) {
-  if (tagNode.children.length !== 1) {
-    return void 0;
-  }
-  const child = tagNode.children[0];
-  if (!nodeIsType(child, AstNodeType.RootNode)) {
-    return void 0;
-  }
-  if (child.children.length !== 1) {
-    return void 0;
-  }
-  const textNode = child.children[0];
-  if (!nodeIsType(textNode, AstNodeType.TextNode)) {
-    return void 0;
-  }
-  return textNode.str;
+	if (tagNode.children.length !== 1) return;
+	const child = tagNode.children[0];
+	if (!nodeIsType(child, "RootNode")) return;
+	if (child.children.length !== 1) return;
+	const textNode = child.children[0];
+	if (!nodeIsType(textNode, "TextNode")) return;
+	return textNode.str;
 }
+//#endregion
+//#region src/generator/utils/getWidthHeightAttr.ts
+/**
+* Gets the width/height attributes of the TagNode if they exist
+*
+*      [img 500x300]https://upload.wikimedia.org/wikipedia/commons/7/70/Example.png[/img]
+*
+*      RootNode
+*        TagNode [img] (returns width:500, height:300)
+*          AttrNode VAL="500x300"
+*            TextNode " 500x300"
+*          RootNode
+*            TextNode "https://upload.wikimedia.org/wikipedia/commons/7/70/Example.png"
+*
+*      [img width=500 height=300]https://upload.wikimedia.org/wikipedia/commons/7/70/Example.png[/img]
+*
+*      RootNode
+*        TagNode [img] (returns width:500, height:300)
+*          AttrNode KEY="width" VAL="500"
+*            TextNode " width"
+*            TextNode "500"
+*          AttrNode KEY="height" VAL="300"
+*            TextNode " height"
+*            TextNode "300"
+*          RootNode
+*            TextNode "https://upload.wikimedia.org/wikipedia/commons/7/70/Example.png
+*/
 function getWidthHeightAttr(tagNode) {
-  let width;
-  let height;
-  for (const child of tagNode.attributes) {
-    if (child.key === "width") {
-      width = child.val;
-    }
-    if (child.key === "height") {
-      height = child.val;
-    }
-    const matches = /(\d+)x(\d+)/.exec(child.val);
-    if (matches) {
-      width = matches[1];
-      height = matches[2];
-    }
-  }
-  return {
-    width,
-    height
-  };
+	let width;
+	let height;
+	for (const child of tagNode.attributes) {
+		if (child.key === "width") width = child.val;
+		if (child.key === "height") height = child.val;
+		const matches = /(\d+)x(\d+)/.exec(child.val);
+		if (matches) {
+			width = matches[1];
+			height = matches[2];
+		}
+	}
+	return {
+		width,
+		height
+	};
 }
-const dangerousUriRe = /^(vbscript|javascript|file|data):/;
-const safeDataUriRe = /^data:image\/(gif|png|jpeg|webp);/;
+//#endregion
+//#region src/generator/utils/isDangerousUrl.ts
+var dangerousUriRe = /^(vbscript|javascript|file|data):/;
+var safeDataUriRe = /^data:image\/(gif|png|jpeg|webp);/;
 function isDangerousUrl(url) {
-  const normalizedUrl = url.trim().toLowerCase();
-  if (!dangerousUriRe.test(normalizedUrl)) {
-    return false;
-  }
-  if (safeDataUriRe.test(normalizedUrl)) {
-    return false;
-  }
-  return true;
+	const normalizedUrl = url.trim().toLowerCase();
+	if (!dangerousUriRe.test(normalizedUrl)) return false;
+	if (safeDataUriRe.test(normalizedUrl)) return false;
+	return true;
 }
+//#endregion
+//#region src/generator/utils/isOrderedList.ts
+/**
+* Determines if the StartTag has an attribute of "1" to indicate that it's an ordered list
+*
+*      [list=1]
+*
+*      TagNode [list]
+*        AttrNode VAL="1"
+*          TextNode "1"
+*        RootNode
+*          TagNode [*]
+*            RootNode
+*              TextNode "Entry 1"
+*          TagNode [*]
+*            RootNode
+*              TextNode "Entry 2"
+*/
 function isOrderedList(node) {
-  for (const child of node.attributes) {
-    const val = child.val;
-    if (val === "1") {
-      return true;
-    }
-  }
-  return false;
+	for (const child of node.attributes) if (child.val === "1") return true;
+	return false;
 }
-const htmlTransforms = [
-  {
-    name: "b",
-    start: () => {
-      return "<strong>";
-    },
-    end: () => {
-      return "</strong>";
-    }
-  },
-  {
-    name: "i",
-    start: () => {
-      return "<em>";
-    },
-    end: () => {
-      return "</em>";
-    }
-  },
-  {
-    name: "u",
-    start: () => {
-      return "<ins>";
-    },
-    end: () => {
-      return "</ins>";
-    }
-  },
-  {
-    name: "s",
-    start: () => {
-      return "<del>";
-    },
-    end: () => {
-      return "</del>";
-    }
-  },
-  {
-    name: "style",
-    start: (tagNode) => {
-      let style = "";
-      for (const child of tagNode.attributes) {
-        switch (child.key) {
-          case "color": {
-            style += `color:${child.val};`;
-            continue;
-          }
-          case "size": {
-            if (/^\d+$/.test(child.val)) {
-              style += `font-size:${child.val}%;`;
-            } else {
-              style += `font-size:${child.val};`;
-            }
-            continue;
-          }
-        }
-      }
-      return `<span style="${style}">`;
-    },
-    end: () => {
-      return "</span>";
-    }
-  },
-  {
-    name: "color",
-    start: (tagNode) => {
-      const color = getTagImmediateAttrVal(tagNode);
-      return `<span style="color:${color};">`;
-    },
-    end: () => {
-      return "</span>";
-    }
-  },
-  {
-    name: "hr",
-    isStandalone: true,
-    start: () => {
-      return "<hr />";
-    }
-  },
-  {
-    name: "br",
-    isStandalone: true,
-    start: () => {
-      return "<br />";
-    }
-  },
-  {
-    name: "list",
-    start: (tagNode) => {
-      return isOrderedList(tagNode) ? "<ol>" : "<ul>";
-    },
-    end: (tagNode) => {
-      return isOrderedList(tagNode) ? "</ol>" : "</ul>";
-    }
-  },
-  {
-    name: "*",
-    isLinebreakTerminated: true,
-    start: () => {
-      return "<li>";
-    },
-    end: () => {
-      return "</li>";
-    }
-  },
-  {
-    name: "img",
-    skipChildren: true,
-    start: (tagNode) => {
-      const src = getTagImmediateText(tagNode);
-      if (!src) {
-        return false;
-      }
-      if (isDangerousUrl(src)) {
-        return false;
-      }
-      const { width, height } = getWidthHeightAttr(tagNode);
-      let str = `<img src="${src}"`;
-      if (width) {
-        str += ` width="${width}"`;
-      }
-      if (height) {
-        str += ` height="${height}"`;
-      }
-      str += ">";
-      return str;
-    }
-  },
-  {
-    name: "url",
-    start: (tagNode) => {
-      const href = getTagImmediateAttrVal(tagNode) ?? getTagImmediateText(tagNode);
-      if (!href) {
-        return false;
-      }
-      if (isDangerousUrl(href)) {
-        return false;
-      }
-      return `<a href="${href}">`;
-    },
-    end: () => {
-      return "</a>";
-    }
-  },
-  {
-    name: "quote",
-    start: (tagNode) => {
-      const author = getTagImmediateAttrVal(tagNode);
-      return author ? `<blockquote><strong>${author}</strong>` : "<blockquote>";
-    },
-    end: () => {
-      return "</blockquote>";
-    }
-  },
-  {
-    name: "table",
-    start: () => {
-      return "<table>";
-    },
-    end: () => {
-      return "</table>";
-    }
-  },
-  {
-    name: "tr",
-    start: () => {
-      return "<tr>";
-    },
-    end: () => {
-      return "</tr>";
-    }
-  },
-  {
-    name: "td",
-    start: () => {
-      return "<td>";
-    },
-    end: () => {
-      return "</td>";
-    }
-  },
-  {
-    name: "code",
-    start: () => {
-      return "<code>";
-    },
-    end: () => {
-      return "</code>";
-    }
-  }
+//#endregion
+//#region src/generator/transforms/htmlTransforms.ts
+var htmlTransforms = [
+	{
+		name: "b",
+		start: () => {
+			return "<strong>";
+		},
+		end: () => {
+			return "</strong>";
+		}
+	},
+	{
+		name: "i",
+		start: () => {
+			return "<em>";
+		},
+		end: () => {
+			return "</em>";
+		}
+	},
+	{
+		name: "u",
+		start: () => {
+			return "<ins>";
+		},
+		end: () => {
+			return "</ins>";
+		}
+	},
+	{
+		name: "s",
+		start: () => {
+			return "<del>";
+		},
+		end: () => {
+			return "</del>";
+		}
+	},
+	{
+		name: "style",
+		start: (tagNode) => {
+			let style = "";
+			for (const child of tagNode.attributes) switch (child.key) {
+				case "color":
+					style += `color:${child.val};`;
+					continue;
+				case "size":
+					if (/^\d+$/.test(child.val)) style += `font-size:${child.val}%;`;
+					else style += `font-size:${child.val};`;
+					continue;
+			}
+			return `<span style="${style}">`;
+		},
+		end: () => {
+			return "</span>";
+		}
+	},
+	{
+		name: "color",
+		start: (tagNode) => {
+			return `<span style="color:${getTagImmediateAttrVal(tagNode)};">`;
+		},
+		end: () => {
+			return "</span>";
+		}
+	},
+	{
+		name: "hr",
+		isStandalone: true,
+		start: () => {
+			return "<hr />";
+		}
+	},
+	{
+		name: "br",
+		isStandalone: true,
+		start: () => {
+			return "<br />";
+		}
+	},
+	{
+		name: "list",
+		start: (tagNode) => {
+			return isOrderedList(tagNode) ? "<ol>" : "<ul>";
+		},
+		end: (tagNode) => {
+			return isOrderedList(tagNode) ? "</ol>" : "</ul>";
+		}
+	},
+	{
+		name: "*",
+		isLinebreakTerminated: true,
+		start: () => {
+			return "<li>";
+		},
+		end: () => {
+			return "</li>";
+		}
+	},
+	{
+		name: "img",
+		skipChildren: true,
+		start: (tagNode) => {
+			const src = getTagImmediateText(tagNode);
+			if (!src) return false;
+			if (isDangerousUrl(src)) return false;
+			const { width, height } = getWidthHeightAttr(tagNode);
+			let str = `<img src="${src}"`;
+			if (width) str += ` width="${width}"`;
+			if (height) str += ` height="${height}"`;
+			str += ">";
+			return str;
+		}
+	},
+	{
+		name: "url",
+		start: (tagNode) => {
+			const href = getTagImmediateAttrVal(tagNode) ?? getTagImmediateText(tagNode);
+			if (!href) return false;
+			if (isDangerousUrl(href)) return false;
+			return `<a href="${href}">`;
+		},
+		end: () => {
+			return "</a>";
+		}
+	},
+	{
+		name: "quote",
+		start: (tagNode) => {
+			const author = getTagImmediateAttrVal(tagNode);
+			return author ? `<blockquote><strong>${author}</strong>` : "<blockquote>";
+		},
+		end: () => {
+			return "</blockquote>";
+		}
+	},
+	{
+		name: "table",
+		start: () => {
+			return "<table>";
+		},
+		end: () => {
+			return "</table>";
+		}
+	},
+	{
+		name: "tr",
+		start: () => {
+			return "<tr>";
+		},
+		end: () => {
+			return "</tr>";
+		}
+	},
+	{
+		name: "td",
+		start: () => {
+			return "<td>";
+		},
+		end: () => {
+			return "</td>";
+		}
+	},
+	{
+		name: "code",
+		start: () => {
+			return "<code>";
+		},
+		end: () => {
+			return "</code>";
+		}
+	}
 ];
-class Generator {
-  constructor(transforms = htmlTransforms) {
-    __publicField(this, "transforms");
-    this.transforms = new Map(transforms.map((transform) => [transform.name, transform]));
-  }
-  generate(root) {
-    const stringify = (node) => {
-      var _a;
-      let output = "";
-      if (nodeIsType(node, AstNodeType.TagNode)) {
-        const tagName = node.tagName;
-        const transform = this.transforms.get(tagName);
-        if (!transform) {
-          throw new Error(`Unrecognized bbcode ${node.tagName}`);
-        }
-        const renderedStartTag = transform.start(node);
-        const renderedEndTag = ((_a = transform.end) == null ? void 0 : _a.call(transform, node)) ?? "";
-        const isInvalidTag = renderedStartTag === false;
-        if (isInvalidTag) {
-          output += node.ogStartTag;
-        } else {
-          output += renderedStartTag;
-        }
-        if (!transform.skipChildren || isInvalidTag) {
-          for (const child of node.children) {
-            output += stringify(child);
-          }
-        }
-        if (isInvalidTag) {
-          output += node.ogEndTag;
-        } else {
-          output += renderedEndTag;
-        }
-      } else if (nodeIsType(node, AstNodeType.TextNode)) {
-        output += node.str;
-      } else if (nodeIsType(node, AstNodeType.LinebreakNode)) {
-        output += "\n";
-      } else {
-        for (const child of node.children) {
-          output += stringify(child);
-        }
-      }
-      return output;
-    };
-    return stringify(root);
-  }
-}
-var TokenType = /* @__PURE__ */ ((TokenType2) => {
-  TokenType2[TokenType2["STR"] = 0] = "STR";
-  TokenType2[TokenType2["LINEBREAK"] = 1] = "LINEBREAK";
-  TokenType2[TokenType2["L_BRACKET"] = 2] = "L_BRACKET";
-  TokenType2[TokenType2["R_BRACKET"] = 3] = "R_BRACKET";
-  TokenType2[TokenType2["BACKSLASH"] = 4] = "BACKSLASH";
-  TokenType2[TokenType2["EQUALS"] = 5] = "EQUALS";
-  TokenType2[TokenType2["XSS_AMP"] = 6] = "XSS_AMP";
-  TokenType2[TokenType2["XSS_LT"] = 7] = "XSS_LT";
-  TokenType2[TokenType2["XSS_GT"] = 8] = "XSS_GT";
-  TokenType2[TokenType2["XSS_D_QUOTE"] = 9] = "XSS_D_QUOTE";
-  TokenType2[TokenType2["XSS_S_QUOTE"] = 10] = "XSS_S_QUOTE";
-  return TokenType2;
-})(TokenType || {});
+//#endregion
+//#region src/generator/Generator.ts
+var Generator = class {
+	transforms;
+	constructor(transforms = htmlTransforms) {
+		this.transforms = new Map(transforms.map((transform) => [transform.name, transform]));
+	}
+	generate(root) {
+		const stringify = (node) => {
+			let output = "";
+			if (nodeIsType(node, "TagNode")) {
+				const tagName = node.tagName;
+				const transform = this.transforms.get(tagName);
+				if (!transform) throw new Error(`Unrecognized bbcode ${node.tagName}`);
+				const renderedStartTag = transform.start(node);
+				const renderedEndTag = transform.end?.(node) ?? "";
+				const isInvalidTag = renderedStartTag === false;
+				if (isInvalidTag) output += node.ogStartTag;
+				else output += renderedStartTag;
+				if (!transform.skipChildren || isInvalidTag) for (const child of node.children) output += stringify(child);
+				if (isInvalidTag) output += node.ogEndTag;
+				else output += renderedEndTag;
+			} else if (nodeIsType(node, "TextNode")) output += node.str;
+			else if (nodeIsType(node, "LinebreakNode")) output += "\n";
+			else for (const child of node.children) output += stringify(child);
+			return output;
+		};
+		return stringify(root);
+	}
+};
+//#endregion
+//#region src/lexer/TokenType.ts
 function tokenTypeToString(tokenType) {
-  switch (tokenType) {
-    case 0:
-      return "STR";
-    case 1:
-      return "LINEBREAK";
-    case 2:
-      return "L_BRACKET";
-    case 3:
-      return "R_BRACKET";
-    case 4:
-      return "BACKSLASH";
-    case 5:
-      return "EQUALS";
-    case 6:
-      return "XSS_AMP";
-    case 7:
-      return "XSS_LT";
-    case 8:
-      return "XSS_GT";
-    case 9:
-      return "XSS_D_QUOTE";
-    case 10:
-      return "XSS_S_QUOTE";
-  }
+	switch (tokenType) {
+		case "STR": return "STR";
+		case "LINEBREAK": return "LINEBREAK";
+		case "L_BRACKET": return "L_BRACKET";
+		case "R_BRACKET": return "R_BRACKET";
+		case "BACKSLASH": return "BACKSLASH";
+		case "EQUALS": return "EQUALS";
+		case "XSS_AMP": return "XSS_AMP";
+		case "XSS_LT": return "XSS_LT";
+		case "XSS_GT": return "XSS_GT";
+		case "XSS_D_QUOTE": return "XSS_D_QUOTE";
+		case "XSS_S_QUOTE": return "XSS_S_QUOTE";
+	}
 }
 function isStringToken(tokenType) {
-  switch (tokenType) {
-    case 6:
-    case 7:
-    case 8:
-    case 9:
-    case 10:
-    case 0: {
-      return true;
-    }
-  }
-  return false;
+	switch (tokenType) {
+		case "XSS_AMP":
+		case "XSS_LT":
+		case "XSS_GT":
+		case "XSS_D_QUOTE":
+		case "XSS_S_QUOTE":
+		case "STR": return true;
+	}
+	return false;
 }
-const symbolTable = {
-  "\n": 1,
-  "[": 2,
-  "]": 3,
-  "/": 4,
-  "=": 5,
-  "&": 6,
-  "<": 7,
-  ">": 8,
-  '"': 9,
-  "'": 10
-  /* XSS_S_QUOTE */
+var symbolTable = {
+	"\n": "LINEBREAK",
+	"[": "L_BRACKET",
+	"]": "R_BRACKET",
+	"/": "BACKSLASH",
+	"=": "EQUALS",
+	"&": "XSS_AMP",
+	"<": "XSS_LT",
+	">": "XSS_GT",
+	"\"": "XSS_D_QUOTE",
+	"'": "XSS_S_QUOTE"
 };
-class Lexer {
-  tokenize(input) {
-    const tokens = new Array();
-    const re = /\n|\[\/|\[(\w+|\*)|\]|=|&|<|>|'|"/g;
-    let offset = 0;
-    while (true) {
-      const match = re.exec(input);
-      if (!match) {
-        break;
-      }
-      const length2 = match.index - offset;
-      if (length2 > 0) {
-        tokens.push({
-          type: TokenType.STR,
-          offset,
-          length: length2
-        });
-      }
-      offset = match.index;
-      if (match[0] === "[/") {
-        tokens.push({
-          type: TokenType.L_BRACKET,
-          offset,
-          length: 1
-        });
-        offset += 1;
-        tokens.push({
-          type: TokenType.BACKSLASH,
-          offset,
-          length: 1
-        });
-        offset += 1;
-      } else if (match[0].startsWith("[")) {
-        tokens.push({
-          type: TokenType.L_BRACKET,
-          offset,
-          length: 1
-        });
-        offset += 1;
-        const length3 = match[0].length - 1;
-        tokens.push({
-          type: TokenType.STR,
-          offset,
-          length: length3
-        });
-        offset += length3;
-      } else {
-        tokens.push({
-          type: symbolTable[match[0]] ?? TokenType.STR,
-          offset,
-          length: 1
-        });
-        offset += 1;
-      }
-    }
-    const length = input.length - offset;
-    if (length > 0) {
-      tokens.push({
-        type: TokenType.STR,
-        offset,
-        length
-      });
-    }
-    return tokens;
-  }
-}
+//#endregion
+//#region src/lexer/Lexer.ts
+var Lexer = class {
+	tokenize(input) {
+		const tokens = new Array();
+		const re = /\n|\[\/|\[(\w+|\*)|\]|=|&|<|>|'|"/g;
+		let offset = 0;
+		while (true) {
+			const match = re.exec(input);
+			if (!match) break;
+			const length = match.index - offset;
+			if (length > 0) tokens.push({
+				type: "STR",
+				offset,
+				length
+			});
+			offset = match.index;
+			if (match[0] === "[/") {
+				tokens.push({
+					type: "L_BRACKET",
+					offset,
+					length: 1
+				});
+				offset += 1;
+				tokens.push({
+					type: "BACKSLASH",
+					offset,
+					length: 1
+				});
+				offset += 1;
+			} else if (match[0].startsWith("[")) {
+				tokens.push({
+					type: "L_BRACKET",
+					offset,
+					length: 1
+				});
+				offset += 1;
+				const length = match[0].length - 1;
+				tokens.push({
+					type: "STR",
+					offset,
+					length
+				});
+				offset += length;
+			} else {
+				tokens.push({
+					type: symbolTable[match[0]] ?? "STR",
+					offset,
+					length: 1
+				});
+				offset += 1;
+			}
+		}
+		const length = input.length - offset;
+		if (length > 0) tokens.push({
+			type: "STR",
+			offset,
+			length
+		});
+		return tokens;
+	}
+};
+//#endregion
+//#region src/lexer/Token.ts
 function stringifyTokens(ogText, tokens) {
-  let s = "";
-  for (const token of tokens) {
-    switch (token.type) {
-      case TokenType.STR: {
-        s += ogText.substring(token.offset, token.offset + token.length);
-        break;
-      }
-      case TokenType.LINEBREAK: {
-        s += "\n";
-        break;
-      }
-      case TokenType.L_BRACKET: {
-        s += "[";
-        break;
-      }
-      case TokenType.R_BRACKET: {
-        s += "]";
-        break;
-      }
-      case TokenType.BACKSLASH: {
-        s += "/";
-        break;
-      }
-      case TokenType.EQUALS: {
-        s += "=";
-        break;
-      }
-      case TokenType.XSS_AMP: {
-        s += "&amp;";
-        break;
-      }
-      case TokenType.XSS_LT: {
-        s += "&lt;";
-        break;
-      }
-      case TokenType.XSS_GT: {
-        s += "&gt;";
-        break;
-      }
-      case TokenType.XSS_D_QUOTE: {
-        s += "&quot;";
-        break;
-      }
-      case TokenType.XSS_S_QUOTE: {
-        s += "&#x27;";
-        break;
-      }
-    }
-  }
-  return s;
-}
-class Parser {
-  constructor(transforms = htmlTransforms) {
-    __publicField(this, "tags");
-    __publicField(this, "linebreakTerminatedTags");
-    __publicField(this, "standaloneTags");
-    this.tags = new Set(transforms.map((transform) => transform.name));
-    this.linebreakTerminatedTags = new Set(transforms.filter((transform) => transform.isLinebreakTerminated).map((transform) => transform.name.toLowerCase()));
-    this.standaloneTags = new Set(transforms.filter((transform) => transform.isStandalone).map((transform) => transform.name.toLowerCase()));
-  }
-  parse(ogText, tokens) {
-    let idx = 0;
-    const parseLabel = () => {
-      const slice = tokens.slice(idx, idx + 1);
-      const label = stringifyTokens(ogText, slice);
-      idx += 1;
-      return label.toLowerCase();
-    };
-    const parseText = (endOnQuotes = false, endOnSpace = false) => {
-      const startIdx = idx;
-      while (idx < tokens.length) {
-        if (!isStringToken(tokens[idx].type)) {
-          break;
-        }
-        if (endOnQuotes && (tokens[idx].type === TokenType.XSS_S_QUOTE || tokens[idx].type === TokenType.XSS_D_QUOTE)) {
-          break;
-        }
-        if (endOnSpace && !endOnQuotes) {
-          const origStr = stringifyTokens(ogText, [tokens[idx]]);
-          const spaceIdx = origStr.indexOf(" ");
-          if (spaceIdx >= 0) {
-            const oldToken = {
-              type: TokenType.STR,
-              offset: tokens[idx].offset,
-              length: spaceIdx
-            };
-            const newToken = {
-              type: TokenType.STR,
-              offset: tokens[idx].offset + spaceIdx,
-              length: tokens[idx].length - spaceIdx
-            };
-            tokens.splice(idx + 0, 1, oldToken);
-            tokens.splice(idx + 1, 0, newToken);
-            idx += 1;
-            break;
-          }
-        }
-        idx += 1;
-      }
-      const slice = tokens.slice(startIdx, idx);
-      const str = stringifyTokens(ogText, slice);
-      return new TextNode(str);
-    };
-    const parseAttr = () => {
-      if (idx + 1 >= tokens.length) {
-        return null;
-      }
-      const attrNode = new AttrNode();
-      if (tokens[idx].type === TokenType.EQUALS && isStringToken(tokens[idx + 1].type)) {
-        idx += 1;
-        const openedWithQuotes = tokens[idx].type === TokenType.XSS_S_QUOTE || tokens[idx].type === TokenType.XSS_D_QUOTE;
-        if (openedWithQuotes) {
-          idx += 1;
-        }
-        const valNode = parseText(openedWithQuotes, true);
-        attrNode.addChild(valNode);
-        if (openedWithQuotes) {
-          if (tokens[idx].type !== TokenType.XSS_S_QUOTE && tokens[idx].type !== TokenType.XSS_D_QUOTE) {
-            return null;
-          }
-          idx += 1;
-        }
-      } else if (isStringToken(tokens[idx].type) && tokens[idx + 1].type === TokenType.EQUALS && (idx + 2 < tokens.length && isStringToken(tokens[idx + 2].type))) {
-        const keyNode = parseText();
-        attrNode.addChild(keyNode);
-        idx += 1;
-        const openedWithQuotes = tokens[idx].type === TokenType.XSS_S_QUOTE || tokens[idx].type === TokenType.XSS_D_QUOTE;
-        if (openedWithQuotes) {
-          idx += 1;
-        }
-        const valNode = parseText(openedWithQuotes, true);
-        if (openedWithQuotes) {
-          if (tokens[idx].type !== TokenType.XSS_S_QUOTE && tokens[idx].type !== TokenType.XSS_D_QUOTE) {
-            return null;
-          }
-          idx += 1;
-        }
-        attrNode.addChild(valNode);
-      } else if (isStringToken(tokens[idx].type) && tokens[idx + 1].type !== TokenType.EQUALS) {
-        const valNode = parseText();
-        attrNode.addChild(valNode);
-      } else {
-        return null;
-      }
-      return attrNode;
-    };
-    const parseTag = () => {
-      if (idx + 1 >= tokens.length) {
-        return null;
-      }
-      if (tokens[idx].type !== TokenType.L_BRACKET) {
-        return null;
-      }
-      if (isStringToken(tokens[idx + 1].type)) {
-        const startIdx = idx;
-        idx += 1;
-        const labelText = parseLabel();
-        if (!this.tags.has(labelText)) {
-          return null;
-        }
-        const attrNodes = new Array();
-        while (true) {
-          const attrNode = parseAttr();
-          if (attrNode === null) {
-            break;
-          }
-          attrNodes.push(attrNode);
-        }
-        if (tokens[idx].type !== TokenType.R_BRACKET) {
-          return null;
-        }
-        idx += 1;
-        const slice = tokens.slice(startIdx, idx);
-        const ogTag = stringifyTokens(ogText, slice);
-        const startTagNode = new StartTagNode(labelText, ogTag, attrNodes);
-        return startTagNode;
-      }
-      if (tokens[idx + 1].type === TokenType.BACKSLASH) {
-        const startIdx = idx;
-        idx += 1;
-        idx += 1;
-        const labelText = parseLabel();
-        if (!this.tags.has(labelText)) {
-          return null;
-        }
-        if (tokens[idx].type !== TokenType.R_BRACKET) {
-          return null;
-        }
-        idx += 1;
-        const slice = tokens.slice(startIdx, idx);
-        const ogTag = stringifyTokens(ogText, slice);
-        const endTagNode = new EndTagNode(labelText, ogTag);
-        return endTagNode;
-      }
-      return null;
-    };
-    const parseRoot = () => {
-      const root2 = new RootNode();
-      while (idx < tokens.length) {
-        if (tokens[idx].type === TokenType.L_BRACKET) {
-          const startIdx = idx;
-          const tagNode = parseTag();
-          if (tagNode !== null) {
-            root2.addChild(tagNode);
-          } else {
-            const invalidTokens = tokens.slice(startIdx, idx);
-            const str = stringifyTokens(ogText, invalidTokens);
-            const textNode = new TextNode(str);
-            root2.addChild(textNode);
-          }
-        } else if (tokens[idx].type === TokenType.LINEBREAK) {
-          idx += 1;
-          root2.addChild(new LinebreakNode());
-        } else {
-          const startIdx = idx;
-          while (idx < tokens.length && tokens[idx].type !== TokenType.L_BRACKET && tokens[idx].type !== TokenType.LINEBREAK) {
-            idx += 1;
-          }
-          const slice = tokens.slice(startIdx, idx);
-          const str = stringifyTokens(ogText, slice);
-          root2.addChild(new TextNode(str));
-        }
-      }
-      return root2;
-    };
-    let root = parseRoot();
-    root = this.matchTagNodes(root);
-    return root;
-  }
-  // ------------------------------------------------------------------------
-  // Post Parsing Transforms
-  // ------------------------------------------------------------------------
-  matchTagNodes(rootNode) {
-    const transformedRoot = new RootNode();
-    for (let i = 0; i < rootNode.children.length; i++) {
-      const child = rootNode.children[i];
-      if (nodeIsType(child, AstNodeType.StartTagNode)) {
-        const endTag = this.findMatchingEndTag(rootNode.children, i, child.tagName);
-        const isStandalone = this.standaloneTags.has(child.tagName);
-        if (endTag || isStandalone) {
-          const tagNode = new TagNode(child, endTag == null ? void 0 : endTag.node);
-          transformedRoot.addChild(tagNode);
-          if (endTag) {
-            const subRoot = new RootNode(rootNode.children.slice(i + 1, endTag.idx));
-            i = endTag.idx;
-            const transformedSubRoot = this.matchTagNodes(subRoot);
-            tagNode.addChild(transformedSubRoot);
-          }
-        } else {
-          transformedRoot.addChild(new TextNode(child.ogTag));
-        }
-      } else if (nodeIsType(child, AstNodeType.EndTagNode)) {
-        transformedRoot.addChild(new TextNode(child.ogTag));
-      } else if (nodeIsType(child, AstNodeType.TextNode)) {
-        transformedRoot.addChild(child);
-      } else if (nodeIsType(child, AstNodeType.LinebreakNode)) {
-        transformedRoot.addChild(child);
-      } else {
-        throw new Error("Unexpected child of RootNode");
-      }
-    }
-    return transformedRoot;
-  }
-  findMatchingEndTag(siblings, startIdx, tagName) {
-    if (this.standaloneTags.has(tagName)) {
-      return null;
-    }
-    for (let i = startIdx; i < siblings.length; i++) {
-      const sibling = siblings[i];
-      const isEndTag = nodeIsType(sibling, AstNodeType.LinebreakNode) && this.linebreakTerminatedTags.has(tagName) || nodeIsType(sibling, AstNodeType.EndTagNode) && sibling.tagName === tagName;
-      if (isEndTag) {
-        return {
-          idx: i,
-          node: sibling
-        };
-      }
-    }
-    return null;
-  }
+	let s = "";
+	for (const token of tokens) switch (token.type) {
+		case "STR":
+			s += ogText.substring(token.offset, token.offset + token.length);
+			break;
+		case "LINEBREAK":
+			s += "\n";
+			break;
+		case "L_BRACKET":
+			s += "[";
+			break;
+		case "R_BRACKET":
+			s += "]";
+			break;
+		case "BACKSLASH":
+			s += "/";
+			break;
+		case "EQUALS":
+			s += "=";
+			break;
+		case "XSS_AMP":
+			s += "&amp;";
+			break;
+		case "XSS_LT":
+			s += "&lt;";
+			break;
+		case "XSS_GT":
+			s += "&gt;";
+			break;
+		case "XSS_D_QUOTE":
+			s += "&quot;";
+			break;
+		case "XSS_S_QUOTE":
+			s += "&#x27;";
+			break;
+	}
+	return s;
 }
+//#endregion
+//#region src/parser/Parser.ts
+var Parser = class {
+	tags;
+	linebreakTerminatedTags;
+	standaloneTags;
+	constructor(transforms = htmlTransforms) {
+		this.tags = new Set(transforms.map((transform) => transform.name));
+		this.linebreakTerminatedTags = new Set(transforms.filter((transform) => transform.isLinebreakTerminated).map((transform) => transform.name.toLowerCase()));
+		this.standaloneTags = new Set(transforms.filter((transform) => transform.isStandalone).map((transform) => transform.name.toLowerCase()));
+	}
+	parse(ogText, tokens) {
+		let idx = 0;
+		const parseLabel = () => {
+			const label = stringifyTokens(ogText, tokens.slice(idx, idx + 1));
+			idx += 1;
+			return label.toLowerCase();
+		};
+		const parseText = (endOnQuotes = false, endOnSpace = false) => {
+			const startIdx = idx;
+			while (idx < tokens.length) {
+				if (!isStringToken(tokens[idx].type)) break;
+				if (endOnQuotes && (tokens[idx].type === "XSS_S_QUOTE" || tokens[idx].type === "XSS_D_QUOTE")) break;
+				/**
+				* SPECIAL CASE:
+				* If we encounter a space, then we must split the current token into 2 tokens and only consume the first part
+				*
+				*      a b    ->      a b
+				*      |              | |
+				*      |              | idx (new)
+				*      |              |
+				*      idx            consumed
+				*
+				* Note: We only handle endOnSpace special case when we don't expect the current text to endOnQuotes
+				* If it endOnQuotes, then it implies that it opened with quotes (and thus we need an enclosing/matching quote)
+				*/
+				if (endOnSpace && !endOnQuotes) {
+					const spaceIdx = stringifyTokens(ogText, [tokens[idx]]).indexOf(" ");
+					if (spaceIdx >= 0) {
+						const oldToken = {
+							type: "STR",
+							offset: tokens[idx].offset,
+							length: spaceIdx
+						};
+						const newToken = {
+							type: "STR",
+							offset: tokens[idx].offset + spaceIdx,
+							length: tokens[idx].length - spaceIdx
+						};
+						tokens.splice(idx + 0, 1, oldToken);
+						tokens.splice(idx + 1, 0, newToken);
+						idx += 1;
+						break;
+					}
+				}
+				idx += 1;
+			}
+			return new TextNode(stringifyTokens(ogText, tokens.slice(startIdx, idx)));
+		};
+		const parseAttr = () => {
+			if (idx + 1 >= tokens.length) return null;
+			const attrNode = new AttrNode();
+			if (tokens[idx].type === "EQUALS" && isStringToken(tokens[idx + 1].type)) {
+				idx += 1;
+				const openedWithQuotes = tokens[idx].type === "XSS_S_QUOTE" || tokens[idx].type === "XSS_D_QUOTE";
+				if (openedWithQuotes) idx += 1;
+				const valNode = parseText(openedWithQuotes, true);
+				attrNode.addChild(valNode);
+				if (openedWithQuotes) {
+					if (tokens[idx].type !== "XSS_S_QUOTE" && tokens[idx].type !== "XSS_D_QUOTE") return null;
+					idx += 1;
+				}
+			} else if (isStringToken(tokens[idx].type) && tokens[idx + 1].type === "EQUALS" && idx + 2 < tokens.length && isStringToken(tokens[idx + 2].type)) {
+				const keyNode = parseText();
+				attrNode.addChild(keyNode);
+				idx += 1;
+				const openedWithQuotes = tokens[idx].type === "XSS_S_QUOTE" || tokens[idx].type === "XSS_D_QUOTE";
+				if (openedWithQuotes) idx += 1;
+				const valNode = parseText(openedWithQuotes, true);
+				if (openedWithQuotes) {
+					if (tokens[idx].type !== "XSS_S_QUOTE" && tokens[idx].type !== "XSS_D_QUOTE") return null;
+					idx += 1;
+				}
+				attrNode.addChild(valNode);
+			} else if (isStringToken(tokens[idx].type) && tokens[idx + 1].type !== "EQUALS") {
+				const valNode = parseText();
+				attrNode.addChild(valNode);
+			} else return null;
+			return attrNode;
+		};
+		const parseTag = () => {
+			if (idx + 1 >= tokens.length) return null;
+			if (tokens[idx].type !== "L_BRACKET") return null;
+			if (isStringToken(tokens[idx + 1].type)) {
+				const startIdx = idx;
+				idx += 1;
+				const labelText = parseLabel();
+				if (!this.tags.has(labelText)) return null;
+				const attrNodes = new Array();
+				while (true) {
+					const attrNode = parseAttr();
+					if (attrNode === null) break;
+					attrNodes.push(attrNode);
+				}
+				if (tokens[idx].type !== "R_BRACKET") return null;
+				idx += 1;
+				return new StartTagNode(labelText, stringifyTokens(ogText, tokens.slice(startIdx, idx)), attrNodes);
+			}
+			if (tokens[idx + 1].type === "BACKSLASH") {
+				const startIdx = idx;
+				idx += 1;
+				idx += 1;
+				const labelText = parseLabel();
+				if (!this.tags.has(labelText)) return null;
+				if (tokens[idx].type !== "R_BRACKET") return null;
+				idx += 1;
+				return new EndTagNode(labelText, stringifyTokens(ogText, tokens.slice(startIdx, idx)));
+			}
+			return null;
+		};
+		const parseRoot = () => {
+			const root = new RootNode();
+			while (idx < tokens.length) if (tokens[idx].type === "L_BRACKET") {
+				const startIdx = idx;
+				const tagNode = parseTag();
+				if (tagNode !== null) root.addChild(tagNode);
+				else {
+					const textNode = new TextNode(stringifyTokens(ogText, tokens.slice(startIdx, idx)));
+					root.addChild(textNode);
+				}
+			} else if (tokens[idx].type === "LINEBREAK") {
+				idx += 1;
+				root.addChild(new LinebreakNode());
+			} else {
+				const startIdx = idx;
+				while (idx < tokens.length && tokens[idx].type !== "L_BRACKET" && tokens[idx].type !== "LINEBREAK") idx += 1;
+				const str = stringifyTokens(ogText, tokens.slice(startIdx, idx));
+				root.addChild(new TextNode(str));
+			}
+			return root;
+		};
+		let root = parseRoot();
+		root = this.matchTagNodes(root);
+		return root;
+	}
+	matchTagNodes(rootNode) {
+		const transformedRoot = new RootNode();
+		for (let i = 0; i < rootNode.children.length; i++) {
+			const child = rootNode.children[i];
+			if (nodeIsType(child, "StartTagNode")) {
+				const endTag = this.findMatchingEndTag(rootNode.children, i, child.tagName);
+				const isStandalone = this.standaloneTags.has(child.tagName);
+				if (endTag || isStandalone) {
+					const tagNode = new TagNode(child, endTag?.node);
+					transformedRoot.addChild(tagNode);
+					if (endTag) {
+						const subRoot = new RootNode(rootNode.children.slice(i + 1, endTag.idx));
+						i = endTag.idx;
+						const transformedSubRoot = this.matchTagNodes(subRoot);
+						tagNode.addChild(transformedSubRoot);
+					}
+				} else transformedRoot.addChild(new TextNode(child.ogTag));
+			} else if (nodeIsType(child, "EndTagNode")) transformedRoot.addChild(new TextNode(child.ogTag));
+			else if (nodeIsType(child, "TextNode")) transformedRoot.addChild(child);
+			else if (nodeIsType(child, "LinebreakNode")) transformedRoot.addChild(child);
+			else throw new Error("Unexpected child of RootNode");
+		}
+		return transformedRoot;
+	}
+	findMatchingEndTag(siblings, startIdx, tagName) {
+		if (this.standaloneTags.has(tagName)) return null;
+		for (let i = startIdx; i < siblings.length; i++) {
+			const sibling = siblings[i];
+			if (nodeIsType(sibling, "LinebreakNode") && this.linebreakTerminatedTags.has(tagName) || nodeIsType(sibling, "EndTagNode") && sibling.tagName === tagName) return {
+				idx: i,
+				node: sibling
+			};
+		}
+		return null;
+	}
+};
+//#endregion
+//#region src/generateHtml.ts
 function generateHtml(input, transforms = htmlTransforms) {
-  const lexer = new Lexer();
-  const tokens = lexer.tokenize(input);
-  const parser = new Parser(transforms);
-  const root = parser.parse(input, tokens);
-  const generator = new Generator(transforms);
-  return generator.generate(root);
+	const tokens = new Lexer().tokenize(input);
+	const root = new Parser(transforms).parse(input, tokens);
+	return new Generator(transforms).generate(root);
 }
-export {
-  AstNode,
-  AstNodeType,
-  AttrNode,
-  EndTagNode,
-  Generator,
-  Lexer,
-  LinebreakNode,
-  Parser,
-  RootNode,
-  StartTagNode,
-  TagNode,
-  TextNode,
-  TokenType,
-  generateHtml,
-  getTagImmediateAttrVal,
-  getTagImmediateText,
-  getWidthHeightAttr,
-  htmlTransforms,
-  isDangerousUrl,
-  isOrderedList,
-  isStringToken,
-  nodeIsType,
-  stringifyTokens,
-  symbolTable,
-  tokenTypeToString
-};
-//# sourceMappingURL=index.js.map
+//#endregion
+export { AstNode, AttrNode, EndTagNode, Generator, Lexer, LinebreakNode, Parser, RootNode, StartTagNode, TagNode, TextNode, generateHtml, getTagImmediateAttrVal, getTagImmediateText, getWidthHeightAttr, htmlTransforms, isDangerousUrl, isOrderedList, isStringToken, nodeIsType, stringifyTokens, symbolTable, tokenTypeToString };
+
+//# sourceMappingURL=index.js.map