vite 7.1.0-beta.0 → 7.1.0-beta.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (14) hide show
  1. package/dist/client/client.mjs +28 -26
  2. package/dist/node/chunks/{dep-CYKWp2mZ.js → dep-B-hsmHjg.js} +1021 -998
  3. package/dist/node/chunks/{dep-BpPEUsd2.js → dep-BeJ5EQ78.js} +126 -129
  4. package/dist/node/chunks/{dep-DQ3EcyiN.js → dep-D3dx-MVo.js} +1 -1
  5. package/dist/node/chunks/{dep-DcjhO6Jt.js → dep-G9cgWHwY.js} +21 -21
  6. package/dist/node/chunks/{dep-KxHho39H.js → dep-L2kJu-gJ.js} +1 -1
  7. package/dist/node/chunks/{dep-BeiFehmI.js → dep-V5uAjiuB.js} +530 -1060
  8. package/dist/node/chunks/{dep-C3Gi22Hg.js → dep-bSJfBHhb.js} +1 -1
  9. package/dist/node/chunks/{dep-DmY5m86w.js → dep-f94b-k0u.js} +10 -10
  10. package/dist/node/chunks/{dep-CVQJZ3QI.js → dep-ll8ogJMK.js} +1 -1
  11. package/dist/node/cli.js +6 -6
  12. package/dist/node/index.js +1 -1
  13. package/dist/node/module-runner.js +13 -13
  14. package/package.json +6 -6
package/dist/node/chunks/{dep-BeiFehmI.js → dep-V5uAjiuB.js} RENAMED
@@ -500,7 +500,7 @@ var EntityDecoder = class {
500
500
  */
501
501
  write(input, offset) {
502
502
  switch (this.state) {
503
- case EntityDecoderState.EntityStart: {
503
+ case EntityDecoderState.EntityStart:
504
504
  if (input.charCodeAt(offset) === CharCodes.NUM) {
505
505
  this.state = EntityDecoderState.NumericStart;
506
506
  this.consumed += 1;
@@ -508,7 +508,6 @@ var EntityDecoder = class {
508
508
  }
509
509
  this.state = EntityDecoderState.NamedEntity;
510
510
  return this.stateNamedEntity(input, offset);
511
- }
512
511
  case EntityDecoderState.NumericStart: return this.stateNumericStart(input, offset);
513
512
  case EntityDecoderState.NumericDecimal: return this.stateNumericDecimal(input, offset);
514
513
  case EntityDecoderState.NumericHex: return this.stateNumericHex(input, offset);
@@ -684,10 +683,9 @@ var EntityDecoder = class {
684
683
  case EntityDecoderState.NamedEntity: return this.result !== 0 && (this.decodeMode !== DecodingMode.Attribute || this.result === this.treeIndex) ? this.emitNotTerminatedNamedEntity() : 0;
685
684
  case EntityDecoderState.NumericDecimal: return this.emitNumericEntity(0, 2);
686
685
  case EntityDecoderState.NumericHex: return this.emitNumericEntity(0, 3);
687
- case EntityDecoderState.NumericStart: {
686
+ case EntityDecoderState.NumericStart:
688
687
  (_a$1 = this.errors) === null || _a$1 === void 0 || _a$1.absenceOfDigitsInNumericCharacterReference(this.consumed);
689
688
  return 0;
690
- }
691
689
  case EntityDecoderState.EntityStart: return 0;
692
690
  }
693
691
  }
@@ -1610,18 +1608,15 @@ var Tokenizer = class {
1610
1608
  this.currentCharacterToken.location.endOffset = nextLocation.startOffset;
1611
1609
  }
1612
1610
  switch (this.currentCharacterToken.type) {
1613
- case TokenType.CHARACTER: {
1611
+ case TokenType.CHARACTER:
1614
1612
  this.handler.onCharacter(this.currentCharacterToken);
1615
1613
  break;
1616
- }
1617
- case TokenType.NULL_CHARACTER: {
1614
+ case TokenType.NULL_CHARACTER:
1618
1615
  this.handler.onNullCharacter(this.currentCharacterToken);
1619
1616
  break;
1620
- }
1621
- case TokenType.WHITESPACE_CHARACTER: {
1617
+ case TokenType.WHITESPACE_CHARACTER:
1622
1618
  this.handler.onWhitespaceCharacter(this.currentCharacterToken);
1623
1619
  break;
1624
- }
1625
1620
  }
1626
1621
  this.currentCharacterToken = null;
1627
1622
  }
@@ -1673,392 +1668,303 @@ var Tokenizer = class {
1673
1668
  }
1674
1669
  _callState(cp) {
1675
1670
  switch (this.state) {
1676
- case State.DATA: {
1671
+ case State.DATA:
1677
1672
  this._stateData(cp);
1678
1673
  break;
1679
- }
1680
- case State.RCDATA: {
1674
+ case State.RCDATA:
1681
1675
  this._stateRcdata(cp);
1682
1676
  break;
1683
- }
1684
- case State.RAWTEXT: {
1677
+ case State.RAWTEXT:
1685
1678
  this._stateRawtext(cp);
1686
1679
  break;
1687
- }
1688
- case State.SCRIPT_DATA: {
1680
+ case State.SCRIPT_DATA:
1689
1681
  this._stateScriptData(cp);
1690
1682
  break;
1691
- }
1692
- case State.PLAINTEXT: {
1683
+ case State.PLAINTEXT:
1693
1684
  this._statePlaintext(cp);
1694
1685
  break;
1695
- }
1696
- case State.TAG_OPEN: {
1686
+ case State.TAG_OPEN:
1697
1687
  this._stateTagOpen(cp);
1698
1688
  break;
1699
- }
1700
- case State.END_TAG_OPEN: {
1689
+ case State.END_TAG_OPEN:
1701
1690
  this._stateEndTagOpen(cp);
1702
1691
  break;
1703
- }
1704
- case State.TAG_NAME: {
1692
+ case State.TAG_NAME:
1705
1693
  this._stateTagName(cp);
1706
1694
  break;
1707
- }
1708
- case State.RCDATA_LESS_THAN_SIGN: {
1695
+ case State.RCDATA_LESS_THAN_SIGN:
1709
1696
  this._stateRcdataLessThanSign(cp);
1710
1697
  break;
1711
- }
1712
- case State.RCDATA_END_TAG_OPEN: {
1698
+ case State.RCDATA_END_TAG_OPEN:
1713
1699
  this._stateRcdataEndTagOpen(cp);
1714
1700
  break;
1715
- }
1716
- case State.RCDATA_END_TAG_NAME: {
1701
+ case State.RCDATA_END_TAG_NAME:
1717
1702
  this._stateRcdataEndTagName(cp);
1718
1703
  break;
1719
- }
1720
- case State.RAWTEXT_LESS_THAN_SIGN: {
1704
+ case State.RAWTEXT_LESS_THAN_SIGN:
1721
1705
  this._stateRawtextLessThanSign(cp);
1722
1706
  break;
1723
- }
1724
- case State.RAWTEXT_END_TAG_OPEN: {
1707
+ case State.RAWTEXT_END_TAG_OPEN:
1725
1708
  this._stateRawtextEndTagOpen(cp);
1726
1709
  break;
1727
- }
1728
- case State.RAWTEXT_END_TAG_NAME: {
1710
+ case State.RAWTEXT_END_TAG_NAME:
1729
1711
  this._stateRawtextEndTagName(cp);
1730
1712
  break;
1731
- }
1732
- case State.SCRIPT_DATA_LESS_THAN_SIGN: {
1713
+ case State.SCRIPT_DATA_LESS_THAN_SIGN:
1733
1714
  this._stateScriptDataLessThanSign(cp);
1734
1715
  break;
1735
- }
1736
- case State.SCRIPT_DATA_END_TAG_OPEN: {
1716
+ case State.SCRIPT_DATA_END_TAG_OPEN:
1737
1717
  this._stateScriptDataEndTagOpen(cp);
1738
1718
  break;
1739
- }
1740
- case State.SCRIPT_DATA_END_TAG_NAME: {
1719
+ case State.SCRIPT_DATA_END_TAG_NAME:
1741
1720
  this._stateScriptDataEndTagName(cp);
1742
1721
  break;
1743
- }
1744
- case State.SCRIPT_DATA_ESCAPE_START: {
1722
+ case State.SCRIPT_DATA_ESCAPE_START:
1745
1723
  this._stateScriptDataEscapeStart(cp);
1746
1724
  break;
1747
- }
1748
- case State.SCRIPT_DATA_ESCAPE_START_DASH: {
1725
+ case State.SCRIPT_DATA_ESCAPE_START_DASH:
1749
1726
  this._stateScriptDataEscapeStartDash(cp);
1750
1727
  break;
1751
- }
1752
- case State.SCRIPT_DATA_ESCAPED: {
1728
+ case State.SCRIPT_DATA_ESCAPED:
1753
1729
  this._stateScriptDataEscaped(cp);
1754
1730
  break;
1755
- }
1756
- case State.SCRIPT_DATA_ESCAPED_DASH: {
1731
+ case State.SCRIPT_DATA_ESCAPED_DASH:
1757
1732
  this._stateScriptDataEscapedDash(cp);
1758
1733
  break;
1759
- }
1760
- case State.SCRIPT_DATA_ESCAPED_DASH_DASH: {
1734
+ case State.SCRIPT_DATA_ESCAPED_DASH_DASH:
1761
1735
  this._stateScriptDataEscapedDashDash(cp);
1762
1736
  break;
1763
- }
1764
- case State.SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN: {
1737
+ case State.SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN:
1765
1738
  this._stateScriptDataEscapedLessThanSign(cp);
1766
1739
  break;
1767
- }
1768
- case State.SCRIPT_DATA_ESCAPED_END_TAG_OPEN: {
1740
+ case State.SCRIPT_DATA_ESCAPED_END_TAG_OPEN:
1769
1741
  this._stateScriptDataEscapedEndTagOpen(cp);
1770
1742
  break;
1771
- }
1772
- case State.SCRIPT_DATA_ESCAPED_END_TAG_NAME: {
1743
+ case State.SCRIPT_DATA_ESCAPED_END_TAG_NAME:
1773
1744
  this._stateScriptDataEscapedEndTagName(cp);
1774
1745
  break;
1775
- }
1776
- case State.SCRIPT_DATA_DOUBLE_ESCAPE_START: {
1746
+ case State.SCRIPT_DATA_DOUBLE_ESCAPE_START:
1777
1747
  this._stateScriptDataDoubleEscapeStart(cp);
1778
1748
  break;
1779
- }
1780
- case State.SCRIPT_DATA_DOUBLE_ESCAPED: {
1749
+ case State.SCRIPT_DATA_DOUBLE_ESCAPED:
1781
1750
  this._stateScriptDataDoubleEscaped(cp);
1782
1751
  break;
1783
- }
1784
- case State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH: {
1752
+ case State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH:
1785
1753
  this._stateScriptDataDoubleEscapedDash(cp);
1786
1754
  break;
1787
- }
1788
- case State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH: {
1755
+ case State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH:
1789
1756
  this._stateScriptDataDoubleEscapedDashDash(cp);
1790
1757
  break;
1791
- }
1792
- case State.SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN: {
1758
+ case State.SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN:
1793
1759
  this._stateScriptDataDoubleEscapedLessThanSign(cp);
1794
1760
  break;
1795
- }
1796
- case State.SCRIPT_DATA_DOUBLE_ESCAPE_END: {
1761
+ case State.SCRIPT_DATA_DOUBLE_ESCAPE_END:
1797
1762
  this._stateScriptDataDoubleEscapeEnd(cp);
1798
1763
  break;
1799
- }
1800
- case State.BEFORE_ATTRIBUTE_NAME: {
1764
+ case State.BEFORE_ATTRIBUTE_NAME:
1801
1765
  this._stateBeforeAttributeName(cp);
1802
1766
  break;
1803
- }
1804
- case State.ATTRIBUTE_NAME: {
1767
+ case State.ATTRIBUTE_NAME:
1805
1768
  this._stateAttributeName(cp);
1806
1769
  break;
1807
- }
1808
- case State.AFTER_ATTRIBUTE_NAME: {
1770
+ case State.AFTER_ATTRIBUTE_NAME:
1809
1771
  this._stateAfterAttributeName(cp);
1810
1772
  break;
1811
- }
1812
- case State.BEFORE_ATTRIBUTE_VALUE: {
1773
+ case State.BEFORE_ATTRIBUTE_VALUE:
1813
1774
  this._stateBeforeAttributeValue(cp);
1814
1775
  break;
1815
- }
1816
- case State.ATTRIBUTE_VALUE_DOUBLE_QUOTED: {
1776
+ case State.ATTRIBUTE_VALUE_DOUBLE_QUOTED:
1817
1777
  this._stateAttributeValueDoubleQuoted(cp);
1818
1778
  break;
1819
- }
1820
- case State.ATTRIBUTE_VALUE_SINGLE_QUOTED: {
1779
+ case State.ATTRIBUTE_VALUE_SINGLE_QUOTED:
1821
1780
  this._stateAttributeValueSingleQuoted(cp);
1822
1781
  break;
1823
- }
1824
- case State.ATTRIBUTE_VALUE_UNQUOTED: {
1782
+ case State.ATTRIBUTE_VALUE_UNQUOTED:
1825
1783
  this._stateAttributeValueUnquoted(cp);
1826
1784
  break;
1827
- }
1828
- case State.AFTER_ATTRIBUTE_VALUE_QUOTED: {
1785
+ case State.AFTER_ATTRIBUTE_VALUE_QUOTED:
1829
1786
  this._stateAfterAttributeValueQuoted(cp);
1830
1787
  break;
1831
- }
1832
- case State.SELF_CLOSING_START_TAG: {
1788
+ case State.SELF_CLOSING_START_TAG:
1833
1789
  this._stateSelfClosingStartTag(cp);
1834
1790
  break;
1835
- }
1836
- case State.BOGUS_COMMENT: {
1791
+ case State.BOGUS_COMMENT:
1837
1792
  this._stateBogusComment(cp);
1838
1793
  break;
1839
- }
1840
- case State.MARKUP_DECLARATION_OPEN: {
1794
+ case State.MARKUP_DECLARATION_OPEN:
1841
1795
  this._stateMarkupDeclarationOpen(cp);
1842
1796
  break;
1843
- }
1844
- case State.COMMENT_START: {
1797
+ case State.COMMENT_START:
1845
1798
  this._stateCommentStart(cp);
1846
1799
  break;
1847
- }
1848
- case State.COMMENT_START_DASH: {
1800
+ case State.COMMENT_START_DASH:
1849
1801
  this._stateCommentStartDash(cp);
1850
1802
  break;
1851
- }
1852
- case State.COMMENT: {
1803
+ case State.COMMENT:
1853
1804
  this._stateComment(cp);
1854
1805
  break;
1855
- }
1856
- case State.COMMENT_LESS_THAN_SIGN: {
1806
+ case State.COMMENT_LESS_THAN_SIGN:
1857
1807
  this._stateCommentLessThanSign(cp);
1858
1808
  break;
1859
- }
1860
- case State.COMMENT_LESS_THAN_SIGN_BANG: {
1809
+ case State.COMMENT_LESS_THAN_SIGN_BANG:
1861
1810
  this._stateCommentLessThanSignBang(cp);
1862
1811
  break;
1863
- }
1864
- case State.COMMENT_LESS_THAN_SIGN_BANG_DASH: {
1812
+ case State.COMMENT_LESS_THAN_SIGN_BANG_DASH:
1865
1813
  this._stateCommentLessThanSignBangDash(cp);
1866
1814
  break;
1867
- }
1868
- case State.COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH: {
1815
+ case State.COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH:
1869
1816
  this._stateCommentLessThanSignBangDashDash(cp);
1870
1817
  break;
1871
- }
1872
- case State.COMMENT_END_DASH: {
1818
+ case State.COMMENT_END_DASH:
1873
1819
  this._stateCommentEndDash(cp);
1874
1820
  break;
1875
- }
1876
- case State.COMMENT_END: {
1821
+ case State.COMMENT_END:
1877
1822
  this._stateCommentEnd(cp);
1878
1823
  break;
1879
- }
1880
- case State.COMMENT_END_BANG: {
1824
+ case State.COMMENT_END_BANG:
1881
1825
  this._stateCommentEndBang(cp);
1882
1826
  break;
1883
- }
1884
- case State.DOCTYPE: {
1827
+ case State.DOCTYPE:
1885
1828
  this._stateDoctype(cp);
1886
1829
  break;
1887
- }
1888
- case State.BEFORE_DOCTYPE_NAME: {
1830
+ case State.BEFORE_DOCTYPE_NAME:
1889
1831
  this._stateBeforeDoctypeName(cp);
1890
1832
  break;
1891
- }
1892
- case State.DOCTYPE_NAME: {
1833
+ case State.DOCTYPE_NAME:
1893
1834
  this._stateDoctypeName(cp);
1894
1835
  break;
1895
- }
1896
- case State.AFTER_DOCTYPE_NAME: {
1836
+ case State.AFTER_DOCTYPE_NAME:
1897
1837
  this._stateAfterDoctypeName(cp);
1898
1838
  break;
1899
- }
1900
- case State.AFTER_DOCTYPE_PUBLIC_KEYWORD: {
1839
+ case State.AFTER_DOCTYPE_PUBLIC_KEYWORD:
1901
1840
  this._stateAfterDoctypePublicKeyword(cp);
1902
1841
  break;
1903
- }
1904
- case State.BEFORE_DOCTYPE_PUBLIC_IDENTIFIER: {
1842
+ case State.BEFORE_DOCTYPE_PUBLIC_IDENTIFIER:
1905
1843
  this._stateBeforeDoctypePublicIdentifier(cp);
1906
1844
  break;
1907
- }
1908
- case State.DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED: {
1845
+ case State.DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED:
1909
1846
  this._stateDoctypePublicIdentifierDoubleQuoted(cp);
1910
1847
  break;
1911
- }
1912
- case State.DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED: {
1848
+ case State.DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED:
1913
1849
  this._stateDoctypePublicIdentifierSingleQuoted(cp);
1914
1850
  break;
1915
- }
1916
- case State.AFTER_DOCTYPE_PUBLIC_IDENTIFIER: {
1851
+ case State.AFTER_DOCTYPE_PUBLIC_IDENTIFIER:
1917
1852
  this._stateAfterDoctypePublicIdentifier(cp);
1918
1853
  break;
1919
- }
1920
- case State.BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS: {
1854
+ case State.BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS:
1921
1855
  this._stateBetweenDoctypePublicAndSystemIdentifiers(cp);
1922
1856
  break;
1923
- }
1924
- case State.AFTER_DOCTYPE_SYSTEM_KEYWORD: {
1857
+ case State.AFTER_DOCTYPE_SYSTEM_KEYWORD:
1925
1858
  this._stateAfterDoctypeSystemKeyword(cp);
1926
1859
  break;
1927
- }
1928
- case State.BEFORE_DOCTYPE_SYSTEM_IDENTIFIER: {
1860
+ case State.BEFORE_DOCTYPE_SYSTEM_IDENTIFIER:
1929
1861
  this._stateBeforeDoctypeSystemIdentifier(cp);
1930
1862
  break;
1931
- }
1932
- case State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED: {
1863
+ case State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED:
1933
1864
  this._stateDoctypeSystemIdentifierDoubleQuoted(cp);
1934
1865
  break;
1935
- }
1936
- case State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED: {
1866
+ case State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED:
1937
1867
  this._stateDoctypeSystemIdentifierSingleQuoted(cp);
1938
1868
  break;
1939
- }
1940
- case State.AFTER_DOCTYPE_SYSTEM_IDENTIFIER: {
1869
+ case State.AFTER_DOCTYPE_SYSTEM_IDENTIFIER:
1941
1870
  this._stateAfterDoctypeSystemIdentifier(cp);
1942
1871
  break;
1943
- }
1944
- case State.BOGUS_DOCTYPE: {
1872
+ case State.BOGUS_DOCTYPE:
1945
1873
  this._stateBogusDoctype(cp);
1946
1874
  break;
1947
- }
1948
- case State.CDATA_SECTION: {
1875
+ case State.CDATA_SECTION:
1949
1876
  this._stateCdataSection(cp);
1950
1877
  break;
1951
- }
1952
- case State.CDATA_SECTION_BRACKET: {
1878
+ case State.CDATA_SECTION_BRACKET:
1953
1879
  this._stateCdataSectionBracket(cp);
1954
1880
  break;
1955
- }
1956
- case State.CDATA_SECTION_END: {
1881
+ case State.CDATA_SECTION_END:
1957
1882
  this._stateCdataSectionEnd(cp);
1958
1883
  break;
1959
- }
1960
- case State.CHARACTER_REFERENCE: {
1884
+ case State.CHARACTER_REFERENCE:
1961
1885
  this._stateCharacterReference();
1962
1886
  break;
1963
- }
1964
- case State.AMBIGUOUS_AMPERSAND: {
1887
+ case State.AMBIGUOUS_AMPERSAND:
1965
1888
  this._stateAmbiguousAmpersand(cp);
1966
1889
  break;
1967
- }
1968
1890
  default: throw new Error("Unknown state");
1969
1891
  }
1970
1892
  }
1971
1893
  _stateData(cp) {
1972
1894
  switch (cp) {
1973
- case CODE_POINTS.LESS_THAN_SIGN: {
1895
+ case CODE_POINTS.LESS_THAN_SIGN:
1974
1896
  this.state = State.TAG_OPEN;
1975
1897
  break;
1976
- }
1977
- case CODE_POINTS.AMPERSAND: {
1898
+ case CODE_POINTS.AMPERSAND:
1978
1899
  this._startCharacterReference();
1979
1900
  break;
1980
- }
1981
- case CODE_POINTS.NULL: {
1901
+ case CODE_POINTS.NULL:
1982
1902
  this._err(ERR.unexpectedNullCharacter);
1983
1903
  this._emitCodePoint(cp);
1984
1904
  break;
1985
- }
1986
- case CODE_POINTS.EOF: {
1905
+ case CODE_POINTS.EOF:
1987
1906
  this._emitEOFToken();
1988
1907
  break;
1989
- }
1990
1908
  default: this._emitCodePoint(cp);
1991
1909
  }
1992
1910
  }
1993
1911
  _stateRcdata(cp) {
1994
1912
  switch (cp) {
1995
- case CODE_POINTS.AMPERSAND: {
1913
+ case CODE_POINTS.AMPERSAND:
1996
1914
  this._startCharacterReference();
1997
1915
  break;
1998
- }
1999
- case CODE_POINTS.LESS_THAN_SIGN: {
1916
+ case CODE_POINTS.LESS_THAN_SIGN:
2000
1917
  this.state = State.RCDATA_LESS_THAN_SIGN;
2001
1918
  break;
2002
- }
2003
- case CODE_POINTS.NULL: {
1919
+ case CODE_POINTS.NULL:
2004
1920
  this._err(ERR.unexpectedNullCharacter);
2005
1921
  this._emitChars(REPLACEMENT_CHARACTER);
2006
1922
  break;
2007
- }
2008
- case CODE_POINTS.EOF: {
1923
+ case CODE_POINTS.EOF:
2009
1924
  this._emitEOFToken();
2010
1925
  break;
2011
- }
2012
1926
  default: this._emitCodePoint(cp);
2013
1927
  }
2014
1928
  }
2015
1929
  _stateRawtext(cp) {
2016
1930
  switch (cp) {
2017
- case CODE_POINTS.LESS_THAN_SIGN: {
1931
+ case CODE_POINTS.LESS_THAN_SIGN:
2018
1932
  this.state = State.RAWTEXT_LESS_THAN_SIGN;
2019
1933
  break;
2020
- }
2021
- case CODE_POINTS.NULL: {
1934
+ case CODE_POINTS.NULL:
2022
1935
  this._err(ERR.unexpectedNullCharacter);
2023
1936
  this._emitChars(REPLACEMENT_CHARACTER);
2024
1937
  break;
2025
- }
2026
- case CODE_POINTS.EOF: {
1938
+ case CODE_POINTS.EOF:
2027
1939
  this._emitEOFToken();
2028
1940
  break;
2029
- }
2030
1941
  default: this._emitCodePoint(cp);
2031
1942
  }
2032
1943
  }
2033
1944
  _stateScriptData(cp) {
2034
1945
  switch (cp) {
2035
- case CODE_POINTS.LESS_THAN_SIGN: {
1946
+ case CODE_POINTS.LESS_THAN_SIGN:
2036
1947
  this.state = State.SCRIPT_DATA_LESS_THAN_SIGN;
2037
1948
  break;
2038
- }
2039
- case CODE_POINTS.NULL: {
1949
+ case CODE_POINTS.NULL:
2040
1950
  this._err(ERR.unexpectedNullCharacter);
2041
1951
  this._emitChars(REPLACEMENT_CHARACTER);
2042
1952
  break;
2043
- }
2044
- case CODE_POINTS.EOF: {
1953
+ case CODE_POINTS.EOF:
2045
1954
  this._emitEOFToken();
2046
1955
  break;
2047
- }
2048
1956
  default: this._emitCodePoint(cp);
2049
1957
  }
2050
1958
  }
2051
1959
  _statePlaintext(cp) {
2052
1960
  switch (cp) {
2053
- case CODE_POINTS.NULL: {
1961
+ case CODE_POINTS.NULL:
2054
1962
  this._err(ERR.unexpectedNullCharacter);
2055
1963
  this._emitChars(REPLACEMENT_CHARACTER);
2056
1964
  break;
2057
- }
2058
- case CODE_POINTS.EOF: {
1965
+ case CODE_POINTS.EOF:
2059
1966
  this._emitEOFToken();
2060
1967
  break;
2061
- }
2062
1968
  default: this._emitCodePoint(cp);
2063
1969
  }
2064
1970
  }
@@ -2068,33 +1974,28 @@ var Tokenizer = class {
2068
1974
  this.state = State.TAG_NAME;
2069
1975
  this._stateTagName(cp);
2070
1976
  } else switch (cp) {
2071
- case CODE_POINTS.EXCLAMATION_MARK: {
1977
+ case CODE_POINTS.EXCLAMATION_MARK:
2072
1978
  this.state = State.MARKUP_DECLARATION_OPEN;
2073
1979
  break;
2074
- }
2075
- case CODE_POINTS.SOLIDUS: {
1980
+ case CODE_POINTS.SOLIDUS:
2076
1981
  this.state = State.END_TAG_OPEN;
2077
1982
  break;
2078
- }
2079
- case CODE_POINTS.QUESTION_MARK: {
1983
+ case CODE_POINTS.QUESTION_MARK:
2080
1984
  this._err(ERR.unexpectedQuestionMarkInsteadOfTagName);
2081
1985
  this._createCommentToken(1);
2082
1986
  this.state = State.BOGUS_COMMENT;
2083
1987
  this._stateBogusComment(cp);
2084
1988
  break;
2085
- }
2086
- case CODE_POINTS.EOF: {
1989
+ case CODE_POINTS.EOF:
2087
1990
  this._err(ERR.eofBeforeTagName);
2088
1991
  this._emitChars("<");
2089
1992
  this._emitEOFToken();
2090
1993
  break;
2091
- }
2092
- default: {
1994
+ default:
2093
1995
  this._err(ERR.invalidFirstCharacterOfTagName);
2094
1996
  this._emitChars("<");
2095
1997
  this.state = State.DATA;
2096
1998
  this._stateData(cp);
2097
- }
2098
1999
  }
2099
2000
  }
2100
2001
  _stateEndTagOpen(cp) {
@@ -2103,23 +2004,20 @@ var Tokenizer = class {
2103
2004
  this.state = State.TAG_NAME;
2104
2005
  this._stateTagName(cp);
2105
2006
  } else switch (cp) {
2106
- case CODE_POINTS.GREATER_THAN_SIGN: {
2007
+ case CODE_POINTS.GREATER_THAN_SIGN:
2107
2008
  this._err(ERR.missingEndTagName);
2108
2009
  this.state = State.DATA;
2109
2010
  break;
2110
- }
2111
- case CODE_POINTS.EOF: {
2011
+ case CODE_POINTS.EOF:
2112
2012
  this._err(ERR.eofBeforeTagName);
2113
2013
  this._emitChars("</");
2114
2014
  this._emitEOFToken();
2115
2015
  break;
2116
- }
2117
- default: {
2016
+ default:
2118
2017
  this._err(ERR.invalidFirstCharacterOfTagName);
2119
2018
  this._createCommentToken(2);
2120
2019
  this.state = State.BOGUS_COMMENT;
2121
2020
  this._stateBogusComment(cp);
2122
- }
2123
2021
  }
2124
2022
  }
2125
2023
  _stateTagName(cp) {
@@ -2128,29 +2026,24 @@ var Tokenizer = class {
2128
2026
  case CODE_POINTS.SPACE:
2129
2027
  case CODE_POINTS.LINE_FEED:
2130
2028
  case CODE_POINTS.TABULATION:
2131
- case CODE_POINTS.FORM_FEED: {
2029
+ case CODE_POINTS.FORM_FEED:
2132
2030
  this.state = State.BEFORE_ATTRIBUTE_NAME;
2133
2031
  break;
2134
- }
2135
- case CODE_POINTS.SOLIDUS: {
2032
+ case CODE_POINTS.SOLIDUS:
2136
2033
  this.state = State.SELF_CLOSING_START_TAG;
2137
2034
  break;
2138
- }
2139
- case CODE_POINTS.GREATER_THAN_SIGN: {
2035
+ case CODE_POINTS.GREATER_THAN_SIGN:
2140
2036
  this.state = State.DATA;
2141
2037
  this.emitCurrentTagToken();
2142
2038
  break;
2143
- }
2144
- case CODE_POINTS.NULL: {
2039
+ case CODE_POINTS.NULL:
2145
2040
  this._err(ERR.unexpectedNullCharacter);
2146
2041
  token.tagName += REPLACEMENT_CHARACTER;
2147
2042
  break;
2148
- }
2149
- case CODE_POINTS.EOF: {
2043
+ case CODE_POINTS.EOF:
2150
2044
  this._err(ERR.eofInTag);
2151
2045
  this._emitEOFToken();
2152
2046
  break;
2153
- }
2154
2047
  default: token.tagName += String.fromCodePoint(isAsciiUpper(cp) ? toAsciiLower(cp) : cp);
2155
2048
  }
2156
2049
  }
@@ -2182,22 +2075,19 @@ var Tokenizer = class {
2182
2075
  case CODE_POINTS.SPACE:
2183
2076
  case CODE_POINTS.LINE_FEED:
2184
2077
  case CODE_POINTS.TABULATION:
2185
- case CODE_POINTS.FORM_FEED: {
2078
+ case CODE_POINTS.FORM_FEED:
2186
2079
  this._advanceBy(this.lastStartTagName.length);
2187
2080
  this.state = State.BEFORE_ATTRIBUTE_NAME;
2188
2081
  return false;
2189
- }
2190
- case CODE_POINTS.SOLIDUS: {
2082
+ case CODE_POINTS.SOLIDUS:
2191
2083
  this._advanceBy(this.lastStartTagName.length);
2192
2084
  this.state = State.SELF_CLOSING_START_TAG;
2193
2085
  return false;
2194
- }
2195
- case CODE_POINTS.GREATER_THAN_SIGN: {
2086
+ case CODE_POINTS.GREATER_THAN_SIGN:
2196
2087
  this._advanceBy(this.lastStartTagName.length);
2197
2088
  this.emitCurrentTagToken();
2198
2089
  this.state = State.DATA;
2199
2090
  return false;
2200
- }
2201
2091
  default: return !this._ensureHibernation();
2202
2092
  }
2203
2093
  }
