tutuca 0.9.35 → 0.9.37

package/dist/tutuca-cli.js

@@ -2066,6 +2066,2632 @@ var init_components = __esm(() => {
   init_attribute();
 });
 
+// node_modules/entities/dist/decode-codepoint.js
+function replaceCodePoint(codePoint) {
+  if (codePoint >= 55296 && codePoint <= 57343 || codePoint > 1114111) {
+    return 65533;
+  }
+  return decodeMap.get(codePoint) ?? codePoint;
+}
+var decodeMap;
+var init_decode_codepoint = __esm(() => {
+  decodeMap = new Map([
+    [0, 65533],
+    [128, 8364],
+    [130, 8218],
+    [131, 402],
+    [132, 8222],
+    [133, 8230],
+    [134, 8224],
+    [135, 8225],
+    [136, 710],
+    [137, 8240],
+    [138, 352],
+    [139, 8249],
+    [140, 338],
+    [142, 381],
+    [145, 8216],
+    [146, 8217],
+    [147, 8220],
+    [148, 8221],
+    [149, 8226],
+    [150, 8211],
+    [151, 8212],
+    [152, 732],
+    [153, 8482],
+    [154, 353],
+    [155, 8250],
+    [156, 339],
+    [158, 382],
+    [159, 376]
+  ]);
+});
+
+// node_modules/entities/dist/internal/decode-shared.js
+function decodeBase64(input) {
+  const binary = atob(input);
+  const evenLength = binary.length & ~1;
+  const out = new Uint16Array(evenLength / 2);
+  for (let index = 0, outIndex = 0;index < evenLength; index += 2) {
+    const lo = binary.charCodeAt(index);
+    const hi = binary.charCodeAt(index + 1);
+    out[outIndex++] = lo | hi << 8;
+  }
+  return out;
+}
+
+// node_modules/entities/dist/generated/decode-data-html.js
+var htmlDecodeTree;
+var init_decode_data_html = __esm(() => {
+  htmlDecodeTree = /* @__PURE__ */ decodeBase64("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");
+});
+
+// node_modules/entities/dist/generated/decode-data-xml.js
+var xmlDecodeTree;
+var init_decode_data_xml = __esm(() => {
+  xmlDecodeTree = /* @__PURE__ */ decodeBase64("AAJhZ2xxBwARABMAFQBtAg0AAAAAAA8AcAAmYG8AcwAnYHQAPmB0ADxg9SFvdCJg");
+});
+
+// node_modules/entities/dist/internal/bin-trie-flags.js
+var BinTrieFlags;
+var init_bin_trie_flags = __esm(() => {
+  (function(BinTrieFlags2) {
+    BinTrieFlags2[BinTrieFlags2["VALUE_LENGTH"] = 49152] = "VALUE_LENGTH";
+    BinTrieFlags2[BinTrieFlags2["FLAG13"] = 8192] = "FLAG13";
+    BinTrieFlags2[BinTrieFlags2["BRANCH_LENGTH"] = 8064] = "BRANCH_LENGTH";
+    BinTrieFlags2[BinTrieFlags2["JUMP_TABLE"] = 127] = "JUMP_TABLE";
+  })(BinTrieFlags || (BinTrieFlags = {}));
+});
+
+// node_modules/entities/dist/decode.js
+function isNumber(code) {
+  return code >= CharCodes.ZERO && code <= CharCodes.NINE;
+}
+function isHexadecimalCharacter(code) {
+  return code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_F || code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_F;
+}
+function isAsciiAlphaNumeric(code) {
+  return code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_Z || code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_Z || isNumber(code);
+}
+function isEntityInAttributeInvalidEnd(code) {
+  return code === CharCodes.EQUALS || isAsciiAlphaNumeric(code);
+}
+
+class EntityDecoder {
+  decodeTree;
+  emitCodePoint;
+  errors;
+  constructor(decodeTree, emitCodePoint, errors) {
+    this.decodeTree = decodeTree;
+    this.emitCodePoint = emitCodePoint;
+    this.errors = errors;
+  }
+  state = EntityDecoderState.EntityStart;
+  consumed = 1;
+  result = 0;
+  treeIndex = 0;
+  excess = 1;
+  decodeMode = DecodingMode.Strict;
+  runConsumed = 0;
+  startEntity(decodeMode) {
+    this.decodeMode = decodeMode;
+    this.state = EntityDecoderState.EntityStart;
+    this.result = 0;
+    this.treeIndex = 0;
+    this.excess = 1;
+    this.consumed = 1;
+    this.runConsumed = 0;
+  }
+  write(input, offset) {
+    switch (this.state) {
+      case EntityDecoderState.EntityStart: {
+        if (input.charCodeAt(offset) === CharCodes.NUM) {
+          this.state = EntityDecoderState.NumericStart;
+          this.consumed += 1;
+          return this.stateNumericStart(input, offset + 1);
+        }
+        this.state = EntityDecoderState.NamedEntity;
+        return this.stateNamedEntity(input, offset);
+      }
+      case EntityDecoderState.NumericStart: {
+        return this.stateNumericStart(input, offset);
+      }
+      case EntityDecoderState.NumericDecimal: {
+        return this.stateNumericDecimal(input, offset);
+      }
+      case EntityDecoderState.NumericHex: {
+        return this.stateNumericHex(input, offset);
+      }
+      case EntityDecoderState.NamedEntity: {
+        return this.stateNamedEntity(input, offset);
+      }
+    }
+  }
+  stateNumericStart(input, offset) {
+    if (offset >= input.length) {
+      return -1;
+    }
+    if ((input.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) {
+      this.state = EntityDecoderState.NumericHex;
+      this.consumed += 1;
+      return this.stateNumericHex(input, offset + 1);
+    }
+    this.state = EntityDecoderState.NumericDecimal;
+    return this.stateNumericDecimal(input, offset);
+  }
+  stateNumericHex(input, offset) {
+    while (offset < input.length) {
+      const char = input.charCodeAt(offset);
+      if (isNumber(char) || isHexadecimalCharacter(char)) {
+        const digit = char <= CharCodes.NINE ? char - CharCodes.ZERO : (char | TO_LOWER_BIT) - CharCodes.LOWER_A + 10;
+        this.result = this.result * 16 + digit;
+        this.consumed++;
+        offset++;
+      } else {
+        return this.emitNumericEntity(char, 3);
+      }
+    }
+    return -1;
+  }
+  stateNumericDecimal(input, offset) {
+    while (offset < input.length) {
+      const char = input.charCodeAt(offset);
+      if (isNumber(char)) {
+        this.result = this.result * 10 + (char - CharCodes.ZERO);
+        this.consumed++;
+        offset++;
+      } else {
+        return this.emitNumericEntity(char, 2);
+      }
+    }
+    return -1;
+  }
+  emitNumericEntity(lastCp, expectedLength) {
+    if (this.consumed <= expectedLength) {
+      this.errors?.absenceOfDigitsInNumericCharacterReference(this.consumed);
+      return 0;
+    }
+    if (lastCp === CharCodes.SEMI) {
+      this.consumed += 1;
+    } else if (this.decodeMode === DecodingMode.Strict) {
+      return 0;
+    }
+    this.emitCodePoint(replaceCodePoint(this.result), this.consumed);
+    if (this.errors) {
+      if (lastCp !== CharCodes.SEMI) {
+        this.errors.missingSemicolonAfterCharacterReference();
+      }
+      this.errors.validateNumericCharacterReference(this.result);
+    }
+    return this.consumed;
+  }
+  stateNamedEntity(input, offset) {
+    const { decodeTree } = this;
+    let current = decodeTree[this.treeIndex];
+    let valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
+    while (offset < input.length) {
+      if (valueLength === 0 && (current & BinTrieFlags.FLAG13) !== 0) {
+        const runLength = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;
+        if (this.runConsumed === 0) {
+          const firstChar = current & BinTrieFlags.JUMP_TABLE;
+          if (input.charCodeAt(offset) !== firstChar) {
+            return this.result === 0 ? 0 : this.emitNotTerminatedNamedEntity();
+          }
+          offset++;
+          this.excess++;
+          this.runConsumed++;
+        }
+        while (this.runConsumed < runLength) {
+          if (offset >= input.length) {
+            return -1;
+          }
+          const charIndexInPacked = this.runConsumed - 1;
+          const packedWord = decodeTree[this.treeIndex + 1 + (charIndexInPacked >> 1)];
+          const expectedChar = charIndexInPacked % 2 === 0 ? packedWord & 255 : packedWord >> 8 & 255;
+          if (input.charCodeAt(offset) !== expectedChar) {
+            this.runConsumed = 0;
+            return this.result === 0 ? 0 : this.emitNotTerminatedNamedEntity();
+          }
+          offset++;
+          this.excess++;
+          this.runConsumed++;
+        }
+        this.runConsumed = 0;
+        this.treeIndex += 1 + (runLength >> 1);
+        current = decodeTree[this.treeIndex];
+        valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
+      }
+      if (offset >= input.length)
+        break;
+      const char = input.charCodeAt(offset);
+      if (char === CharCodes.SEMI && valueLength !== 0 && (current & BinTrieFlags.FLAG13) !== 0) {
+        return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);
+      }
+      this.treeIndex = determineBranch(decodeTree, current, this.treeIndex + Math.max(1, valueLength), char);
+      if (this.treeIndex < 0) {
+        return this.result === 0 || this.decodeMode === DecodingMode.Attribute && (valueLength === 0 || isEntityInAttributeInvalidEnd(char)) ? 0 : this.emitNotTerminatedNamedEntity();
+      }
+      current = decodeTree[this.treeIndex];
+      valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
+      if (valueLength !== 0) {
+        if (char === CharCodes.SEMI) {
+          return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);
+        }
+        if (this.decodeMode !== DecodingMode.Strict && (current & BinTrieFlags.FLAG13) === 0) {
+          this.result = this.treeIndex;
+          this.consumed += this.excess;
+          this.excess = 0;
+        }
+      }
+      offset++;
+      this.excess++;
+    }
+    return -1;
+  }
+  emitNotTerminatedNamedEntity() {
+    const { result, decodeTree } = this;
+    const valueLength = (decodeTree[result] & BinTrieFlags.VALUE_LENGTH) >> 14;
+    this.emitNamedEntityData(result, valueLength, this.consumed);
+    this.errors?.missingSemicolonAfterCharacterReference();
+    return this.consumed;
+  }
+  emitNamedEntityData(result, valueLength, consumed) {
+    const { decodeTree } = this;
+    this.emitCodePoint(valueLength === 1 ? decodeTree[result] & ~(BinTrieFlags.VALUE_LENGTH | BinTrieFlags.FLAG13) : decodeTree[result + 1], consumed);
+    if (valueLength === 3) {
+      this.emitCodePoint(decodeTree[result + 2], consumed);
+    }
+    return consumed;
+  }
+  end() {
+    switch (this.state) {
+      case EntityDecoderState.NamedEntity: {
+        return this.result !== 0 && (this.decodeMode !== DecodingMode.Attribute || this.result === this.treeIndex) ? this.emitNotTerminatedNamedEntity() : 0;
+      }
+      case EntityDecoderState.NumericDecimal: {
+        return this.emitNumericEntity(0, 2);
+      }
+      case EntityDecoderState.NumericHex: {
+        return this.emitNumericEntity(0, 3);
+      }
+      case EntityDecoderState.NumericStart: {
+        this.errors?.absenceOfDigitsInNumericCharacterReference(this.consumed);
+        return 0;
+      }
+      case EntityDecoderState.EntityStart: {
+        return 0;
+      }
+    }
+  }
+}
+function determineBranch(decodeTree, current, nodeIndex, char) {
+  const branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;
+  const jumpOffset = current & BinTrieFlags.JUMP_TABLE;
+  if (branchCount === 0) {
+    return jumpOffset !== 0 && char === jumpOffset ? nodeIndex : -1;
+  }
+  if (jumpOffset) {
+    const value = char - jumpOffset;
+    return value < 0 || value >= branchCount ? -1 : decodeTree[nodeIndex + value] - 1;
+  }
+  const packedKeySlots = branchCount + 1 >> 1;
+  let lo = 0;
+  let hi = branchCount - 1;
+  while (lo <= hi) {
+    const mid = lo + hi >>> 1;
+    const slot = mid >> 1;
+    const packed = decodeTree[nodeIndex + slot];
+    const midKey = packed >> (mid & 1) * 8 & 255;
+    if (midKey < char) {
+      lo = mid + 1;
+    } else if (midKey > char) {
+      hi = mid - 1;
+    } else {
+      return decodeTree[nodeIndex + packedKeySlots + mid];
+    }
+  }
+  return -1;
+}
+var CharCodes, TO_LOWER_BIT = 32, EntityDecoderState, DecodingMode;
+var init_decode = __esm(() => {
+  init_decode_codepoint();
+  init_bin_trie_flags();
+  init_decode_data_html();
+  init_decode_data_xml();
+  (function(CharCodes2) {
+    CharCodes2[CharCodes2["NUM"] = 35] = "NUM";
+    CharCodes2[CharCodes2["SEMI"] = 59] = "SEMI";
+    CharCodes2[CharCodes2["EQUALS"] = 61] = "EQUALS";
+    CharCodes2[CharCodes2["ZERO"] = 48] = "ZERO";
+    CharCodes2[CharCodes2["NINE"] = 57] = "NINE";
+    CharCodes2[CharCodes2["LOWER_A"] = 97] = "LOWER_A";
+    CharCodes2[CharCodes2["LOWER_F"] = 102] = "LOWER_F";
+    CharCodes2[CharCodes2["LOWER_X"] = 120] = "LOWER_X";
+    CharCodes2[CharCodes2["LOWER_Z"] = 122] = "LOWER_Z";
+    CharCodes2[CharCodes2["UPPER_A"] = 65] = "UPPER_A";
+    CharCodes2[CharCodes2["UPPER_F"] = 70] = "UPPER_F";
+    CharCodes2[CharCodes2["UPPER_Z"] = 90] = "UPPER_Z";
+  })(CharCodes || (CharCodes = {}));
+  (function(EntityDecoderState2) {
+    EntityDecoderState2[EntityDecoderState2["EntityStart"] = 0] = "EntityStart";
+    EntityDecoderState2[EntityDecoderState2["NumericStart"] = 1] = "NumericStart";
+    EntityDecoderState2[EntityDecoderState2["NumericDecimal"] = 2] = "NumericDecimal";
+    EntityDecoderState2[EntityDecoderState2["NumericHex"] = 3] = "NumericHex";
+    EntityDecoderState2[EntityDecoderState2["NamedEntity"] = 4] = "NamedEntity";
+  })(EntityDecoderState || (EntityDecoderState = {}));
+  (function(DecodingMode2) {
+    DecodingMode2[DecodingMode2["Legacy"] = 0] = "Legacy";
+    DecodingMode2[DecodingMode2["Strict"] = 1] = "Strict";
+    DecodingMode2[DecodingMode2["Attribute"] = 2] = "Attribute";
+  })(DecodingMode || (DecodingMode = {}));
+});
+
+// node_modules/htmlparser2/dist/Tokenizer.js
+function isWhitespace(c) {
+  return c === CharCodes2.Space || c === CharCodes2.NewLine || c === CharCodes2.Tab || c === CharCodes2.FormFeed || c === CharCodes2.CarriageReturn;
+}
+function isEndOfTagSection(c) {
+  return c === CharCodes2.Slash || c === CharCodes2.Gt || isWhitespace(c);
+}
+function isASCIIAlpha(c) {
+  return c >= CharCodes2.LowerA && c <= CharCodes2.LowerZ || c >= CharCodes2.UpperA && c <= CharCodes2.UpperZ;
+}
+
+class Tokenizer {
+  cbs;
+  state = State.Text;
+  buffer = "";
+  sectionStart = 0;
+  index = 0;
+  entityStart = 0;
+  baseState = State.Text;
+  isSpecial = false;
+  running = true;
+  offset = 0;
+  xmlMode;
+  decodeEntities;
+  recognizeSelfClosing;
+  entityDecoder;
+  constructor({ xmlMode = false, decodeEntities = true, recognizeSelfClosing = xmlMode }, cbs) {
+    this.cbs = cbs;
+    this.xmlMode = xmlMode;
+    this.decodeEntities = decodeEntities;
+    this.recognizeSelfClosing = recognizeSelfClosing;
+    this.entityDecoder = new EntityDecoder(xmlMode ? xmlDecodeTree : htmlDecodeTree, (cp, consumed) => this.emitCodePoint(cp, consumed));
+  }
+  reset() {
+    this.state = State.Text;
+    this.buffer = "";
+    this.sectionStart = 0;
+    this.index = 0;
+    this.baseState = State.Text;
+    this.isSpecial = false;
+    this.currentSequence = Sequences.Empty;
+    this.sequenceIndex = 0;
+    this.running = true;
+    this.offset = 0;
+  }
+  write(chunk) {
+    this.offset += this.buffer.length;
+    this.buffer = chunk;
+    this.parse();
+  }
+  end() {
+    if (this.running)
+      this.finish();
+  }
+  pause() {
+    this.running = false;
+  }
+  resume() {
+    this.running = true;
+    if (this.index < this.buffer.length + this.offset) {
+      this.parse();
+    }
+  }
+  stateText(c) {
+    if (c === CharCodes2.Lt || !this.decodeEntities && this.fastForwardTo(CharCodes2.Lt)) {
+      if (this.index > this.sectionStart) {
+        this.cbs.ontext(this.sectionStart, this.index);
+      }
+      this.state = State.BeforeTagName;
+      this.sectionStart = this.index;
+    } else if (this.decodeEntities && c === CharCodes2.Amp) {
+      this.startEntity();
+    }
+  }
+  currentSequence = Sequences.Empty;
+  sequenceIndex = 0;
+  enterTagBody() {
+    if (this.currentSequence === Sequences.Plaintext) {
+      this.currentSequence = Sequences.Empty;
+      this.state = State.InPlainText;
+    } else if (this.isSpecial) {
+      this.state = State.InSpecialTag;
+      this.sequenceIndex = 0;
+    } else {
+      this.state = State.Text;
+    }
+  }
+  stateSpecialStartSequence(c) {
+    const lower = c | 32;
+    if (this.sequenceIndex < this.currentSequence.length) {
+      if (lower === this.currentSequence[this.sequenceIndex]) {
+        this.sequenceIndex++;
+        return;
+      }
+      if (this.sequenceIndex === 3) {
+        if (this.currentSequence === Sequences.ScriptEnd && lower === Sequences.StyleEnd[3]) {
+          this.currentSequence = Sequences.StyleEnd;
+          this.sequenceIndex = 4;
+          return;
+        }
+        if (this.currentSequence === Sequences.TitleEnd && lower === Sequences.TextareaEnd[3]) {
+          this.currentSequence = Sequences.TextareaEnd;
+          this.sequenceIndex = 4;
+          return;
+        }
+      } else if (this.sequenceIndex === 4 && this.currentSequence === Sequences.NoembedEnd && lower === Sequences.NoframesEnd[4]) {
+        this.currentSequence = Sequences.NoframesEnd;
+        this.sequenceIndex = 5;
+        return;
+      }
+    } else if (isEndOfTagSection(c)) {
+      this.sequenceIndex = 0;
+      this.state = State.InTagName;
+      this.stateInTagName(c);
+      return;
+    }
+    this.isSpecial = false;
+    this.currentSequence = Sequences.Empty;
+    this.sequenceIndex = 0;
+    this.state = State.InTagName;
+    this.stateInTagName(c);
+  }
+  stateCDATASequence(c) {
+    if (c === Sequences.Cdata[this.sequenceIndex]) {
+      if (++this.sequenceIndex === Sequences.Cdata.length) {
+        this.state = State.InCommentLike;
+        this.currentSequence = Sequences.CdataEnd;
+        this.sequenceIndex = 0;
+        this.sectionStart = this.index + 1;
+      }
+    } else {
+      this.sequenceIndex = 0;
+      if (this.xmlMode) {
+        this.state = State.InDeclaration;
+        this.stateInDeclaration(c);
+      } else {
+        this.state = State.InSpecialComment;
+        this.stateInSpecialComment(c);
+      }
+    }
+  }
+  fastForwardTo(c) {
+    while (++this.index < this.buffer.length + this.offset) {
+      if (this.buffer.charCodeAt(this.index - this.offset) === c) {
+        return true;
+      }
+    }
+    this.index = this.buffer.length + this.offset - 1;
+    return false;
+  }
+  emitComment(offset) {
+    this.cbs.oncomment(this.sectionStart, this.index, offset);
+    this.sequenceIndex = 0;
+    this.sectionStart = this.index + 1;
+    this.state = State.Text;
+  }
+  stateInCommentLike(c) {
+    if (!this.xmlMode && this.currentSequence === Sequences.CommentEnd && this.sequenceIndex <= 1 && this.index === this.sectionStart + this.sequenceIndex && c === CharCodes2.Gt) {
+      this.emitComment(this.sequenceIndex);
+    } else if (this.currentSequence === Sequences.CommentEnd && this.sequenceIndex === 2 && c === CharCodes2.Gt) {
+      this.emitComment(2);
+    } else if (this.currentSequence === Sequences.CommentEnd && this.sequenceIndex === this.currentSequence.length - 1 && c !== CharCodes2.Gt) {
+      this.sequenceIndex = Number(c === CharCodes2.Dash);
+    } else if (c === this.currentSequence[this.sequenceIndex]) {
+      if (++this.sequenceIndex === this.currentSequence.length) {
+        if (this.currentSequence === Sequences.CdataEnd) {
+          this.cbs.oncdata(this.sectionStart, this.index, 2);
+        } else {
+          this.cbs.oncomment(this.sectionStart, this.index, 3);
+        }
+        this.sequenceIndex = 0;
+        this.sectionStart = this.index + 1;
+        this.state = State.Text;
+      }
+    } else if (this.sequenceIndex === 0) {
+      if (this.fastForwardTo(this.currentSequence[0])) {
+        this.sequenceIndex = 1;
+      }
+    } else if (c !== this.currentSequence[this.sequenceIndex - 1]) {
+      this.sequenceIndex = 0;
+    }
+  }
+  isTagStartChar(c) {
+    return this.xmlMode ? !isEndOfTagSection(c) : isASCIIAlpha(c);
+  }
+  stateInSpecialTag(c) {
+    if (this.sequenceIndex === this.currentSequence.length) {
+      if (isEndOfTagSection(c)) {
+        const endOfText = this.index - this.currentSequence.length;
+        if (this.sectionStart < endOfText) {
+          const actualIndex = this.index;
+          this.index = endOfText;
+          this.cbs.ontext(this.sectionStart, endOfText);
+          this.index = actualIndex;
+        }
+        this.isSpecial = false;
+        this.sectionStart = endOfText + 2;
+        this.stateInClosingTagName(c);
+        return;
+      }
+      this.sequenceIndex = 0;
+    }
+    if ((c | 32) === this.currentSequence[this.sequenceIndex]) {
+      this.sequenceIndex += 1;
+    } else if (this.sequenceIndex === 0) {
+      if (this.currentSequence === Sequences.TitleEnd || this.currentSequence === Sequences.TextareaEnd) {
+        if (this.decodeEntities && c === CharCodes2.Amp) {
+          this.startEntity();
+        }
+      } else if (this.fastForwardTo(CharCodes2.Lt)) {
+        this.sequenceIndex = 1;
+      }
+    } else {
+      this.sequenceIndex = Number(c === CharCodes2.Lt);
+    }
+  }
+  stateBeforeTagName(c) {
+    if (c === CharCodes2.ExclamationMark) {
+      this.state = State.BeforeDeclaration;
+      this.sectionStart = this.index + 1;
+    } else if (c === CharCodes2.Questionmark) {
+      if (this.xmlMode) {
+        this.state = State.InProcessingInstruction;
+        this.sequenceIndex = 0;
+        this.sectionStart = this.index + 1;
+      } else {
+        this.state = State.InSpecialComment;
+        this.sectionStart = this.index;
+      }
+    } else if (this.isTagStartChar(c)) {
+      this.sectionStart = this.index;
+      const special = this.xmlMode || this.cbs.isInForeignContext?.() ? undefined : specialStartSequences.get(c | 32);
+      if (special === undefined) {
+        this.state = State.InTagName;
+      } else {
+        this.isSpecial = true;
+        this.currentSequence = special;
+        this.sequenceIndex = 3;
+        this.state = State.SpecialStartSequence;
+      }
+    } else if (c === CharCodes2.Slash) {
+      this.state = State.BeforeClosingTagName;
+    } else {
+      this.state = State.Text;
+      this.stateText(c);
+    }
+  }
+  stateInTagName(c) {
+    if (isEndOfTagSection(c)) {
+      this.cbs.onopentagname(this.sectionStart, this.index);
+      this.sectionStart = -1;
+      this.state = State.BeforeAttributeName;
+      this.stateBeforeAttributeName(c);
+    }
+  }
+  stateBeforeClosingTagName(c) {
+    if (isWhitespace(c)) {
+      if (this.xmlMode) {} else {
+        this.state = State.InSpecialComment;
+        this.sectionStart = this.index;
+      }
+    } else if (c === CharCodes2.Gt) {
+      this.state = State.Text;
+      if (!this.xmlMode) {
+        this.sectionStart = this.index + 1;
+      }
+    } else {
+      this.state = this.isTagStartChar(c) ? State.InClosingTagName : State.InSpecialComment;
+      this.sectionStart = this.index;
+    }
+  }
+  stateInClosingTagName(c) {
+    if (isEndOfTagSection(c)) {
+      this.cbs.onclosetag(this.sectionStart, this.index);
+      this.sectionStart = -1;
+      this.state = State.AfterClosingTagName;
+      this.stateAfterClosingTagName(c);
+    }
+  }
+  stateAfterClosingTagName(c) {
+    if (c === CharCodes2.Gt || this.fastForwardTo(CharCodes2.Gt)) {
+      this.state = State.Text;
+      this.sectionStart = this.index + 1;
+    }
+  }
+  stateBeforeAttributeName(c) {
+    if (c === CharCodes2.Gt) {
+      this.cbs.onopentagend(this.index);
+      this.enterTagBody();
+      this.sectionStart = this.index + 1;
+    } else if (c === CharCodes2.Slash) {
+      this.state = State.InSelfClosingTag;
+    } else if (!isWhitespace(c)) {
+      this.state = State.InAttributeName;
+      this.sectionStart = this.index;
+    }
+  }
+  stateInSelfClosingTag(c) {
+    if (c === CharCodes2.Gt) {
+      this.cbs.onselfclosingtag(this.index);
+      this.sectionStart = this.index + 1;
+      if (!this.recognizeSelfClosing) {
+        this.enterTagBody();
+        return;
+      }
+      this.state = State.Text;
+      this.isSpecial = false;
+      this.currentSequence = Sequences.Empty;
+    } else if (!isWhitespace(c)) {
+      this.state = State.BeforeAttributeName;
+      this.stateBeforeAttributeName(c);
+    }
+  }
+  stateInAttributeName(c) {
+    if (c === CharCodes2.Eq || isEndOfTagSection(c)) {
+      this.cbs.onattribname(this.sectionStart, this.index);
+      this.sectionStart = this.index;
+      this.state = State.AfterAttributeName;
+      this.stateAfterAttributeName(c);
+    }
+  }
+  stateAfterAttributeName(c) {
+    if (c === CharCodes2.Eq) {
+      this.state = State.BeforeAttributeValue;
+    } else if (c === CharCodes2.Slash || c === CharCodes2.Gt) {
+      this.cbs.onattribend(QuoteType.NoValue, this.sectionStart);
+      this.sectionStart = -1;
+      this.state = State.BeforeAttributeName;
+      this.stateBeforeAttributeName(c);
+    } else if (!isWhitespace(c)) {
+      this.cbs.onattribend(QuoteType.NoValue, this.sectionStart);
+      this.state = State.InAttributeName;
+      this.sectionStart = this.index;
+    }
+  }
+  stateBeforeAttributeValue(c) {
+    if (c === CharCodes2.DoubleQuote) {
+      this.state = State.InAttributeValueDq;
+      this.sectionStart = this.index + 1;
+    } else if (c === CharCodes2.SingleQuote) {
+      this.state = State.InAttributeValueSq;
+      this.sectionStart = this.index + 1;
+    } else if (!isWhitespace(c)) {
+      this.sectionStart = this.index;
+      this.state = State.InAttributeValueNq;
+      this.stateInAttributeValueNoQuotes(c);
+    }
+  }
+  handleInAttributeValue(c, quote) {
+    if (c === quote || !this.decodeEntities && this.fastForwardTo(quote)) {
+      this.cbs.onattribdata(this.sectionStart, this.index);
+      this.sectionStart = -1;
+      this.cbs.onattribend(quote === CharCodes2.DoubleQuote ? QuoteType.Double : QuoteType.Single, this.index + 1);
+      this.state = State.BeforeAttributeName;
+    } else if (this.decodeEntities && c === CharCodes2.Amp) {
+      this.startEntity();
+    }
+  }
+  stateInAttributeValueDoubleQuotes(c) {
+    this.handleInAttributeValue(c, CharCodes2.DoubleQuote);
+  }
+  stateInAttributeValueSingleQuotes(c) {
+    this.handleInAttributeValue(c, CharCodes2.SingleQuote);
+  }
+  stateInAttributeValueNoQuotes(c) {
+    if (isWhitespace(c) || c === CharCodes2.Gt) {
+      this.cbs.onattribdata(this.sectionStart, this.index);
+      this.sectionStart = -1;
+      this.cbs.onattribend(QuoteType.Unquoted, this.index);
+      this.state = State.BeforeAttributeName;
+      this.stateBeforeAttributeName(c);
+    } else if (this.decodeEntities && c === CharCodes2.Amp) {
+      this.startEntity();
+    }
+  }
+  stateBeforeDeclaration(c) {
+    if (c === CharCodes2.OpeningSquareBracket) {
+      this.state = State.CDATASequence;
+      this.sequenceIndex = 0;
+    } else if (this.xmlMode) {
+      this.state = c === CharCodes2.Dash ? State.BeforeComment : State.InDeclaration;
+    } else if ((c | 32) === Sequences.Doctype[0]) {
+      this.state = State.DeclarationSequence;
+      this.currentSequence = Sequences.Doctype;
+      this.sequenceIndex = 1;
+    } else if (c === CharCodes2.Gt) {
+      this.cbs.oncomment(this.sectionStart, this.index, 0);
+      this.state = State.Text;
+      this.sectionStart = this.index + 1;
+    } else if (c === CharCodes2.Dash) {
+      this.state = State.BeforeComment;
+    } else {
+      this.state = State.InSpecialComment;
+    }
+  }
+  stateDeclarationSequence(c) {
+    if (this.sequenceIndex === this.currentSequence.length) {
+      this.state = State.InDeclaration;
+      this.stateInDeclaration(c);
+    } else if ((c | 32) === this.currentSequence[this.sequenceIndex]) {
+      this.sequenceIndex += 1;
+    } else if (c === CharCodes2.Gt) {
+      this.cbs.oncomment(this.sectionStart, this.index, 0);
+      this.state = State.Text;
+      this.sectionStart = this.index + 1;
+    } else {
+      this.state = State.InSpecialComment;
+    }
+  }
+  stateInDeclaration(c) {
+    if (c === CharCodes2.Gt || this.fastForwardTo(CharCodes2.Gt)) {
+      this.cbs.ondeclaration(this.sectionStart, this.index);
+      this.state = State.Text;
+      this.sectionStart = this.index + 1;
+    }
+  }
+  stateInProcessingInstruction(c) {
+    if (c === CharCodes2.Questionmark) {
+      this.sequenceIndex = 1;
+    } else if (c === CharCodes2.Gt && this.sequenceIndex === 1) {
+      this.cbs.onprocessinginstruction(this.sectionStart, this.index - 1);
+      this.sequenceIndex = 0;
+      this.state = State.Text;
+      this.sectionStart = this.index + 1;
+    } else {
+      this.sequenceIndex = Number(this.fastForwardTo(CharCodes2.Questionmark));
+    }
+  }
+  stateBeforeComment(c) {
+    if (c === CharCodes2.Dash) {
+      this.state = State.InCommentLike;
+      this.currentSequence = Sequences.CommentEnd;
+      this.sequenceIndex = 0;
+      this.sectionStart = this.index + 1;
+    } else if (this.xmlMode) {
+      this.state = State.InDeclaration;
+    } else if (c === CharCodes2.Gt) {
+      this.cbs.oncomment(this.sectionStart, this.index, 0);
+      this.state = State.Text;
+      this.sectionStart = this.index + 1;
+    } else {
+      this.state = State.InSpecialComment;
+    }
+  }
+  stateInSpecialComment(c) {
+    if (c === CharCodes2.Gt || this.fastForwardTo(CharCodes2.Gt)) {
+      this.cbs.oncomment(this.sectionStart, this.index, 0);
+      this.state = State.Text;
+      this.sectionStart = this.index + 1;
+    }
+  }
+  startEntity() {
+    this.baseState = this.state;
+    this.state = State.InEntity;
+    this.entityStart = this.index;
+    this.entityDecoder.startEntity(this.xmlMode ? DecodingMode.Strict : this.baseState === State.Text || this.baseState === State.InSpecialTag ? DecodingMode.Legacy : DecodingMode.Attribute);
+  }
+  stateInEntity() {
+    const indexInBuffer = this.index - this.offset;
+    const length = this.entityDecoder.write(this.buffer, indexInBuffer);
+    if (length >= 0) {
+      this.state = this.baseState;
+      if (length === 0) {
+        this.index -= 1;
+      }
+    } else {
+      if (indexInBuffer < this.buffer.length && this.buffer.charCodeAt(indexInBuffer) === CharCodes2.Amp) {
+        this.state = this.baseState;
+        this.index -= 1;
+        return;
+      }
+      this.index = this.offset + this.buffer.length - 1;
+    }
+  }
+  cleanup() {
+    if (this.running && this.sectionStart !== this.index) {
+      if (this.state === State.Text || this.state === State.InPlainText || this.state === State.InSpecialTag && this.sequenceIndex === 0) {
+        this.cbs.ontext(this.sectionStart, this.index);
+        this.sectionStart = this.index;
+      } else if (this.state === State.InAttributeValueDq || this.state === State.InAttributeValueSq || this.state === State.InAttributeValueNq) {
+        this.cbs.onattribdata(this.sectionStart, this.index);
+        this.sectionStart = this.index;
+      }
+    }
+  }
+  shouldContinue() {
+    return this.index < this.buffer.length + this.offset && this.running;
+  }
+  parse() {
+    while (this.shouldContinue()) {
+      const c = this.buffer.charCodeAt(this.index - this.offset);
+      switch (this.state) {
+        case State.Text: {
+          this.stateText(c);
+          break;
+        }
+        case State.InPlainText: {
+          this.index = this.buffer.length + this.offset - 1;
+          break;
+        }
+        case State.SpecialStartSequence: {
+          this.stateSpecialStartSequence(c);
+          break;
+        }
+        case State.InSpecialTag: {
+          this.stateInSpecialTag(c);
+          break;
+        }
+        case State.CDATASequence: {
+          this.stateCDATASequence(c);
+          break;
+        }
+        case State.DeclarationSequence: {
+          this.stateDeclarationSequence(c);
+          break;
+        }
+        case State.InAttributeValueDq: {
+          this.stateInAttributeValueDoubleQuotes(c);
+          break;
+        }
+        case State.InAttributeName: {
+          this.stateInAttributeName(c);
+          break;
+        }
+        case State.InCommentLike: {
+          this.stateInCommentLike(c);
+          break;
+        }
+        case State.InSpecialComment: {
+          this.stateInSpecialComment(c);
+          break;
+        }
+        case State.BeforeAttributeName: {
+          this.stateBeforeAttributeName(c);
+          break;
+        }
+        case State.InTagName: {
+          this.stateInTagName(c);
+          break;
+        }
+        case State.InClosingTagName: {
+          this.stateInClosingTagName(c);
+          break;
+        }
+        case State.BeforeTagName: {
+          this.stateBeforeTagName(c);
+          break;
+        }
+        case State.AfterAttributeName: {
+          this.stateAfterAttributeName(c);
+          break;
+        }
+        case State.InAttributeValueSq: {
+          this.stateInAttributeValueSingleQuotes(c);
+          break;
+        }
+        case State.BeforeAttributeValue: {
+          this.stateBeforeAttributeValue(c);
+          break;
+        }
+        case State.BeforeClosingTagName: {
+          this.stateBeforeClosingTagName(c);
+          break;
+        }
+        case State.AfterClosingTagName: {
+          this.stateAfterClosingTagName(c);
+          break;
+        }
+        case State.InAttributeValueNq: {
+          this.stateInAttributeValueNoQuotes(c);
+          break;
+        }
+        case State.InSelfClosingTag: {
+          this.stateInSelfClosingTag(c);
+          break;
+        }
+        case State.InDeclaration: {
+          this.stateInDeclaration(c);
+          break;
+        }
+        case State.BeforeDeclaration: {
+          this.stateBeforeDeclaration(c);
+          break;
+        }
+        case State.BeforeComment: {
+          this.stateBeforeComment(c);
+          break;
+        }
+        case State.InProcessingInstruction: {
+          this.stateInProcessingInstruction(c);
+          break;
+        }
+        case State.InEntity: {
+          this.stateInEntity();
+          break;
+        }
+      }
+      this.index++;
+    }
+    this.cleanup();
+  }
+  finish() {
+    if (this.state === State.InEntity) {
+      this.entityDecoder.end();
+      this.state = this.baseState;
+    }
+    this.handleTrailingData();
+    this.cbs.onend();
+  }
+  handleTrailingCommentLikeData(endIndex) {
+    if (this.state !== State.InCommentLike) {
+      return false;
+    }
+    if (this.currentSequence === Sequences.CdataEnd) {
+      if (this.xmlMode) {
+        if (this.sectionStart < endIndex) {
+          this.cbs.oncdata(this.sectionStart, endIndex, 0);
+        }
+      } else {
+        const cdataStart = this.sectionStart - Sequences.Cdata.length - 1;
+        this.cbs.oncomment(cdataStart, endIndex, 0);
+      }
+    } else {
+      const offset = this.xmlMode ? 0 : Math.min(this.sequenceIndex, Sequences.CommentEnd.length - 1);
+      this.cbs.oncomment(this.sectionStart, endIndex, offset);
+    }
+    return true;
+  }
+  handleTrailingMarkupDeclaration(endIndex) {
+    if (this.xmlMode) {
+      switch (this.state) {
+        case State.InSpecialComment:
+        case State.BeforeComment:
+        case State.CDATASequence:
+        case State.DeclarationSequence:
+        case State.InDeclaration: {
+          this.cbs.ontext(this.sectionStart, endIndex);
+          return true;
+        }
+        default: {
+          return false;
+        }
+      }
+    }
+    switch (this.state) {
+      case State.BeforeDeclaration:
+      case State.InSpecialComment:
+      case State.BeforeComment:
+      case State.CDATASequence: {
+        this.cbs.oncomment(this.sectionStart, endIndex, 0);
+        return true;
+      }
+      case State.DeclarationSequence: {
+        if (this.sequenceIndex !== Sequences.Doctype.length) {
+          this.cbs.oncomment(this.sectionStart, endIndex, 0);
+        }
+        return true;
+      }
+      case State.InDeclaration: {
+        return true;
+      }
+      default: {
+        return false;
+      }
+    }
+  }
+  handleTrailingData() {
+    const endIndex = this.buffer.length + this.offset;
+    if (this.handleTrailingCommentLikeData(endIndex) || this.handleTrailingMarkupDeclaration(endIndex)) {
+      return;
+    }
+    if (this.sectionStart >= endIndex) {
+      return;
+    }
+    switch (this.state) {
+      case State.InTagName:
+      case State.BeforeAttributeName:
+      case State.BeforeAttributeValue:
+      case State.AfterAttributeName:
+      case State.InAttributeName:
+      case State.InAttributeValueSq:
+      case State.InAttributeValueDq:
+      case State.InAttributeValueNq:
+      case State.InClosingTagName: {
+        break;
+      }
+      default: {
+        this.cbs.ontext(this.sectionStart, endIndex);
+      }
+    }
+  }
+  emitCodePoint(cp, consumed) {
+    if (this.baseState !== State.Text && this.baseState !== State.InSpecialTag) {
+      if (this.sectionStart < this.entityStart) {
+        this.cbs.onattribdata(this.sectionStart, this.entityStart);
+      }
+      this.sectionStart = this.entityStart + consumed;
+      this.index = this.sectionStart - 1;
+      this.cbs.onattribentity(cp);
+    } else {
+      if (this.sectionStart < this.entityStart) {
+        this.cbs.ontext(this.sectionStart, this.entityStart);
+      }
+      this.sectionStart = this.entityStart + consumed;
+      this.index = this.sectionStart - 1;
+      this.cbs.ontextentity(cp, this.sectionStart);
+    }
+  }
+}
+var CharCodes2, State, QuoteType, Sequences, specialStartSequences;
+var init_Tokenizer = __esm(() => {
+  init_decode();
+  (function(CharCodes3) {
+    CharCodes3[CharCodes3["Tab"] = 9] = "Tab";
+    CharCodes3[CharCodes3["NewLine"] = 10] = "NewLine";
+    CharCodes3[CharCodes3["FormFeed"] = 12] = "FormFeed";
+    CharCodes3[CharCodes3["CarriageReturn"] = 13] = "CarriageReturn";
+    CharCodes3[CharCodes3["Space"] = 32] = "Space";
+    CharCodes3[CharCodes3["ExclamationMark"] = 33] = "ExclamationMark";
+    CharCodes3[CharCodes3["Number"] = 35] = "Number";
+    CharCodes3[CharCodes3["Amp"] = 38] = "Amp";
+    CharCodes3[CharCodes3["SingleQuote"] = 39] = "SingleQuote";
+    CharCodes3[CharCodes3["DoubleQuote"] = 34] = "DoubleQuote";
+    CharCodes3[CharCodes3["Dash"] = 45] = "Dash";
+    CharCodes3[CharCodes3["Slash"] = 47] = "Slash";
+    CharCodes3[CharCodes3["Zero"] = 48] = "Zero";
+    CharCodes3[CharCodes3["Nine"] = 57] = "Nine";
+    CharCodes3[CharCodes3["Semi"] = 59] = "Semi";
+    CharCodes3[CharCodes3["Lt"] = 60] = "Lt";
+    CharCodes3[CharCodes3["Eq"] = 61] = "Eq";
+    CharCodes3[CharCodes3["Gt"] = 62] = "Gt";
+    CharCodes3[CharCodes3["Questionmark"] = 63] = "Questionmark";
+    CharCodes3[CharCodes3["UpperA"] = 65] = "UpperA";
+    CharCodes3[CharCodes3["LowerA"] = 97] = "LowerA";
+    CharCodes3[CharCodes3["UpperF"] = 70] = "UpperF";
+    CharCodes3[CharCodes3["LowerF"] = 102] = "LowerF";
+    CharCodes3[CharCodes3["UpperZ"] = 90] = "UpperZ";
+    CharCodes3[CharCodes3["LowerZ"] = 122] = "LowerZ";
+    CharCodes3[CharCodes3["LowerX"] = 120] = "LowerX";
+    CharCodes3[CharCodes3["OpeningSquareBracket"] = 91] = "OpeningSquareBracket";
+  })(CharCodes2 || (CharCodes2 = {}));
+  (function(State2) {
+    State2[State2["Text"] = 1] = "Text";
+    State2[State2["BeforeTagName"] = 2] = "BeforeTagName";
+    State2[State2["InTagName"] = 3] = "InTagName";
+    State2[State2["InSelfClosingTag"] = 4] = "InSelfClosingTag";
+    State2[State2["BeforeClosingTagName"] = 5] = "BeforeClosingTagName";
+    State2[State2["InClosingTagName"] = 6] = "InClosingTagName";
+    State2[State2["AfterClosingTagName"] = 7] = "AfterClosingTagName";
+    State2[State2["BeforeAttributeName"] = 8] = "BeforeAttributeName";
+    State2[State2["InAttributeName"] = 9] = "InAttributeName";
+    State2[State2["AfterAttributeName"] = 10] = "AfterAttributeName";
+    State2[State2["BeforeAttributeValue"] = 11] = "BeforeAttributeValue";
+    State2[State2["InAttributeValueDq"] = 12] = "InAttributeValueDq";
+    State2[State2["InAttributeValueSq"] = 13] = "InAttributeValueSq";
+    State2[State2["InAttributeValueNq"] = 14] = "InAttributeValueNq";
+    State2[State2["BeforeDeclaration"] = 15] = "BeforeDeclaration";
+    State2[State2["InDeclaration"] = 16] = "InDeclaration";
+    State2[State2["InProcessingInstruction"] = 17] = "InProcessingInstruction";
+    State2[State2["BeforeComment"] = 18] = "BeforeComment";
+    State2[State2["CDATASequence"] = 19] = "CDATASequence";
+    State2[State2["DeclarationSequence"] = 20] = "DeclarationSequence";
+    State2[State2["InSpecialComment"] = 21] = "InSpecialComment";
+    State2[State2["InCommentLike"] = 22] = "InCommentLike";
+    State2[State2["SpecialStartSequence"] = 23] = "SpecialStartSequence";
+    State2[State2["InSpecialTag"] = 24] = "InSpecialTag";
+    State2[State2["InPlainText"] = 25] = "InPlainText";
+    State2[State2["InEntity"] = 26] = "InEntity";
+  })(State || (State = {}));
+  (function(QuoteType2) {
+    QuoteType2[QuoteType2["NoValue"] = 0] = "NoValue";
+    QuoteType2[QuoteType2["Unquoted"] = 1] = "Unquoted";
+    QuoteType2[QuoteType2["Single"] = 2] = "Single";
+    QuoteType2[QuoteType2["Double"] = 3] = "Double";
+  })(QuoteType || (QuoteType = {}));
+  Sequences = {
+    Empty: new Uint8Array(0),
+    Cdata: new Uint8Array([67, 68, 65, 84, 65, 91]),
+    CdataEnd: new Uint8Array([93, 93, 62]),
+    CommentEnd: new Uint8Array([45, 45, 33, 62]),
+    Doctype: new Uint8Array([100, 111, 99, 116, 121, 112, 101]),
+    IframeEnd: new Uint8Array([60, 47, 105, 102, 114, 97, 109, 101]),
+    NoembedEnd: new Uint8Array([
+      60,
+      47,
+      110,
+      111,
+      101,
+      109,
+      98,
+      101,
+      100
+    ]),
+    NoframesEnd: new Uint8Array([
+      60,
+      47,
+      110,
+      111,
+      102,
+      114,
+      97,
+      109,
+      101,
+      115
+    ]),
+    Plaintext: new Uint8Array([
+      60,
+      47,
+      112,
+      108,
+      97,
+      105,
+      110,
+      116,
+      101,
+      120,
+      116
+    ]),
+    ScriptEnd: new Uint8Array([60, 47, 115, 99, 114, 105, 112, 116]),
+    StyleEnd: new Uint8Array([60, 47, 115, 116, 121, 108, 101]),
+    TitleEnd: new Uint8Array([60, 47, 116, 105, 116, 108, 101]),
+    TextareaEnd: new Uint8Array([
+      60,
+      47,
+      116,
+      101,
+      120,
+      116,
+      97,
+      114,
+      101,
+      97
+    ]),
+    XmpEnd: new Uint8Array([60, 47, 120, 109, 112])
+  };
+  specialStartSequences = new Map([
+    [Sequences.IframeEnd[2], Sequences.IframeEnd],
+    [Sequences.NoembedEnd[2], Sequences.NoembedEnd],
+    [Sequences.Plaintext[2], Sequences.Plaintext],
+    [Sequences.ScriptEnd[2], Sequences.ScriptEnd],
+    [Sequences.TitleEnd[2], Sequences.TitleEnd],
+    [Sequences.XmpEnd[2], Sequences.XmpEnd]
+  ]);
+});
+
+// node_modules/domelementtype/dist/index.js
+var ElementType, Root, Text, Directive, Comment, Script, Style, Tag, CDATA, Doctype;
+var init_dist = __esm(() => {
+  (function(ElementType2) {
+    ElementType2["Root"] = "root";
+    ElementType2["Text"] = "text";
+    ElementType2["Directive"] = "directive";
+    ElementType2["Comment"] = "comment";
+    ElementType2["Script"] = "script";
+    ElementType2["Style"] = "style";
+    ElementType2["Tag"] = "tag";
+    ElementType2["CDATA"] = "cdata";
+    ElementType2["Doctype"] = "doctype";
+  })(ElementType || (ElementType = {}));
+  Root = ElementType.Root;
+  Text = ElementType.Text;
+  Directive = ElementType.Directive;
+  Comment = ElementType.Comment;
+  Script = ElementType.Script;
+  Style = ElementType.Style;
+  Tag = ElementType.Tag;
+  CDATA = ElementType.CDATA;
+  Doctype = ElementType.Doctype;
+});
+
+// node_modules/domutils/dist/querying.js
+var init_querying = () => {};
+
+// node_modules/domutils/dist/legacy.js
+var init_legacy = () => {};
+
+// node_modules/domutils/dist/stringify.js
+var init_stringify = () => {};
+
+// node_modules/domutils/dist/feeds.js
+var init_feeds = () => {};
+
+// node_modules/domutils/dist/helpers.js
+var DocumentPosition;
+var init_helpers = __esm(() => {
+  (function(DocumentPosition2) {
+    DocumentPosition2[DocumentPosition2["DISCONNECTED"] = 1] = "DISCONNECTED";
+    DocumentPosition2[DocumentPosition2["PRECEDING"] = 2] = "PRECEDING";
+    DocumentPosition2[DocumentPosition2["FOLLOWING"] = 4] = "FOLLOWING";
+    DocumentPosition2[DocumentPosition2["CONTAINS"] = 8] = "CONTAINS";
+    DocumentPosition2[DocumentPosition2["CONTAINED_BY"] = 16] = "CONTAINED_BY";
+  })(DocumentPosition || (DocumentPosition = {}));
+});
+
+// node_modules/domutils/dist/traversal.js
+var init_traversal = () => {};
+
+// node_modules/domutils/dist/index.js
+var init_dist2 = __esm(() => {
+  init_feeds();
+  init_helpers();
+  init_legacy();
+  init_querying();
+  init_stringify();
+  init_traversal();
+});
+
+// node_modules/htmlparser2/dist/index.js
+var init_dist3 = __esm(() => {
+  init_dist();
+  init_Tokenizer();
+  init_dist2();
+});
+
+// tools/core/htmllinter-tables.js
+var VOID_ELEMENTS, RAW_TEXT_ELEMENTS, RCDATA_ELEMENTS, SPECIAL_ELEMENTS, FORMATTING_ELEMENTS, DEFAULT_SCOPE_BOUNDARIES, SCOPE_LIST_ITEM, SCOPE_BUTTON, SCOPE_DEFAULT, SCOPE_TABLE, SCOPE_SELECT, STANDARD_SVG_CAMEL_ELEMENTS, STANDARD_SVG_CAMEL_ATTRS, MATHML_CAMEL_ATTRS, FOREIGN_BREAKOUT_TAGS, MATHML_TEXT_INTEGRATION_POINTS, BLOCK_LEVEL_AUTO_CLOSE_P, SELECT_VALID_CHILDREN, SELECT_BREAKOUT_TAGS, MODES, NS, FRAGMENT_CONTEXT_MODES;
+var init_htmllinter_tables = __esm(() => {
+  VOID_ELEMENTS = new Set([
+    "area",
+    "base",
+    "br",
+    "col",
+    "embed",
+    "hr",
+    "img",
+    "input",
+    "link",
+    "meta",
+    "source",
+    "track",
+    "wbr"
+  ]);
+  RAW_TEXT_ELEMENTS = new Set([
+    "script",
+    "style",
+    "iframe",
+    "noembed",
+    "noframes",
+    "noscript",
+    "xmp",
+    "plaintext"
+  ]);
+  RCDATA_ELEMENTS = new Set(["textarea", "title"]);
+  SPECIAL_ELEMENTS = new Set([
+    "address",
+    "applet",
+    "area",
+    "article",
+    "aside",
+    "base",
+    "basefont",
+    "bgsound",
+    "blockquote",
+    "br",
+    "button",
+    "caption",
+    "center",
+    "col",
+    "colgroup",
+    "dd",
+    "details",
+    "dir",
+    "div",
+    "dl",
+    "dt",
+    "embed",
+    "fieldset",
+    "figcaption",
+    "figure",
+    "footer",
+    "form",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "header",
+    "hgroup",
+    "hr",
+    "iframe",
+    "img",
+    "input",
+    "keygen",
+    "li",
+    "link",
+    "listing",
+    "main",
+    "marquee",
+    "menu",
+    "meta",
+    "nav",
+    "noembed",
+    "noframes",
+    "noscript",
+    "object",
+    "ol",
+    "p",
+    "param",
+    "plaintext",
+    "pre",
+    "script",
+    "search",
+    "section",
+    "select",
+    "source",
+    "style",
+    "summary",
+    "table",
+    "tbody",
+    "td",
+    "template",
+    "textarea",
+    "tfoot",
+    "th",
+    "thead",
+    "title",
+    "tr",
+    "track",
+    "ul",
+    "wbr",
+    "xmp"
+  ]);
+  FORMATTING_ELEMENTS = new Set([
+    "a",
+    "b",
+    "big",
+    "code",
+    "em",
+    "font",
+    "i",
+    "nobr",
+    "s",
+    "small",
+    "strike",
+    "strong",
+    "tt",
+    "u"
+  ]);
+  DEFAULT_SCOPE_BOUNDARIES = new Set([
+    "applet",
+    "caption",
+    "html",
+    "table",
+    "td",
+    "th",
+    "marquee",
+    "object",
+    "template"
+  ]);
+  SCOPE_LIST_ITEM = new Set([...DEFAULT_SCOPE_BOUNDARIES, "ol", "ul"]);
+  SCOPE_BUTTON = new Set([...DEFAULT_SCOPE_BOUNDARIES, "button"]);
+  SCOPE_DEFAULT = DEFAULT_SCOPE_BOUNDARIES;
+  SCOPE_TABLE = new Set(["html", "table", "template"]);
+  SCOPE_SELECT = new Set;
+  STANDARD_SVG_CAMEL_ELEMENTS = new Set([
+    "altGlyph",
+    "altGlyphDef",
+    "altGlyphItem",
+    "animateColor",
+    "animateMotion",
+    "animateTransform",
+    "clipPath",
+    "feBlend",
+    "feColorMatrix",
+    "feComponentTransfer",
+    "feComposite",
+    "feConvolveMatrix",
+    "feDiffuseLighting",
+    "feDisplacementMap",
+    "feDistantLight",
+    "feDropShadow",
+    "feFlood",
+    "feFuncA",
+    "feFuncB",
+    "feFuncG",
+    "feFuncR",
+    "feGaussianBlur",
+    "feImage",
+    "feMerge",
+    "feMergeNode",
+    "feMorphology",
+    "feOffset",
+    "fePointLight",
+    "feSpecularLighting",
+    "feSpotLight",
+    "feTile",
+    "feTurbulence",
+    "foreignObject",
+    "glyphRef",
+    "linearGradient",
+    "radialGradient",
+    "textPath"
+  ]);
+  STANDARD_SVG_CAMEL_ATTRS = new Set([
+    "attributeName",
+    "attributeType",
+    "baseFrequency",
+    "baseProfile",
+    "calcMode",
+    "clipPathUnits",
+    "diffuseConstant",
+    "edgeMode",
+    "filterUnits",
+    "glyphRef",
+    "gradientTransform",
+    "gradientUnits",
+    "kernelMatrix",
+    "kernelUnitLength",
+    "keyPoints",
+    "keySplines",
+    "keyTimes",
+    "lengthAdjust",
+    "limitingConeAngle",
+    "markerHeight",
+    "markerUnits",
+    "markerWidth",
+    "maskContentUnits",
+    "maskUnits",
+    "numOctaves",
+    "pathLength",
+    "patternContentUnits",
+    "patternTransform",
+    "patternUnits",
+    "pointsAtX",
+    "pointsAtY",
+    "pointsAtZ",
+    "preserveAlpha",
+    "preserveAspectRatio",
+    "primitiveUnits",
+    "refX",
+    "refY",
+    "repeatCount",
+    "repeatDur",
+    "requiredExtensions",
+    "requiredFeatures",
+    "specularConstant",
+    "specularExponent",
+    "spreadMethod",
+    "startOffset",
+    "stdDeviation",
+    "stitchTiles",
+    "surfaceScale",
+    "systemLanguage",
+    "tableValues",
+    "targetX",
+    "targetY",
+    "textLength",
+    "viewBox",
+    "xChannelSelector",
+    "yChannelSelector",
+    "zoomAndPan"
+  ]);
+  MATHML_CAMEL_ATTRS = new Set(["definitionURL"]);
+  FOREIGN_BREAKOUT_TAGS = new Set([
+    "b",
+    "big",
+    "blockquote",
+    "body",
+    "br",
+    "center",
+    "code",
+    "dd",
+    "div",
+    "dl",
+    "dt",
+    "em",
+    "embed",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "head",
+    "hr",
+    "i",
+    "img",
+    "li",
+    "listing",
+    "menu",
+    "meta",
+    "nobr",
+    "ol",
+    "p",
+    "pre",
+    "ruby",
+    "s",
+    "small",
+    "span",
+    "strong",
+    "strike",
+    "sub",
+    "sup",
+    "table",
+    "tt",
+    "u",
+    "ul",
+    "var"
+  ]);
+  MATHML_TEXT_INTEGRATION_POINTS = new Set(["mi", "mo", "mn", "ms", "mtext"]);
+  BLOCK_LEVEL_AUTO_CLOSE_P = new Set([
+    "address",
+    "article",
+    "aside",
+    "blockquote",
+    "center",
+    "details",
+    "dialog",
+    "dir",
+    "div",
+    "dl",
+    "fieldset",
+    "figcaption",
+    "figure",
+    "footer",
+    "form",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "header",
+    "hgroup",
+    "hr",
+    "main",
+    "menu",
+    "nav",
+    "ol",
+    "p",
+    "plaintext",
+    "pre",
+    "search",
+    "section",
+    "summary",
+    "table",
+    "ul",
+    "xmp",
+    "li",
+    "dd",
+    "dt"
+  ]);
+  SELECT_VALID_CHILDREN = new Set(["option", "optgroup", "hr", "script", "template"]);
+  SELECT_BREAKOUT_TAGS = new Set(["input", "keygen", "textarea", "select"]);
+  MODES = Object.freeze({
+    inBody: "inBody",
+    inTable: "inTable",
+    inTableText: "inTableText",
+    inCaption: "inCaption",
+    inColumnGroup: "inColumnGroup",
+    inTableBody: "inTableBody",
+    inRow: "inRow",
+    inCell: "inCell",
+    inSelect: "inSelect",
+    inSelectInTable: "inSelectInTable",
+    inTemplate: "inTemplate",
+    text: "text"
+  });
+  NS = Object.freeze({
+    html: "html",
+    svg: "svg",
+    math: "math"
+  });
+  FRAGMENT_CONTEXT_MODES = Object.freeze({
+    template: { mode: MODES.inTemplate, ns: NS.html },
+    body: { mode: MODES.inBody, ns: NS.html },
+    div: { mode: MODES.inBody, ns: NS.html },
+    table: { mode: MODES.inTable, ns: NS.html },
+    tbody: { mode: MODES.inTableBody, ns: NS.html },
+    thead: { mode: MODES.inTableBody, ns: NS.html },
+    tfoot: { mode: MODES.inTableBody, ns: NS.html },
+    caption: { mode: MODES.inCaption, ns: NS.html },
+    colgroup: { mode: MODES.inColumnGroup, ns: NS.html },
+    tr: { mode: MODES.inRow, ns: NS.html },
+    td: { mode: MODES.inCell, ns: NS.html },
+    th: { mode: MODES.inCell, ns: NS.html },
+    select: { mode: MODES.inSelect, ns: NS.html },
+    svg: { mode: MODES.inBody, ns: NS.svg },
+    math: { mode: MODES.inBody, ns: NS.math }
+  });
+});
+
+// tools/core/htmllinter.js
+function lintHtml(html, onFinding, opts = {}) {
+  const ctx = new LinterCtx(html, onFinding, opts);
+  const tokenizer = new Tokenizer({ xmlMode: false, decodeEntities: false, recognizeSelfClosing: true }, ctx);
+  ctx.tokenizer = tokenizer;
+  tokenizer.write(html);
+  tokenizer.end();
+  return ctx.findingCount;
+}
+
+class LinterCtx {
+  constructor(html, onFinding, opts) {
+    this.html = html;
+    this.onFinding = onFinding;
+    this.findingCount = 0;
+    this.lineStarts = computeLineStarts(html);
+    const ctxName = opts.fragmentContext ?? "template";
+    const ctxInfo = FRAGMENT_CONTEXT_MODES[ctxName] ?? FRAGMENT_CONTEXT_MODES.template;
+    this.openElements = [];
+    if (ctxName === "tr") {
+      this.openElements.push({ name: "table", ns: NS.html, start: -1 });
+      this.openElements.push({ name: "tbody", ns: NS.html, start: -1 });
+    } else if (ctxName === "tbody" || ctxName === "thead" || ctxName === "tfoot") {
+      this.openElements.push({ name: "table", ns: NS.html, start: -1 });
+    } else if (ctxName === "td" || ctxName === "th") {
+      this.openElements.push({ name: "table", ns: NS.html, start: -1 });
+      this.openElements.push({ name: "tbody", ns: NS.html, start: -1 });
+      this.openElements.push({ name: "tr", ns: NS.html, start: -1 });
+    } else if (ctxName === "caption") {
+      this.openElements.push({ name: "table", ns: NS.html, start: -1 });
+    } else if (ctxName === "colgroup") {
+      this.openElements.push({ name: "table", ns: NS.html, start: -1 });
+    } else if (ctxName === "svg") {
+      this.openElements.push({ name: "svg", ns: NS.svg, start: -1 });
+    } else if (ctxName === "math") {
+      this.openElements.push({ name: "math", ns: NS.math, start: -1 });
+    } else if (ctxName === "select") {
+      this.openElements.push({ name: "select", ns: NS.html, start: -1 });
+    }
+    this.insertionMode = ctxInfo.mode;
+    this.originalInsertionMode = MODES.inBody;
+    this.templateInsertionModes = ctxName === "template" ? [MODES.inTemplate] : [];
+    this.activeFormatting = [];
+    this.formPointer = null;
+    this.framesetOk = true;
+    this.svgCamelElements = opts.svgCamelElements ?? STANDARD_SVG_CAMEL_ELEMENTS;
+    this.transparentTagPrefixes = opts.transparentTagPrefixes ?? [];
+    this.currentTagName = "";
+    this.currentTagRawName = "";
+    this.currentTagStart = 0;
+    this.tokenizer = null;
+    this.textRestoreMode = null;
+  }
+  onopentagname(start, end) {
+    const raw = this.html.slice(start, end);
+    this.currentTagRawName = raw;
+    this.currentTagName = raw.toLowerCase();
+    this.currentTagStart = start;
+  }
+  onattribname(_start, _end) {}
+  onattribdata(_start, _end) {}
+  onattribentity(_cp) {}
+  onattribend(_quote, _end) {}
+  ontextentity(_cp, _end) {}
+  onopentagend(endIndex) {
+    this.handleStartTag(false, endIndex);
+  }
+  onselfclosingtag(endIndex) {
+    this.handleStartTag(true, endIndex);
+  }
+  onclosetag(start, end) {
+    const raw = this.html.slice(start, end);
+    const name = raw.toLowerCase();
+    this.handleEndTag(name, start);
+  }
+  ontext(start, end) {
+    if (start >= end)
+      return;
+    this.handleText(start, end);
+  }
+  oncomment(_start, _end, _endOffset) {}
+  oncdata(start, _end, _endOffset) {
+    if (this.currentNamespace() === NS.html) {
+      this.report(HTML_TAG_NOT_ALLOWED_IN_PARENT, LEVEL_WARN, start, {
+        tag: "[CDATA[",
+        mode: this.insertionMode,
+        action: "ignored"
+      });
+    }
+  }
+  ondeclaration(_start, _end) {}
+  onprocessinginstruction(_start, _end) {}
+  isInForeignContext() {
+    return this.currentNamespace() !== NS.html;
+  }
+  onend() {}
+  report(id, level, offset, info) {
+    this.findingCount++;
+    const { line, column } = offsetToLineCol(this.lineStarts, offset);
+    this.onFinding({
+      id,
+      level,
+      info,
+      location: { start: offset, end: offset + (info.tag?.length ?? 0), line, column }
+    });
+  }
+  currentNode() {
+    return this.openElements[this.openElements.length - 1] ?? null;
+  }
+  currentNamespace() {
+    const top = this.currentNode();
+    return top ? top.ns : NS.html;
+  }
+  push(name, ns, start) {
+    this.openElements.push({ name, ns, start });
+  }
+  pop() {
+    return this.openElements.pop();
+  }
+  hasInScope(target, scopeSet) {
+    for (let i = this.openElements.length - 1;i >= 0; i--) {
+      const f = this.openElements[i];
+      if (f.name === target && f.ns === NS.html)
+        return true;
+      if (f.ns === NS.html && scopeSet.has(f.name))
+        return false;
+      if (f.ns !== NS.html) {
+        return false;
+      }
+    }
+    return false;
+  }
+  hasInDefaultScope(target) {
+    return this.hasInScope(target, SCOPE_DEFAULT);
+  }
+  hasInButtonScope(target) {
+    return this.hasInScope(target, SCOPE_BUTTON);
+  }
+  hasInListItemScope(target) {
+    return this.hasInScope(target, SCOPE_LIST_ITEM);
+  }
+  hasInTableScope(target) {
+    return this.hasInScope(target, SCOPE_TABLE);
+  }
+  hasInSelectScope(target) {
+    for (let i = this.openElements.length - 1;i >= 0; i--) {
+      const f = this.openElements[i];
+      if (f.ns !== NS.html)
+        return false;
+      if (f.name === target)
+        return true;
+      if (f.name !== "optgroup" && f.name !== "option")
+        return false;
+    }
+    return false;
+  }
+  popUntilName(name) {
+    while (this.openElements.length) {
+      const f = this.openElements.pop();
+      if (f.name === name)
+        return f;
+    }
+    return null;
+  }
+  generateImpliedEndTags(except = null) {
+    const implied = new Set(["dd", "dt", "li", "optgroup", "option", "p", "rb", "rp", "rt", "rtc"]);
+    while (this.openElements.length) {
+      const top = this.currentNode();
+      if (top.ns !== NS.html)
+        break;
+      if (!implied.has(top.name) || top.name === except)
+        break;
+      this.openElements.pop();
+    }
+  }
+  isTransparentTag(name) {
+    for (const prefix of this.transparentTagPrefixes) {
+      if (name === prefix || name.startsWith(`${prefix}:`))
+        return true;
+    }
+    return false;
+  }
+  handleStartTag(selfClosing, endIndex) {
+    const name = this.currentTagName;
+    const raw = this.currentTagRawName;
+    const start = this.currentTagStart;
+    const ns = this.currentNamespace();
+    if (ns === NS.html) {
+      if (raw !== name) {
+        this.report(HTML_TAG_NAME_HAS_UPPERCASE, LEVEL_ERROR, start, {
+          raw,
+          lowercased: name
+        });
+      }
+    } else if (ns === NS.svg) {
+      if (raw !== raw.toLowerCase() && !this.svgCamelElements.has(raw)) {
+        this.report(HTML_SVG_TAG_WILL_LOWERCASE, LEVEL_ERROR, start, {
+          raw,
+          lowercased: name
+        });
+      }
+    }
+    if (this.isTransparentTag(name))
+      return;
+    if (ns !== NS.html && !this.shouldBreakoutFromForeign(name)) {
+      this.startTagInForeign(name, raw, selfClosing, start);
+      return;
+    }
+    if (ns !== NS.html && this.shouldBreakoutFromForeign(name)) {
+      while (this.openElements.length && this.currentNode()?.ns !== NS.html) {
+        this.openElements.pop();
+      }
+    }
+    this.dispatchStartTag(name, raw, selfClosing, start, endIndex);
+  }
+  shouldBreakoutFromForeign(name) {
+    if (FOREIGN_BREAKOUT_TAGS.has(name))
+      return true;
+    if (name === "font")
+      return true;
+    return false;
+  }
+  startTagInForeign(name, raw, selfClosing, start) {
+    const ns = name === "svg" ? NS.svg : name === "math" ? NS.math : this.currentNamespace();
+    const top = this.currentNode();
+    if (top && top.ns === NS.math && MATHML_TEXT_INTEGRATION_POINTS.has(top.name) && name !== "mglyph" && name !== "malignmark") {
+      this.dispatchStartTag(name, raw, selfClosing, start, start + raw.length);
+      return;
+    }
+    if (selfClosing)
+      return;
+    this.push(raw, ns, start);
+  }
+  dispatchStartTag(name, raw, selfClosing, start, endIndex) {
+    switch (this.insertionMode) {
+      case MODES.inTemplate:
+        return this.startInTemplate(name, raw, selfClosing, start, endIndex);
+      case MODES.inBody:
+        return this.startInBody(name, raw, selfClosing, start, endIndex);
+      case MODES.inTable:
+        return this.startInTable(name, raw, selfClosing, start, endIndex);
+      case MODES.inTableText:
+        this.flushTableText();
+        this.insertionMode = this.originalInsertionMode;
+        return this.dispatchStartTag(name, raw, selfClosing, start, endIndex);
+      case MODES.inCaption:
+        return this.startInCaption(name, raw, selfClosing, start, endIndex);
+      case MODES.inColumnGroup:
+        return this.startInColumnGroup(name, raw, selfClosing, start, endIndex);
+      case MODES.inTableBody:
+        return this.startInTableBody(name, raw, selfClosing, start, endIndex);
+      case MODES.inRow:
+        return this.startInRow(name, raw, selfClosing, start, endIndex);
+      case MODES.inCell:
+        return this.startInCell(name, raw, selfClosing, start, endIndex);
+      case MODES.inSelect:
+        return this.startInSelect(name, raw, selfClosing, start, endIndex);
+      case MODES.inSelectInTable:
+        return this.startInSelectInTable(name, raw, selfClosing, start, endIndex);
+      case MODES.text:
+        return;
+    }
+  }
+  startInBody(name, raw, selfClosing, start, _endIndex) {
+    if (name === "html" || name === "head" || name === "body" || name === "frame" || name === "frameset") {
+      this.report(HTML_TAG_NOT_ALLOWED_IN_PARENT, LEVEL_WARN, start, {
+        tag: raw,
+        mode: this.insertionMode,
+        action: "ignored"
+      });
+      return;
+    }
+    if (name === "address" || name === "article" || name === "aside" || name === "blockquote" || name === "center" || name === "details" || name === "dialog" || name === "dir" || name === "div" || name === "dl" || name === "fieldset" || name === "figcaption" || name === "figure" || name === "footer" || name === "header" || name === "hgroup" || name === "main" || name === "menu" || name === "nav" || name === "ol" || name === "p" || name === "search" || name === "section" || name === "summary" || name === "ul") {
+      if (this.hasInButtonScope("p"))
+        this.implicitlyClose("p", start, raw);
+      this.push(raw, NS.html, start);
+      return;
+    }
+    if (name === "h1" || name === "h2" || name === "h3" || name === "h4" || name === "h5" || name === "h6") {
+      if (this.hasInButtonScope("p"))
+        this.implicitlyClose("p", start, raw);
+      const top = this.currentNode();
+      if (top && /^h[1-6]$/.test(top.name)) {
+        this.report(HTML_TAG_NOT_ALLOWED_IN_PARENT, LEVEL_ERROR, start, {
+          tag: raw,
+          parent: top.name,
+          mode: this.insertionMode,
+          action: "auto-close-implicit"
+        });
+        this.openElements.pop();
+      }
+      this.push(raw, NS.html, start);
+      return;
+    }
+    if (name === "pre" || name === "listing") {
+      if (this.hasInButtonScope("p"))
+        this.implicitlyClose("p", start, raw);
+      this.push(raw, NS.html, start);
+      this.framesetOk = false;
+      return;
+    }
+    if (name === "form") {
+      if (this.formPointer !== null && !this.openElementsHas("template")) {
+        this.report(HTML_DUPLICATE_FORM, LEVEL_ERROR, start, {
+          tag: raw,
+          mode: this.insertionMode
+        });
+        return;
+      }
+      if (this.hasInButtonScope("p"))
+        this.implicitlyClose("p", start, raw);
+      this.push(raw, NS.html, start);
+      this.formPointer = this.currentNode();
+      return;
+    }
+    if (name === "li") {
+      this.framesetOk = false;
+      for (let i = this.openElements.length - 1;i >= 0; i--) {
+        const f = this.openElements[i];
+        if (f.ns !== NS.html)
+          break;
+        if (f.name === "li") {
+          this.generateImpliedEndTags("li");
+          while (this.openElements.length) {
+            const popped = this.openElements.pop();
+            if (popped.name === "li")
+              break;
+          }
+          break;
+        }
+        if (SPECIAL_ELEMENTS.has(f.name) && f.name !== "address" && f.name !== "div" && f.name !== "p") {
+          break;
+        }
+      }
+      if (this.hasInButtonScope("p"))
+        this.implicitlyClose("p", start, raw);
+      this.push(raw, NS.html, start);
+      return;
+    }
+    if (name === "dd" || name === "dt") {
+      this.framesetOk = false;
+      for (let i = this.openElements.length - 1;i >= 0; i--) {
+        const f = this.openElements[i];
+        if (f.ns !== NS.html)
+          break;
+        if (f.name === "dd" || f.name === "dt") {
+          this.generateImpliedEndTags(f.name);
+          while (this.openElements.length) {
+            const popped = this.openElements.pop();
+            if (popped.name === f.name)
+              break;
+          }
+          break;
+        }
+        if (SPECIAL_ELEMENTS.has(f.name) && f.name !== "address" && f.name !== "div" && f.name !== "p") {
+          break;
+        }
+      }
+      if (this.hasInButtonScope("p"))
+        this.implicitlyClose("p", start, raw);
+      this.push(raw, NS.html, start);
+      return;
+    }
+    if (name === "plaintext") {
+      if (this.hasInButtonScope("p"))
+        this.implicitlyClose("p", start, raw);
+      this.push(raw, NS.html, start);
+      return;
+    }
+    if (name === "button") {
+      if (this.hasInDefaultScope("button")) {
+        this.report(HTML_TAG_NOT_ALLOWED_IN_PARENT, LEVEL_ERROR, start, {
+          tag: raw,
+          parent: "button",
+          mode: this.insertionMode,
+          action: "auto-close-implicit"
+        });
+        this.generateImpliedEndTags();
+        this.popUntilName("button");
+      }
+      this.push(raw, NS.html, start);
+      this.framesetOk = false;
+      return;
+    }
+    if (name === "a") {
+      if (this.openElementsHas("a") || this.activeFormattingHas("a")) {
+        this.report(HTML_NESTED_INTERACTIVE, LEVEL_WARN, start, {
+          tag: raw,
+          mode: this.insertionMode
+        });
+        this.runAdoptionAgency("a");
+      }
+      this.push(raw, NS.html, start);
+      this.activeFormatting.push(this.currentNode());
+      return;
+    }
+    if (FORMATTING_ELEMENTS.has(name)) {
+      this.push(raw, NS.html, start);
+      this.activeFormatting.push(this.currentNode());
+      return;
+    }
+    if (name === "nobr") {
+      if (this.hasInDefaultScope("nobr")) {
+        this.report(HTML_NESTED_INTERACTIVE, LEVEL_WARN, start, {
+          tag: raw,
+          mode: this.insertionMode
+        });
+        this.runAdoptionAgency("nobr");
+      }
+      this.push(raw, NS.html, start);
+      this.activeFormatting.push(this.currentNode());
+      return;
+    }
+    if (name === "table") {
+      if (this.hasInButtonScope("p"))
+        this.implicitlyClose("p", start, raw);
+      this.push(raw, NS.html, start);
+      this.framesetOk = false;
+      this.insertionMode = MODES.inTable;
+      return;
+    }
+    if (name === "area" || name === "br" || name === "embed" || name === "img" || name === "keygen" || name === "wbr" || name === "input" || name === "param" || name === "source" || name === "track" || name === "hr" || name === "meta" || name === "link" || name === "col" || name === "base") {
+      this.framesetOk = false;
+      return;
+    }
+    if (name === "select") {
+      if (this.hasInButtonScope("p"))
+        this.implicitlyClose("p", start, raw);
+      this.push(raw, NS.html, start);
+      this.framesetOk = false;
+      this.insertionMode = MODES.inSelect;
+      return;
+    }
+    if (name === "option" || name === "optgroup") {
+      if (this.currentNode()?.name === "option") {
+        this.openElements.pop();
+      }
+      this.push(raw, NS.html, start);
+      return;
+    }
+    if (name === "textarea" || name === "title" || RAW_TEXT_ELEMENTS.has(name)) {
+      this.push(raw, NS.html, start);
+      return;
+    }
+    if (name === "math" || name === "svg") {
+      this.push(raw, name === "svg" ? NS.svg : NS.math, start);
+      this.framesetOk = false;
+      return;
+    }
+    if (name === "caption" || name === "col" || name === "colgroup" || name === "frame" || name === "tbody" || name === "td" || name === "tfoot" || name === "th" || name === "thead" || name === "tr") {
+      this.report(HTML_TAG_NOT_ALLOWED_IN_PARENT, LEVEL_ERROR, start, {
+        tag: raw,
+        parent: this.currentNode()?.name ?? "(root)",
+        mode: this.insertionMode,
+        action: "ignored"
+      });
+      return;
+    }
+    if (selfClosing)
+      return;
+    this.push(raw, NS.html, start);
+  }
+  openElementsHas(name) {
+    for (let i = this.openElements.length - 1;i >= 0; i--) {
+      const f = this.openElements[i];
+      if (f.ns === NS.html && f.name === name)
+        return true;
+    }
+    return false;
+  }
+  activeFormattingHas(name) {
+    for (let i = this.activeFormatting.length - 1;i >= 0; i--) {
+      const e = this.activeFormatting[i];
+      if (e === null)
+        return false;
+      if (e.name === name)
+        return true;
+    }
+    return false;
+  }
+  runAdoptionAgency(name) {
+    for (let i = this.activeFormatting.length - 1;i >= 0; i--) {
+      const e = this.activeFormatting[i];
+      if (e === null)
+        break;
+      if (e.name === name) {
+        this.activeFormatting.splice(i, 1);
+        const idx = this.openElements.indexOf(e);
+        if (idx >= 0)
+          this.openElements.splice(idx, 1);
+        return;
+      }
+    }
+  }
+  implicitlyClose(name, _start, _newTagRaw) {
+    while (this.openElements.length) {
+      const popped = this.openElements.pop();
+      if (popped.name === name)
+        break;
+    }
+  }
+  startInTemplate(name, raw, selfClosing, start, endIndex) {
+    let next;
+    if (name === "caption" || name === "colgroup" || name === "tbody" || name === "tfoot" || name === "thead") {
+      next = MODES.inTable;
+    } else if (name === "col") {
+      next = MODES.inColumnGroup;
+    } else if (name === "tr") {
+      next = MODES.inTableBody;
+    } else if (name === "td" || name === "th") {
+      next = MODES.inRow;
+    } else {
+      this.popTemplateMode();
+      this.pushTemplateMode(MODES.inBody);
+      this.insertionMode = MODES.inBody;
+      return this.startInBody(name, raw, selfClosing, start, endIndex);
+    }
+    this.popTemplateMode();
+    this.pushTemplateMode(next);
+    this.insertionMode = next;
+    return this.dispatchStartTag(name, raw, selfClosing, start, endIndex);
+  }
+  popTemplateMode() {
+    if (this.templateInsertionModes.length)
+      this.templateInsertionModes.pop();
+  }
+  pushTemplateMode(mode) {
+    this.templateInsertionModes.push(mode);
+  }
+  startInTable(name, raw, selfClosing, start, endIndex) {
+    if (name === "caption") {
+      this.clearStackBackToTable();
+      this.activeFormatting.push(null);
+      this.push(raw, NS.html, start);
+      this.insertionMode = MODES.inCaption;
+      return;
+    }
+    if (name === "colgroup") {
+      this.clearStackBackToTable();
+      this.push(raw, NS.html, start);
+      this.insertionMode = MODES.inColumnGroup;
+      return;
+    }
+    if (name === "col") {
+      this.clearStackBackToTable();
+      this.push("colgroup", NS.html, start);
+      this.insertionMode = MODES.inColumnGroup;
+      return this.dispatchStartTag(name, raw, selfClosing, start, endIndex);
+    }
+    if (name === "tbody" || name === "thead" || name === "tfoot") {
+      this.clearStackBackToTable();
+      this.push(raw, NS.html, start);
+      this.insertionMode = MODES.inTableBody;
+      return;
+    }
+    if (name === "td" || name === "th" || name === "tr") {
+      this.clearStackBackToTable();
+      this.push("tbody", NS.html, start);
+      this.insertionMode = MODES.inTableBody;
+      return this.dispatchStartTag(name, raw, selfClosing, start, endIndex);
+    }
+    if (name === "table") {
+      this.report(HTML_TAG_NOT_ALLOWED_IN_PARENT, LEVEL_ERROR, start, {
+        tag: raw,
+        parent: "table",
+        mode: this.insertionMode,
+        action: "auto-close-implicit"
+      });
+      if (this.hasInTableScope("table")) {
+        this.popUntilName("table");
+        this.resetInsertionModeAppropriately();
+        return this.dispatchStartTag(name, raw, selfClosing, start, endIndex);
+      }
+      return;
+    }
+    if (name === "style" || name === "script" || name === "template") {
+      return this.startInBody(name, raw, selfClosing, start, endIndex);
+    }
+    if (name === "input") {
+      this.report(HTML_TAG_NOT_ALLOWED_IN_PARENT, LEVEL_WARN, start, {
+        tag: raw,
+        parent: "table",
+        mode: this.insertionMode,
+        action: "foster-parent"
+      });
+      return;
+    }
+    if (name === "form") {
+      this.report(HTML_TAG_NOT_ALLOWED_IN_PARENT, LEVEL_ERROR, start, {
+        tag: raw,
+        parent: "table",
+        mode: this.insertionMode,
+        action: "ignored"
+      });
+      return;
+    }
+    this.report(HTML_TAG_NOT_ALLOWED_IN_PARENT, LEVEL_ERROR, start, {
+      tag: raw,
+      parent: this.currentNode()?.name ?? "table",
+      mode: this.insertionMode,
+      action: "foster-parent"
+    });
+    return this.startInBody(name, raw, selfClosing, start, endIndex);
+  }
+  clearStackBackToTable() {
+    while (this.openElements.length) {
+      const top = this.currentNode();
+      if (!top)
+        break;
+      if (top.name === "table" || top.name === "template")
+        break;
+      this.openElements.pop();
+    }
+  }
+  flushTableText() {
+    if (!this.pendingTableText)
+      return;
+    const { hasNonWhitespace, start, snippet } = this.pendingTableText;
+    if (hasNonWhitespace) {
+      this.report(HTML_TEXT_NOT_ALLOWED_IN_PARENT, LEVEL_ERROR, start, {
+        mode: this.originalInsertionMode,
+        snippet
+      });
+    }
+    this.pendingTableText = null;
+  }
+  startInCaption(name, raw, selfClosing, start, endIndex) {
+    if (name === "caption" || name === "col" || name === "colgroup" || name === "tbody" || name === "td" || name === "tfoot" || name === "th" || name === "thead" || name === "tr") {
+      if (this.hasInTableScope("caption")) {
+        this.generateImpliedEndTags();
+        this.popUntilName("caption");
+        this.clearActiveFormattingToMarker();
+        this.insertionMode = MODES.inTable;
+        return this.dispatchStartTag(name, raw, selfClosing, start, endIndex);
+      }
+      return;
+    }
+    return this.startInBody(name, raw, selfClosing, start, endIndex);
+  }
+  clearActiveFormattingToMarker() {
+    while (this.activeFormatting.length) {
+      const e = this.activeFormatting.pop();
+      if (e === null)
+        return;
+    }
+  }
+  startInColumnGroup(name, raw, selfClosing, start, endIndex) {
+    if (name === "col") {
+      return;
+    }
+    if (name === "template") {
+      return this.startInBody(name, raw, selfClosing, start, endIndex);
+    }
+    if (this.currentNode()?.name === "colgroup") {
+      this.openElements.pop();
+      this.insertionMode = MODES.inTable;
+      return this.dispatchStartTag(name, raw, selfClosing, start, endIndex);
+    }
+    this.report(HTML_TAG_NOT_ALLOWED_IN_PARENT, LEVEL_ERROR, start, {
+      tag: raw,
+      parent: "colgroup",
+      mode: this.insertionMode,
+      action: "ignored"
+    });
+  }
+  startInTableBody(name, raw, selfClosing, start, endIndex) {
+    if (name === "tr") {
+      this.clearStackBackToTableBody();
+      this.push(raw, NS.html, start);
+      this.insertionMode = MODES.inRow;
+      return;
+    }
+    if (TABLE_BODY_CELL_TAGS.has(name)) {
+      this.report(HTML_TAG_NOT_ALLOWED_IN_PARENT, LEVEL_WARN, start, {
+        tag: raw,
+        parent: this.currentNode()?.name ?? "tbody",
+        mode: this.insertionMode,
+        action: "auto-close-implicit"
+      });
+      this.clearStackBackToTableBody();
+      this.push("tr", NS.html, start);
+      this.insertionMode = MODES.inRow;
+      return this.dispatchStartTag(name, raw, selfClosing, start, endIndex);
+    }
+    if (name === "caption" || name === "col" || name === "colgroup" || name === "tbody" || name === "tfoot" || name === "thead") {
+      if (this.hasInTableScope("tbody") || this.hasInTableScope("thead") || this.hasInTableScope("tfoot")) {
+        this.clearStackBackToTableBody();
+        this.openElements.pop();
+        this.insertionMode = MODES.inTable;
+        return this.dispatchStartTag(name, raw, selfClosing, start, endIndex);
+      }
+      return;
+    }
+    return this.startInTable(name, raw, selfClosing, start, endIndex);
+  }
+  clearStackBackToTableBody() {
+    while (this.openElements.length) {
+      const top = this.currentNode();
+      if (!top)
+        break;
+      if (top.name === "tbody" || top.name === "thead" || top.name === "tfoot" || top.name === "template" || top.name === "table")
+        break;
+      this.openElements.pop();
+    }
+  }
+  startInRow(name, raw, selfClosing, start, endIndex) {
+    if (TABLE_BODY_CELL_TAGS.has(name)) {
+      this.clearStackBackToTableRow();
+      this.push(raw, NS.html, start);
+      this.insertionMode = MODES.inCell;
+      this.activeFormatting.push(null);
+      return;
+    }
+    if (name === "caption" || name === "col" || name === "colgroup" || name === "tbody" || name === "tfoot" || name === "thead" || name === "tr") {
+      if (this.hasInTableScope("tr")) {
+        this.clearStackBackToTableRow();
+        this.openElements.pop();
+        this.insertionMode = MODES.inTableBody;
+        return this.dispatchStartTag(name, raw, selfClosing, start, endIndex);
+      }
+      return;
+    }
+    return this.startInTable(name, raw, selfClosing, start, endIndex);
+  }
+  clearStackBackToTableRow() {
+    while (this.openElements.length) {
+      const top = this.currentNode();
+      if (!top)
+        break;
+      if (top.name === "tr" || top.name === "template" || top.name === "table")
+        break;
+      this.openElements.pop();
+    }
+  }
+  startInCell(name, raw, selfClosing, start, endIndex) {
+    if (name === "caption" || name === "col" || name === "colgroup" || name === "tbody" || name === "td" || name === "tfoot" || name === "th" || name === "thead" || name === "tr") {
+      if (this.hasInTableScope("td") || this.hasInTableScope("th")) {
+        this.closeCell();
+        return this.dispatchStartTag(name, raw, selfClosing, start, endIndex);
+      }
+      return;
+    }
+    return this.startInBody(name, raw, selfClosing, start, endIndex);
+  }
+  closeCell() {
+    this.generateImpliedEndTags();
+    while (this.openElements.length) {
+      const popped = this.openElements.pop();
+      if (popped.name === "td" || popped.name === "th")
+        break;
+    }
+    this.clearActiveFormattingToMarker();
+    this.insertionMode = MODES.inRow;
+  }
+  startInSelect(name, raw, _selfClosing, start, _endIndex) {
+    if (name === "option") {
+      if (this.currentNode()?.name === "option")
+        this.openElements.pop();
+      this.push(raw, NS.html, start);
+      return;
+    }
+    if (name === "optgroup") {
+      if (this.currentNode()?.name === "option")
+        this.openElements.pop();
+      if (this.currentNode()?.name === "optgroup")
+        this.openElements.pop();
+      this.push(raw, NS.html, start);
+      return;
+    }
+    if (name === "hr")
+      return;
+    if (SELECT_BREAKOUT_TAGS.has(name)) {
+      this.report(HTML_TAG_NOT_ALLOWED_IN_PARENT, LEVEL_ERROR, start, {
+        tag: raw,
+        parent: "select",
+        mode: this.insertionMode,
+        action: "auto-close-implicit"
+      });
+      if (this.hasInSelectScope("select")) {
+        this.popUntilName("select");
+        this.resetInsertionModeAppropriately();
+      }
+      if (name === "select")
+        return;
+      return this.dispatchStartTag(name, raw, false, start, _endIndex);
+    }
+    if (name === "script" || name === "template") {
+      return this.startInBody(name, raw, false, start, _endIndex);
+    }
+    this.report(HTML_TAG_NOT_ALLOWED_IN_PARENT, LEVEL_ERROR, start, {
+      tag: raw,
+      parent: "select",
+      mode: this.insertionMode,
+      action: "ignored"
+    });
+  }
+  startInSelectInTable(name, raw, selfClosing, start, endIndex) {
+    if (name === "caption" || name === "table" || name === "tbody" || name === "tfoot" || name === "thead" || name === "tr" || name === "td" || name === "th") {
+      this.report(HTML_TAG_NOT_ALLOWED_IN_PARENT, LEVEL_ERROR, start, {
+        tag: raw,
+        parent: "select",
+        mode: this.insertionMode,
+        action: "auto-close-implicit"
+      });
+      this.popUntilName("select");
+      this.resetInsertionModeAppropriately();
+      return this.dispatchStartTag(name, raw, selfClosing, start, endIndex);
+    }
+    return this.startInSelect(name, raw, selfClosing, start, endIndex);
+  }
+  resetInsertionModeAppropriately() {
+    for (let i = this.openElements.length - 1;i >= 0; i--) {
+      const f = this.openElements[i];
+      if (f.ns !== NS.html)
+        continue;
+      const last = i === 0;
+      switch (f.name) {
+        case "select":
+          this.insertionMode = MODES.inSelect;
+          return;
+        case "td":
+        case "th":
+          if (!last) {
+            this.insertionMode = MODES.inCell;
+            return;
+          }
+          break;
+        case "tr":
+          this.insertionMode = MODES.inRow;
+          return;
+        case "tbody":
+        case "thead":
+        case "tfoot":
+          this.insertionMode = MODES.inTableBody;
+          return;
+        case "caption":
+          this.insertionMode = MODES.inCaption;
+          return;
+        case "colgroup":
+          this.insertionMode = MODES.inColumnGroup;
+          return;
+        case "table":
+          this.insertionMode = MODES.inTable;
+          return;
+        case "template":
+          this.insertionMode = this.templateInsertionModes[this.templateInsertionModes.length - 1] ?? MODES.inBody;
+          return;
+        default:
+          break;
+      }
+    }
+    this.insertionMode = MODES.inBody;
+  }
+  handleEndTag(name, start) {
+    if (this.isTransparentTag(name))
+      return;
+    const ns = this.currentNamespace();
+    if (ns !== NS.html) {
+      for (let i = this.openElements.length - 1;i >= 0; i--) {
+        const f = this.openElements[i];
+        if (f.ns === NS.html)
+          break;
+        if (f.name.toLowerCase() === name) {
+          this.openElements.length = i;
+          return;
+        }
+      }
+    }
+    if (VOID_ELEMENTS.has(name)) {
+      this.report(HTML_VOID_ELEMENT_HAS_CLOSE_TAG, LEVEL_WARN, start, {
+        tag: name,
+        mode: this.insertionMode
+      });
+      return;
+    }
+    if (FORMATTING_ELEMENTS.has(name)) {
+      const top = this.currentNode();
+      if (top && top.ns === NS.html && top.name === name) {
+        this.openElements.pop();
+        this.removeFromActiveFormattingByRef(top);
+        return;
+      }
+      if (this.activeFormattingHas(name) || this.openElementsHas(name)) {
+        this.report(HTML_MISNESTED_FORMATTING, LEVEL_WARN, start, {
+          tag: name,
+          mode: this.insertionMode
+        });
+        this.runAdoptionAgency(name);
+        return;
+      }
+      this.report(HTML_UNEXPECTED_END_TAG, LEVEL_WARN, start, {
+        tag: name,
+        mode: this.insertionMode
+      });
+      return;
+    }
+    for (let i = this.openElements.length - 1;i >= 0; i--) {
+      const f = this.openElements[i];
+      if (f.ns === NS.html && f.name === name) {
+        this.openElements.length = i;
+        if (name === "form")
+          this.formPointer = null;
+        if (TABLE_SCOPE_TAGS.has(name) || name === "select" || name === "template") {
+          this.resetInsertionModeAppropriately();
+        }
+        return;
+      }
+      if (f.ns === NS.html && SPECIAL_ELEMENTS.has(f.name)) {
+        break;
+      }
+    }
+  }
+  removeFromActiveFormattingByRef(ref) {
+    const idx = this.activeFormatting.indexOf(ref);
+    if (idx >= 0)
+      this.activeFormatting.splice(idx, 1);
+  }
+  handleText(start, end) {
+    if (this.insertionMode === MODES.inTable || this.insertionMode === MODES.inTableBody || this.insertionMode === MODES.inRow) {
+      const slice = this.html.slice(start, end);
+      const hasNonWhitespace = /\S/.test(slice);
+      if (hasNonWhitespace) {
+        this.report(HTML_TEXT_NOT_ALLOWED_IN_PARENT, LEVEL_ERROR, start, {
+          mode: this.insertionMode,
+          snippet: slice.length > 40 ? `${slice.slice(0, 40)}…` : slice
+        });
+      }
+      return;
+    }
+    if (this.insertionMode === MODES.inColumnGroup) {
+      const slice = this.html.slice(start, end);
+      if (/\S/.test(slice)) {
+        if (this.currentNode()?.name === "colgroup") {
+          this.openElements.pop();
+          this.insertionMode = MODES.inTable;
+          return this.handleText(start, end);
+        }
+      }
+      return;
+    }
+    if (this.insertionMode === MODES.inSelect || this.insertionMode === MODES.inSelectInTable) {
+      return;
+    }
+  }
+}
+function computeLineStarts(html) {
+  const arr = [0];
+  for (let i = 0;i < html.length; i++) {
+    if (html.charCodeAt(i) === 10)
+      arr.push(i + 1);
+  }
+  return arr;
+}
+function offsetToLineCol(lineStarts, offset) {
+  let lo = 0;
+  let hi = lineStarts.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >>> 1;
+    if (lineStarts[mid] <= offset)
+      lo = mid;
+    else
+      hi = mid - 1;
+  }
+  return { line: lo + 1, column: offset - lineStarts[lo] + 1 };
+}
+var HTML_TAG_NAME_HAS_UPPERCASE = "HTML_TAG_NAME_HAS_UPPERCASE", HTML_SVG_TAG_WILL_LOWERCASE = "HTML_SVG_TAG_WILL_LOWERCASE", HTML_TAG_NOT_ALLOWED_IN_PARENT = "HTML_TAG_NOT_ALLOWED_IN_PARENT", HTML_TEXT_NOT_ALLOWED_IN_PARENT = "HTML_TEXT_NOT_ALLOWED_IN_PARENT", HTML_VOID_ELEMENT_HAS_CLOSE_TAG = "HTML_VOID_ELEMENT_HAS_CLOSE_TAG", HTML_DUPLICATE_FORM = "HTML_DUPLICATE_FORM", HTML_NESTED_INTERACTIVE = "HTML_NESTED_INTERACTIVE", HTML_MISNESTED_FORMATTING = "HTML_MISNESTED_FORMATTING", HTML_UNEXPECTED_END_TAG = "HTML_UNEXPECTED_END_TAG", LEVEL_ERROR = "error", LEVEL_WARN = "warn", TABLE_SCOPE_TAGS, TABLE_BODY_CELL_TAGS;
+var init_htmllinter = __esm(() => {
+  init_dist3();
+  init_htmllinter_tables();
+  TABLE_SCOPE_TAGS = new Set([
+    "caption",
+    "colgroup",
+    "thead",
+    "tbody",
+    "tfoot",
+    "tr",
+    "td",
+    "th",
+    "table"
+  ]);
+  TABLE_BODY_CELL_TAGS = new Set(["td", "th"]);
+});
+
 // tools/core/lint-check.js
 function checkComponent(Comp, lx = new LintContext) {
   return lx.push({ componentName: Comp.name }, () => {
@@ -2087,6 +4713,12 @@ function checkView(lx, view, Comp, referencedAlters) {
   checkEventModifiers(lx, view);
   checkKnownHandlerNames(lx, view, Comp, referencedAlters);
   checkMacroCallArgs(lx, view, Comp);
+  checkHtmlStructure(lx, view);
+}
+function checkHtmlStructure(lx, view) {
+  if (typeof view.rawView !== "string" || !view.rawView)
+    return;
+  lintHtml(view.rawView, (f) => lx.report(f.id, { ...f.info, location: f.location }, f.level), HTML_LINT_OPTS);
 }
 function checkParseIssues(lx, view) {
   const issues = view.ctx.parseIssues;
@@ -2434,21 +5066,22 @@ class LintContext {
     }
   }
   error(id, info) {
-    this.report(id, info, LEVEL_ERROR);
+    this.report(id, info, LEVEL_ERROR2);
   }
   warn(id, info) {
-    this.report(id, info, LEVEL_WARN);
+    this.report(id, info, LEVEL_WARN2);
   }
   hint(id, info) {
     this.report(id, info, LEVEL_HINT);
   }
-  report(id, info = {}, level = LEVEL_ERROR) {
+  report(id, info = {}, level = LEVEL_ERROR2) {
     this.reports.push({ id, info, level, context: { ...this.frame } });
   }
 }
-var ALT_HANDLER_NOT_DEFINED = "ALT_HANDLER_NOT_DEFINED", ALT_HANDLER_NOT_REFERENCED = "ALT_HANDLER_NOT_REFERENCED", RENDER_IT_OUTSIDE_OF_LOOP = "RENDER_IT_OUTSIDE_OF_LOOP", UNKNOWN_EVENT_MODIFIER = "UNKNOWN_EVENT_MODIFIER", UNKNOWN_HANDLER_ARG_NAME = "UNKNOWN_HANDLER_ARG_NAME", INPUT_HANDLER_NOT_IMPLEMENTED = "INPUT_HANDLER_NOT_IMPLEMENTED", INPUT_HANDLER_NOT_REFERENCED = "INPUT_HANDLER_NOT_REFERENCED", INPUT_HANDLER_METHOD_NOT_IMPLEMENTED = "INPUT_HANDLER_METHOD_NOT_IMPLEMENTED", INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD = "INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD", INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER = "INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER", FIELD_VAL_NOT_DEFINED = "FIELD_VAL_NOT_DEFINED", DUPLICATE_ATTR_DEFINITION = "DUPLICATE_ATTR_DEFINITION", IF_NO_BRANCH_SET = "IF_NO_BRANCH_SET", UNKNOWN_REQUEST_NAME = "UNKNOWN_REQUEST_NAME", UNKNOWN_COMPONENT_NAME = "UNKNOWN_COMPONENT_NAME", UNKNOWN_MACRO_ARG = "UNKNOWN_MACRO_ARG", UNKNOWN_DIRECTIVE = "UNKNOWN_DIRECTIVE", UNKNOWN_X_OP = "UNKNOWN_X_OP", UNKNOWN_X_ATTR = "UNKNOWN_X_ATTR", MAYBE_DROP_AT_PREFIX = "MAYBE_DROP_AT_PREFIX", BAD_VALUE = "BAD_VALUE", PARSE_ISSUE_KIND_TO_LINT_ID, X_KNOWN_OP_NAMES, X_KNOWN_ATTR_NAMES, AT_PREFIX_HINT_KNOWN_BY_KIND, LEVEL_WARN = "warn", LEVEL_ERROR = "error", LEVEL_HINT = "hint", NO_WRAPPERS, KNOWN_HANDLER_NAMES, NODE_KIND_TO_CTX, LintParseContext;
+var ALT_HANDLER_NOT_DEFINED = "ALT_HANDLER_NOT_DEFINED", ALT_HANDLER_NOT_REFERENCED = "ALT_HANDLER_NOT_REFERENCED", RENDER_IT_OUTSIDE_OF_LOOP = "RENDER_IT_OUTSIDE_OF_LOOP", UNKNOWN_EVENT_MODIFIER = "UNKNOWN_EVENT_MODIFIER", UNKNOWN_HANDLER_ARG_NAME = "UNKNOWN_HANDLER_ARG_NAME", INPUT_HANDLER_NOT_IMPLEMENTED = "INPUT_HANDLER_NOT_IMPLEMENTED", INPUT_HANDLER_NOT_REFERENCED = "INPUT_HANDLER_NOT_REFERENCED", INPUT_HANDLER_METHOD_NOT_IMPLEMENTED = "INPUT_HANDLER_METHOD_NOT_IMPLEMENTED", INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD = "INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD", INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER = "INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER", FIELD_VAL_NOT_DEFINED = "FIELD_VAL_NOT_DEFINED", DUPLICATE_ATTR_DEFINITION = "DUPLICATE_ATTR_DEFINITION", IF_NO_BRANCH_SET = "IF_NO_BRANCH_SET", UNKNOWN_REQUEST_NAME = "UNKNOWN_REQUEST_NAME", UNKNOWN_COMPONENT_NAME = "UNKNOWN_COMPONENT_NAME", UNKNOWN_MACRO_ARG = "UNKNOWN_MACRO_ARG", UNKNOWN_DIRECTIVE = "UNKNOWN_DIRECTIVE", UNKNOWN_X_OP = "UNKNOWN_X_OP", UNKNOWN_X_ATTR = "UNKNOWN_X_ATTR", MAYBE_DROP_AT_PREFIX = "MAYBE_DROP_AT_PREFIX", BAD_VALUE = "BAD_VALUE", PARSE_ISSUE_KIND_TO_LINT_ID, X_KNOWN_OP_NAMES, X_KNOWN_ATTR_NAMES, AT_PREFIX_HINT_KNOWN_BY_KIND, LEVEL_WARN2 = "warn", LEVEL_ERROR2 = "error", LEVEL_HINT = "hint", HTML_LINT_OPTS, NO_WRAPPERS, KNOWN_HANDLER_NAMES, NODE_KIND_TO_CTX, LintParseContext;
 var init_lint_check = __esm(() => {
   init_anode();
+  init_htmllinter();
   PARSE_ISSUE_KIND_TO_LINT_ID = {
     "unknown-directive": UNKNOWN_DIRECTIVE,
     "unknown-x-op": UNKNOWN_X_OP,
@@ -2469,6 +5102,10 @@ var init_lint_check = __esm(() => {
     "unknown-x-op": X_KNOWN_OP_NAMES,
     "unknown-x-attr": X_KNOWN_ATTR_NAMES
   };
+  HTML_LINT_OPTS = {
+    fragmentContext: "template",
+    transparentTagPrefixes: ["x"]
+  };
   NO_WRAPPERS = {};
   KNOWN_HANDLER_NAMES = new Set([
     "value",
@@ -2500,8 +5137,8 @@ var init_lint_check = __esm(() => {
     PushViewNameNode: { originAttr: "<x push-view>" }
   };
   LintParseContext = class LintParseContext extends ParseContext {
-    constructor(document2, Text, Comment) {
-      super(document2, Text, Comment);
+    constructor(document2, Text2, Comment2) {
+      super(document2, Text2, Comment2);
       this.attrs = [];
       this.parseIssues = [];
     }
@@ -2682,7 +5319,7 @@ var init_stack = __esm(() => {
 });
 
 // src/transactor.js
-class State {
+class State2 {
   constructor(val) {
     this.val = val;
     this.changeSubs = [];
@@ -2705,7 +5342,7 @@ class Transactor {
   constructor(comps, rootValue) {
     this.comps = comps;
     this.transactions = [];
-    this.state = new State(rootValue);
+    this.state = new State2(rootValue);
     this.onTransactionPushed = () => {};
   }
   pushTransaction(t) {
@@ -3010,8 +5647,6 @@ function applyProperties(node, props, previous) {
       node.setAttribute(propName, propValue);
     else if (propName === "dangerouslySetInnerHTML")
       node.innerHTML = propValue.__html ?? "";
-    else if (isObject(propValue))
-      patchObject(node, previous, propName, propValue);
     else if (propName === "className")
       node.setAttribute("class", propValue);
     else
@@ -3031,18 +5666,6 @@ function removeProperty(node, propName, previous) {
   else
     node[propName] = null;
 }
-function patchObject(node, previous, propName, propValue) {
-  const previousValue = previous?.[propName];
-  if (isObject(previousValue) && prototypesDiffer(previousValue, propValue)) {
-    node[propName] = propValue;
-    return;
-  }
-  if (!isObject(node[propName]))
-    node[propName] = {};
-  const target = node[propName];
-  for (const k in propValue)
-    target[k] = propValue[k];
-}
 
 class VBase {
 }
@@ -3080,26 +5703,9 @@ function diffProps(a, b) {
     if (!Object.hasOwn(b, aKey)) {
       diff ??= {};
       diff[aKey] = undefined;
-      continue;
-    }
-    const aValue = a[aKey];
-    const bValue = b[aKey];
-    if (aValue === bValue)
-      continue;
-    if (isObject(aValue) && isObject(bValue)) {
-      if (prototypesDiffer(bValue, aValue)) {
-        diff ??= {};
-        diff[aKey] = bValue;
-      } else {
-        const objectDiff = diffProps(aValue, bValue);
-        if (objectDiff) {
-          diff ??= {};
-          diff[aKey] = objectDiff;
-        }
-      }
-    } else {
+    } else if (a[aKey] !== b[aKey]) {
       diff ??= {};
-      diff[aKey] = bValue;
+      diff[aKey] = b[aKey];
     }
   }
   for (const bKey in b) {
@@ -3252,7 +5858,7 @@ function h(tagName, properties, children) {
   addChild(normalizedChildren, children);
   return new VNode(tag, props, normalizedChildren, key, namespace);
 }
-var isHtmlAttribute = (propName) => propName[4] === "-" && (propName[0] === "d" || propName[0] === "a"), isObject = (v) => v !== null && typeof v === "object", prototypesDiffer = (a, b) => Object.getPrototypeOf(a) !== Object.getPrototypeOf(b), getKey = (child) => child instanceof VNode ? child.key : undefined, isIterable = (obj) => obj != null && typeof obj !== "string" && typeof obj[Symbol.iterator] === "function", VText, VComment, VFragment, VNode;
+var isHtmlAttribute = (propName) => propName[4] === "-" && (propName[0] === "d" || propName[0] === "a"), getKey = (child) => child instanceof VNode ? child.key : undefined, isIterable = (obj) => obj != null && typeof obj !== "string" && typeof obj[Symbol.iterator] === "function", VText, VComment, VFragment, VNode;
 var init_vdom = __esm(() => {
   VText = class VText extends VBase {
     constructor(text) {
@@ -8440,19 +11046,21 @@ async function createNodeEnv() {
       return;
     console.error(err.message);
   });
-  const dom = new JSDOM("<!DOCTYPE html><html><head></head><body></body></html>", { virtualConsole });
-  const { document: document2, Text, Comment } = dom.window;
+  const dom = new JSDOM("<!DOCTYPE html><html><head></head><body></body></html>", {
+    virtualConsole
+  });
+  const { document: document2, Text: Text2, Comment: Comment2 } = dom.window;
   globalThis.document = document2;
 
   class HeadlessParseContext extends ParseContext {
     constructor() {
-      super(document2, Text, Comment);
+      super(document2, Text2, Comment2);
     }
   }
 
   class HeadlessLintParseContext extends LintParseContext {
     constructor() {
-      super(document2, Text, Comment);
+      super(document2, Text2, Comment2);
     }
   }
   return {
@@ -8599,12 +11207,36 @@ function lintIdToMessage(id, info) {
     }
     case "BAD_VALUE":
       return `${badValueMessage(info)}${fmtTagSuffix(info)}`;
+    case "HTML_TAG_NAME_HAS_UPPERCASE":
+      return `Tag <${info.raw}> will be lowercased to <${info.lowercased}>${fmtLocationSuffix(info)}`;
+    case "HTML_SVG_TAG_WILL_LOWERCASE":
+      return `SVG tag <${info.raw}> is not in the WHATWG case-correction list — will be lowercased to <${info.lowercased}>${fmtLocationSuffix(info)}`;
+    case "HTML_TAG_NOT_ALLOWED_IN_PARENT":
+      return `<${info.tag}> not allowed under <${info.parent ?? "?"}> in ${info.mode} (action: ${info.action})${fmtLocationSuffix(info)}`;
+    case "HTML_TEXT_NOT_ALLOWED_IN_PARENT":
+      return `Non-whitespace text not allowed in ${info.mode}: ${JSON.stringify(info.snippet)}${fmtLocationSuffix(info)}`;
+    case "HTML_VOID_ELEMENT_HAS_CLOSE_TAG":
+      return `Void element <${info.tag}> has an explicit close tag${fmtLocationSuffix(info)}`;
+    case "HTML_DUPLICATE_FORM":
+      return `Nested <form> — the inner form will be dropped by the parser${fmtLocationSuffix(info)}`;
+    case "HTML_NESTED_INTERACTIVE":
+      return `<${info.tag}> nested inside another <${info.tag}> — adoption agency will reorder${fmtLocationSuffix(info)}`;
+    case "HTML_MISNESTED_FORMATTING":
+      return `Misnested formatting tag </${info.tag}> — adoption agency will reorder nodes${fmtLocationSuffix(info)}`;
+    case "HTML_UNEXPECTED_END_TAG":
+      return `Unexpected end tag </${info.tag}>${fmtLocationSuffix(info)}`;
     case "LINT_ERROR":
       return info.message;
     default:
       return id;
   }
 }
+function fmtLocationSuffix(info) {
+  const loc = info?.location;
+  if (!loc)
+    return "";
+  return ` at L${loc.line}:C${loc.column}`;
+}
 
 // tools/format/cli.js
 function fmtModuleInfo(info) {