tutuca 0.9.36 → 0.9.38

package/dist/tutuca-dev.js

@@ -1644,6 +1644,2054 @@ class ParseCtxClassSetCollector extends ParseContext {
   }
 }
 
+// tools/core/html-tokenizer.js
+var CharCodes = {
+  Tab: 9,
+  NewLine: 10,
+  FormFeed: 12,
+  CarriageReturn: 13,
+  Space: 32,
+  ExclamationMark: 33,
+  Number: 35,
+  SingleQuote: 39,
+  DoubleQuote: 34,
+  Dash: 45,
+  Slash: 47,
+  Zero: 48,
+  Nine: 57,
+  Semi: 59,
+  Lt: 60,
+  Eq: 61,
+  Gt: 62,
+  Questionmark: 63,
+  UpperA: 65,
+  LowerA: 97,
+  UpperF: 70,
+  LowerF: 102,
+  UpperZ: 90,
+  LowerZ: 122,
+  LowerX: 120,
+  OpeningSquareBracket: 91
+};
+var State = {
+  Text: 1,
+  BeforeTagName: 2,
+  InTagName: 3,
+  InSelfClosingTag: 4,
+  BeforeClosingTagName: 5,
+  InClosingTagName: 6,
+  AfterClosingTagName: 7,
+  BeforeAttributeName: 8,
+  InAttributeName: 9,
+  AfterAttributeName: 10,
+  BeforeAttributeValue: 11,
+  InAttributeValueDq: 12,
+  InAttributeValueSq: 13,
+  InAttributeValueNq: 14,
+  BeforeDeclaration: 15,
+  InDeclaration: 16,
+  InProcessingInstruction: 17,
+  BeforeComment: 18,
+  CDATASequence: 19,
+  DeclarationSequence: 20,
+  InSpecialComment: 21,
+  InCommentLike: 22,
+  SpecialStartSequence: 23,
+  InSpecialTag: 24,
+  InPlainText: 25
+};
+function isWhitespace(c) {
+  return c === CharCodes.Space || c === CharCodes.NewLine || c === CharCodes.Tab || c === CharCodes.FormFeed || c === CharCodes.CarriageReturn;
+}
+function isEndOfTagSection(c) {
+  return c === CharCodes.Slash || c === CharCodes.Gt || isWhitespace(c);
+}
+function isASCIIAlpha(c) {
+  return c >= CharCodes.LowerA && c <= CharCodes.LowerZ || c >= CharCodes.UpperA && c <= CharCodes.UpperZ;
+}
+var QuoteType = {
+  NoValue: 0,
+  Unquoted: 1,
+  Single: 2,
+  Double: 3
+};
+var 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])
+};
+var 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]
+]);
+
+class HtmlTokenizer {
+  constructor({ xmlMode = false, recognizeSelfClosing = xmlMode } = {}, cbs) {
+    this.cbs = cbs;
+    this.xmlMode = xmlMode;
+    this.recognizeSelfClosing = recognizeSelfClosing;
+    this.state = State.Text;
+    this.buffer = "";
+    this.sectionStart = 0;
+    this.index = 0;
+    this.isSpecial = false;
+    this.running = true;
+    this.offset = 0;
+    this.currentSequence = Sequences.Empty;
+    this.sequenceIndex = 0;
+  }
+  reset() {
+    this.state = State.Text;
+    this.buffer = "";
+    this.sectionStart = 0;
+    this.index = 0;
+    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 === CharCodes.Lt || this.fastForwardTo(CharCodes.Lt)) {
+      if (this.index > this.sectionStart) {
+        this.cbs.ontext(this.sectionStart, this.index);
+      }
+      this.state = State.BeforeTagName;
+      this.sectionStart = this.index;
+    }
+  }
+  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 === CharCodes.Gt) {
+      this.emitComment(this.sequenceIndex);
+    } else if (this.currentSequence === Sequences.CommentEnd && this.sequenceIndex === 2 && c === CharCodes.Gt) {
+      this.emitComment(2);
+    } else if (this.currentSequence === Sequences.CommentEnd && this.sequenceIndex === this.currentSequence.length - 1 && c !== CharCodes.Gt) {
+      this.sequenceIndex = Number(c === CharCodes.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.fastForwardTo(CharCodes.Lt)) {
+        this.sequenceIndex = 1;
+      }
+    } else {
+      this.sequenceIndex = Number(c === CharCodes.Lt);
+    }
+  }
+  stateBeforeTagName(c) {
+    if (c === CharCodes.ExclamationMark) {
+      this.state = State.BeforeDeclaration;
+      this.sectionStart = this.index + 1;
+    } else if (c === CharCodes.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 === CharCodes.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) {
+        this.state = State.InSpecialComment;
+        this.sectionStart = this.index;
+      }
+    } else if (c === CharCodes.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 === CharCodes.Gt || this.fastForwardTo(CharCodes.Gt)) {
+      this.state = State.Text;
+      this.sectionStart = this.index + 1;
+    }
+  }
+  stateBeforeAttributeName(c) {
+    if (c === CharCodes.Gt) {
+      this.cbs.onopentagend(this.index);
+      this.enterTagBody();
+      this.sectionStart = this.index + 1;
+    } else if (c === CharCodes.Slash) {
+      this.state = State.InSelfClosingTag;
+    } else if (!isWhitespace(c)) {
+      this.state = State.InAttributeName;
+      this.sectionStart = this.index;
+    }
+  }
+  stateInSelfClosingTag(c) {
+    if (c === CharCodes.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 === CharCodes.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 === CharCodes.Eq) {
+      this.state = State.BeforeAttributeValue;
+    } else if (c === CharCodes.Slash || c === CharCodes.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 === CharCodes.DoubleQuote) {
+      this.state = State.InAttributeValueDq;
+      this.sectionStart = this.index + 1;
+    } else if (c === CharCodes.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.fastForwardTo(quote)) {
+      this.cbs.onattribdata(this.sectionStart, this.index);
+      this.sectionStart = -1;
+      this.cbs.onattribend(quote === CharCodes.DoubleQuote ? QuoteType.Double : QuoteType.Single, this.index + 1);
+      this.state = State.BeforeAttributeName;
+    }
+  }
+  stateInAttributeValueDoubleQuotes(c) {
+    this.handleInAttributeValue(c, CharCodes.DoubleQuote);
+  }
+  stateInAttributeValueSingleQuotes(c) {
+    this.handleInAttributeValue(c, CharCodes.SingleQuote);
+  }
+  stateInAttributeValueNoQuotes(c) {
+    if (isWhitespace(c) || c === CharCodes.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);
+    }
+  }
+  stateBeforeDeclaration(c) {
+    if (c === CharCodes.OpeningSquareBracket) {
+      this.state = State.CDATASequence;
+      this.sequenceIndex = 0;
+    } else if (this.xmlMode) {
+      this.state = c === CharCodes.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 === CharCodes.Gt) {
+      this.cbs.oncomment(this.sectionStart, this.index, 0);
+      this.state = State.Text;
+      this.sectionStart = this.index + 1;
+    } else if (c === CharCodes.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 === CharCodes.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 === CharCodes.Gt || this.fastForwardTo(CharCodes.Gt)) {
+      this.cbs.ondeclaration(this.sectionStart, this.index);
+      this.state = State.Text;
+      this.sectionStart = this.index + 1;
+    }
+  }
+  stateInProcessingInstruction(c) {
+    if (c === CharCodes.Questionmark) {
+      this.sequenceIndex = 1;
+    } else if (c === CharCodes.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(CharCodes.Questionmark));
+    }
+  }
+  stateBeforeComment(c) {
+    if (c === CharCodes.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 === CharCodes.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 === CharCodes.Gt || this.fastForwardTo(CharCodes.Gt)) {
+      this.cbs.oncomment(this.sectionStart, this.index, 0);
+      this.state = State.Text;
+      this.sectionStart = this.index + 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;
+      }
+      this.index++;
+    }
+    this.cleanup();
+  }
+  finish() {
+    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);
+    }
+  }
+}
+
+// tools/core/htmllinter-tables.js
+var VOID_ELEMENTS = new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "source",
+  "track",
+  "wbr"
+]);
+var RAW_TEXT_ELEMENTS = new Set([
+  "script",
+  "style",
+  "iframe",
+  "noembed",
+  "noframes",
+  "noscript",
+  "xmp",
+  "plaintext"
+]);
+var RCDATA_ELEMENTS = new Set(["textarea", "title"]);
+var 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"
+]);
+var FORMATTING_ELEMENTS = new Set([
+  "a",
+  "b",
+  "big",
+  "code",
+  "em",
+  "font",
+  "i",
+  "nobr",
+  "s",
+  "small",
+  "strike",
+  "strong",
+  "tt",
+  "u"
+]);
+var DEFAULT_SCOPE_BOUNDARIES = new Set([
+  "applet",
+  "caption",
+  "html",
+  "table",
+  "td",
+  "th",
+  "marquee",
+  "object",
+  "template"
+]);
+var SCOPE_LIST_ITEM = new Set([...DEFAULT_SCOPE_BOUNDARIES, "ol", "ul"]);
+var SCOPE_BUTTON = new Set([...DEFAULT_SCOPE_BOUNDARIES, "button"]);
+var SCOPE_DEFAULT = DEFAULT_SCOPE_BOUNDARIES;
+var SCOPE_TABLE = new Set(["html", "table", "template"]);
+var SCOPE_SELECT = new Set;
+var 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"
+]);
+var 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"
+]);
+var MATHML_CAMEL_ATTRS = new Set(["definitionURL"]);
+var 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"
+]);
+var MATHML_TEXT_INTEGRATION_POINTS = new Set(["mi", "mo", "mn", "ms", "mtext"]);
+var 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"
+]);
+var SELECT_VALID_CHILDREN = new Set(["option", "optgroup", "hr", "script", "template"]);
+var SELECT_BREAKOUT_TAGS = new Set(["input", "keygen", "textarea", "select"]);
+var 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"
+});
+var NS = Object.freeze({
+  html: "html",
+  svg: "svg",
+  math: "math"
+});
+var 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
+var HTML_TAG_NAME_HAS_UPPERCASE = "HTML_TAG_NAME_HAS_UPPERCASE";
+var HTML_SVG_TAG_WILL_LOWERCASE = "HTML_SVG_TAG_WILL_LOWERCASE";
+var HTML_TAG_NOT_ALLOWED_IN_PARENT = "HTML_TAG_NOT_ALLOWED_IN_PARENT";
+var HTML_TEXT_NOT_ALLOWED_IN_PARENT = "HTML_TEXT_NOT_ALLOWED_IN_PARENT";
+var HTML_VOID_ELEMENT_HAS_CLOSE_TAG = "HTML_VOID_ELEMENT_HAS_CLOSE_TAG";
+var HTML_DUPLICATE_FORM = "HTML_DUPLICATE_FORM";
+var HTML_NESTED_INTERACTIVE = "HTML_NESTED_INTERACTIVE";
+var HTML_MISNESTED_FORMATTING = "HTML_MISNESTED_FORMATTING";
+var HTML_UNEXPECTED_END_TAG = "HTML_UNEXPECTED_END_TAG";
+var LEVEL_ERROR = "error";
+var LEVEL_WARN = "warn";
+var TABLE_SCOPE_TAGS = new Set([
+  "caption",
+  "colgroup",
+  "thead",
+  "tbody",
+  "tfoot",
+  "tr",
+  "td",
+  "th",
+  "table"
+]);
+var TABLE_BODY_CELL_TAGS = new Set(["td", "th"]);
+function lintHtml(html, onFinding, opts = {}) {
+  const TokenizerClass = opts.TokenizerClass ?? HtmlTokenizer;
+  const ctx = new LinterCtx(html, onFinding, opts);
+  const tokenizer = new TokenizerClass({ 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 };
+}
+
 // tools/core/lint-check.js
 var ALT_HANDLER_NOT_DEFINED = "ALT_HANDLER_NOT_DEFINED";
 var ALT_HANDLER_NOT_REFERENCED = "ALT_HANDLER_NOT_REFERENCED";
@@ -1686,8 +3734,8 @@ var AT_PREFIX_HINT_KNOWN_BY_KIND = {
   "unknown-x-op": X_KNOWN_OP_NAMES,
   "unknown-x-attr": X_KNOWN_ATTR_NAMES
 };
-var LEVEL_WARN = "warn";
-var LEVEL_ERROR = "error";
+var LEVEL_WARN2 = "warn";
+var LEVEL_ERROR2 = "error";
 var LEVEL_HINT = "hint";
 function checkComponent(Comp, lx = new LintContext) {
   return lx.push({ componentName: Comp.name }, () => {
@@ -1709,6 +3757,16 @@ function checkView(lx, view, Comp, referencedAlters) {
   checkEventModifiers(lx, view);
   checkKnownHandlerNames(lx, view, Comp, referencedAlters);
   checkMacroCallArgs(lx, view, Comp);
+  checkHtmlStructure(lx, view);
+}
+var HTML_LINT_OPTS = {
+  fragmentContext: "template",
+  transparentTagPrefixes: ["x"]
+};
+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;
@@ -2086,15 +4144,15 @@ 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 } });
   }
 }
@@ -2218,12 +4276,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}`;
+}
 
 // src/components.js
 class Components {
@@ -2553,7 +4635,7 @@ class Stack {
 }
 
 // src/transactor.js
-class State {
+class State2 {
   constructor(val) {
     this.val = val;
     this.changeSubs = [];
@@ -2576,7 +4658,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) {
@@ -8780,10 +10862,11 @@ function check(app) {
   for (const Comp of app.comps.byId.values()) {
     const shadowViews = {};
     for (const name in Comp.views) {
+      const rawView = Comp.views[name].rawView;
       const ctx = new LintParseContext;
-      ANode.parse(Comp.views[name].rawView, ctx);
+      ANode.parse(rawView, ctx);
       ctx.compile(Comp.scope);
-      shadowViews[name] = { name, ctx };
+      shadowViews[name] = { name, ctx, rawView };
     }
     const shadowComp = Object.create(Comp);
     shadowComp.views = shadowViews;