@@ -2235,20 +2125,17 @@ var Tokenizer = class {
2235
2125
  }
2236
2126
  _stateScriptDataLessThanSign(cp) {
2237
2127
  switch (cp) {
2238
- case CODE_POINTS.SOLIDUS: {
2128
+ case CODE_POINTS.SOLIDUS:
2239
2129
  this.state = State.SCRIPT_DATA_END_TAG_OPEN;
2240
2130
  break;
2241
- }
2242
- case CODE_POINTS.EXCLAMATION_MARK: {
2131
+ case CODE_POINTS.EXCLAMATION_MARK:
2243
2132
  this.state = State.SCRIPT_DATA_ESCAPE_START;
2244
2133
  this._emitChars("<!");
2245
2134
  break;
2246
- }
2247
- default: {
2135
+ default:
2248
2136
  this._emitChars("<");
2249
2137
  this.state = State.SCRIPT_DATA;
2250
2138
  this._stateScriptData(cp);
2251
- }
2252
2139
  }
2253
2140
  }
2254
2141
  _stateScriptDataEndTagOpen(cp) {
@@ -2288,86 +2175,71 @@ var Tokenizer = class {
2288
2175
  }
2289
2176
  _stateScriptDataEscaped(cp) {
2290
2177
  switch (cp) {
2291
- case CODE_POINTS.HYPHEN_MINUS: {
2178
+ case CODE_POINTS.HYPHEN_MINUS:
2292
2179
  this.state = State.SCRIPT_DATA_ESCAPED_DASH;
2293
2180
  this._emitChars("-");
2294
2181
  break;
2295
- }
2296
- case CODE_POINTS.LESS_THAN_SIGN: {
2182
+ case CODE_POINTS.LESS_THAN_SIGN:
2297
2183
  this.state = State.SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN;
2298
2184
  break;
2299
- }
2300
- case CODE_POINTS.NULL: {
2185
+ case CODE_POINTS.NULL:
2301
2186
  this._err(ERR.unexpectedNullCharacter);
2302
2187
  this._emitChars(REPLACEMENT_CHARACTER);
2303
2188
  break;
2304
- }
2305
- case CODE_POINTS.EOF: {
2189
+ case CODE_POINTS.EOF:
2306
2190
  this._err(ERR.eofInScriptHtmlCommentLikeText);
2307
2191
  this._emitEOFToken();
2308
2192
  break;
2309
- }
2310
2193
  default: this._emitCodePoint(cp);
2311
2194
  }
2312
2195
  }
2313
2196
  _stateScriptDataEscapedDash(cp) {
2314
2197
  switch (cp) {
2315
- case CODE_POINTS.HYPHEN_MINUS: {
2198
+ case CODE_POINTS.HYPHEN_MINUS:
2316
2199
  this.state = State.SCRIPT_DATA_ESCAPED_DASH_DASH;
2317
2200
  this._emitChars("-");
2318
2201
  break;
2319
- }
2320
- case CODE_POINTS.LESS_THAN_SIGN: {
2202
+ case CODE_POINTS.LESS_THAN_SIGN:
2321
2203
  this.state = State.SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN;
2322
2204
  break;
2323
- }
2324
- case CODE_POINTS.NULL: {
2205
+ case CODE_POINTS.NULL:
2325
2206
  this._err(ERR.unexpectedNullCharacter);
2326
2207
  this.state = State.SCRIPT_DATA_ESCAPED;
2327
2208
  this._emitChars(REPLACEMENT_CHARACTER);
2328
2209
  break;
2329
- }
2330
- case CODE_POINTS.EOF: {
2210
+ case CODE_POINTS.EOF:
2331
2211
  this._err(ERR.eofInScriptHtmlCommentLikeText);
2332
2212
  this._emitEOFToken();
2333
2213
  break;
2334
- }
2335
- default: {
2214
+ default:
2336
2215
  this.state = State.SCRIPT_DATA_ESCAPED;
2337
2216
  this._emitCodePoint(cp);
2338
- }
2339
2217
  }
2340
2218
  }
2341
2219
  _stateScriptDataEscapedDashDash(cp) {
2342
2220
  switch (cp) {
2343
- case CODE_POINTS.HYPHEN_MINUS: {
2221
+ case CODE_POINTS.HYPHEN_MINUS:
2344
2222
  this._emitChars("-");
2345
2223
  break;
2346
- }
2347
- case CODE_POINTS.LESS_THAN_SIGN: {
2224
+ case CODE_POINTS.LESS_THAN_SIGN:
2348
2225
  this.state = State.SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN;
2349
2226
  break;
2350
- }
2351
- case CODE_POINTS.GREATER_THAN_SIGN: {
2227
+ case CODE_POINTS.GREATER_THAN_SIGN:
2352
2228
  this.state = State.SCRIPT_DATA;
2353
2229
  this._emitChars(">");
2354
2230
  break;
2355
- }
2356
- case CODE_POINTS.NULL: {
2231
+ case CODE_POINTS.NULL:
2357
2232
  this._err(ERR.unexpectedNullCharacter);
2358
2233
  this.state = State.SCRIPT_DATA_ESCAPED;
2359
2234
  this._emitChars(REPLACEMENT_CHARACTER);
2360
2235
  break;
2361
- }
2362
- case CODE_POINTS.EOF: {
2236
+ case CODE_POINTS.EOF:
2363
2237
  this._err(ERR.eofInScriptHtmlCommentLikeText);
2364
2238
  this._emitEOFToken();
2365
2239
  break;
2366
- }
2367
- default: {
2240
+ default:
2368
2241
  this.state = State.SCRIPT_DATA_ESCAPED;
2369
2242
  this._emitCodePoint(cp);
2370
- }
2371
2243
  }
2372
2244
  }
2373
2245
  _stateScriptDataEscapedLessThanSign(cp) {
@@ -2411,89 +2283,74 @@ var Tokenizer = class {
2411
2283
  }
2412
2284
  _stateScriptDataDoubleEscaped(cp) {
2413
2285
  switch (cp) {
2414
- case CODE_POINTS.HYPHEN_MINUS: {
2286
+ case CODE_POINTS.HYPHEN_MINUS:
2415
2287
  this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH;
2416
2288
  this._emitChars("-");
2417
2289
  break;
2418
- }
2419
- case CODE_POINTS.LESS_THAN_SIGN: {
2290
+ case CODE_POINTS.LESS_THAN_SIGN:
2420
2291
  this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN;
2421
2292
  this._emitChars("<");
2422
2293
  break;
2423
- }
2424
- case CODE_POINTS.NULL: {
2294
+ case CODE_POINTS.NULL:
2425
2295
  this._err(ERR.unexpectedNullCharacter);
2426
2296
  this._emitChars(REPLACEMENT_CHARACTER);
2427
2297
  break;
2428
- }
2429
- case CODE_POINTS.EOF: {
2298
+ case CODE_POINTS.EOF:
2430
2299
  this._err(ERR.eofInScriptHtmlCommentLikeText);
2431
2300
  this._emitEOFToken();
2432
2301
  break;
2433
- }
2434
2302
  default: this._emitCodePoint(cp);
2435
2303
  }
2436
2304
  }
2437
2305
  _stateScriptDataDoubleEscapedDash(cp) {
2438
2306
  switch (cp) {
2439
- case CODE_POINTS.HYPHEN_MINUS: {
2307
+ case CODE_POINTS.HYPHEN_MINUS:
2440
2308
  this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH;
2441
2309
  this._emitChars("-");
2442
2310
  break;
2443
- }
2444
- case CODE_POINTS.LESS_THAN_SIGN: {
2311
+ case CODE_POINTS.LESS_THAN_SIGN:
2445
2312
  this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN;
2446
2313
  this._emitChars("<");
2447
2314
  break;
2448
- }
2449
- case CODE_POINTS.NULL: {
2315
+ case CODE_POINTS.NULL:
2450
2316
  this._err(ERR.unexpectedNullCharacter);
2451
2317
  this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;
2452
2318
  this._emitChars(REPLACEMENT_CHARACTER);
2453
2319
  break;
2454
- }
2455
- case CODE_POINTS.EOF: {
2320
+ case CODE_POINTS.EOF:
2456
2321
  this._err(ERR.eofInScriptHtmlCommentLikeText);
2457
2322
  this._emitEOFToken();
2458
2323
  break;
2459
- }
2460
- default: {
2324
+ default:
2461
2325
  this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;
2462
2326
  this._emitCodePoint(cp);
2463
- }
2464
2327
  }
2465
2328
  }
2466
2329
  _stateScriptDataDoubleEscapedDashDash(cp) {
2467
2330
  switch (cp) {
2468
- case CODE_POINTS.HYPHEN_MINUS: {
2331
+ case CODE_POINTS.HYPHEN_MINUS:
2469
2332
  this._emitChars("-");
2470
2333
  break;
2471
- }
2472
- case CODE_POINTS.LESS_THAN_SIGN: {
2334
+ case CODE_POINTS.LESS_THAN_SIGN:
2473
2335
  this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN;
2474
2336
  this._emitChars("<");
2475
2337
  break;
2476
- }
2477
- case CODE_POINTS.GREATER_THAN_SIGN: {
2338
+ case CODE_POINTS.GREATER_THAN_SIGN:
2478
2339
  this.state = State.SCRIPT_DATA;
2479
2340
  this._emitChars(">");
2480
2341
  break;
2481
- }
2482
- case CODE_POINTS.NULL: {
2342
+ case CODE_POINTS.NULL:
2483
2343
  this._err(ERR.unexpectedNullCharacter);
2484
2344
  this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;
2485
2345
  this._emitChars(REPLACEMENT_CHARACTER);
2486
2346
  break;
2487
- }
2488
- case CODE_POINTS.EOF: {
2347
+ case CODE_POINTS.EOF:
2489
2348
  this._err(ERR.eofInScriptHtmlCommentLikeText);
2490
2349
  this._emitEOFToken();
2491
2350
  break;
2492
- }
2493
- default: {
2351
+ default:
2494
2352
  this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;
2495
2353
  this._emitCodePoint(cp);
2496
- }
2497
2354
  }
2498
2355
  }
2499
2356
  _stateScriptDataDoubleEscapedLessThanSign(cp) {
@@ -2523,22 +2380,19 @@ var Tokenizer = class {
2523
2380
  case CODE_POINTS.FORM_FEED: break;
2524
2381
  case CODE_POINTS.SOLIDUS:
2525
2382
  case CODE_POINTS.GREATER_THAN_SIGN:
2526
- case CODE_POINTS.EOF: {
2383
+ case CODE_POINTS.EOF:
2527
2384
  this.state = State.AFTER_ATTRIBUTE_NAME;
2528
2385
  this._stateAfterAttributeName(cp);
2529
2386
  break;
2530
- }
2531
- case CODE_POINTS.EQUALS_SIGN: {
2387
+ case CODE_POINTS.EQUALS_SIGN:
2532
2388
  this._err(ERR.unexpectedEqualsSignBeforeAttributeName);
2533
2389
  this._createAttr("=");
2534
2390
  this.state = State.ATTRIBUTE_NAME;
2535
2391
  break;
2536
- }
2537
- default: {
2392
+ default:
2538
2393
  this._createAttr("");
2539
2394
  this.state = State.ATTRIBUTE_NAME;
2540
2395
  this._stateAttributeName(cp);
2541
- }
2542
2396
  }
2543
2397
  }
2544
2398
  _stateAttributeName(cp) {
@@ -2549,29 +2403,25 @@ var Tokenizer = class {
2549
2403
  case CODE_POINTS.FORM_FEED:
2550
2404
  case CODE_POINTS.SOLIDUS:
2551
2405
  case CODE_POINTS.GREATER_THAN_SIGN:
2552
- case CODE_POINTS.EOF: {
2406
+ case CODE_POINTS.EOF:
2553
2407
  this._leaveAttrName();
2554
2408
  this.state = State.AFTER_ATTRIBUTE_NAME;
2555
2409
  this._stateAfterAttributeName(cp);
2556
2410
  break;
2557
- }
2558
- case CODE_POINTS.EQUALS_SIGN: {
2411
+ case CODE_POINTS.EQUALS_SIGN:
2559
2412
  this._leaveAttrName();
2560
2413
  this.state = State.BEFORE_ATTRIBUTE_VALUE;
2561
2414
  break;
2562
- }
2563
2415
  case CODE_POINTS.QUOTATION_MARK:
2564
2416
  case CODE_POINTS.APOSTROPHE:
2565
- case CODE_POINTS.LESS_THAN_SIGN: {
2417
+ case CODE_POINTS.LESS_THAN_SIGN:
2566
2418
  this._err(ERR.unexpectedCharacterInAttributeName);
2567
2419
  this.currentAttr.name += String.fromCodePoint(cp);
2568
2420
  break;
2569
- }
2570
- case CODE_POINTS.NULL: {
2421
+ case CODE_POINTS.NULL:
2571
2422
  this._err(ERR.unexpectedNullCharacter);
2572
2423
  this.currentAttr.name += REPLACEMENT_CHARACTER;
2573
2424
  break;
2574
- }
2575
2425
  default: this.currentAttr.name += String.fromCodePoint(isAsciiUpper(cp) ? toAsciiLower(cp) : cp);
2576
2426
  }
2577
2427
  }
@@ -2581,29 +2431,24 @@ var Tokenizer = class {
2581
2431
  case CODE_POINTS.LINE_FEED:
2582
2432
  case CODE_POINTS.TABULATION:
2583
2433
  case CODE_POINTS.FORM_FEED: break;
2584
- case CODE_POINTS.SOLIDUS: {
2434
+ case CODE_POINTS.SOLIDUS:
2585
2435
  this.state = State.SELF_CLOSING_START_TAG;
2586
2436
  break;
2587
- }
2588
- case CODE_POINTS.EQUALS_SIGN: {
2437
+ case CODE_POINTS.EQUALS_SIGN:
2589
2438
  this.state = State.BEFORE_ATTRIBUTE_VALUE;
2590
2439
  break;
2591
- }
2592
- case CODE_POINTS.GREATER_THAN_SIGN: {
2440
+ case CODE_POINTS.GREATER_THAN_SIGN:
2593
2441
  this.state = State.DATA;
2594
2442
  this.emitCurrentTagToken();
2595
2443
  break;
2596
- }
2597
- case CODE_POINTS.EOF: {
2444
+ case CODE_POINTS.EOF:
2598
2445
  this._err(ERR.eofInTag);
2599
2446
  this._emitEOFToken();
2600
2447
  break;
2601
- }
2602
- default: {
2448
+ default:
2603
2449
  this._createAttr("");
2604
2450
  this.state = State.ATTRIBUTE_NAME;
2605
2451
  this._stateAttributeName(cp);
2606
- }
2607
2452
  }
2608
2453
  }
2609
2454
  _stateBeforeAttributeValue(cp) {
@@ -2612,69 +2457,57 @@ var Tokenizer = class {
2612
2457
  case CODE_POINTS.LINE_FEED:
2613
2458
  case CODE_POINTS.TABULATION:
2614
2459
  case CODE_POINTS.FORM_FEED: break;
2615
- case CODE_POINTS.QUOTATION_MARK: {
2460
+ case CODE_POINTS.QUOTATION_MARK:
2616
2461
  this.state = State.ATTRIBUTE_VALUE_DOUBLE_QUOTED;
2617
2462
  break;
2618
- }
2619
- case CODE_POINTS.APOSTROPHE: {
2463
+ case CODE_POINTS.APOSTROPHE:
2620
2464
  this.state = State.ATTRIBUTE_VALUE_SINGLE_QUOTED;
2621
2465
  break;
2622
- }
2623
- case CODE_POINTS.GREATER_THAN_SIGN: {
2466
+ case CODE_POINTS.GREATER_THAN_SIGN:
2624
2467
  this._err(ERR.missingAttributeValue);
2625
2468
  this.state = State.DATA;
2626
2469
  this.emitCurrentTagToken();
2627
2470
  break;
2628
- }
2629
- default: {
2471
+ default:
2630
2472
  this.state = State.ATTRIBUTE_VALUE_UNQUOTED;
2631
2473
  this._stateAttributeValueUnquoted(cp);
2632
- }
2633
2474
  }
2634
2475
  }
2635
2476
  _stateAttributeValueDoubleQuoted(cp) {
2636
2477
  switch (cp) {
2637
- case CODE_POINTS.QUOTATION_MARK: {
2478
+ case CODE_POINTS.QUOTATION_MARK:
2638
2479
  this.state = State.AFTER_ATTRIBUTE_VALUE_QUOTED;
2639
2480
  break;
2640
- }
2641
- case CODE_POINTS.AMPERSAND: {
2481
+ case CODE_POINTS.AMPERSAND:
2642
2482
  this._startCharacterReference();
2643
2483
  break;
2644
- }
2645
- case CODE_POINTS.NULL: {
2484
+ case CODE_POINTS.NULL:
2646
2485
  this._err(ERR.unexpectedNullCharacter);
2647
2486
  this.currentAttr.value += REPLACEMENT_CHARACTER;
2648
2487
  break;
2649
- }
2650
- case CODE_POINTS.EOF: {
2488
+ case CODE_POINTS.EOF:
2651
2489
  this._err(ERR.eofInTag);
2652
2490
  this._emitEOFToken();
2653
2491
  break;
2654
- }
2655
2492
  default: this.currentAttr.value += String.fromCodePoint(cp);
2656
2493
  }
2657
2494
  }
2658
2495
  _stateAttributeValueSingleQuoted(cp) {
2659
2496
  switch (cp) {
2660
- case CODE_POINTS.APOSTROPHE: {
2497
+ case CODE_POINTS.APOSTROPHE:
2661
2498
  this.state = State.AFTER_ATTRIBUTE_VALUE_QUOTED;
2662
2499
  break;
2663
- }
2664
- case CODE_POINTS.AMPERSAND: {
2500
+ case CODE_POINTS.AMPERSAND:
2665
2501
  this._startCharacterReference();
2666
2502
  break;
2667
- }
2668
- case CODE_POINTS.NULL: {
2503
+ case CODE_POINTS.NULL:
2669
2504
  this._err(ERR.unexpectedNullCharacter);
2670
2505
  this.currentAttr.value += REPLACEMENT_CHARACTER;
2671
2506
  break;
2672
- }
2673
- case CODE_POINTS.EOF: {
2507
+ case CODE_POINTS.EOF:
2674
2508
  this._err(ERR.eofInTag);
2675
2509
  this._emitEOFToken();
2676
2510
  break;
2677
- }
2678
2511
  default: this.currentAttr.value += String.fromCodePoint(cp);
2679
2512
  }
2680
2513
  }
@@ -2683,40 +2516,34 @@ var Tokenizer = class {
2683
2516
  case CODE_POINTS.SPACE:
2684
2517
  case CODE_POINTS.LINE_FEED:
2685
2518
  case CODE_POINTS.TABULATION:
2686
- case CODE_POINTS.FORM_FEED: {
2519
+ case CODE_POINTS.FORM_FEED:
2687
2520
  this._leaveAttrValue();
2688
2521
  this.state = State.BEFORE_ATTRIBUTE_NAME;
2689
2522
  break;
2690
- }
2691
- case CODE_POINTS.AMPERSAND: {
2523
+ case CODE_POINTS.AMPERSAND:
2692
2524
  this._startCharacterReference();
2693
2525
  break;
2694
- }
2695
- case CODE_POINTS.GREATER_THAN_SIGN: {
2526
+ case CODE_POINTS.GREATER_THAN_SIGN:
2696
2527
  this._leaveAttrValue();
2697
2528
  this.state = State.DATA;
2698
2529
  this.emitCurrentTagToken();
2699
2530
  break;
2700
- }
2701
- case CODE_POINTS.NULL: {
2531
+ case CODE_POINTS.NULL:
2702
2532
  this._err(ERR.unexpectedNullCharacter);
2703
2533
  this.currentAttr.value += REPLACEMENT_CHARACTER;
2704
2534
  break;
2705
- }
2706
2535
  case CODE_POINTS.QUOTATION_MARK:
2707
2536
  case CODE_POINTS.APOSTROPHE:
2708
2537
  case CODE_POINTS.LESS_THAN_SIGN:
2709
2538
  case CODE_POINTS.EQUALS_SIGN:
2710
- case CODE_POINTS.GRAVE_ACCENT: {
2539
+ case CODE_POINTS.GRAVE_ACCENT:
2711
2540
  this._err(ERR.unexpectedCharacterInUnquotedAttributeValue);
2712
2541
  this.currentAttr.value += String.fromCodePoint(cp);
2713
2542
  break;
2714
- }
2715
- case CODE_POINTS.EOF: {
2543
+ case CODE_POINTS.EOF:
2716
2544
  this._err(ERR.eofInTag);
2717
2545
  this._emitEOFToken();
2718
2546
  break;
2719
- }
2720
2547
  default: this.currentAttr.value += String.fromCodePoint(cp);
2721
2548
  }
2722
2549
  }
