bbcode-compiler 0.1.4 → 0.1.6

package/dist/index.js

@@ -1,16 +1,1014 @@
-export * from './generateHtml.js';
-export * from './lexer/Lexer.js';
-export * from './lexer/Token.js';
-export * from './lexer/TokenType.js';
-export * from './parser/Parser.js';
-export * from './parser/AstNode.js';
-export * from './parser/nodeIsType.js';
-export * from './generator/Generator.js';
-export * from './generator/transforms/Transform.js';
-export * from './generator/transforms/htmlTransforms.js';
-export * from './generator/utils/getWidthHeightAttr.js';
-export * from './generator/utils/getTagImmediateAttrVal.js';
-export * from './generator/utils/getTagImmediateText.js';
-export * from './generator/utils/isDangerousUrl.js';
-export * from './generator/utils/isOrderedList.js';
-//# sourceMappingURL=index.js.map
+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[AstNodeType2["RootNode"] = 0] = "RootNode";
+  AstNodeType2[AstNodeType2["TextNode"] = 1] = "TextNode";
+  AstNodeType2[AstNodeType2["LinebreakNode"] = 2] = "LinebreakNode";
+  AstNodeType2[AstNodeType2["TagNode"] = 3] = "TagNode";
+  AstNodeType2[AstNodeType2["StartTagNode"] = 4] = "StartTagNode";
+  AstNodeType2[AstNodeType2["EndTagNode"] = 5] = "EndTagNode";
+  AstNodeType2[AstNodeType2["AttrNode"] = 6] = "AttrNode";
+  return AstNodeType2;
+})(AstNodeType || {});
+function nodeTypeToString(nodeType) {
+  switch (nodeType) {
+    case 0:
+      return "RootNode";
+    case 1:
+      return "TextNode";
+    case 2:
+      return "LinebreakNode";
+    case 3:
+      return "TagNode";
+    case 4:
+      return "StartTagNode";
+    case 5:
+      return "EndTagNode";
+    case 6:
+      return "AttrNode";
+  }
+}
+class AstNode {
+  constructor(children = []) {
+    // eslint-disable-next-line no-use-before-define
+    __publicField(this, "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 nodeTypeToString(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;
+  }
+}
+class RootNode extends AstNode {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "nodeType", 0);
+  }
+  isValid() {
+    for (const child of this.children) {
+      if (child.nodeType !== 3 && child.nodeType !== 1 && child.nodeType !== 2) {
+        return false;
+      }
+    }
+    return super.isValid() && this.children.length > 0;
+  }
+}
+class TextNode extends AstNode {
+  constructor(str) {
+    super();
+    __publicField(this, "nodeType", 1);
+    __publicField(this, "str");
+    this.str = str;
+  }
+  isValid() {
+    return super.isValid() && this.children.length === 0;
+  }
+  toShortString() {
+    return `${super.toShortString()} "${this.str}"`;
+  }
+}
+class LinebreakNode extends AstNode {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "nodeType", 2);
+  }
+  toShortString() {
+    return `${super.toShortString()} "\\n"`;
+  }
+}
+const _AttrNode = class _AttrNode extends AstNode {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "nodeType", 6);
+  }
+  get key() {
+    switch (this.children.length) {
+      case 1: {
+        return _AttrNode.DEFAULT_KEY;
+      }
+      case 2: {
+        if (!nodeIsType(
+          this.children[0],
+          1
+          /* 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],
+          1
+          /* TextNode */
+        )) {
+          throw new Error("Invalid TextNode");
+        }
+        return this.children[0].str.trim();
+      }
+      case 2: {
+        if (!nodeIsType(
+          this.children[1],
+          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;
+  }
+};
+__publicField(_AttrNode, "DEFAULT_KEY", "default");
+let AttrNode = _AttrNode;
+class StartTagNode extends AstNode {
+  constructor(tagName, ogTag, attrNodes = []) {
+    super(attrNodes);
+    __publicField(this, "nodeType", 4);
+    __publicField(this, "tagName");
+    __publicField(this, "ogTag");
+    this.tagName = tagName.toLowerCase();
+    this.ogTag = ogTag;
+  }
+  isValid() {
+    for (const child of this.children) {
+      if (child.nodeType !== 6) {
+        return false;
+      }
+    }
+    return super.isValid();
+  }
+  toShortString() {
+    return `${super.toShortString()} ${this.ogTag}`;
+  }
+}
+class EndTagNode extends AstNode {
+  constructor(tagName, ogTag) {
+    super();
+    __publicField(this, "nodeType", 5);
+    __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}`;
+  }
+}
+class TagNode extends AstNode {
+  constructor(startTag, endTag) {
+    super();
+    __publicField(this, "nodeType", 3);
+    __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,
+      2
+      /* LinebreakNode */
+    )) {
+      return "\n";
+    } else {
+      return this._endTag.ogTag;
+    }
+  }
+  isValid() {
+    var _a;
+    if (this._endTag && nodeIsType(
+      this._endTag,
+      5
+      /* EndTagNode */
+    ) && this._startTag.tagName !== this._endTag.tagName) {
+      return false;
+    }
+    if (this.children.length === 1 && this.children[0].nodeType !== 0) {
+      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;
+  }
+}
+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: "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);
+}
+export {
+  AstNode,
+  AstNodeType,
+  AttrNode,
+  EndTagNode,
+  Generator,
+  Lexer,
+  LinebreakNode,
+  Parser,
+  RootNode,
+  StartTagNode,
+  TagNode,
+  TextNode,
+  TokenType,
+  generateHtml,
+  getTagImmediateAttrVal,
+  getTagImmediateText,
+  getWidthHeightAttr,
+  htmlTransforms,
+  isDangerousUrl,
+  isOrderedList,
+  isStringToken,
+  nodeIsType,
+  nodeTypeToString,
+  stringifyTokens,
+  symbolTable,
+  tokenTypeToString
+};
+//# sourceMappingURL=index.js.map