bbcode-compiler 0.1.9 → 0.1.11

package/dist/index.umd.cjs

@@ -1,1065 +1,916 @@
 (function(global, factory) {
-  typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.BbcodeCompiler = {}));
-})(this, function(exports2) {
-  "use strict";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);
-
-  function nodeIsType(node, 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;
-    }
-  };
-  __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;
-    }
-  }
-  function getTagImmediateAttrVal(tagNode) {
-    if (tagNode.attributes.length !== 1) {
-      return void 0;
-    }
-    const attrNode = tagNode.attributes[0];
-    return attrNode.val;
-  }
-  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;
-  }
-  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
-    };
-  }
-  const dangerousUriRe = /^(vbscript|javascript|file|data):/;
-  const 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;
-  }
-  function isOrderedList(node) {
-    for (const child of node.attributes) {
-      const val = child.val;
-      if (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>";
-      }
-    }
-  ];
-  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 || {});
-  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";
-    }
-  }
-  function isStringToken(tokenType) {
-    switch (tokenType) {
-      case 6:
-      case 7:
-      case 8:
-      case 9:
-      case 10:
-      case 0: {
-        return true;
-      }
-    }
-    return false;
-  }
-  const symbolTable = {
-    "\n": 1,
-    "[": 2,
-    "]": 3,
-    "/": 4,
-    "=": 5,
-    "&": 6,
-    "<": 7,
-    ">": 8,
-    '"': 9,
-    "'": 10
-    /* 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;
-    }
-  }
-  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;
-    }
-  }
-  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);
-  }
-  exports2.AstNode = AstNode;
-  exports2.AstNodeType = AstNodeType;
-  exports2.AttrNode = AttrNode;
-  exports2.EndTagNode = EndTagNode;
-  exports2.Generator = Generator;
-  exports2.Lexer = Lexer;
-  exports2.LinebreakNode = LinebreakNode;
-  exports2.Parser = Parser;
-  exports2.RootNode = RootNode;
-  exports2.StartTagNode = StartTagNode;
-  exports2.TagNode = TagNode;
-  exports2.TextNode = TextNode;
-  exports2.TokenType = TokenType;
-  exports2.generateHtml = generateHtml;
-  exports2.getTagImmediateAttrVal = getTagImmediateAttrVal;
-  exports2.getTagImmediateText = getTagImmediateText;
-  exports2.getWidthHeightAttr = getWidthHeightAttr;
-  exports2.htmlTransforms = htmlTransforms;
-  exports2.isDangerousUrl = isDangerousUrl;
-  exports2.isOrderedList = isOrderedList;
-  exports2.isStringToken = isStringToken;
-  exports2.nodeIsType = nodeIsType;
-  exports2.stringifyTokens = stringifyTokens;
-  exports2.symbolTable = symbolTable;
-  exports2.tokenTypeToString = tokenTypeToString;
-  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+	typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.BbcodeCompiler = {}));
+})(this, function(exports) {
+	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+	//#region src/parser/nodeIsType.ts
+	function nodeIsType(node, nodeType) {
+		return node.nodeType === nodeType;
+	}
+	//#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;
+		}
+	};
+	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;
+		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;
+		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
+		};
+	}
+	//#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;
+	}
+	//#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) if (child.val === "1") return true;
+		return false;
+	}
+	//#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>";
+			}
+		}
+	];
+	//#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 "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 "XSS_AMP":
+			case "XSS_LT":
+			case "XSS_GT":
+			case "XSS_D_QUOTE":
+			case "XSS_S_QUOTE":
+			case "STR": return true;
+		}
+		return false;
+	}
+	var symbolTable = {
+		"\n": "LINEBREAK",
+		"[": "L_BRACKET",
+		"]": "R_BRACKET",
+		"/": "BACKSLASH",
+		"=": "EQUALS",
+		"&": "XSS_AMP",
+		"<": "XSS_LT",
+		">": "XSS_GT",
+		"\"": "XSS_D_QUOTE",
+		"'": "XSS_S_QUOTE"
+	};
+	//#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 "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 tokens = new Lexer().tokenize(input);
+		const root = new Parser(transforms).parse(input, tokens);
+		return new Generator(transforms).generate(root);
+	}
+	//#endregion
+	exports.AstNode = AstNode;
+	exports.AttrNode = AttrNode;
+	exports.EndTagNode = EndTagNode;
+	exports.Generator = Generator;
+	exports.Lexer = Lexer;
+	exports.LinebreakNode = LinebreakNode;
+	exports.Parser = Parser;
+	exports.RootNode = RootNode;
+	exports.StartTagNode = StartTagNode;
+	exports.TagNode = TagNode;
+	exports.TextNode = TextNode;
+	exports.generateHtml = generateHtml;
+	exports.getTagImmediateAttrVal = getTagImmediateAttrVal;
+	exports.getTagImmediateText = getTagImmediateText;
+	exports.getWidthHeightAttr = getWidthHeightAttr;
+	exports.htmlTransforms = htmlTransforms;
+	exports.isDangerousUrl = isDangerousUrl;
+	exports.isOrderedList = isOrderedList;
+	exports.isStringToken = isStringToken;
+	exports.nodeIsType = nodeIsType;
+	exports.stringifyTokens = stringifyTokens;
+	exports.symbolTable = symbolTable;
+	exports.tokenTypeToString = tokenTypeToString;
 });
-//# sourceMappingURL=index.umd.cjs.map
+
+//# sourceMappingURL=index.umd.cjs.map