@@ -2725,32 +2552,27 @@ var Tokenizer = class {
2725
2552
  case CODE_POINTS.SPACE:
2726
2553
  case CODE_POINTS.LINE_FEED:
2727
2554
  case CODE_POINTS.TABULATION:
2728
- case CODE_POINTS.FORM_FEED: {
2555
+ case CODE_POINTS.FORM_FEED:
2729
2556
  this._leaveAttrValue();
2730
2557
  this.state = State.BEFORE_ATTRIBUTE_NAME;
2731
2558
  break;
2732
- }
2733
- case CODE_POINTS.SOLIDUS: {
2559
+ case CODE_POINTS.SOLIDUS:
2734
2560
  this._leaveAttrValue();
2735
2561
  this.state = State.SELF_CLOSING_START_TAG;
2736
2562
  break;
2737
- }
2738
- case CODE_POINTS.GREATER_THAN_SIGN: {
2563
+ case CODE_POINTS.GREATER_THAN_SIGN:
2739
2564
  this._leaveAttrValue();
2740
2565
  this.state = State.DATA;
2741
2566
  this.emitCurrentTagToken();
2742
2567
  break;
2743
- }
2744
- case CODE_POINTS.EOF: {
2568
+ case CODE_POINTS.EOF:
2745
2569
  this._err(ERR.eofInTag);
2746
2570
  this._emitEOFToken();
2747
2571
  break;
2748
- }
2749
- default: {
2572
+ default:
2750
2573
  this._err(ERR.missingWhitespaceBetweenAttributes);
2751
2574
  this.state = State.BEFORE_ATTRIBUTE_NAME;
2752
2575
  this._stateBeforeAttributeName(cp);
2753
- }
2754
2576
  }
2755
2577
  }
2756
2578
  _stateSelfClosingStartTag(cp) {
@@ -2762,36 +2584,31 @@ var Tokenizer = class {
2762
2584
  this.emitCurrentTagToken();
2763
2585
  break;
2764
2586
  }
2765
- case CODE_POINTS.EOF: {
2587
+ case CODE_POINTS.EOF:
2766
2588
  this._err(ERR.eofInTag);
2767
2589
  this._emitEOFToken();
2768
2590
  break;
2769
- }
2770
- default: {
2591
+ default:
2771
2592
  this._err(ERR.unexpectedSolidusInTag);
2772
2593
  this.state = State.BEFORE_ATTRIBUTE_NAME;
2773
2594
  this._stateBeforeAttributeName(cp);
2774
- }
2775
2595
  }
2776
2596
  }
2777
2597
  _stateBogusComment(cp) {
2778
2598
  const token = this.currentToken;
2779
2599
  switch (cp) {
2780
- case CODE_POINTS.GREATER_THAN_SIGN: {
2600
+ case CODE_POINTS.GREATER_THAN_SIGN:
2781
2601
  this.state = State.DATA;
2782
2602
  this.emitCurrentComment(token);
2783
2603
  break;
2784
- }
2785
- case CODE_POINTS.EOF: {
2604
+ case CODE_POINTS.EOF:
2786
2605
  this.emitCurrentComment(token);
2787
2606
  this._emitEOFToken();
2788
2607
  break;
2789
- }
2790
- case CODE_POINTS.NULL: {
2608
+ case CODE_POINTS.NULL:
2791
2609
  this._err(ERR.unexpectedNullCharacter);
2792
2610
  token.data += REPLACEMENT_CHARACTER;
2793
2611
  break;
2794
- }
2795
2612
  default: token.data += String.fromCodePoint(cp);
2796
2613
  }
2797
2614
  }
@@ -2818,10 +2635,9 @@ var Tokenizer = class {
2818
2635
  }
2819
2636
  _stateCommentStart(cp) {
2820
2637
  switch (cp) {
2821
- case CODE_POINTS.HYPHEN_MINUS: {
2638
+ case CODE_POINTS.HYPHEN_MINUS:
2822
2639
  this.state = State.COMMENT_START_DASH;
2823
2640
  break;
2824
- }
2825
2641
  case CODE_POINTS.GREATER_THAN_SIGN: {
2826
2642
  this._err(ERR.abruptClosingOfEmptyComment);
2827
2643
  this.state = State.DATA;
@@ -2829,80 +2645,68 @@ var Tokenizer = class {
2829
2645
  this.emitCurrentComment(token);
2830
2646
  break;
2831
2647
  }
2832
- default: {
2648
+ default:
2833
2649
  this.state = State.COMMENT;
2834
2650
  this._stateComment(cp);
2835
- }
2836
2651
  }
2837
2652
  }
2838
2653
  _stateCommentStartDash(cp) {
2839
2654
  const token = this.currentToken;
2840
2655
  switch (cp) {
2841
- case CODE_POINTS.HYPHEN_MINUS: {
2656
+ case CODE_POINTS.HYPHEN_MINUS:
2842
2657
  this.state = State.COMMENT_END;
2843
2658
  break;
2844
- }
2845
- case CODE_POINTS.GREATER_THAN_SIGN: {
2659
+ case CODE_POINTS.GREATER_THAN_SIGN:
2846
2660
  this._err(ERR.abruptClosingOfEmptyComment);
2847
2661
  this.state = State.DATA;
2848
2662
  this.emitCurrentComment(token);
2849
2663
  break;
2850
- }
2851
- case CODE_POINTS.EOF: {
2664
+ case CODE_POINTS.EOF:
2852
2665
  this._err(ERR.eofInComment);
2853
2666
  this.emitCurrentComment(token);
2854
2667
  this._emitEOFToken();
2855
2668
  break;
2856
- }
2857
- default: {
2669
+ default:
2858
2670
  token.data += "-";
2859
2671
  this.state = State.COMMENT;
2860
2672
  this._stateComment(cp);
2861
- }
2862
2673
  }
2863
2674
  }
2864
2675
  _stateComment(cp) {
2865
2676
  const token = this.currentToken;
2866
2677
  switch (cp) {
2867
- case CODE_POINTS.HYPHEN_MINUS: {
2678
+ case CODE_POINTS.HYPHEN_MINUS:
2868
2679
  this.state = State.COMMENT_END_DASH;
2869
2680
  break;
2870
- }
2871
- case CODE_POINTS.LESS_THAN_SIGN: {
2681
+ case CODE_POINTS.LESS_THAN_SIGN:
2872
2682
  token.data += "<";
2873
2683
  this.state = State.COMMENT_LESS_THAN_SIGN;
2874
2684
  break;
2875
- }
2876
- case CODE_POINTS.NULL: {
2685
+ case CODE_POINTS.NULL:
2877
2686
  this._err(ERR.unexpectedNullCharacter);
2878
2687
  token.data += REPLACEMENT_CHARACTER;
2879
2688
  break;
2880
- }
2881
- case CODE_POINTS.EOF: {
2689
+ case CODE_POINTS.EOF:
2882
2690
  this._err(ERR.eofInComment);
2883
2691
  this.emitCurrentComment(token);
2884
2692
  this._emitEOFToken();
2885
2693
  break;
2886
- }
2887
2694
  default: token.data += String.fromCodePoint(cp);
2888
2695
  }
2889
2696
  }
2890
2697
  _stateCommentLessThanSign(cp) {
2891
2698
  const token = this.currentToken;
2892
2699
  switch (cp) {
2893
- case CODE_POINTS.EXCLAMATION_MARK: {
2700
+ case CODE_POINTS.EXCLAMATION_MARK:
2894
2701
  token.data += "!";
2895
2702
  this.state = State.COMMENT_LESS_THAN_SIGN_BANG;
2896
2703
  break;
2897
- }
2898
- case CODE_POINTS.LESS_THAN_SIGN: {
2704
+ case CODE_POINTS.LESS_THAN_SIGN:
2899
2705
  token.data += "<";
2900
2706
  break;
2901
- }
2902
- default: {
2707
+ default:
2903
2708
  this.state = State.COMMENT;
2904
2709
  this._stateComment(cp);
2905
- }
2906
2710
  }
2907
2711
  }
2908
2712
  _stateCommentLessThanSignBang(cp) {
@@ -2927,77 +2731,65 @@ var Tokenizer = class {
2927
2731
  _stateCommentEndDash(cp) {
2928
2732
  const token = this.currentToken;
2929
2733
  switch (cp) {
2930
- case CODE_POINTS.HYPHEN_MINUS: {
2734
+ case CODE_POINTS.HYPHEN_MINUS:
2931
2735
  this.state = State.COMMENT_END;
2932
2736
  break;
2933
- }
2934
- case CODE_POINTS.EOF: {
2737
+ case CODE_POINTS.EOF:
2935
2738
  this._err(ERR.eofInComment);
2936
2739
  this.emitCurrentComment(token);
2937
2740
  this._emitEOFToken();
2938
2741
  break;
2939
- }
2940
- default: {
2742
+ default:
2941
2743
  token.data += "-";
2942
2744
  this.state = State.COMMENT;
2943
2745
  this._stateComment(cp);
2944
- }
2945
2746
  }
2946
2747
  }
2947
2748
  _stateCommentEnd(cp) {
2948
2749
  const token = this.currentToken;
2949
2750
  switch (cp) {
2950
- case CODE_POINTS.GREATER_THAN_SIGN: {
2751
+ case CODE_POINTS.GREATER_THAN_SIGN:
2951
2752
  this.state = State.DATA;
2952
2753
  this.emitCurrentComment(token);
2953
2754
  break;
2954
- }
2955
- case CODE_POINTS.EXCLAMATION_MARK: {
2755
+ case CODE_POINTS.EXCLAMATION_MARK:
2956
2756
  this.state = State.COMMENT_END_BANG;
2957
2757
  break;
2958
- }
2959
- case CODE_POINTS.HYPHEN_MINUS: {
2758
+ case CODE_POINTS.HYPHEN_MINUS:
2960
2759
  token.data += "-";
2961
2760
  break;
2962
- }
2963
- case CODE_POINTS.EOF: {
2761
+ case CODE_POINTS.EOF:
2964
2762
  this._err(ERR.eofInComment);
2965
2763
  this.emitCurrentComment(token);
2966
2764
  this._emitEOFToken();
2967
2765
  break;
2968
- }
2969
- default: {
2766
+ default:
2970
2767
  token.data += "--";
2971
2768
  this.state = State.COMMENT;
2972
2769
  this._stateComment(cp);
2973
- }
2974
2770
  }
2975
2771
  }
2976
2772
  _stateCommentEndBang(cp) {
2977
2773
  const token = this.currentToken;
2978
2774
  switch (cp) {
2979
- case CODE_POINTS.HYPHEN_MINUS: {
2775
+ case CODE_POINTS.HYPHEN_MINUS:
2980
2776
  token.data += "--!";
2981
2777
  this.state = State.COMMENT_END_DASH;
2982
2778
  break;
2983
- }
2984
- case CODE_POINTS.GREATER_THAN_SIGN: {
2779
+ case CODE_POINTS.GREATER_THAN_SIGN:
2985
2780
  this._err(ERR.incorrectlyClosedComment);
2986
2781
  this.state = State.DATA;
2987
2782
  this.emitCurrentComment(token);
2988
2783
  break;
2989
- }
2990
- case CODE_POINTS.EOF: {
2784
+ case CODE_POINTS.EOF:
2991
2785
  this._err(ERR.eofInComment);
2992
2786
  this.emitCurrentComment(token);
2993
2787
  this._emitEOFToken();
2994
2788
  break;
2995
- }
2996
- default: {
2789
+ default:
2997
2790
  token.data += "--!";
2998
2791
  this.state = State.COMMENT;
2999
2792
  this._stateComment(cp);
3000
- }
3001
2793
  }
3002
2794
  }
3003
2795
  _stateDoctype(cp) {
@@ -3005,15 +2797,13 @@ var Tokenizer = class {
3005
2797
  case CODE_POINTS.SPACE:
3006
2798
  case CODE_POINTS.LINE_FEED:
3007
2799
  case CODE_POINTS.TABULATION:
3008
- case CODE_POINTS.FORM_FEED: {
2800
+ case CODE_POINTS.FORM_FEED:
3009
2801
  this.state = State.BEFORE_DOCTYPE_NAME;
3010
2802
  break;
3011
- }
3012
- case CODE_POINTS.GREATER_THAN_SIGN: {
2803
+ case CODE_POINTS.GREATER_THAN_SIGN:
3013
2804
  this.state = State.BEFORE_DOCTYPE_NAME;
3014
2805
  this._stateBeforeDoctypeName(cp);
3015
2806
  break;
3016
- }
3017
2807
  case CODE_POINTS.EOF: {
3018
2808
  this._err(ERR.eofInDoctype);
3019
2809
  this._createDoctypeToken(null);
@@ -3023,11 +2813,10 @@ var Tokenizer = class {
3023
2813
  this._emitEOFToken();
3024
2814
  break;
3025
2815
  }
3026
- default: {
2816
+ default:
3027
2817
  this._err(ERR.missingWhitespaceBeforeDoctypeName);
3028
2818
  this.state = State.BEFORE_DOCTYPE_NAME;
3029
2819
  this._stateBeforeDoctypeName(cp);
3030
- }
3031
2820
  }
3032
2821
  }
3033
2822
  _stateBeforeDoctypeName(cp) {
@@ -3039,12 +2828,11 @@ var Tokenizer = class {
3039
2828
  case CODE_POINTS.LINE_FEED:
3040
2829
  case CODE_POINTS.TABULATION:
3041
2830
  case CODE_POINTS.FORM_FEED: break;
3042
- case CODE_POINTS.NULL: {
2831
+ case CODE_POINTS.NULL:
3043
2832
  this._err(ERR.unexpectedNullCharacter);
3044
2833
  this._createDoctypeToken(REPLACEMENT_CHARACTER);
3045
2834
  this.state = State.DOCTYPE_NAME;
3046
2835
  break;
3047
- }
3048
2836
  case CODE_POINTS.GREATER_THAN_SIGN: {
3049
2837
  this._err(ERR.missingDoctypeName);
3050
2838
  this._createDoctypeToken(null);
@@ -3063,10 +2851,9 @@ var Tokenizer = class {
3063
2851
  this._emitEOFToken();
3064
2852
  break;
3065
2853
  }
3066
- default: {
2854
+ default:
3067
2855
  this._createDoctypeToken(String.fromCodePoint(cp));
3068
2856
  this.state = State.DOCTYPE_NAME;
3069
- }
3070
2857
  }
3071
2858
  }
3072
2859
  _stateDoctypeName(cp) {
@@ -3075,27 +2862,23 @@ var Tokenizer = class {
3075
2862
  case CODE_POINTS.SPACE:
3076
2863
  case CODE_POINTS.LINE_FEED:
3077
2864
  case CODE_POINTS.TABULATION:
3078
- case CODE_POINTS.FORM_FEED: {
2865
+ case CODE_POINTS.FORM_FEED:
3079
2866
  this.state = State.AFTER_DOCTYPE_NAME;
3080
2867
  break;
3081
- }
3082
- case CODE_POINTS.GREATER_THAN_SIGN: {
2868
+ case CODE_POINTS.GREATER_THAN_SIGN:
3083
2869
  this.state = State.DATA;
3084
2870
  this.emitCurrentDoctype(token);
3085
2871
  break;
3086
- }
3087
- case CODE_POINTS.NULL: {
2872
+ case CODE_POINTS.NULL:
3088
2873
  this._err(ERR.unexpectedNullCharacter);
3089
2874
  token.name += REPLACEMENT_CHARACTER;
3090
2875
  break;
3091
- }
3092
- case CODE_POINTS.EOF: {
2876
+ case CODE_POINTS.EOF:
3093
2877
  this._err(ERR.eofInDoctype);
3094
2878
  token.forceQuirks = true;
3095
2879
  this.emitCurrentDoctype(token);
3096
2880
  this._emitEOFToken();
3097
2881
  break;
3098
- }
3099
2882
  default: token.name += String.fromCodePoint(isAsciiUpper(cp) ? toAsciiLower(cp) : cp);
3100
2883
  }
3101
2884
  }
@@ -3106,18 +2889,16 @@ var Tokenizer = class {
3106
2889
  case CODE_POINTS.LINE_FEED:
3107
2890
  case CODE_POINTS.TABULATION:
3108
2891
  case CODE_POINTS.FORM_FEED: break;
3109
- case CODE_POINTS.GREATER_THAN_SIGN: {
2892
+ case CODE_POINTS.GREATER_THAN_SIGN:
3110
2893
  this.state = State.DATA;
3111
2894
  this.emitCurrentDoctype(token);
3112
2895
  break;
3113
- }
3114
- case CODE_POINTS.EOF: {
2896
+ case CODE_POINTS.EOF:
3115
2897
  this._err(ERR.eofInDoctype);
3116
2898
  token.forceQuirks = true;
3117
2899
  this.emitCurrentDoctype(token);
3118
2900
  this._emitEOFToken();
3119
2901
  break;
3120
- }
3121
2902
  default: if (this._consumeSequenceIfMatch(SEQUENCES.PUBLIC, false)) this.state = State.AFTER_DOCTYPE_PUBLIC_KEYWORD;
3122
2903
  else if (this._consumeSequenceIfMatch(SEQUENCES.SYSTEM, false)) this.state = State.AFTER_DOCTYPE_SYSTEM_KEYWORD;
3123
2904
  else if (!this._ensureHibernation()) {
@@ -3134,42 +2915,36 @@ var Tokenizer = class {
3134
2915
  case CODE_POINTS.SPACE:
3135
2916
  case CODE_POINTS.LINE_FEED:
3136
2917
  case CODE_POINTS.TABULATION:
3137
- case CODE_POINTS.FORM_FEED: {
2918
+ case CODE_POINTS.FORM_FEED:
3138
2919
  this.state = State.BEFORE_DOCTYPE_PUBLIC_IDENTIFIER;
3139
2920
  break;
3140
- }
3141
- case CODE_POINTS.QUOTATION_MARK: {
2921
+ case CODE_POINTS.QUOTATION_MARK:
3142
2922
  this._err(ERR.missingWhitespaceAfterDoctypePublicKeyword);
3143
2923
  token.publicId = "";
3144
2924
  this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED;
3145
2925
  break;
3146
- }
3147
- case CODE_POINTS.APOSTROPHE: {
2926
+ case CODE_POINTS.APOSTROPHE:
3148
2927
  this._err(ERR.missingWhitespaceAfterDoctypePublicKeyword);
3149
2928
  token.publicId = "";
3150
2929
  this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED;
3151
2930
  break;
3152
- }
3153
- case CODE_POINTS.GREATER_THAN_SIGN: {
2931
+ case CODE_POINTS.GREATER_THAN_SIGN:
3154
2932
  this._err(ERR.missingDoctypePublicIdentifier);
3155
2933
  token.forceQuirks = true;
3156
2934
  this.state = State.DATA;
3157
2935
  this.emitCurrentDoctype(token);
3158
2936
  break;
3159
- }
3160
- case CODE_POINTS.EOF: {
2937
+ case CODE_POINTS.EOF:
3161
2938
  this._err(ERR.eofInDoctype);
3162
2939
  token.forceQuirks = true;
3163
2940
  this.emitCurrentDoctype(token);
3164
2941
  this._emitEOFToken();
3165
2942
  break;
3166
- }
3167
- default: {
2943
+ default:
3168
2944
  this._err(ERR.missingQuoteBeforeDoctypePublicIdentifier);
3169
2945
  token.forceQuirks = true;
3170
2946
  this.state = State.BOGUS_DOCTYPE;
3171
2947
  this._stateBogusDoctype(cp);
3172
- }
3173
2948
  }
3174
2949
  }
3175
2950
  _stateBeforeDoctypePublicIdentifier(cp) {
@@ -3179,93 +2954,80 @@ var Tokenizer = class {
3179
2954
  case CODE_POINTS.LINE_FEED:
3180
2955
  case CODE_POINTS.TABULATION:
3181
2956
  case CODE_POINTS.FORM_FEED: break;
3182
- case CODE_POINTS.QUOTATION_MARK: {
2957
+ case CODE_POINTS.QUOTATION_MARK:
3183
2958
  token.publicId = "";
3184
2959
  this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED;
3185
2960
  break;
3186
- }
3187
- case CODE_POINTS.APOSTROPHE: {
2961
+ case CODE_POINTS.APOSTROPHE:
3188
2962
  token.publicId = "";
3189
2963
  this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED;
3190
2964
  break;
3191
- }
3192
- case CODE_POINTS.GREATER_THAN_SIGN: {
2965
+ case CODE_POINTS.GREATER_THAN_SIGN:
3193
2966
  this._err(ERR.missingDoctypePublicIdentifier);
3194
2967
  token.forceQuirks = true;
3195
2968
  this.state = State.DATA;
3196
2969
  this.emitCurrentDoctype(token);
3197
2970
  break;
3198
- }
3199
- case CODE_POINTS.EOF: {
2971
+ case CODE_POINTS.EOF:
3200
2972
  this._err(ERR.eofInDoctype);
3201
2973
  token.forceQuirks = true;
3202
2974
  this.emitCurrentDoctype(token);
3203
2975
  this._emitEOFToken();
3204
2976
  break;
3205
- }
3206
- default: {
2977
+ default:
3207
2978
  this._err(ERR.missingQuoteBeforeDoctypePublicIdentifier);
3208
2979
  token.forceQuirks = true;
3209
2980
  this.state = State.BOGUS_DOCTYPE;
3210
2981
  this._stateBogusDoctype(cp);
3211
- }
3212
2982
  }
3213
2983
  }
3214
2984
  _stateDoctypePublicIdentifierDoubleQuoted(cp) {
3215
2985
  const token = this.currentToken;
3216
2986
  switch (cp) {
3217
- case CODE_POINTS.QUOTATION_MARK: {
2987
+ case CODE_POINTS.QUOTATION_MARK:
3218
2988
  this.state = State.AFTER_DOCTYPE_PUBLIC_IDENTIFIER;
3219
2989
  break;
3220
- }
3221
- case CODE_POINTS.NULL: {
2990
+ case CODE_POINTS.NULL:
3222
2991
  this._err(ERR.unexpectedNullCharacter);
3223
2992
  token.publicId += REPLACEMENT_CHARACTER;
3224
2993
  break;
3225
- }
3226
- case CODE_POINTS.GREATER_THAN_SIGN: {
2994
+ case CODE_POINTS.GREATER_THAN_SIGN:
3227
2995
  this._err(ERR.abruptDoctypePublicIdentifier);
3228
2996
  token.forceQuirks = true;
3229
2997
  this.emitCurrentDoctype(token);
3230
2998
  this.state = State.DATA;
3231
2999
  break;
3232
- }
3233
- case CODE_POINTS.EOF: {
3000
+ case CODE_POINTS.EOF:
3234
3001
  this._err(ERR.eofInDoctype);
3235
3002
  token.forceQuirks = true;
3236
3003
  this.emitCurrentDoctype(token);
3237
3004
  this._emitEOFToken();
3238
3005
  break;
3239
- }
3240
3006
  default: token.publicId += String.fromCodePoint(cp);
3241
3007
  }
3242
3008
  }
3243
3009
  _stateDoctypePublicIdentifierSingleQuoted(cp) {
3244
3010
  const token = this.currentToken;
3245
3011
  switch (cp) {
3246
- case CODE_POINTS.APOSTROPHE: {
3012
+ case CODE_POINTS.APOSTROPHE:
3247
3013
  this.state = State.AFTER_DOCTYPE_PUBLIC_IDENTIFIER;
3248
3014
  break;
3249
- }
3250
- case CODE_POINTS.NULL: {
3015
+ case CODE_POINTS.NULL:
3251
3016
  this._err(ERR.unexpectedNullCharacter);
3252
3017
  token.publicId += REPLACEMENT_CHARACTER;
3253
3018
  break;
3254
- }
3255
- case CODE_POINTS.GREATER_THAN_SIGN: {
3019
+ case CODE_POINTS.GREATER_THAN_SIGN:
3256
3020
  this._err(ERR.abruptDoctypePublicIdentifier);
3257
3021
  token.forceQuirks = true;
3258
3022
  this.emitCurrentDoctype(token);
3259
3023
  this.state = State.DATA;
3260
3024
  break;
3261
- }
3262
- case CODE_POINTS.EOF: {
3025
+ case CODE_POINTS.EOF:
3263
3026
  this._err(ERR.eofInDoctype);
3264
3027
  token.forceQuirks = true;
3265
3028
  this.emitCurrentDoctype(token);
3266
3029
  this._emitEOFToken();
3267
3030
  break;
3268
- }
3269
3031
  default: token.publicId += String.fromCodePoint(cp);
3270
3032
  }
3271
3033
  }
@@ -3275,40 +3037,34 @@ var Tokenizer = class {
3275
3037
  case CODE_POINTS.SPACE:
3276
3038
  case CODE_POINTS.LINE_FEED:
3277
3039
  case CODE_POINTS.TABULATION:
3278
- case CODE_POINTS.FORM_FEED: {
3040
+ case CODE_POINTS.FORM_FEED:
3279
3041
  this.state = State.BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS;
3280
3042
  break;
3281
- }
3282
- case CODE_POINTS.GREATER_THAN_SIGN: {
3043
+ case CODE_POINTS.GREATER_THAN_SIGN:
3283
3044
  this.state = State.DATA;
3284
3045
  this.emitCurrentDoctype(token);
3285
3046
  break;
3286
- }
3287
- case CODE_POINTS.QUOTATION_MARK: {
3047
+ case CODE_POINTS.QUOTATION_MARK:
3288
3048
  this._err(ERR.missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers);
3289
3049
  token.systemId = "";
3290
3050
  this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED;
3291
3051
  break;
3292
- }
3293
- case CODE_POINTS.APOSTROPHE: {
3052
+ case CODE_POINTS.APOSTROPHE:
3294
3053
  this._err(ERR.missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers);
3295
3054
  token.systemId = "";
3296
3055
  this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED;
3297
3056
  break;
3298
- }
3299
- case CODE_POINTS.EOF: {
3057
+ case CODE_POINTS.EOF:
3300
3058
  this._err(ERR.eofInDoctype);
3301
3059
  token.forceQuirks = true;
3302
3060
  this.emitCurrentDoctype(token);
3303
3061
  this._emitEOFToken();
3304
3062
  break;
3305
- }
3306
- default: {
3063
+ default:
3307
3064
  this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
3308
3065
  token.forceQuirks = true;
3309
3066
  this.state = State.BOGUS_DOCTYPE;
3310
3067
  this._stateBogusDoctype(cp);
3311
- }
3312
3068
  }
3313
3069
  }
3314
3070
  _stateBetweenDoctypePublicAndSystemIdentifiers(cp) {
@@ -3318,34 +3074,29 @@ var Tokenizer = class {
3318
3074
  case CODE_POINTS.LINE_FEED:
3319
3075
  case CODE_POINTS.TABULATION:
3320
3076
  case CODE_POINTS.FORM_FEED: break;
3321
- case CODE_POINTS.GREATER_THAN_SIGN: {
3077
+ case CODE_POINTS.GREATER_THAN_SIGN:
3322
3078
  this.emitCurrentDoctype(token);
3323
3079
  this.state = State.DATA;
3324
3080
  break;
3325
- }
3326
- case CODE_POINTS.QUOTATION_MARK: {
3081
+ case CODE_POINTS.QUOTATION_MARK:
3327
3082
  token.systemId = "";
3328
3083
  this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED;
3329
3084
  break;
3330
- }
3331
- case CODE_POINTS.APOSTROPHE: {
3085
+ case CODE_POINTS.APOSTROPHE:
3332
3086
  token.systemId = "";
3333
3087
  this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED;
3334
3088
  break;
3335
- }
3336
- case CODE_POINTS.EOF: {
3089
+ case CODE_POINTS.EOF:
3337
3090
  this._err(ERR.eofInDoctype);
3338
3091
  token.forceQuirks = true;
3339
3092
  this.emitCurrentDoctype(token);
3340
3093
  this._emitEOFToken();
3341
3094
  break;
3342
- }
3343
- default: {
3095
+ default:
3344
3096
  this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
3345
3097
  token.forceQuirks = true;
3346
3098
  this.state = State.BOGUS_DOCTYPE;
3347
3099
  this._stateBogusDoctype(cp);
3348
- }
3349
3100
  }
3350
3101
  }
3351
3102
  _stateAfterDoctypeSystemKeyword(cp) {
@@ -3354,42 +3105,36 @@ var Tokenizer = class {
3354
3105
  case CODE_POINTS.SPACE:
3355
3106
  case CODE_POINTS.LINE_FEED:
3356
3107
  case CODE_POINTS.TABULATION:
3357
- case CODE_POINTS.FORM_FEED: {
3108
+ case CODE_POINTS.FORM_FEED:
3358
3109
  this.state = State.BEFORE_DOCTYPE_SYSTEM_IDENTIFIER;
3359
3110
  break;
3360
- }
3361
- case CODE_POINTS.QUOTATION_MARK: {
3111
+ case CODE_POINTS.QUOTATION_MARK:
3362
3112
  this._err(ERR.missingWhitespaceAfterDoctypeSystemKeyword);
3363
3113
  token.systemId = "";
3364
3114
  this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED;
3365
3115
  break;
3366
- }
3367
- case CODE_POINTS.APOSTROPHE: {
3116
+ case CODE_POINTS.APOSTROPHE:
3368
3117
  this._err(ERR.missingWhitespaceAfterDoctypeSystemKeyword);
3369
3118
  token.systemId = "";
3370
3119
  this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED;
3371
3120
  break;
3372
- }
3373
- case CODE_POINTS.GREATER_THAN_SIGN: {
3121
+ case CODE_POINTS.GREATER_THAN_SIGN:
3374
3122
  this._err(ERR.missingDoctypeSystemIdentifier);
3375
3123
  token.forceQuirks = true;
3376
3124
  this.state = State.DATA;
3377
3125
  this.emitCurrentDoctype(token);
3378
3126
  break;
3379
- }
3380
- case CODE_POINTS.EOF: {
3127
+ case CODE_POINTS.EOF:
3381
3128
  this._err(ERR.eofInDoctype);
3382
3129
  token.forceQuirks = true;
3383
3130
  this.emitCurrentDoctype(token);
3384
3131
  this._emitEOFToken();
3385
3132
  break;
3386
- }
3387
- default: {
3133
+ default:
3388
3134
  this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
3389
3135
  token.forceQuirks = true;
3390
3136
  this.state = State.BOGUS_DOCTYPE;
3391
3137
  this._stateBogusDoctype(cp);
3392
- }
3393
3138
  }
3394
3139
  }
3395
3140
  _stateBeforeDoctypeSystemIdentifier(cp) {
@@ -3399,93 +3144,80 @@ var Tokenizer = class {
3399
3144
  case CODE_POINTS.LINE_FEED:
3400
3145
  case CODE_POINTS.TABULATION:
3401
3146
  case CODE_POINTS.FORM_FEED: break;
3402
- case CODE_POINTS.QUOTATION_MARK: {
3147
+ case CODE_POINTS.QUOTATION_MARK:
3403
3148
  token.systemId = "";
3404
3149
  this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED;
3405
3150
  break;
3406
- }
3407
- case CODE_POINTS.APOSTROPHE: {
3151
+ case CODE_POINTS.APOSTROPHE:
3408
3152
  token.systemId = "";
3409
3153
  this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED;
3410
3154
  break;
3411
- }
3412
- case CODE_POINTS.GREATER_THAN_SIGN: {
3155
+ case CODE_POINTS.GREATER_THAN_SIGN:
3413
3156
  this._err(ERR.missingDoctypeSystemIdentifier);
3414
3157
  token.forceQuirks = true;
3415
3158
  this.state = State.DATA;
3416
3159
  this.emitCurrentDoctype(token);
3417
3160
  break;
3418
- }
3419
- case CODE_POINTS.EOF: {
3161
+ case CODE_POINTS.EOF:
3420
3162
  this._err(ERR.eofInDoctype);
3421
3163
  token.forceQuirks = true;
3422
3164
  this.emitCurrentDoctype(token);
3423
3165
  this._emitEOFToken();
3424
3166
  break;
3425
- }
3426
- default: {
3167
+ default:
3427
3168
  this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
3428
3169
  token.forceQuirks = true;
3429
3170
  this.state = State.BOGUS_DOCTYPE;
3430
3171
  this._stateBogusDoctype(cp);
3431
- }
3432
3172
  }
3433
3173
  }
3434
3174
  _stateDoctypeSystemIdentifierDoubleQuoted(cp) {
3435
3175
  const token = this.currentToken;
3436
3176
  switch (cp) {
3437
- case CODE_POINTS.QUOTATION_MARK: {
3177
+ case CODE_POINTS.QUOTATION_MARK:
3438
3178
  this.state = State.AFTER_DOCTYPE_SYSTEM_IDENTIFIER;
3439
3179
  break;
3440
- }
3441
- case CODE_POINTS.NULL: {
3180
+ case CODE_POINTS.NULL:
3442
3181
  this._err(ERR.unexpectedNullCharacter);
3443
3182
  token.systemId += REPLACEMENT_CHARACTER;
3444
3183
  break;
3445
- }
3446
- case CODE_POINTS.GREATER_THAN_SIGN: {
3184
+ case CODE_POINTS.GREATER_THAN_SIGN:
3447
3185
  this._err(ERR.abruptDoctypeSystemIdentifier);
3448
3186
  token.forceQuirks = true;
3449
3187
  this.emitCurrentDoctype(token);
3450
3188
  this.state = State.DATA;
3451
3189
  break;
3452
- }
3453
- case CODE_POINTS.EOF: {
3190
+ case CODE_POINTS.EOF:
3454
3191
  this._err(ERR.eofInDoctype);
3455
3192
  token.forceQuirks = true;
3456
3193
  this.emitCurrentDoctype(token);
3457
3194
  this._emitEOFToken();
3458
3195
  break;
3459
- }
3460
3196
  default: token.systemId += String.fromCodePoint(cp);
3461
3197
  }
3462
3198
  }
3463
3199
  _stateDoctypeSystemIdentifierSingleQuoted(cp) {
3464
3200
  const token = this.currentToken;
3465
3201
  switch (cp) {
3466
- case CODE_POINTS.APOSTROPHE: {
3202
+ case CODE_POINTS.APOSTROPHE:
3467
3203
  this.state = State.AFTER_DOCTYPE_SYSTEM_IDENTIFIER;
3468
3204
  break;
3469
- }
3470
- case CODE_POINTS.NULL: {
3205
+ case CODE_POINTS.NULL:
3471
3206
  this._err(ERR.unexpectedNullCharacter);
3472
3207
  token.systemId += REPLACEMENT_CHARACTER;
3473
3208
  break;
3474
- }
3475
- case CODE_POINTS.GREATER_THAN_SIGN: {
3209
+ case CODE_POINTS.GREATER_THAN_SIGN:
3476
3210
  this._err(ERR.abruptDoctypeSystemIdentifier);
3477
3211
  token.forceQuirks = true;
3478
3212
  this.emitCurrentDoctype(token);
3479
3213
  this.state = State.DATA;
3480
3214
  break;
3481
- }
3482
- case CODE_POINTS.EOF: {
3215
+ case CODE_POINTS.EOF:
3483
3216
  this._err(ERR.eofInDoctype);
3484
3217
  token.forceQuirks = true;
3485
3218
  this.emitCurrentDoctype(token);
3486
3219
  this._emitEOFToken();
3487
3220
  break;
3488
- }
3489
3221
  default: token.systemId += String.fromCodePoint(cp);
3490
3222
  }
3491
3223
  }
@@ -3496,56 +3228,48 @@ var Tokenizer = class {
3496
3228
  case CODE_POINTS.LINE_FEED:
3497
3229
  case CODE_POINTS.TABULATION:
3498
3230
  case CODE_POINTS.FORM_FEED: break;
3499
- case CODE_POINTS.GREATER_THAN_SIGN: {
3231
+ case CODE_POINTS.GREATER_THAN_SIGN:
3500
3232
  this.emitCurrentDoctype(token);
3501
3233
  this.state = State.DATA;
3502
3234
  break;
3503
- }
3504
- case CODE_POINTS.EOF: {
3235
+ case CODE_POINTS.EOF:
3505
3236
  this._err(ERR.eofInDoctype);
3506
3237
  token.forceQuirks = true;
3507
3238
  this.emitCurrentDoctype(token);
3508
3239
  this._emitEOFToken();
3509
3240
  break;
3510
- }
3511
- default: {
3241
+ default:
3512
3242
  this._err(ERR.unexpectedCharacterAfterDoctypeSystemIdentifier);
3513
3243
  this.state = State.BOGUS_DOCTYPE;
3514
3244
  this._stateBogusDoctype(cp);
3515
- }
3516
3245
  }
3517
3246
  }
3518
3247
  _stateBogusDoctype(cp) {
3519
3248
  const token = this.currentToken;
3520
3249
  switch (cp) {
3521
- case CODE_POINTS.GREATER_THAN_SIGN: {
3250
+ case CODE_POINTS.GREATER_THAN_SIGN:
3522
3251
  this.emitCurrentDoctype(token);
3523
3252
  this.state = State.DATA;
3524
3253
  break;
3525
- }
3526
- case CODE_POINTS.NULL: {
3254
+ case CODE_POINTS.NULL:
3527
3255
  this._err(ERR.unexpectedNullCharacter);
3528
3256
  break;
3529
- }
3530
- case CODE_POINTS.EOF: {
3257
+ case CODE_POINTS.EOF:
3531
3258
  this.emitCurrentDoctype(token);
3532
3259
  this._emitEOFToken();
3533
3260
  break;
3534
- }
3535
3261
  default:
3536
3262
  }
3537
3263
  }
3538
3264
  _stateCdataSection(cp) {
3539
3265
  switch (cp) {
3540
- case CODE_POINTS.RIGHT_SQUARE_BRACKET: {
3266
+ case CODE_POINTS.RIGHT_SQUARE_BRACKET:
3541
3267
  this.state = State.CDATA_SECTION_BRACKET;
3542
3268
  break;
3543
- }
3544
- case CODE_POINTS.EOF: {
3269
+ case CODE_POINTS.EOF:
3545
3270
  this._err(ERR.eofInCdata);
3546
3271
  this._emitEOFToken();
3547
3272
  break;
3548
- }
3549
3273
  default: this._emitCodePoint(cp);
3550
3274
  }
3551
3275
  }
@@ -3559,19 +3283,16 @@ var Tokenizer = class {
3559
3283
  }
3560
3284
  _stateCdataSectionEnd(cp) {
3561
3285
  switch (cp) {
3562
- case CODE_POINTS.GREATER_THAN_SIGN: {
3286
+ case CODE_POINTS.GREATER_THAN_SIGN:
3563
3287
  this.state = State.DATA;
3564
3288
  break;
3565
- }
3566
- case CODE_POINTS.RIGHT_SQUARE_BRACKET: {
3289
+ case CODE_POINTS.RIGHT_SQUARE_BRACKET:
3567
3290
  this._emitChars("]");
3568
3291
  break;
3569
- }
3570
- default: {
3292
+ default:
3571
3293
  this._emitChars("]]");
3572
3294
  this.state = State.CDATA_SECTION;
3573
3295
  this._stateCdataSection(cp);
3574
- }
3575
3296
  }
3576
3297
  }
3577
3298
  _stateCharacterReference() {
@@ -3805,19 +3526,16 @@ var OpenElementStack = class {
3805
3526
  for (let i = this.stackTop; i >= 0; i--) {
3806
3527
  const tn = this.tagIDs[i];
3807
3528
  switch (this.treeAdapter.getNamespaceURI(this.items[i])) {
3808
- case NS.HTML: {
3529
+ case NS.HTML:
3809
3530
  if (tn === tagName) return true;
3810
3531
  if (htmlScope.has(tn)) return false;
3811
3532
  break;
3812
- }
3813
- case NS.SVG: {
3533
+ case NS.SVG:
3814
3534
  if (SCOPING_ELEMENTS_SVG.has(tn)) return false;
3815
3535
  break;
3816
- }
3817
- case NS.MATHML: {
3536
+ case NS.MATHML:
3818
3537
  if (SCOPING_ELEMENTS_MATHML.has(tn)) return false;
3819
3538
  break;
3820
- }
3821
3539
  }
3822
3540
  }
3823
3541
  return true;
@@ -3835,19 +3553,16 @@ var OpenElementStack = class {
3835
3553
  for (let i = this.stackTop; i >= 0; i--) {
3836
3554
  const tn = this.tagIDs[i];
3837
3555
  switch (this.treeAdapter.getNamespaceURI(this.items[i])) {
3838
- case NS.HTML: {
3556
+ case NS.HTML:
3839
3557
  if (NUMBERED_HEADERS.has(tn)) return true;
3840
3558
  if (SCOPING_ELEMENTS_HTML.has(tn)) return false;
3841
3559
  break;
3842
- }
3843
- case NS.SVG: {
3560
+ case NS.SVG:
3844
3561
  if (SCOPING_ELEMENTS_SVG.has(tn)) return false;
3845
3562
  break;
3846
- }
3847
- case NS.MATHML: {
3563
+ case NS.MATHML:
3848
3564
  if (SCOPING_ELEMENTS_MATHML.has(tn)) return false;
3849
3565
  break;
3850
- }
3851
3566
  }
3852
3567
  }
3853
3568
  return true;
@@ -4710,27 +4425,23 @@ var Parser = class {
4710
4425
  if (!this.fragmentContext || this.treeAdapter.getNamespaceURI(this.fragmentContext) !== NS.HTML) return;
4711
4426
  switch (this.fragmentContextID) {
4712
4427
  case TAG_ID.TITLE:
4713
- case TAG_ID.TEXTAREA: {
4428
+ case TAG_ID.TEXTAREA:
4714
4429
  this.tokenizer.state = TokenizerMode.RCDATA;
4715
4430
  break;
4716
- }
4717
4431
  case TAG_ID.STYLE:
4718
4432
  case TAG_ID.XMP:
4719
4433
  case TAG_ID.IFRAME:
4720
4434
  case TAG_ID.NOEMBED:
4721
4435
  case TAG_ID.NOFRAMES:
4722
- case TAG_ID.NOSCRIPT: {
4436
+ case TAG_ID.NOSCRIPT:
4723
4437
  this.tokenizer.state = TokenizerMode.RAWTEXT;
4724
4438
  break;
4725
- }
4726
- case TAG_ID.SCRIPT: {
4439
+ case TAG_ID.SCRIPT:
4727
4440
  this.tokenizer.state = TokenizerMode.SCRIPT_DATA;
4728
4441
  break;
4729
- }
4730
- case TAG_ID.PLAINTEXT: {
4442
+ case TAG_ID.PLAINTEXT:
4731
4443
  this.tokenizer.state = TokenizerMode.PLAINTEXT;
4732
4444
  break;
4733
- }
4734
4445
  default:
4735
4446
  }
4736
4447
  }
@@ -4869,38 +4580,30 @@ var Parser = class {
4869
4580
  /** @protected */
4870
4581
  _processToken(token) {
4871
4582
  switch (token.type) {
4872
- case TokenType.CHARACTER: {
4583
+ case TokenType.CHARACTER:
4873
4584
  this.onCharacter(token);
4874
4585
  break;
4875
- }
4876
- case TokenType.NULL_CHARACTER: {
4586
+ case TokenType.NULL_CHARACTER:
4877
4587
  this.onNullCharacter(token);
4878
4588
  break;
4879
- }
4880
- case TokenType.COMMENT: {
4589
+ case TokenType.COMMENT:
4881
4590
  this.onComment(token);
4882
4591
  break;
4883
- }
4884
- case TokenType.DOCTYPE: {
4592
+ case TokenType.DOCTYPE:
4885
4593
  this.onDoctype(token);
4886
4594
  break;
4887
- }
4888
- case TokenType.START_TAG: {
4595
+ case TokenType.START_TAG:
4889
4596
  this._processStartTag(token);
4890
4597
  break;
4891
- }
4892
- case TokenType.END_TAG: {
4598
+ case TokenType.END_TAG:
4893
4599
  this.onEndTag(token);
4894
4600
  break;
4895
- }
4896
- case TokenType.EOF: {
4601
+ case TokenType.EOF:
4897
4602
  this.onEof(token);
4898
4603
  break;
4899
- }
4900
- case TokenType.WHITESPACE_CHARACTER: {
4604
+ case TokenType.WHITESPACE_CHARACTER:
4901
4605
  this.onWhitespaceCharacter(token);
4902
4606
  break;
4903
- }
4904
4607
  }
4905
4608
  }
4906
4609
  /** @protected */
@@ -4937,63 +4640,51 @@ var Parser = class {
4937
4640
  /** @protected */
4938
4641
  _resetInsertionMode() {
4939
4642
  for (let i = this.openElements.stackTop; i >= 0; i--) switch (i === 0 && this.fragmentContext ? this.fragmentContextID : this.openElements.tagIDs[i]) {
4940
- case TAG_ID.TR: {
4643
+ case TAG_ID.TR:
4941
4644
  this.insertionMode = InsertionMode.IN_ROW;
4942
4645
  return;
4943
- }
4944
4646
  case TAG_ID.TBODY:
4945
4647
  case TAG_ID.THEAD:
4946
- case TAG_ID.TFOOT: {
4648
+ case TAG_ID.TFOOT:
4947
4649
  this.insertionMode = InsertionMode.IN_TABLE_BODY;
4948
4650
  return;
4949
- }
4950
- case TAG_ID.CAPTION: {
4651
+ case TAG_ID.CAPTION:
4951
4652
  this.insertionMode = InsertionMode.IN_CAPTION;
4952
4653
  return;
4953
- }
4954
- case TAG_ID.COLGROUP: {
4654
+ case TAG_ID.COLGROUP:
4955
4655
  this.insertionMode = InsertionMode.IN_COLUMN_GROUP;
4956
4656
  return;
4957
- }
4958
- case TAG_ID.TABLE: {
4657
+ case TAG_ID.TABLE:
4959
4658
  this.insertionMode = InsertionMode.IN_TABLE;
4960
4659
  return;
4961
- }
4962
- case TAG_ID.BODY: {
4660
+ case TAG_ID.BODY:
4963
4661
  this.insertionMode = InsertionMode.IN_BODY;
4964
4662
  return;
4965
- }
4966
- case TAG_ID.FRAMESET: {
4663
+ case TAG_ID.FRAMESET:
4967
4664
  this.insertionMode = InsertionMode.IN_FRAMESET;
4968
4665
  return;
4969
- }
4970
- case TAG_ID.SELECT: {
4666
+ case TAG_ID.SELECT:
4971
4667
  this._resetInsertionModeForSelect(i);
4972
4668
  return;
4973
- }
4974
- case TAG_ID.TEMPLATE: {
4669
+ case TAG_ID.TEMPLATE:
4975
4670
  this.insertionMode = this.tmplInsertionModeStack[0];
4976
4671
  return;
4977
- }
4978
- case TAG_ID.HTML: {
4672
+ case TAG_ID.HTML:
4979
4673
  this.insertionMode = this.headElement ? InsertionMode.AFTER_HEAD : InsertionMode.BEFORE_HEAD;
4980
4674
  return;
4981
- }
4982
4675
  case TAG_ID.TD:
4983
- case TAG_ID.TH: {
4676
+ case TAG_ID.TH:
4984
4677
  if (i > 0) {
4985
4678
  this.insertionMode = InsertionMode.IN_CELL;
4986
4679
  return;
4987
4680
  }
4988
4681
  break;
4989
- }
4990
- case TAG_ID.HEAD: {
4682
+ case TAG_ID.HEAD:
4991
4683
  if (i > 0) {
4992
4684
  this.insertionMode = InsertionMode.IN_HEAD;
4993
4685
  return;
4994
4686
  }
4995
4687
  break;
4996
- }
4997
4688
  }
4998
4689
  this.insertionMode = InsertionMode.IN_BODY;
4999
4690
  }
@@ -5022,13 +4713,12 @@ var Parser = class {
5022
4713
  for (let i = this.openElements.stackTop; i >= 0; i--) {
5023
4714
  const openElement = this.openElements.items[i];
5024
4715
  switch (this.openElements.tagIDs[i]) {
5025
- case TAG_ID.TEMPLATE: {
4716
+ case TAG_ID.TEMPLATE:
5026
4717
  if (this.treeAdapter.getNamespaceURI(openElement) === NS.HTML) return {
5027
4718
  parent: this.treeAdapter.getTemplateContent(openElement),
5028
4719
  beforeElement: null
5029
4720
  };
5030
4721
  break;
5031
- }
5032
4722
  case TAG_ID.TABLE: {
5033
4723
  const parent = this.treeAdapter.getParentNode(openElement);
5034
4724
  if (parent) return {
@@ -5067,65 +4757,52 @@ var Parser = class {
5067
4757
  return;
5068
4758
  }
5069
4759
  switch (this.insertionMode) {
5070
- case InsertionMode.INITIAL: {
4760
+ case InsertionMode.INITIAL:
5071
4761
  tokenInInitialMode(this, token);
5072
4762
  break;
5073
- }
5074
- case InsertionMode.BEFORE_HTML: {
4763
+ case InsertionMode.BEFORE_HTML:
5075
4764
  tokenBeforeHtml(this, token);
5076
4765
  break;
5077
- }
5078
- case InsertionMode.BEFORE_HEAD: {
4766
+ case InsertionMode.BEFORE_HEAD:
5079
4767
  tokenBeforeHead(this, token);
5080
4768
  break;
5081
- }
5082
- case InsertionMode.IN_HEAD: {
4769
+ case InsertionMode.IN_HEAD:
5083
4770
  tokenInHead(this, token);
5084
4771
  break;
5085
- }
5086
- case InsertionMode.IN_HEAD_NO_SCRIPT: {
4772
+ case InsertionMode.IN_HEAD_NO_SCRIPT:
5087
4773
  tokenInHeadNoScript(this, token);
5088
4774
  break;
5089
- }
5090
- case InsertionMode.AFTER_HEAD: {
4775
+ case InsertionMode.AFTER_HEAD:
5091
4776
  tokenAfterHead(this, token);
5092
4777
  break;
5093
- }
5094
4778
  case InsertionMode.IN_BODY:
5095
4779
  case InsertionMode.IN_CAPTION:
5096
4780
  case InsertionMode.IN_CELL:
5097
- case InsertionMode.IN_TEMPLATE: {
4781
+ case InsertionMode.IN_TEMPLATE:
5098
4782
  characterInBody(this, token);
5099
4783
  break;
5100
- }
5101
4784
  case InsertionMode.TEXT:
5102
4785
  case InsertionMode.IN_SELECT:
5103
- case InsertionMode.IN_SELECT_IN_TABLE: {
4786
+ case InsertionMode.IN_SELECT_IN_TABLE:
5104
4787
  this._insertCharacters(token);
5105
4788
  break;
5106
- }
5107
4789
  case InsertionMode.IN_TABLE:
5108
4790
  case InsertionMode.IN_TABLE_BODY:
5109
- case InsertionMode.IN_ROW: {
4791
+ case InsertionMode.IN_ROW:
5110
4792
  characterInTable(this, token);
5111
4793
  break;
5112
- }
5113
- case InsertionMode.IN_TABLE_TEXT: {
4794
+ case InsertionMode.IN_TABLE_TEXT:
5114
4795
  characterInTableText(this, token);
5115
4796
  break;
5116
- }
5117
- case InsertionMode.IN_COLUMN_GROUP: {
4797
+ case InsertionMode.IN_COLUMN_GROUP:
5118
4798
  tokenInColumnGroup(this, token);
5119
4799
  break;
5120
- }
5121
- case InsertionMode.AFTER_BODY: {
4800
+ case InsertionMode.AFTER_BODY:
5122
4801
  tokenAfterBody(this, token);
5123
4802
  break;
5124
- }
5125
- case InsertionMode.AFTER_AFTER_BODY: {
4803
+ case InsertionMode.AFTER_AFTER_BODY:
5126
4804
  tokenAfterAfterBody(this, token);
5127
4805
  break;
5128
- }
5129
4806
  default:
5130
4807
  }
5131
4808
  }
@@ -5137,52 +4814,41 @@ var Parser = class {
5137
4814
  return;
5138
4815
  }
5139
4816
  switch (this.insertionMode) {
5140
- case InsertionMode.INITIAL: {
4817
+ case InsertionMode.INITIAL:
5141
4818
  tokenInInitialMode(this, token);
5142
4819
  break;
5143
- }
5144
- case InsertionMode.BEFORE_HTML: {
4820
+ case InsertionMode.BEFORE_HTML:
5145
4821
  tokenBeforeHtml(this, token);
5146
4822
  break;
5147
- }
5148
- case InsertionMode.BEFORE_HEAD: {
4823
+ case InsertionMode.BEFORE_HEAD:
5149
4824
  tokenBeforeHead(this, token);
5150
4825
  break;
5151
- }
5152
- case InsertionMode.IN_HEAD: {
4826
+ case InsertionMode.IN_HEAD:
5153
4827
  tokenInHead(this, token);
5154
4828
  break;
5155
- }
5156
- case InsertionMode.IN_HEAD_NO_SCRIPT: {
4829
+ case InsertionMode.IN_HEAD_NO_SCRIPT:
5157
4830
  tokenInHeadNoScript(this, token);
5158
4831
  break;
5159
- }
5160
- case InsertionMode.AFTER_HEAD: {
4832
+ case InsertionMode.AFTER_HEAD:
5161
4833
  tokenAfterHead(this, token);
5162
4834
  break;
5163
- }
5164
- case InsertionMode.TEXT: {
4835
+ case InsertionMode.TEXT:
5165
4836
  this._insertCharacters(token);
5166
4837
  break;
5167
- }
5168
4838
  case InsertionMode.IN_TABLE:
5169
4839
  case InsertionMode.IN_TABLE_BODY:
5170
- case InsertionMode.IN_ROW: {
4840
+ case InsertionMode.IN_ROW:
5171
4841
  characterInTable(this, token);
5172
4842
  break;
5173
- }
5174
- case InsertionMode.IN_COLUMN_GROUP: {
4843
+ case InsertionMode.IN_COLUMN_GROUP:
5175
4844
  tokenInColumnGroup(this, token);
5176
4845
  break;
5177
- }
5178
- case InsertionMode.AFTER_BODY: {
4846
+ case InsertionMode.AFTER_BODY:
5179
4847
  tokenAfterBody(this, token);
5180
4848
  break;
5181
- }
5182
- case InsertionMode.AFTER_AFTER_BODY: {
4849
+ case InsertionMode.AFTER_AFTER_BODY:
5183
4850
  tokenAfterAfterBody(this, token);
5184
4851
  break;
5185
- }
5186
4852
  default:
5187
4853
  }
5188
4854
  }
@@ -5211,23 +4877,19 @@ var Parser = class {
5211
4877
  case InsertionMode.IN_SELECT_IN_TABLE:
5212
4878
  case InsertionMode.IN_TEMPLATE:
5213
4879
  case InsertionMode.IN_FRAMESET:
5214
- case InsertionMode.AFTER_FRAMESET: {
4880
+ case InsertionMode.AFTER_FRAMESET:
5215
4881
  appendComment(this, token);
5216
4882
  break;
5217
- }
5218
- case InsertionMode.IN_TABLE_TEXT: {
4883
+ case InsertionMode.IN_TABLE_TEXT:
5219
4884
  tokenInTableText(this, token);
5220
4885
  break;
5221
- }
5222
- case InsertionMode.AFTER_BODY: {
4886
+ case InsertionMode.AFTER_BODY:
5223
4887
  appendCommentToRootHtmlElement(this, token);
5224
4888
  break;
5225
- }
5226
4889
  case InsertionMode.AFTER_AFTER_BODY:
5227
- case InsertionMode.AFTER_AFTER_FRAMESET: {
4890
+ case InsertionMode.AFTER_AFTER_FRAMESET:
5228
4891
  appendCommentToDocument(this, token);
5229
4892
  break;
5230
- }
5231
4893
  default:
5232
4894
  }
5233
4895
  }
@@ -5235,21 +4897,18 @@ var Parser = class {
5235
4897
  onDoctype(token) {
5236
4898
  this.skipNextNewLine = false;
5237
4899
  switch (this.insertionMode) {
5238
- case InsertionMode.INITIAL: {
4900
+ case InsertionMode.INITIAL:
5239
4901
  doctypeInInitialMode(this, token);
5240
4902
  break;
5241
- }
5242
4903
  case InsertionMode.BEFORE_HEAD:
5243
4904
  case InsertionMode.IN_HEAD:
5244
4905
  case InsertionMode.IN_HEAD_NO_SCRIPT:
5245
- case InsertionMode.AFTER_HEAD: {
4906
+ case InsertionMode.AFTER_HEAD:
5246
4907
  this._err(token, ERR.misplacedDoctype);
5247
4908
  break;
5248
- }
5249
- case InsertionMode.IN_TABLE_TEXT: {
4909
+ case InsertionMode.IN_TABLE_TEXT:
5250
4910
  tokenInTableText(this, token);
5251
4911
  break;
5252
- }
5253
4912
  default:
5254
4913
  }
5255
4914
  }
@@ -5278,94 +4937,72 @@ var Parser = class {
5278
4937
  /** @protected */
5279
4938
  _startTagOutsideForeignContent(token) {
5280
4939
  switch (this.insertionMode) {
5281
- case InsertionMode.INITIAL: {
4940
+ case InsertionMode.INITIAL:
5282
4941
  tokenInInitialMode(this, token);
5283
4942
  break;
5284
- }
5285
- case InsertionMode.BEFORE_HTML: {
4943
+ case InsertionMode.BEFORE_HTML:
5286
4944
  startTagBeforeHtml(this, token);
5287
4945
  break;
5288
- }
5289
- case InsertionMode.BEFORE_HEAD: {
4946
+ case InsertionMode.BEFORE_HEAD:
5290
4947
  startTagBeforeHead(this, token);
5291
4948
  break;
5292
- }
5293
- case InsertionMode.IN_HEAD: {
4949
+ case InsertionMode.IN_HEAD:
5294
4950
  startTagInHead(this, token);
5295
4951
  break;
5296
- }
5297
- case InsertionMode.IN_HEAD_NO_SCRIPT: {
4952
+ case InsertionMode.IN_HEAD_NO_SCRIPT:
5298
4953
  startTagInHeadNoScript(this, token);
5299
4954
  break;
5300
- }
5301
- case InsertionMode.AFTER_HEAD: {
4955
+ case InsertionMode.AFTER_HEAD:
5302
4956
  startTagAfterHead(this, token);
5303
4957
  break;
5304
- }
5305
- case InsertionMode.IN_BODY: {
4958
+ case InsertionMode.IN_BODY:
5306
4959
  startTagInBody(this, token);
5307
4960
  break;
5308
- }
5309
- case InsertionMode.IN_TABLE: {
4961
+ case InsertionMode.IN_TABLE:
5310
4962
  startTagInTable(this, token);
5311
4963
  break;
5312
- }
5313
- case InsertionMode.IN_TABLE_TEXT: {
4964
+ case InsertionMode.IN_TABLE_TEXT:
5314
4965
  tokenInTableText(this, token);
5315
4966
  break;
5316
- }
5317
- case InsertionMode.IN_CAPTION: {
4967
+ case InsertionMode.IN_CAPTION:
5318
4968
  startTagInCaption(this, token);
5319
4969
  break;
5320
- }
5321
- case InsertionMode.IN_COLUMN_GROUP: {
4970
+ case InsertionMode.IN_COLUMN_GROUP:
5322
4971
  startTagInColumnGroup(this, token);
5323
4972
  break;
5324
- }
5325
- case InsertionMode.IN_TABLE_BODY: {
4973
+ case InsertionMode.IN_TABLE_BODY:
5326
4974
  startTagInTableBody(this, token);
5327
4975
  break;
5328
- }
5329
- case InsertionMode.IN_ROW: {
4976
+ case InsertionMode.IN_ROW:
5330
4977
  startTagInRow(this, token);
5331
4978
  break;
5332
- }
5333
- case InsertionMode.IN_CELL: {
4979
+ case InsertionMode.IN_CELL:
5334
4980
  startTagInCell(this, token);
5335
4981
  break;
5336
- }
5337
- case InsertionMode.IN_SELECT: {
4982
+ case InsertionMode.IN_SELECT:
5338
4983
  startTagInSelect(this, token);
5339
4984
  break;
5340
- }
5341
- case InsertionMode.IN_SELECT_IN_TABLE: {
4985
+ case InsertionMode.IN_SELECT_IN_TABLE:
5342
4986
  startTagInSelectInTable(this, token);
5343
4987
  break;
5344
- }
5345
- case InsertionMode.IN_TEMPLATE: {
4988
+ case InsertionMode.IN_TEMPLATE:
5346
4989
  startTagInTemplate(this, token);
5347
4990
  break;
5348
- }
5349
- case InsertionMode.AFTER_BODY: {
4991
+ case InsertionMode.AFTER_BODY:
5350
4992
  startTagAfterBody(this, token);
5351
4993
  break;
5352
- }
5353
- case InsertionMode.IN_FRAMESET: {
4994
+ case InsertionMode.IN_FRAMESET:
5354
4995
  startTagInFrameset(this, token);
5355
4996
  break;
5356
- }
5357
- case InsertionMode.AFTER_FRAMESET: {
4997
+ case InsertionMode.AFTER_FRAMESET:
5358
4998
  startTagAfterFrameset(this, token);
5359
4999
  break;
5360
- }
5361
- case InsertionMode.AFTER_AFTER_BODY: {
5000
+ case InsertionMode.AFTER_AFTER_BODY:
5362
5001
  startTagAfterAfterBody(this, token);
5363
5002
  break;
5364
- }
5365
- case InsertionMode.AFTER_AFTER_FRAMESET: {
5003
+ case InsertionMode.AFTER_AFTER_FRAMESET:
5366
5004
  startTagAfterAfterFrameset(this, token);
5367
5005
  break;
5368
- }
5369
5006
  default:
5370
5007
  }
5371
5008
  }
@@ -5379,124 +5016,96 @@ var Parser = class {
5379
5016
  /** @protected */
5380
5017
  _endTagOutsideForeignContent(token) {
5381
5018
  switch (this.insertionMode) {
5382
- case InsertionMode.INITIAL: {
5019
+ case InsertionMode.INITIAL:
5383
5020
  tokenInInitialMode(this, token);
5384
5021
  break;
5385
- }
5386
- case InsertionMode.BEFORE_HTML: {
5022
+ case InsertionMode.BEFORE_HTML:
5387
5023
  endTagBeforeHtml(this, token);
5388
5024
  break;
5389
- }
5390
- case InsertionMode.BEFORE_HEAD: {
5025
+ case InsertionMode.BEFORE_HEAD:
5391
5026
  endTagBeforeHead(this, token);
5392
5027
  break;
5393
- }
5394
- case InsertionMode.IN_HEAD: {
5028
+ case InsertionMode.IN_HEAD:
5395
5029
  endTagInHead(this, token);
5396
5030
  break;
5397
- }
5398
- case InsertionMode.IN_HEAD_NO_SCRIPT: {
5031
+ case InsertionMode.IN_HEAD_NO_SCRIPT:
5399
5032
  endTagInHeadNoScript(this, token);
5400
5033
  break;
5401
- }
5402
- case InsertionMode.AFTER_HEAD: {
5034
+ case InsertionMode.AFTER_HEAD:
5403
5035
  endTagAfterHead(this, token);
5404
5036
  break;
5405
- }
5406
- case InsertionMode.IN_BODY: {
5037
+ case InsertionMode.IN_BODY:
5407
5038
  endTagInBody(this, token);
5408
5039
  break;
5409
- }
5410
- case InsertionMode.TEXT: {
5040
+ case InsertionMode.TEXT:
5411
5041
  endTagInText(this, token);
5412
5042
  break;
5413
- }
5414
- case InsertionMode.IN_TABLE: {
5043
+ case InsertionMode.IN_TABLE:
5415
5044
  endTagInTable(this, token);
5416
5045
  break;
5417
- }
5418
- case InsertionMode.IN_TABLE_TEXT: {
5046
+ case InsertionMode.IN_TABLE_TEXT:
5419
5047
  tokenInTableText(this, token);
5420
5048
  break;
5421
- }
5422
- case InsertionMode.IN_CAPTION: {
5049
+ case InsertionMode.IN_CAPTION:
5423
5050
  endTagInCaption(this, token);
5424
5051
  break;
5425
- }
5426
- case InsertionMode.IN_COLUMN_GROUP: {
5052
+ case InsertionMode.IN_COLUMN_GROUP:
5427
5053
  endTagInColumnGroup(this, token);
5428
5054
  break;
5429
- }
5430
- case InsertionMode.IN_TABLE_BODY: {
5055
+ case InsertionMode.IN_TABLE_BODY:
5431
5056
  endTagInTableBody(this, token);
5432
5057
  break;
5433
- }
5434
- case InsertionMode.IN_ROW: {
5058
+ case InsertionMode.IN_ROW:
5435
5059
  endTagInRow(this, token);
5436
5060
  break;
5437
- }
5438
- case InsertionMode.IN_CELL: {
5061
+ case InsertionMode.IN_CELL:
5439
5062
  endTagInCell(this, token);
5440
5063
  break;
5441
- }
5442
- case InsertionMode.IN_SELECT: {
5064
+ case InsertionMode.IN_SELECT:
5443
5065
  endTagInSelect(this, token);
5444
5066
  break;
5445
- }
5446
- case InsertionMode.IN_SELECT_IN_TABLE: {
5067
+ case InsertionMode.IN_SELECT_IN_TABLE:
5447
5068
  endTagInSelectInTable(this, token);
5448
5069
  break;
5449
- }
5450
- case InsertionMode.IN_TEMPLATE: {
5070
+ case InsertionMode.IN_TEMPLATE:
5451
5071
  endTagInTemplate(this, token);
5452
5072
  break;
5453
- }
5454
- case InsertionMode.AFTER_BODY: {
5073
+ case InsertionMode.AFTER_BODY:
5455
5074
  endTagAfterBody(this, token);
5456
5075
  break;
5457
- }
5458
- case InsertionMode.IN_FRAMESET: {
5076
+ case InsertionMode.IN_FRAMESET:
5459
5077
  endTagInFrameset(this, token);
5460
5078
  break;
5461
- }
5462
- case InsertionMode.AFTER_FRAMESET: {
5079
+ case InsertionMode.AFTER_FRAMESET:
5463
5080
  endTagAfterFrameset(this, token);
5464
5081
  break;
5465
- }
5466
- case InsertionMode.AFTER_AFTER_BODY: {
5082
+ case InsertionMode.AFTER_AFTER_BODY:
5467
5083
  tokenAfterAfterBody(this, token);
5468
5084
  break;
5469
- }
5470
5085
  default:
5471
5086
  }
5472
5087
  }
5473
5088
  /** @internal */
5474
5089
  onEof(token) {
5475
5090
  switch (this.insertionMode) {
5476
- case InsertionMode.INITIAL: {
5091
+ case InsertionMode.INITIAL:
5477
5092
  tokenInInitialMode(this, token);
5478
5093
  break;
5479
- }
5480
- case InsertionMode.BEFORE_HTML: {
5094
+ case InsertionMode.BEFORE_HTML:
5481
5095
  tokenBeforeHtml(this, token);
5482
5096
  break;
5483
- }
5484
- case InsertionMode.BEFORE_HEAD: {
5097
+ case InsertionMode.BEFORE_HEAD:
5485
5098
  tokenBeforeHead(this, token);
5486
5099
  break;
5487
- }
5488
- case InsertionMode.IN_HEAD: {
5100
+ case InsertionMode.IN_HEAD:
5489
5101
  tokenInHead(this, token);
5490
5102
  break;
5491
- }
5492
- case InsertionMode.IN_HEAD_NO_SCRIPT: {
5103
+ case InsertionMode.IN_HEAD_NO_SCRIPT:
5493
5104
  tokenInHeadNoScript(this, token);
5494
5105
  break;
5495
- }
5496
- case InsertionMode.AFTER_HEAD: {
5106
+ case InsertionMode.AFTER_HEAD:
5497
5107
  tokenAfterHead(this, token);
5498
5108
  break;
5499
- }
5500
5109
  case InsertionMode.IN_BODY:
5501
5110
  case InsertionMode.IN_TABLE:
5502
5111
  case InsertionMode.IN_CAPTION:
@@ -5505,30 +5114,25 @@ var Parser = class {
5505
5114
  case InsertionMode.IN_ROW:
5506
5115
  case InsertionMode.IN_CELL:
5507
5116
  case InsertionMode.IN_SELECT:
5508
- case InsertionMode.IN_SELECT_IN_TABLE: {
5117
+ case InsertionMode.IN_SELECT_IN_TABLE:
5509
5118
  eofInBody(this, token);
5510
5119
  break;
5511
- }
5512
- case InsertionMode.TEXT: {
5120
+ case InsertionMode.TEXT:
5513
5121
  eofInText(this, token);
5514
5122
  break;
5515
- }
5516
- case InsertionMode.IN_TABLE_TEXT: {
5123
+ case InsertionMode.IN_TABLE_TEXT:
5517
5124
  tokenInTableText(this, token);
5518
5125
  break;
5519
- }
5520
- case InsertionMode.IN_TEMPLATE: {
5126
+ case InsertionMode.IN_TEMPLATE:
5521
5127
  eofInTemplate(this, token);
5522
5128
  break;
5523
- }
5524
5129
  case InsertionMode.AFTER_BODY:
5525
5130
  case InsertionMode.IN_FRAMESET:
5526
5131
  case InsertionMode.AFTER_FRAMESET:
5527
5132
  case InsertionMode.AFTER_AFTER_BODY:
5528
- case InsertionMode.AFTER_AFTER_FRAMESET: {
5133
+ case InsertionMode.AFTER_AFTER_FRAMESET:
5529
5134
  stopParsing(this, token);
5530
5135
  break;
5531
- }
5532
5136
  default:
5533
5137
  }
5534
5138
  }
@@ -5554,30 +5158,26 @@ var Parser = class {
5554
5158
  case InsertionMode.IN_SELECT:
5555
5159
  case InsertionMode.IN_SELECT_IN_TABLE:
5556
5160
  case InsertionMode.IN_FRAMESET:
5557
- case InsertionMode.AFTER_FRAMESET: {
5161
+ case InsertionMode.AFTER_FRAMESET:
5558
5162
  this._insertCharacters(token);
5559
5163
  break;
5560
- }
5561
5164
  case InsertionMode.IN_BODY:
5562
5165
  case InsertionMode.IN_CAPTION:
5563
5166
  case InsertionMode.IN_CELL:
5564
5167
  case InsertionMode.IN_TEMPLATE:
5565
5168
  case InsertionMode.AFTER_BODY:
5566
5169
  case InsertionMode.AFTER_AFTER_BODY:
5567
- case InsertionMode.AFTER_AFTER_FRAMESET: {
5170
+ case InsertionMode.AFTER_AFTER_FRAMESET:
5568
5171
  whitespaceCharacterInBody(this, token);
5569
5172
  break;
5570
- }
5571
5173
  case InsertionMode.IN_TABLE:
5572
5174
  case InsertionMode.IN_TABLE_BODY:
5573
- case InsertionMode.IN_ROW: {
5175
+ case InsertionMode.IN_ROW:
5574
5176
  characterInTable(this, token);
5575
5177
  break;
5576
- }
5577
- case InsertionMode.IN_TABLE_TEXT: {
5178
+ case InsertionMode.IN_TABLE_TEXT:
5578
5179
  whitespaceCharacterInTableText(this, token);
5579
5180
  break;
5580
- }
5581
5181
  default:
5582
5182
  }
5583
5183
  }
@@ -5727,16 +5327,14 @@ function tokenBeforeHtml(p, token) {
5727
5327
  }
5728
5328
  function startTagBeforeHead(p, token) {
5729
5329
  switch (token.tagID) {
5730
- case TAG_ID.HTML: {
5330
+ case TAG_ID.HTML:
5731
5331
  startTagInBody(p, token);
5732
5332
  break;
5733
- }
5734
- case TAG_ID.HEAD: {
5333
+ case TAG_ID.HEAD:
5735
5334
  p._insertElement(token, NS.HTML);
5736
5335
  p.headElement = p.openElements.current;
5737
5336
  p.insertionMode = InsertionMode.IN_HEAD;
5738
5337
  break;
5739
- }
5740
5338
  default: tokenBeforeHead(p, token);
5741
5339
  }
5742
5340
  }
@@ -5753,72 +5351,61 @@ function tokenBeforeHead(p, token) {
5753
5351
  }
5754
5352
  function startTagInHead(p, token) {
5755
5353
  switch (token.tagID) {
5756
- case TAG_ID.HTML: {
5354
+ case TAG_ID.HTML:
5757
5355
  startTagInBody(p, token);
5758
5356
  break;
5759
- }
5760
5357
  case TAG_ID.BASE:
5761
5358
  case TAG_ID.BASEFONT:
5762
5359
  case TAG_ID.BGSOUND:
5763
5360
  case TAG_ID.LINK:
5764
- case TAG_ID.META: {
5361
+ case TAG_ID.META:
5765
5362
  p._appendElement(token, NS.HTML);
5766
5363
  token.ackSelfClosing = true;
5767
5364
  break;
5768
- }
5769
- case TAG_ID.TITLE: {
5365
+ case TAG_ID.TITLE:
5770
5366
  p._switchToTextParsing(token, TokenizerMode.RCDATA);
5771
5367
  break;
5772
- }
5773
- case TAG_ID.NOSCRIPT: {
5368
+ case TAG_ID.NOSCRIPT:
5774
5369
  if (p.options.scriptingEnabled) p._switchToTextParsing(token, TokenizerMode.RAWTEXT);
5775
5370
  else {
5776
5371
  p._insertElement(token, NS.HTML);
5777
5372
  p.insertionMode = InsertionMode.IN_HEAD_NO_SCRIPT;
5778
5373
  }
5779
5374
  break;
5780
- }
5781
5375
  case TAG_ID.NOFRAMES:
5782
- case TAG_ID.STYLE: {
5376
+ case TAG_ID.STYLE:
5783
5377
  p._switchToTextParsing(token, TokenizerMode.RAWTEXT);
5784
5378
  break;
5785
- }
5786
- case TAG_ID.SCRIPT: {
5379
+ case TAG_ID.SCRIPT:
5787
5380
  p._switchToTextParsing(token, TokenizerMode.SCRIPT_DATA);
5788
5381
  break;
5789
- }
5790
- case TAG_ID.TEMPLATE: {
5382
+ case TAG_ID.TEMPLATE:
5791
5383
  p._insertTemplate(token);
5792
5384
  p.activeFormattingElements.insertMarker();
5793
5385
  p.framesetOk = false;
5794
5386
  p.insertionMode = InsertionMode.IN_TEMPLATE;
5795
5387
  p.tmplInsertionModeStack.unshift(InsertionMode.IN_TEMPLATE);
5796
5388
  break;
5797
- }
5798
- case TAG_ID.HEAD: {
5389
+ case TAG_ID.HEAD:
5799
5390
  p._err(token, ERR.misplacedStartTagForHeadElement);
5800
5391
  break;
5801
- }
5802
5392
  default: tokenInHead(p, token);
5803
5393
  }
5804
5394
  }
5805
5395
  function endTagInHead(p, token) {
5806
5396
  switch (token.tagID) {
5807
- case TAG_ID.HEAD: {
5397
+ case TAG_ID.HEAD:
5808
5398
  p.openElements.pop();
5809
5399
  p.insertionMode = InsertionMode.AFTER_HEAD;
5810
5400
  break;
5811
- }
5812
5401
  case TAG_ID.BODY:
5813
5402
  case TAG_ID.BR:
5814
- case TAG_ID.HTML: {
5403
+ case TAG_ID.HTML:
5815
5404
  tokenInHead(p, token);
5816
5405
  break;
5817
- }
5818
- case TAG_ID.TEMPLATE: {
5406
+ case TAG_ID.TEMPLATE:
5819
5407
  templateEndTagInHead(p, token);
5820
5408
  break;
5821
- }
5822
5409
  default: p._err(token, ERR.endTagWithoutMatchingOpenElement);
5823
5410
  }
5824
5411
  }
@@ -5839,38 +5426,33 @@ function tokenInHead(p, token) {
5839
5426
  }
5840
5427
  function startTagInHeadNoScript(p, token) {
5841
5428
  switch (token.tagID) {
5842
- case TAG_ID.HTML: {
5429
+ case TAG_ID.HTML:
5843
5430
  startTagInBody(p, token);
5844
5431
  break;
5845
- }
5846
5432
  case TAG_ID.BASEFONT:
5847
5433
  case TAG_ID.BGSOUND:
5848
5434
  case TAG_ID.HEAD:
5849
5435
  case TAG_ID.LINK:
5850
5436
  case TAG_ID.META:
5851
5437
  case TAG_ID.NOFRAMES:
5852
- case TAG_ID.STYLE: {
5438
+ case TAG_ID.STYLE:
5853
5439
  startTagInHead(p, token);
5854
5440
  break;
5855
- }
5856
- case TAG_ID.NOSCRIPT: {
5441
+ case TAG_ID.NOSCRIPT:
5857
5442
  p._err(token, ERR.nestedNoscriptInHead);
5858
5443
  break;
5859
- }
5860
5444
  default: tokenInHeadNoScript(p, token);
5861
5445
  }
5862
5446
  }
5863
5447
  function endTagInHeadNoScript(p, token) {
5864
5448
  switch (token.tagID) {
5865
- case TAG_ID.NOSCRIPT: {
5449
+ case TAG_ID.NOSCRIPT:
5866
5450
  p.openElements.pop();
5867
5451
  p.insertionMode = InsertionMode.IN_HEAD;
5868
5452
  break;
5869
- }
5870
- case TAG_ID.BR: {
5453
+ case TAG_ID.BR:
5871
5454
  tokenInHeadNoScript(p, token);
5872
5455
  break;
5873
- }
5874
5456
  default: p._err(token, ERR.endTagWithoutMatchingOpenElement);
5875
5457
  }
5876
5458
  }
@@ -5883,21 +5465,18 @@ function tokenInHeadNoScript(p, token) {
5883
5465
  }
5884
5466
  function startTagAfterHead(p, token) {
5885
5467
  switch (token.tagID) {
5886
- case TAG_ID.HTML: {
5468
+ case TAG_ID.HTML:
5887
5469
  startTagInBody(p, token);
5888
5470
  break;
5889
- }
5890
- case TAG_ID.BODY: {
5471
+ case TAG_ID.BODY:
5891
5472
  p._insertElement(token, NS.HTML);
5892
5473
  p.framesetOk = false;
5893
5474
  p.insertionMode = InsertionMode.IN_BODY;
5894
5475
  break;
5895
- }
5896
- case TAG_ID.FRAMESET: {
5476
+ case TAG_ID.FRAMESET:
5897
5477
  p._insertElement(token, NS.HTML);
5898
5478
  p.insertionMode = InsertionMode.IN_FRAMESET;
5899
5479
  break;
5900
- }
5901
5480
  case TAG_ID.BASE:
5902
5481
  case TAG_ID.BASEFONT:
5903
5482
  case TAG_ID.BGSOUND:
@@ -5907,17 +5486,15 @@ function startTagAfterHead(p, token) {
5907
5486
  case TAG_ID.SCRIPT:
5908
5487
  case TAG_ID.STYLE:
5909
5488
  case TAG_ID.TEMPLATE:
5910
- case TAG_ID.TITLE: {
5489
+ case TAG_ID.TITLE:
5911
5490
  p._err(token, ERR.abandonedHeadElementChild);
5912
5491
  p.openElements.push(p.headElement, TAG_ID.HEAD);
5913
5492
  startTagInHead(p, token);
5914
5493
  p.openElements.remove(p.headElement);
5915
5494
  break;
5916
- }
5917
- case TAG_ID.HEAD: {
5495
+ case TAG_ID.HEAD:
5918
5496
  p._err(token, ERR.misplacedStartTagForHeadElement);
5919
5497
  break;
5920
- }
5921
5498
  default: tokenAfterHead(p, token);
5922
5499
  }
5923
5500
  }
@@ -5925,14 +5502,12 @@ function endTagAfterHead(p, token) {
5925
5502
  switch (token.tagID) {
5926
5503
  case TAG_ID.BODY:
5927
5504
  case TAG_ID.HTML:
5928
- case TAG_ID.BR: {
5505
+ case TAG_ID.BR:
5929
5506
  tokenAfterHead(p, token);
5930
5507
  break;
5931
- }
5932
- case TAG_ID.TEMPLATE: {
5508
+ case TAG_ID.TEMPLATE:
5933
5509
  templateEndTagInHead(p, token);
5934
5510
  break;
5935
- }
5936
5511
  default: p._err(token, ERR.endTagWithoutMatchingOpenElement);
5937
5512
  }
5938
5513
  }
@@ -5943,30 +5518,24 @@ function tokenAfterHead(p, token) {
5943
5518
  }
5944
5519
  function modeInBody(p, token) {
5945
5520
  switch (token.type) {
5946
- case TokenType.CHARACTER: {
5521
+ case TokenType.CHARACTER:
5947
5522
  characterInBody(p, token);
5948
5523
  break;
5949
- }
5950
- case TokenType.WHITESPACE_CHARACTER: {
5524
+ case TokenType.WHITESPACE_CHARACTER:
5951
5525
  whitespaceCharacterInBody(p, token);
5952
5526
  break;
5953
- }
5954
- case TokenType.COMMENT: {
5527
+ case TokenType.COMMENT:
5955
5528
  appendComment(p, token);
5956
5529
  break;
5957
- }
5958
- case TokenType.START_TAG: {
5530
+ case TokenType.START_TAG:
5959
5531
  startTagInBody(p, token);
5960
5532
  break;
5961
- }
5962
- case TokenType.END_TAG: {
5533
+ case TokenType.END_TAG:
5963
5534
  endTagInBody(p, token);
5964
5535
  break;
5965
- }
5966
- case TokenType.EOF: {
5536
+ case TokenType.EOF:
5967
5537
  eofInBody(p, token);
5968
5538
  break;
5969
- }
5970
5539
  default:
5971
5540
  }
5972
5541
  }
@@ -6191,23 +5760,20 @@ function startTagInBody(p, token) {
6191
5760
  case TAG_ID.FONT:
6192
5761
  case TAG_ID.SMALL:
6193
5762
  case TAG_ID.STRIKE:
6194
- case TAG_ID.STRONG: {
5763
+ case TAG_ID.STRONG:
6195
5764
  bStartTagInBody(p, token);
6196
5765
  break;
6197
- }
6198
- case TAG_ID.A: {
5766
+ case TAG_ID.A:
6199
5767
  aStartTagInBody(p, token);
6200
5768
  break;
6201
- }
6202
5769
  case TAG_ID.H1:
6203
5770
  case TAG_ID.H2:
6204
5771
  case TAG_ID.H3:
6205
5772
  case TAG_ID.H4:
6206
5773
  case TAG_ID.H5:
6207
- case TAG_ID.H6: {
5774
+ case TAG_ID.H6:
6208
5775
  numberedHeaderStartTagInBody(p, token);
6209
5776
  break;
6210
- }
6211
5777
  case TAG_ID.P:
6212
5778
  case TAG_ID.DL:
6213
5779
  case TAG_ID.OL:
@@ -6232,56 +5798,46 @@ function startTagInBody(p, token) {
6232
5798
  case TAG_ID.SUMMARY:
6233
5799
  case TAG_ID.FIELDSET:
6234
5800
  case TAG_ID.BLOCKQUOTE:
6235
- case TAG_ID.FIGCAPTION: {
5801
+ case TAG_ID.FIGCAPTION:
6236
5802
  addressStartTagInBody(p, token);
6237
5803
  break;
6238
- }
6239
5804
  case TAG_ID.LI:
6240
5805
  case TAG_ID.DD:
6241
- case TAG_ID.DT: {
5806
+ case TAG_ID.DT:
6242
5807
  listItemStartTagInBody(p, token);
6243
5808
  break;
6244
- }
6245
5809
  case TAG_ID.BR:
6246
5810
  case TAG_ID.IMG:
6247
5811
  case TAG_ID.WBR:
6248
5812
  case TAG_ID.AREA:
6249
5813
  case TAG_ID.EMBED:
6250
- case TAG_ID.KEYGEN: {
5814
+ case TAG_ID.KEYGEN:
6251
5815
  areaStartTagInBody(p, token);
6252
5816
  break;
6253
- }
6254
- case TAG_ID.HR: {
5817
+ case TAG_ID.HR:
6255
5818
  hrStartTagInBody(p, token);
6256
5819
  break;
6257
- }
6258
5820
  case TAG_ID.RB:
6259
- case TAG_ID.RTC: {
5821
+ case TAG_ID.RTC:
6260
5822
  rbStartTagInBody(p, token);
6261
5823
  break;
6262
- }
6263
5824
  case TAG_ID.RT:
6264
- case TAG_ID.RP: {
5825
+ case TAG_ID.RP:
6265
5826
  rtStartTagInBody(p, token);
6266
5827
  break;
6267
- }
6268
5828
  case TAG_ID.PRE:
6269
- case TAG_ID.LISTING: {
5829
+ case TAG_ID.LISTING:
6270
5830
  preStartTagInBody(p, token);
6271
5831
  break;
6272
- }
6273
- case TAG_ID.XMP: {
5832
+ case TAG_ID.XMP:
6274
5833
  xmpStartTagInBody(p, token);
6275
5834
  break;
6276
- }
6277
- case TAG_ID.SVG: {
5835
+ case TAG_ID.SVG:
6278
5836
  svgStartTagInBody(p, token);
6279
5837
  break;
6280
- }
6281
- case TAG_ID.HTML: {
5838
+ case TAG_ID.HTML:
6282
5839
  htmlStartTagInBody(p, token);
6283
5840
  break;
6284
- }
6285
5841
  case TAG_ID.BASE:
6286
5842
  case TAG_ID.LINK:
6287
5843
  case TAG_ID.META:
@@ -6290,89 +5846,70 @@ function startTagInBody(p, token) {
6290
5846
  case TAG_ID.SCRIPT:
6291
5847
  case TAG_ID.BGSOUND:
6292
5848
  case TAG_ID.BASEFONT:
6293
- case TAG_ID.TEMPLATE: {
5849
+ case TAG_ID.TEMPLATE:
6294
5850
  startTagInHead(p, token);
6295
5851
  break;
6296
- }
6297
- case TAG_ID.BODY: {
5852
+ case TAG_ID.BODY:
6298
5853
  bodyStartTagInBody(p, token);
6299
5854
  break;
6300
- }
6301
- case TAG_ID.FORM: {
5855
+ case TAG_ID.FORM:
6302
5856
  formStartTagInBody(p, token);
6303
5857
  break;
6304
- }
6305
- case TAG_ID.NOBR: {
5858
+ case TAG_ID.NOBR:
6306
5859
  nobrStartTagInBody(p, token);
6307
5860
  break;
6308
- }
6309
- case TAG_ID.MATH: {
5861
+ case TAG_ID.MATH:
6310
5862
  mathStartTagInBody(p, token);
6311
5863
  break;
6312
- }
6313
- case TAG_ID.TABLE: {
5864
+ case TAG_ID.TABLE:
6314
5865
  tableStartTagInBody(p, token);
6315
5866
  break;
6316
- }
6317
- case TAG_ID.INPUT: {
5867
+ case TAG_ID.INPUT:
6318
5868
  inputStartTagInBody(p, token);
6319
5869
  break;
6320
- }
6321
5870
  case TAG_ID.PARAM:
6322
5871
  case TAG_ID.TRACK:
6323
- case TAG_ID.SOURCE: {
5872
+ case TAG_ID.SOURCE:
6324
5873
  paramStartTagInBody(p, token);
6325
5874
  break;
6326
- }
6327
- case TAG_ID.IMAGE: {
5875
+ case TAG_ID.IMAGE:
6328
5876
  imageStartTagInBody(p, token);
6329
5877
  break;
6330
- }
6331
- case TAG_ID.BUTTON: {
5878
+ case TAG_ID.BUTTON:
6332
5879
  buttonStartTagInBody(p, token);
6333
5880
  break;
6334
- }
6335
5881
  case TAG_ID.APPLET:
6336
5882
  case TAG_ID.OBJECT:
6337
- case TAG_ID.MARQUEE: {
5883
+ case TAG_ID.MARQUEE:
6338
5884
  appletStartTagInBody(p, token);
6339
5885
  break;
6340
- }
6341
- case TAG_ID.IFRAME: {
5886
+ case TAG_ID.IFRAME:
6342
5887
  iframeStartTagInBody(p, token);
6343
5888
  break;
6344
- }
6345
- case TAG_ID.SELECT: {
5889
+ case TAG_ID.SELECT:
6346
5890
  selectStartTagInBody(p, token);
6347
5891
  break;
6348
- }
6349
5892
  case TAG_ID.OPTION:
6350
- case TAG_ID.OPTGROUP: {
5893
+ case TAG_ID.OPTGROUP:
6351
5894
  optgroupStartTagInBody(p, token);
6352
5895
  break;
6353
- }
6354
5896
  case TAG_ID.NOEMBED:
6355
- case TAG_ID.NOFRAMES: {
5897
+ case TAG_ID.NOFRAMES:
6356
5898
  rawTextStartTagInBody(p, token);
6357
5899
  break;
6358
- }
6359
- case TAG_ID.FRAMESET: {
5900
+ case TAG_ID.FRAMESET:
6360
5901
  framesetStartTagInBody(p, token);
6361
5902
  break;
6362
- }
6363
- case TAG_ID.TEXTAREA: {
5903
+ case TAG_ID.TEXTAREA:
6364
5904
  textareaStartTagInBody(p, token);
6365
5905
  break;
6366
- }
6367
- case TAG_ID.NOSCRIPT: {
5906
+ case TAG_ID.NOSCRIPT:
6368
5907
  if (p.options.scriptingEnabled) rawTextStartTagInBody(p, token);
6369
5908
  else genericStartTagInBody(p, token);
6370
5909
  break;
6371
- }
6372
- case TAG_ID.PLAINTEXT: {
5910
+ case TAG_ID.PLAINTEXT:
6373
5911
  plaintextStartTagInBody(p, token);
6374
5912
  break;
6375
- }
6376
5913
  case TAG_ID.COL:
6377
5914
  case TAG_ID.TH:
6378
5915
  case TAG_ID.TD:
@@ -6485,14 +6022,12 @@ function endTagInBody(p, token) {
6485
6022
  case TAG_ID.NOBR:
6486
6023
  case TAG_ID.SMALL:
6487
6024
  case TAG_ID.STRIKE:
6488
- case TAG_ID.STRONG: {
6025
+ case TAG_ID.STRONG:
6489
6026
  callAdoptionAgency(p, token);
6490
6027
  break;
6491
- }
6492
- case TAG_ID.P: {
6028
+ case TAG_ID.P:
6493
6029
  pEndTagInBody(p);
6494
6030
  break;
6495
- }
6496
6031
  case TAG_ID.DL:
6497
6032
  case TAG_ID.UL:
6498
6033
  case TAG_ID.OL:
@@ -6519,54 +6054,44 @@ function endTagInBody(p, token) {
6519
6054
  case TAG_ID.LISTING:
6520
6055
  case TAG_ID.FIELDSET:
6521
6056
  case TAG_ID.BLOCKQUOTE:
6522
- case TAG_ID.FIGCAPTION: {
6057
+ case TAG_ID.FIGCAPTION:
6523
6058
  addressEndTagInBody(p, token);
6524
6059
  break;
6525
- }
6526
- case TAG_ID.LI: {
6060
+ case TAG_ID.LI:
6527
6061
  liEndTagInBody(p);
6528
6062
  break;
6529
- }
6530
6063
  case TAG_ID.DD:
6531
- case TAG_ID.DT: {
6064
+ case TAG_ID.DT:
6532
6065
  ddEndTagInBody(p, token);
6533
6066
  break;
6534
- }
6535
6067
  case TAG_ID.H1:
6536
6068
  case TAG_ID.H2:
6537
6069
  case TAG_ID.H3:
6538
6070
  case TAG_ID.H4:
6539
6071
  case TAG_ID.H5:
6540
- case TAG_ID.H6: {
6072
+ case TAG_ID.H6:
6541
6073
  numberedHeaderEndTagInBody(p);
6542
6074
  break;
6543
- }
6544
- case TAG_ID.BR: {
6075
+ case TAG_ID.BR:
6545
6076
  brEndTagInBody(p);
6546
6077
  break;
6547
- }
6548
- case TAG_ID.BODY: {
6078
+ case TAG_ID.BODY:
6549
6079
  bodyEndTagInBody(p, token);
6550
6080
  break;
6551
- }
6552
- case TAG_ID.HTML: {
6081
+ case TAG_ID.HTML:
6553
6082
  htmlEndTagInBody(p, token);
6554
6083
  break;
6555
- }
6556
- case TAG_ID.FORM: {
6084
+ case TAG_ID.FORM:
6557
6085
  formEndTagInBody(p);
6558
6086
  break;
6559
- }
6560
6087
  case TAG_ID.APPLET:
6561
6088
  case TAG_ID.OBJECT:
6562
- case TAG_ID.MARQUEE: {
6089
+ case TAG_ID.MARQUEE:
6563
6090
  appletEndTagInBody(p, token);
6564
6091
  break;
6565
- }
6566
- case TAG_ID.TEMPLATE: {
6092
+ case TAG_ID.TEMPLATE:
6567
6093
  templateEndTagInHead(p, token);
6568
6094
  break;
6569
- }
6570
6095
  default: genericEndTagInBody(p, token);
6571
6096
  }
6572
6097
  }
@@ -6593,14 +6118,12 @@ function characterInTable(p, token) {
6593
6118
  p.originalInsertionMode = p.insertionMode;
6594
6119
  p.insertionMode = InsertionMode.IN_TABLE_TEXT;
6595
6120
  switch (token.type) {
6596
- case TokenType.CHARACTER: {
6121
+ case TokenType.CHARACTER:
6597
6122
  characterInTableText(p, token);
6598
6123
  break;
6599
- }
6600
- case TokenType.WHITESPACE_CHARACTER: {
6124
+ case TokenType.WHITESPACE_CHARACTER:
6601
6125
  whitespaceCharacterInTableText(p, token);
6602
6126
  break;
6603
- }
6604
6127
  }
6605
6128
  } else tokenInTable(p, token);
6606
6129
  }
@@ -6655,62 +6178,51 @@ function startTagInTable(p, token) {
6655
6178
  switch (token.tagID) {
6656
6179
  case TAG_ID.TD:
6657
6180
  case TAG_ID.TH:
6658
- case TAG_ID.TR: {
6181
+ case TAG_ID.TR:
6659
6182
  tdStartTagInTable(p, token);
6660
6183
  break;
6661
- }
6662
6184
  case TAG_ID.STYLE:
6663
6185
  case TAG_ID.SCRIPT:
6664
- case TAG_ID.TEMPLATE: {
6186
+ case TAG_ID.TEMPLATE:
6665
6187
  startTagInHead(p, token);
6666
6188
  break;
6667
- }
6668
- case TAG_ID.COL: {
6189
+ case TAG_ID.COL:
6669
6190
  colStartTagInTable(p, token);
6670
6191
  break;
6671
- }
6672
- case TAG_ID.FORM: {
6192
+ case TAG_ID.FORM:
6673
6193
  formStartTagInTable(p, token);
6674
6194
  break;
6675
- }
6676
- case TAG_ID.TABLE: {
6195
+ case TAG_ID.TABLE:
6677
6196
  tableStartTagInTable(p, token);
6678
6197
  break;
6679
- }
6680
6198
  case TAG_ID.TBODY:
6681
6199
  case TAG_ID.TFOOT:
6682
- case TAG_ID.THEAD: {
6200
+ case TAG_ID.THEAD:
6683
6201
  tbodyStartTagInTable(p, token);
6684
6202
  break;
6685
- }
6686
- case TAG_ID.INPUT: {
6203
+ case TAG_ID.INPUT:
6687
6204
  inputStartTagInTable(p, token);
6688
6205
  break;
6689
- }
6690
- case TAG_ID.CAPTION: {
6206
+ case TAG_ID.CAPTION:
6691
6207
  captionStartTagInTable(p, token);
6692
6208
  break;
6693
- }
6694
- case TAG_ID.COLGROUP: {
6209
+ case TAG_ID.COLGROUP:
6695
6210
  colgroupStartTagInTable(p, token);
6696
6211
  break;
6697
- }
6698
6212
  default: tokenInTable(p, token);
6699
6213
  }
6700
6214
  }
6701
6215
  function endTagInTable(p, token) {
6702
6216
  switch (token.tagID) {
6703
- case TAG_ID.TABLE: {
6217
+ case TAG_ID.TABLE:
6704
6218
  if (p.openElements.hasInTableScope(TAG_ID.TABLE)) {
6705
6219
  p.openElements.popUntilTagNamePopped(TAG_ID.TABLE);
6706
6220
  p._resetInsertionMode();
6707
6221
  }
6708
6222
  break;
6709
- }
6710
- case TAG_ID.TEMPLATE: {
6223
+ case TAG_ID.TEMPLATE:
6711
6224
  templateEndTagInHead(p, token);
6712
6225
  break;
6713
- }
6714
6226
  case TAG_ID.BODY:
6715
6227
  case TAG_ID.CAPTION:
6716
6228
  case TAG_ID.COL:
@@ -6772,7 +6284,7 @@ function endTagInCaption(p, token) {
6772
6284
  const tn = token.tagID;
6773
6285
  switch (tn) {
6774
6286
  case TAG_ID.CAPTION:
6775
- case TAG_ID.TABLE: {
6287
+ case TAG_ID.TABLE:
6776
6288
  if (p.openElements.hasInTableScope(TAG_ID.CAPTION)) {
6777
6289
  p.openElements.generateImpliedEndTags();
6778
6290
  p.openElements.popUntilTagNamePopped(TAG_ID.CAPTION);
@@ -6781,7 +6293,6 @@ function endTagInCaption(p, token) {
6781
6293
  if (tn === TAG_ID.TABLE) endTagInTable(p, token);
6782
6294
  }
6783
6295
  break;
6784
- }
6785
6296
  case TAG_ID.BODY:
6786
6297
  case TAG_ID.COL:
6787
6298
  case TAG_ID.COLGROUP:
@@ -6797,35 +6308,30 @@ function endTagInCaption(p, token) {
6797
6308
  }
6798
6309
  function startTagInColumnGroup(p, token) {
6799
6310
  switch (token.tagID) {
6800
- case TAG_ID.HTML: {
6311
+ case TAG_ID.HTML:
6801
6312
  startTagInBody(p, token);
6802
6313
  break;
6803
- }
6804
- case TAG_ID.COL: {
6314
+ case TAG_ID.COL:
6805
6315
  p._appendElement(token, NS.HTML);
6806
6316
  token.ackSelfClosing = true;
6807
6317
  break;
6808
- }
6809
- case TAG_ID.TEMPLATE: {
6318
+ case TAG_ID.TEMPLATE:
6810
6319
  startTagInHead(p, token);
6811
6320
  break;
6812
- }
6813
6321
  default: tokenInColumnGroup(p, token);
6814
6322
  }
6815
6323
  }
6816
6324
  function endTagInColumnGroup(p, token) {
6817
6325
  switch (token.tagID) {
6818
- case TAG_ID.COLGROUP: {
6326
+ case TAG_ID.COLGROUP:
6819
6327
  if (p.openElements.currentTagId === TAG_ID.COLGROUP) {
6820
6328
  p.openElements.pop();
6821
6329
  p.insertionMode = InsertionMode.IN_TABLE;
6822
6330
  }
6823
6331
  break;
6824
- }
6825
- case TAG_ID.TEMPLATE: {
6332
+ case TAG_ID.TEMPLATE:
6826
6333
  templateEndTagInHead(p, token);
6827
6334
  break;
6828
- }
6829
6335
  case TAG_ID.COL: break;
6830
6336
  default: tokenInColumnGroup(p, token);
6831
6337
  }
@@ -6839,26 +6345,24 @@ function tokenInColumnGroup(p, token) {
6839
6345
  }
6840
6346
  function startTagInTableBody(p, token) {
6841
6347
  switch (token.tagID) {
6842
- case TAG_ID.TR: {
6348
+ case TAG_ID.TR:
6843
6349
  p.openElements.clearBackToTableBodyContext();
6844
6350
  p._insertElement(token, NS.HTML);
6845
6351
  p.insertionMode = InsertionMode.IN_ROW;
6846
6352
  break;
6847
- }
6848
6353
  case TAG_ID.TH:
6849
- case TAG_ID.TD: {
6354
+ case TAG_ID.TD:
6850
6355
  p.openElements.clearBackToTableBodyContext();
6851
6356
  p._insertFakeElement(TAG_NAMES.TR, TAG_ID.TR);
6852
6357
  p.insertionMode = InsertionMode.IN_ROW;
6853
6358
  startTagInRow(p, token);
6854
6359
  break;
6855
- }
6856
6360
  case TAG_ID.CAPTION:
6857
6361
  case TAG_ID.COL:
6858
6362
  case TAG_ID.COLGROUP:
6859
6363
  case TAG_ID.TBODY:
6860
6364
  case TAG_ID.TFOOT:
6861
- case TAG_ID.THEAD: {
6365
+ case TAG_ID.THEAD:
6862
6366
  if (p.openElements.hasTableBodyContextInTableScope()) {
6863
6367
  p.openElements.clearBackToTableBodyContext();
6864
6368
  p.openElements.pop();
@@ -6866,7 +6370,6 @@ function startTagInTableBody(p, token) {
6866
6370
  startTagInTable(p, token);
6867
6371
  }
6868
6372
  break;
6869
- }
6870
6373
  default: startTagInTable(p, token);
6871
6374
  }
6872
6375
  }
@@ -6875,15 +6378,14 @@ function endTagInTableBody(p, token) {
6875
6378
  switch (token.tagID) {
6876
6379
  case TAG_ID.TBODY:
6877
6380
  case TAG_ID.TFOOT:
6878
- case TAG_ID.THEAD: {
6381
+ case TAG_ID.THEAD:
6879
6382
  if (p.openElements.hasInTableScope(tn)) {
6880
6383
  p.openElements.clearBackToTableBodyContext();
6881
6384
  p.openElements.pop();
6882
6385
  p.insertionMode = InsertionMode.IN_TABLE;
6883
6386
  }
6884
6387
  break;
6885
- }
6886
- case TAG_ID.TABLE: {
6388
+ case TAG_ID.TABLE:
6887
6389
  if (p.openElements.hasTableBodyContextInTableScope()) {
6888
6390
  p.openElements.clearBackToTableBodyContext();
6889
6391
  p.openElements.pop();
@@ -6891,7 +6393,6 @@ function endTagInTableBody(p, token) {
6891
6393
  endTagInTable(p, token);
6892
6394
  }
6893
6395
  break;
6894
- }
6895
6396
  case TAG_ID.BODY:
6896
6397
  case TAG_ID.CAPTION:
6897
6398
  case TAG_ID.COL:
@@ -6906,20 +6407,19 @@ function endTagInTableBody(p, token) {
6906
6407
  function startTagInRow(p, token) {
6907
6408
  switch (token.tagID) {
6908
6409
  case TAG_ID.TH:
6909
- case TAG_ID.TD: {
6410
+ case TAG_ID.TD:
6910
6411
  p.openElements.clearBackToTableRowContext();
6911
6412
  p._insertElement(token, NS.HTML);
6912
6413
  p.insertionMode = InsertionMode.IN_CELL;
6913
6414
  p.activeFormattingElements.insertMarker();
6914
6415
  break;
6915
- }
6916
6416
  case TAG_ID.CAPTION:
6917
6417
  case TAG_ID.COL:
6918
6418
  case TAG_ID.COLGROUP:
6919
6419
  case TAG_ID.TBODY:
6920
6420
  case TAG_ID.TFOOT:
6921
6421
  case TAG_ID.THEAD:
6922
- case TAG_ID.TR: {
6422
+ case TAG_ID.TR:
6923
6423
  if (p.openElements.hasInTableScope(TAG_ID.TR)) {
6924
6424
  p.openElements.clearBackToTableRowContext();
6925
6425
  p.openElements.pop();
@@ -6927,21 +6427,19 @@ function startTagInRow(p, token) {
6927
6427
  startTagInTableBody(p, token);
6928
6428
  }
6929
6429
  break;
6930
- }
6931
6430
  default: startTagInTable(p, token);
6932
6431
  }
6933
6432
  }
6934
6433
  function endTagInRow(p, token) {
6935
6434
  switch (token.tagID) {
6936
- case TAG_ID.TR: {
6435
+ case TAG_ID.TR:
6937
6436
  if (p.openElements.hasInTableScope(TAG_ID.TR)) {
6938
6437
  p.openElements.clearBackToTableRowContext();
6939
6438
  p.openElements.pop();
6940
6439
  p.insertionMode = InsertionMode.IN_TABLE_BODY;
6941
6440
  }
6942
6441
  break;
6943
- }
6944
- case TAG_ID.TABLE: {
6442
+ case TAG_ID.TABLE:
6945
6443
  if (p.openElements.hasInTableScope(TAG_ID.TR)) {
6946
6444
  p.openElements.clearBackToTableRowContext();
6947
6445
  p.openElements.pop();
@@ -6949,10 +6447,9 @@ function endTagInRow(p, token) {
6949
6447
  endTagInTableBody(p, token);
6950
6448
  }
6951
6449
  break;
6952
- }
6953
6450
  case TAG_ID.TBODY:
6954
6451
  case TAG_ID.TFOOT:
6955
- case TAG_ID.THEAD: {
6452
+ case TAG_ID.THEAD:
6956
6453
  if (p.openElements.hasInTableScope(token.tagID) || p.openElements.hasInTableScope(TAG_ID.TR)) {
6957
6454
  p.openElements.clearBackToTableRowContext();
6958
6455
  p.openElements.pop();
@@ -6960,7 +6457,6 @@ function endTagInRow(p, token) {
6960
6457
  endTagInTableBody(p, token);
6961
6458
  }
6962
6459
  break;
6963
- }
6964
6460
  case TAG_ID.BODY:
6965
6461
  case TAG_ID.CAPTION:
6966
6462
  case TAG_ID.COL:
@@ -6984,7 +6480,7 @@ function endTagInCell(p, token) {
6984
6480
  const tn = token.tagID;
6985
6481
  switch (tn) {
6986
6482
  case TAG_ID.TD:
6987
- case TAG_ID.TH: {
6483
+ case TAG_ID.TH:
6988
6484
  if (p.openElements.hasInTableScope(tn)) {
6989
6485
  p.openElements.generateImpliedEndTags();
6990
6486
  p.openElements.popUntilTagNamePopped(tn);
@@ -6992,18 +6488,16 @@ function endTagInCell(p, token) {
6992
6488
  p.insertionMode = InsertionMode.IN_ROW;
6993
6489
  }
6994
6490
  break;
6995
- }
6996
6491
  case TAG_ID.TABLE:
6997
6492
  case TAG_ID.TBODY:
6998
6493
  case TAG_ID.TFOOT:
6999
6494
  case TAG_ID.THEAD:
7000
- case TAG_ID.TR: {
6495
+ case TAG_ID.TR:
7001
6496
  if (p.openElements.hasInTableScope(tn)) {
7002
6497
  p._closeTableCell();
7003
6498
  endTagInRow(p, token);
7004
6499
  }
7005
6500
  break;
7006
- }
7007
6501
  case TAG_ID.BODY:
7008
6502
  case TAG_ID.CAPTION:
7009
6503
  case TAG_ID.COL:
@@ -7014,69 +6508,59 @@ function endTagInCell(p, token) {
7014
6508
  }
7015
6509
  function startTagInSelect(p, token) {
7016
6510
  switch (token.tagID) {
7017
- case TAG_ID.HTML: {
6511
+ case TAG_ID.HTML:
7018
6512
  startTagInBody(p, token);
7019
6513
  break;
7020
- }
7021
- case TAG_ID.OPTION: {
6514
+ case TAG_ID.OPTION:
7022
6515
  if (p.openElements.currentTagId === TAG_ID.OPTION) p.openElements.pop();
7023
6516
  p._insertElement(token, NS.HTML);
7024
6517
  break;
7025
- }
7026
- case TAG_ID.OPTGROUP: {
6518
+ case TAG_ID.OPTGROUP:
7027
6519
  if (p.openElements.currentTagId === TAG_ID.OPTION) p.openElements.pop();
7028
6520
  if (p.openElements.currentTagId === TAG_ID.OPTGROUP) p.openElements.pop();
7029
6521
  p._insertElement(token, NS.HTML);
7030
6522
  break;
7031
- }
7032
- case TAG_ID.HR: {
6523
+ case TAG_ID.HR:
7033
6524
  if (p.openElements.currentTagId === TAG_ID.OPTION) p.openElements.pop();
7034
6525
  if (p.openElements.currentTagId === TAG_ID.OPTGROUP) p.openElements.pop();
7035
6526
  p._appendElement(token, NS.HTML);
7036
6527
  token.ackSelfClosing = true;
7037
6528
  break;
7038
- }
7039
6529
  case TAG_ID.INPUT:
7040
6530
  case TAG_ID.KEYGEN:
7041
6531
  case TAG_ID.TEXTAREA:
7042
- case TAG_ID.SELECT: {
6532
+ case TAG_ID.SELECT:
7043
6533
  if (p.openElements.hasInSelectScope(TAG_ID.SELECT)) {
7044
6534
  p.openElements.popUntilTagNamePopped(TAG_ID.SELECT);
7045
6535
  p._resetInsertionMode();
7046
6536
  if (token.tagID !== TAG_ID.SELECT) p._processStartTag(token);
7047
6537
  }
7048
6538
  break;
7049
- }
7050
6539
  case TAG_ID.SCRIPT:
7051
- case TAG_ID.TEMPLATE: {
6540
+ case TAG_ID.TEMPLATE:
7052
6541
  startTagInHead(p, token);
7053
6542
  break;
7054
- }
7055
6543
  default:
7056
6544
  }
7057
6545
  }
7058
6546
  function endTagInSelect(p, token) {
7059
6547
  switch (token.tagID) {
7060
- case TAG_ID.OPTGROUP: {
6548
+ case TAG_ID.OPTGROUP:
7061
6549
  if (p.openElements.stackTop > 0 && p.openElements.currentTagId === TAG_ID.OPTION && p.openElements.tagIDs[p.openElements.stackTop - 1] === TAG_ID.OPTGROUP) p.openElements.pop();
7062
6550
  if (p.openElements.currentTagId === TAG_ID.OPTGROUP) p.openElements.pop();
7063
6551
  break;
7064
- }
7065
- case TAG_ID.OPTION: {
6552
+ case TAG_ID.OPTION:
7066
6553
  if (p.openElements.currentTagId === TAG_ID.OPTION) p.openElements.pop();
7067
6554
  break;
7068
- }
7069
- case TAG_ID.SELECT: {
6555
+ case TAG_ID.SELECT:
7070
6556
  if (p.openElements.hasInSelectScope(TAG_ID.SELECT)) {
7071
6557
  p.openElements.popUntilTagNamePopped(TAG_ID.SELECT);
7072
6558
  p._resetInsertionMode();
7073
6559
  }
7074
6560
  break;
7075
- }
7076
- case TAG_ID.TEMPLATE: {
6561
+ case TAG_ID.TEMPLATE:
7077
6562
  templateEndTagInHead(p, token);
7078
6563
  break;
7079
- }
7080
6564
  default:
7081
6565
  }
7082
6566
  }
@@ -7109,44 +6593,38 @@ function startTagInTemplate(p, token) {
7109
6593
  case TAG_ID.SCRIPT:
7110
6594
  case TAG_ID.STYLE:
7111
6595
  case TAG_ID.TEMPLATE:
7112
- case TAG_ID.TITLE: {
6596
+ case TAG_ID.TITLE:
7113
6597
  startTagInHead(p, token);
7114
6598
  break;
7115
- }
7116
6599
  case TAG_ID.CAPTION:
7117
6600
  case TAG_ID.COLGROUP:
7118
6601
  case TAG_ID.TBODY:
7119
6602
  case TAG_ID.TFOOT:
7120
- case TAG_ID.THEAD: {
6603
+ case TAG_ID.THEAD:
7121
6604
  p.tmplInsertionModeStack[0] = InsertionMode.IN_TABLE;
7122
6605
  p.insertionMode = InsertionMode.IN_TABLE;
7123
6606
  startTagInTable(p, token);
7124
6607
  break;
7125
- }
7126
- case TAG_ID.COL: {
6608
+ case TAG_ID.COL:
7127
6609
  p.tmplInsertionModeStack[0] = InsertionMode.IN_COLUMN_GROUP;
7128
6610
  p.insertionMode = InsertionMode.IN_COLUMN_GROUP;
7129
6611
  startTagInColumnGroup(p, token);
7130
6612
  break;
7131
- }
7132
- case TAG_ID.TR: {
6613
+ case TAG_ID.TR:
7133
6614
  p.tmplInsertionModeStack[0] = InsertionMode.IN_TABLE_BODY;
7134
6615
  p.insertionMode = InsertionMode.IN_TABLE_BODY;
7135
6616
  startTagInTableBody(p, token);
7136
6617
  break;
7137
- }
7138
6618
  case TAG_ID.TD:
7139
- case TAG_ID.TH: {
6619
+ case TAG_ID.TH:
7140
6620
  p.tmplInsertionModeStack[0] = InsertionMode.IN_ROW;
7141
6621
  p.insertionMode = InsertionMode.IN_ROW;
7142
6622
  startTagInRow(p, token);
7143
6623
  break;
7144
- }
7145
- default: {
6624
+ default:
7146
6625
  p.tmplInsertionModeStack[0] = InsertionMode.IN_BODY;
7147
6626
  p.insertionMode = InsertionMode.IN_BODY;
7148
6627
  startTagInBody(p, token);
7149
- }
7150
6628
  }
7151
6629
  }
7152
6630
  function endTagInTemplate(p, token) {
@@ -7182,23 +6660,19 @@ function tokenAfterBody(p, token) {
7182
6660
  }
7183
6661
  function startTagInFrameset(p, token) {
7184
6662
  switch (token.tagID) {
7185
- case TAG_ID.HTML: {
6663
+ case TAG_ID.HTML:
7186
6664
  startTagInBody(p, token);
7187
6665
  break;
7188
- }
7189
- case TAG_ID.FRAMESET: {
6666
+ case TAG_ID.FRAMESET:
7190
6667
  p._insertElement(token, NS.HTML);
7191
6668
  break;
7192
- }
7193
- case TAG_ID.FRAME: {
6669
+ case TAG_ID.FRAME:
7194
6670
  p._appendElement(token, NS.HTML);
7195
6671
  token.ackSelfClosing = true;
7196
6672
  break;
7197
- }
7198
- case TAG_ID.NOFRAMES: {
6673
+ case TAG_ID.NOFRAMES:
7199
6674
  startTagInHead(p, token);
7200
6675
  break;
7201
- }
7202
6676
  default:
7203
6677
  }
7204
6678
  }
@@ -7210,14 +6684,12 @@ function endTagInFrameset(p, token) {
7210
6684
  }
7211
6685
  function startTagAfterFrameset(p, token) {
7212
6686
  switch (token.tagID) {
7213
- case TAG_ID.HTML: {
6687
+ case TAG_ID.HTML:
7214
6688
  startTagInBody(p, token);
7215
6689
  break;
7216
- }
7217
- case TAG_ID.NOFRAMES: {
6690
+ case TAG_ID.NOFRAMES:
7218
6691
  startTagInHead(p, token);
7219
6692
  break;
7220
- }
7221
6693
  default:
7222
6694
  }
7223
6695
  }
@@ -7234,14 +6706,12 @@ function tokenAfterAfterBody(p, token) {
7234
6706
  }
7235
6707
  function startTagAfterAfterFrameset(p, token) {
7236
6708
  switch (token.tagID) {
7237
- case TAG_ID.HTML: {
6709
+ case TAG_ID.HTML:
7238
6710
  startTagInBody(p, token);
7239
6711
  break;
7240
- }
7241
- case TAG_ID.NOFRAMES: {
6712
+ case TAG_ID.NOFRAMES:
7242
6713
  startTagInHead(p, token);
7243
6714
  break;
7244
- }
7245
6715
  default:
7246
6716
  }
7247
6717
  }