12.2.3.1. 既知の符号化法による構文解析

~HTML構文解析器が `既知の確定的な符号化法@ を伴う入力~byte~stream上で演算するときの ( 符号化法, `確度$ ) は、 ( その符号化法, `確か^i ) になるとする。 ◎ When the HTML parser is to operate on an input byte stream that has a known definite encoding, then the character encoding is that encoding and the confidence is certain.

12.2.3.2. 符号化法の決定-法

文書を構文解析する前に符号化法を一義的に決定するのは、実用的でない事例もあるかもしれない。 そのため，この仕様は、 2 周回の仕組みを供する： ◎ In some cases, it might be impractical to unambiguously determine the encoding before parsing the document. Because of this, this specification provides for a two-pass mechanism with an optional pre-scan.＼

1. 1 周回~目の予走査は、任意選択である — 実装には、文書を構文解析し始める前に可用な~byte列に，それが何であれ［ 下に述べる，単純~化された構文解析~algoを適用する ］ことも許容される。 ◎ Implementations are allowed, as described below, to apply a simplified parsing algorithm to whatever bytes they have available before beginning to parse the document.＼
2. 2 周回~目の本番の構文解析器は、［ 予走査から導出された暫定的な符号化法と，他の帯域外の~metadata ］を利用して開始される。 文書が読込まれている間に，~UAがこの情報と競合するような符号化法~宣言を発見した場合、構文解析器は — 文書の構文解析-を，本番の符号化法の下で遂行するようにしておく下で — 再び呼出されることになる。 ◎ Then, the real parser is started, using a tentative encoding derived from this pre-parse and other out-of-band metadata. If, while the document is being loaded, the user agent discovers a character encoding declaration that conflicts with this information, then the parser can get reinvoked to perform a parse of the document with the real encoding.

~UAは 1 周回~目にて，文書の復号-時に利用する符号化法を決定するときには、次に与える `符号化法を~sniffする~algo@ を利用し~MUST。 この~algoは、所与の［ それまでに可用なすべての~byte列, ~UAに可用な帯域外の~metadata（もしあれば — 例：文書の`~Content-Type~metadata$） ］に対し， ( 符号化法, `確度$ ~IN { `暫定的^i, `確か^i } ) の組を返す： ◎ User agents must use the following algorithm, called the encoding sniffing algorithm, to determine the character encoding to use when decoding a document in the first pass. This algorithm takes as input any out-of-band metadata available to the user agent (e.g. the Content-Type metadata of the document) and all the bytes available so far, and returns a character encoding and a confidence that is either tentative or certain.

1. ~IF［ 利用者は、文書の符号化法を 特定の符号化法で上書きするよう，明示的に~UAに指図した ］ ⇒ ~UAの任意選択で ⇒ ~RET ( その符号化法, `確か^i ) ◎ If the user has explicitly instructed the user agent to override the document's character encoding with a specific encoding, optionally return that encoding with the confidence certain.

   注記： ~UAは概して、利用者からのそのような要請を複数~sessionにわたって覚える。 また、一部の事例では `iframe$e 内の文書にもそれらを適用する。 ◎ Typically, user agents remember such user requests across sessions, and in some cases apply them to documents in iframes as well.

2. ~UAは、［ この~algoの，この段も含む以降の各~段 ］にて，資源の~byte列が更に可用になるまで待機して~MAY。 具体例として，~UAは、［ 500ms 経つか, 1024 ~byte得られるか ］いずれか早い方まで待機するかもしれない。 一般に，符号化法を見出すために~sourceを予め構文解析すれば、処理能は改善される — そうすれば、符号化法~情報が見出されたとき，構文解析-時に利用した~data構造を棄てる必要は抑制されるので。 しかしながら、この処理能の改善より，［ 符号化法を決定するための~dataを得るために，~UAが遅延し過ぎることによる~cost ］の方が重くなることもある。 ◎ The user agent may wait for more bytes of the resource to be available, either in this step or at any later step in this algorithm. For instance, a user agent might wait 500ms or 1024 bytes, whichever came first. In general preparsing the source to find the encoding improves performance, as it reduces the need to throw away the data structures used when parsing upon finding the encoding information. However, if the user agent delays too long to obtain data to determine the encoding, then the cost of the delay could outweigh any performance improvements from the preparse.

   注記： 符号化法~宣言に対する著作~適合性~要件は、それを 最初の 1024 ~byteまで に現れるものに制限する。 したがって，~UAには、下に示す予走査~algoを最初の 1024 ~byteまでに限って（この手続きが呼出すように）利用し，それを超えて停滞しないことが奨励される。 ◎ The authoring conformance requirements for character encoding declarations limit them to only appearing in the first 1024 bytes. User agents are therefore encouraged to use the prescan algorithm below (as invoked by these steps) on the first 1024 bytes, but not to stall beyond that.

3. ~IF［ ~transport層は、~supportされる符号化法を指定している ］ ⇒ ~RET ( その符号化法, `確か^i ) ◎ If the transport layer specifies a character encoding, and it is supported, return that encoding with the confidence certain.

4. ~UAの任意選択で、次を走らす — ~UAは，~byteをまったく走査しない方が効率的であると決めて~MAY — その場合、この段は まるごと飛ばされる： ◎ Optionally＼

   1. `~byte~streamを予走査して符号化法を決定する$ — その %終端~条件 は、~UAが［ それ以上~byteを走査しても効率的にならない ］と決める所までとする。 ~UAには、最初の 1024~byteのみ予走査することが奨励される。 ◎ prescan the byte stream to determine its encoding. The end condition is that the user agent decides that scanning further bytes would not be efficient. User agents are encouraged to only prescan the first 1024 bytes. User agents may decide that scanning any bytes is not efficient, in which case these substeps are entirely skipped.
   2. ~IF［ 前~段にて成功裡に符号化法が得られた ］ ⇒＃ ~RET ( その符号化法, `暫定的^i ) ◎ The aforementioned algorithm either aborts unsuccessfully or returns a character encoding. If it returns a character encoding, then return the same encoding, with confidence tentative.

5. ~IF［［ この~algoを走らせている`~HTML構文解析器$を結付けている`文書$ %新たな文書 ］が`属する閲覧文脈$ %B は，ある`文書$ %親~文書 を`通して入子にされて$いる（ %親~文書 は %B の`親~閲覧文脈$にて`作動中の文書$である） ］： ◎ If the HTML parser for which this algorithm is being run is associated with a Document that is itself in a nested browsing context, run these substeps: ◎ Let new document be the Document with which the HTML parser is associated. ◎ Let parent document be the Document through which new document is nested (the active document of the parent browsing context of new document).

   1. ~IF［ ( %親~文書 の`生成元$, %新たな文書 の`生成元$ ) は、`同一生成元$である ］~AND［ %親~文書 の`符号化法$docは`~ASCII互換な符号化法$である ］ ⇒ ~RET ( %親~文書 の`符号化法$doc, `暫定的^i ) ◎ If parent document's origin is same origin with new document's origin, and parent document's character encoding is an ASCII-compatible encoding, then return parent document's character encoding, with the confidence tentative.
6. ~ELIF［ ~UAは、当の頁に見込まれる符号化法の情報を有する — 例：最後に訪問したときの頁の符号化法に基づくものなど ］ ⇒ ~RET ( その符号化法, `暫定的^i ) ◎ Otherwise, if the user agent has information on the likely encoding for this page, e.g. based on the encoding of the page when it was last visited, then return that encoding, with the confidence tentative.

7. ~UAの任意選択で、次を走らす：

   1. ~data~streamに頻度解析その他の~algoを適用して，符号化法を自動検出しようと試みる — そのような~algoは、資源の内容の他にも資源についての情報（例：資源の~address）があれば，それを利用して~MAY `UNIVCHARDET$r ◎ The user agent may attempt to autodetect the character encoding from applying frequency analysis or other algorithms to the data stream. Such algorithms may use information about the resource other than the resource's contents, including the address of the resource.＼
   2. ~IF［ 前~段にて符号化法を決定するのに成功した ］~AND［ 結果の符号化法は~supportされる符号化法である ］ ⇒ ~RET ( 結果の符号化法, `暫定的^i ) ◎ If autodetection succeeds in determining a character encoding, and that encoding is a supported encoding, then return that encoding, with the confidence tentative. [UNIVCHARDET]

   注記： ~UAには、~network越しに得られた資源に対しては，符号化法を自動検出しようと試みないことが一般に奨励される — そうすることは、内来的に相互運用可能でない経験則を孕むので。 符号化法を~HTML文書の前置きに基づいて検出しようと試みるのは、とりわけ込み入っている — ~HTML~markupは，概して~ASCII文字のみを利用しており、~HTML文書は，~text内容に~~先立って多量の~markupから始まる傾向にあるので。 ◎ User agents are generally discouraged from attempting to autodetect encodings for resources obtained over the network, since doing so involves inherently non-interoperable heuristics. Attempting to detect encodings based on an HTML document's preamble is especially tricky since HTML markup typically uses only ASCII characters, and HTML documents tend to begin with a lot of markup rather than with text content.

   注記： ~UTF-8符号化法の~bit~patternは、非常に検出し易い。 局所~file~systemからの~fileは、［ 値が `7F^X より大きく, ~UTF-8~patternに合致するような，~byte列 ］を包含しているならば，およそ ~UTF-8と見込まれる一方で、合致しない~byte列を伴う文書は，およそ そうでないと見込まれる。 ~UAは，前置きのみならず~file全体を精査できるなら、特に~UTF-8を検出することが，とりわけ効果的になり得る。 `PPUTF8$r `UTF8DET$r ◎ The UTF-8 encoding has a highly detectable bit pattern. Files from the local file system that contain bytes with values greater than 0x7F which match the UTF-8 pattern are very likely to be UTF-8, while documents with byte sequences that do not match it are very likely not. When a user agent can examine the whole file, rather than just the preamble, detecting for UTF-8 specifically can be especially effective. [PPUTF8] [UTF8DET]

8. ~RET ( ［ 実装により定義される／利用者により指定される ］既定の符号化法, `暫定的^i ) ◎ Otherwise, return an implementation-defined or user-specified default character encoding, with the confidence tentative.

   • 制御~下にある環境や，文書の符号化法が 制定-済みの環境（例えば，新たな~networkに専用の利用が意図される~UA用の）に対しては、包括的 `UTF-8^enc 符号化法が示唆される。 ◎ In controlled environments or in environments where the encoding of documents can be prescribed (for example, for user agents intended for dedicated use in new networks), the comprehensive UTF-8 encoding is suggested.

   • 他の環境においては、既定の符号化法は，概して利用者の~localeに依存する（~localeとは、利用者が 頁たちにわたって頻用すると見込まれる言語の近似であり、符号化法も その言語から~~導出されることが多い）。 次の表に、旧来の内容との互換性のために，利用者の~localeに基づいて示唆される既定の符号化法を与える： ◎ In other environments, the default encoding is typically dependent on the user's locale (an approximation of the languages, and thus often encodings, of the pages that the user is likely to frequent). The following table gives suggested defaults based on the user's locale, for compatibility with legacy content. Locales are identified by BCP 47 language tags. [BCP47] [ENCODING]

     言語~tag `BCP47$r	~locale言語 ◎ Locale language	示唆される既定の符号化法 `ENCODING$r ◎ Suggested default encoding
     ar	Arabic	`windows-1256$enc
     ba	Bashkir	`windows-1251$enc
     be	Belarusian	`windows-1251$enc
     bg	Bulgarian	`windows-1251$enc
     cs	Czech	`windows-1250$enc
     el	Greek	`ISO-8859-7$enc
     et	Estonian	`windows-1257$enc
     fa	Persian	`windows-1256$enc
     he	Hebrew	`windows-1255$enc
     hr	Croatian	`windows-1250$enc
     hu	Hungarian	`ISO-8859-2$enc
     ja	Japanese	`Shift_JIS$enc
     kk	Kazakh	`windows-1251$enc
     ko	Korean	`EUC-KR$enc
     ku	Kurdish	`windows-1254$enc
     ky	Kyrgyz	`windows-1251$enc
     lt	Lithuanian	`windows-1257$enc
     lv	Latvian	`windows-1257$enc
     mk	Macedonian	`windows-1251$enc
     pl	Polish	`ISO-8859-2$enc
     ru	Russian	`windows-1251$enc
     sah	Yakut	`windows-1251$enc
     sk	Slovak	`windows-1250$enc
     sl	Slovenian	`ISO-8859-2$enc
     sr	Serbian	`windows-1251$enc
     tg	Tajik	`windows-1251$enc
     th	Thai	`windows-874$enc
     tr	Turkish	`windows-1254$enc
     tt	Tatar	`windows-1251$enc
     uk	Ukrainian	`windows-1251$enc
     vi	Vietnamese	`windows-1258$enc
     zh-CN	Chinese (People's Republic of China)	`gb18030$enc
     zh-TW	Chinese (Taiwan)	`Big5$enc
     他のすべての~locale ◎ All other locales		`windows-1252$enc

     この表の内容は、 Windows, Chrome, Firefox による既定~のそれらの共通部分から導出されている。 ◎ The contents of this table are derived from the intersection of Windows, Chrome, and Firefox defaults.

文書の`符号化法$docは、即時に，この~algoから返される値に設定され~MUST — ~UAが，返された値を利用して［ 入力~byte~stream用に利用する復号器 ］を選定するときと同時に。 ◎ The document's character encoding must immediately be set to the value returned from this algorithm, at the same time as the user agent uses the returned value to select the decoder to use for the input byte stream.

1. ~WHILE［ %位置↗ ~NEQ `3C^X ( `<^bl ) ］ ⇒ %位置 ~INCBY 1 ◎ ↓

2. ~IF［ 次の表の中に［ `~byte小文字~化する$( 入力~byte~streamの ( %位置 ~PLUS 1 ) から 5 個までの~byte ) ］の結果を成す~byteたちに合致する行はある ］ ⇒ ［ 最初に合致した行の~label列に与える~label ］に対応する［ 表の下に与える手続き ］を走らす：

   表内の `小文字^i は `61^X 〜 `7A^X を表す／ 空欄は無条件を表す（当の~byteが存在しない場合も含め）。

   1 個目	2 個目	3 個目	4 個目	5 個目	~label
   `21^X (`!^bl)	`2D^X (`-^bl)	`2D^X (`-^bl)			`~comment^i
   `6D^X (`m^bl)	`65^X (`e^bl)	`74^X (`t^bl)	`61^X (`a^bl)	`空白~byte^i, `2F^X (`/^bl)	`meta^i
   `小文字^i					`他の~tag^i
   `2F^X (`/^bl)	`小文字^i				`他の~tag^i
   `21^X (`!^bl), `2F^X (`/^bl), `3F^X (`?^bl)					`他の~mark^i

   ◎ Loop: If position points to:

   `~comment^i ◎ A sequence of bytes starting with: 0x3C 0x21 0x2D 0x2D (`<!--`)

   1. ~WHILE［ 入力~byte~streamの %位置 から 3 個までの~byteが成す~byte列 ~NEQ `2D^X `2D^X `3E^X ( `-->^bl ) † ］ ⇒ %位置 ~INCBY 1
   2. %位置 ~INCBY 2

   （† 2 個の `2D^X ~byteは、合致した `!--^bl と重なり得る） ◎ Advance the position pointer so that it points at the first 0x3E byte which is preceded by two 0x2D bytes (i.e. at the end of an ASCII '-->' sequence) and comes after the 0x3C byte that was found. (The two 0x2D bytes can be the same as those in the '<!--' sequence.)

   `meta^i ◎ A sequence of bytes starting with: 0x3C, 0x4D or 0x6D, 0x45 or 0x65, 0x54 or 0x74, 0x41 or 0x61, and one of 0x09, 0x0A, 0x0C, 0x0D, 0x20, 0x2F (case-insensitive ASCII '<meta' followed by a space or slash)

   1. %位置 ~INCBY 5 ◎ Advance the position pointer so that it points at the next 0x09, 0x0A, 0x0C, 0x0D, 0x20, or 0x2F byte (the one in sequence of characters matched above).
   2. %属性~list ~LET （文字列からなる）空~list ◎ Let attribute list be an empty list of strings.
   3. %~pragmaは得られた ~LET ~F ◎ Let got pragma be false.
   4. %~pragmaが必要 ~LET ~NULL ◎ Let need pragma be null.
   5. %~charset ~LET ~NULL （この値は、この~algoの目的においては［ 認識されない符号化法／空~文字列 ］とは別個である。） ◎ Let charset be the null value (which, for the purposes of this algorithm, is distinct from an unrecognized encoding or the empty string).

   6. ~WHILE 無条件： ◎ Attributes:＼

      1. ( %属性~名, %属性~値 ) ~LET `属性を取得する$ ◎ Get an attribute and its value.＼
      2. ~IF［ %属性~名 ~EQ ε ］ ⇒ ~BREAK ◎ If no attribute was sniffed, then jump to the processing step below.
      3. ~IF［ %属性~名 ~IN %属性~list ］ ⇒ ~CONTINUE ◎ If the attribute's name is already in attribute list, then return to the step labeled attributes.
      4. %属性~list に %属性~名 を追加する ◎ Add the attribute's name to attribute list.

      5. %属性~名 に応じて： ◎ Run the appropriate step from the following list, if one applies:

         `http-equiv^l ◎ If the attribute's name is "http-equiv"

         ~IF［ %属性~値 ~EQ `content-type^l ］ ⇒ %~pragmaは得られた ~SET ~T ◎ If the attribute's value is "content-type", then set got pragma to true.

         `content^l ◎ If the attribute's name is "content"

         1. ~IF［ %~charset ~NEQ ~NULL ］ ⇒ ~CONTINUE
         2. %符号化法 ~LET `~meta要素から符号化法を抽出する$( %属性~値 )
         3. ~IF［ %符号化法 ~EQ ε ］ ⇒ ~CONTINUE
         4. %~charset ~LET %符号化法
         5. %~pragmaが必要 ~SET ~T

         ◎ Apply the algorithm for extracting a character encoding from a meta element, giving the attribute's value as the string to parse. If a character encoding is returned, and if charset is still set to null, let charset be the encoding returned, and set need pragma to true.

         `charset^l ◎ If the attribute's name is "charset"

         1. %~charset ~LET `~labelから符号化法を取得する$( %属性~値 )
         2. %~pragmaが必要 ~SET ~F

         ◎ Let charset be the result of getting an encoding from the attribute's value, and set need pragma to false.

      6. （ ~CONTINUE ） ◎ Return to the step labeled attributes.
   7. ~IF［ %~pragmaが必要 ~EQ ~NULL ］ ⇒ ~GOTO `次n~byte^i ◎ Processing: If need pragma is null, then jump to the step below labeled next byte.
   8. ~IF［ %~pragmaが必要 ~EQ ~T ］~AND［ %~pragmaは得られた ~EQ ~F ］ ⇒ ~GOTO `次n~byte^i ◎ If need pragma is true but got pragma is false, then jump to the step below labeled next byte.
   9. ~IF［ %~charset ~EQ 失敗 ］ ⇒ ~GOTO `次n~byte^i ◎ If charset is failure, then jump to the step below labeled next byte.
   10. ~IF［ %~charset は`~UTF-16$である ］ ⇒ %~charset ~SET `UTF-8$enc ◎ If charset is a UTF-16 encoding, then set charset to UTF-8.
   11. ~IF［ %~charset ~EQ `x-user-defined$enc ］ ⇒ %~charset ~SET `windows-1252$enc ◎ If charset is x-user-defined, then set charset to windows-1252.
   12. ~RET %~charset ◎ Abort the prescan a byte stream to determine its encoding algorithm, returning the encoding given by charset.

   `他の~tag^i ◎ A sequence of bytes starting with a 0x3C byte (<), optionally a 0x2F byte (/), and finally a byte in the range 0x41-0x5A or 0x61-0x7A (A-Z or a-z)

   1. ~WHILE［ %位置↗ ~NIN { `空白~byte^i, `3E^X (`>^bl) } ］ ⇒ %位置 ~INCBY 1 ◎ Advance the position pointer so that it points at the next 0x09 (HT), 0x0A (LF), 0x0C (FF), 0x0D (CR), 0x20 (SP), or 0x3E (>) byte.
   2. ~WHILE ［ `属性を取得する$の結果 ~NEQ ( ε, ε ) ］ ⇒ （何もしない） ◎ Repeatedly get an attribute until no further attributes can be found, then＼ ◎ jump to the step below labeled next byte.

   `他の~mark^i ◎ A sequence of bytes starting with: 0x3C 0x21 (`<!`) ◎ A sequence of bytes starting with: 0x3C 0x2F (`</`) ◎ A sequence of bytes starting with: 0x3C 0x3F (`<?`)

   ~WHILE［ %位置↗ ~NEQ `3E^X ( `>^bl ) ］ ⇒ %位置 ~INCBY 1 ◎ Advance the position pointer so that it points at the first 0x3E byte (>) that comes after the 0x3C byte that was found.

3. `次n~byte^i ⇒＃ %位置 ~INCBY 1； ~GOTO この手続きの最初の段 ◎ Any other byte • Do nothing with that byte. ◎ Next byte: Move position so it points at the next byte in the input byte stream, and return to the step above labeled loop.

上の~algoにおける `属性を取得する@ 下位手続きは、次を走らす： ◎ When the prescan a byte stream to determine its encoding algorithm says to get an attribute, it means doing this:

1. ~WHILE［ %位置↗ ~IN { `空白~byte^i, `2F^X (`/^bl) } ］ ⇒ %位置 ~INCBY 1 ◎ If the byte at position is one of 0x09 (HT), 0x0A (LF), 0x0C (FF), 0x0D (CR), 0x20 (SP), or 0x2F (/) then advance position to the next byte and redo this step.
2. ~IF［ %位置↗ ~EQ `3E^X (`>^bl) ］ ⇒ ~RET ( ε, ε ) ◎ If the byte at position is 0x3E (>), then abort the get an attribute algorithm. There isn't one.
3. ~Assert： %位置 は属性~名の始端を指す。 ◎ Otherwise, the byte at position is the start of the attribute name.＼
4. %属性~名~LET 空~文字列 ◎ Let attribute name and attribute value be the empty string.

5. ~WHILE［ %位置↗ ~NIN { `空白~byte^i } ］：

   1. %位置↗ に応じて： ◎ Process the byte at position as follows:

      `3D^X (`=^bl) ◎ If it is 0x3D (=), and the attribute name is longer than the empty string

      1. ~IF［ %属性~名 ~EQ 空~文字列 ］ ⇒ ~GOTO ~AnyElse
      2. %位置 ~INCBY 1
      3. ~GOTO `値^i

      ◎ Advance position to the next byte and jump to the step below labeled value. ◎ ↑If it is 0x09 (HT), 0x0A (LF), 0x0C (FF), 0x0D (CR), or 0x20 (SP) • Jump to the step below labeled spaces.

      `2F^X (`/^bl)

      `3E^X (`>^bl)

      ~RET ( %属性~名, 空~文字列 ) ◎ If it is 0x2F (/) or 0x3E (>) ◎ Abort the get an attribute algorithm. The attribute's name is the value of attribute name, its value is the empty string.

      ~AnyElse

      %属性~名 ~APPEND ~cp( `~byte小文字~化する$( %位置↗ ) ) ◎ If it is in the range 0x41 (A) to 0x5A (Z) • Append the code point b+0x20 to attribute name (where b is the value of the byte at position). (This converts the input to lowercase.) ◎ Anything else • Append the code point with the same value as the byte at position to attribute name.＼

      （~ASCII範囲の外側にある~byteが ここでどう取扱われるかは、実際に問われることはない — ~ASCII~byteのみが符号化法の検出に寄与し得るので。） ◎ (It doesn't actually matter how bytes outside the ASCII range are handled here, since only ASCII bytes can contribute to the detection of a character encoding.)

   2. %位置 ~INCBY 1 ◎ Advance position to the next byte and return to the previous step.
6. ~WHILE［ %位置↗ ~IN { `空白~byte^i } ］ ⇒ %位置 ~INCBY 1 ◎ Spaces: If the byte at position is one of 0x09 (HT), 0x0A (LF), 0x0C (FF), 0x0D (CR), or 0x20 (SP) then advance position to the next byte, then, repeat this step.
7. ~IF［ %位置↗ ~NEQ `3D^X (`=^bl) ］ ⇒ ~RET ( %属性~名, 空~文字列 ) ◎ If the byte at position is not 0x3D (=), abort the get an attribute algorithm. The attribute's name is the value of attribute name, its value is the empty string.
8. ~WHILE［ %位置↗ ~EQ `3D^X (`=^bl) ］ ⇒ %位置↗ ~INCBY 1 ◎ Advance position past the 0x3D (=) byte.
9. `値^i : ~WHILE［ %位置↗ ~IN { `空白~byte^i } ］ ⇒ %位置 ~INCBY 1 ◎ Value: If the byte at position is one of 0x09 (HT), 0x0A (LF), 0x0C (FF), 0x0D (CR), or 0x20 (SP) then advance position to the next byte, then, repeat this step.
10. %属性~値 ~LET 空~文字列 ◎ ↑

11. ~IF［ %位置↗ ~IN { `22^X (`"^bl), `27^X (`'^bl) } ］： ◎ Process the byte at position as follows: ◎ If it is 0x22 (") or 0x27 (')

    1. %引用符 ~LET %位置↗ ◎ Let b be the value of the byte at position.

    2. ~WHILE 無条件： ◎ Quote loop:＼

       1. %位置 ~INCBY 1 ◎ Advance position to the next byte.

       2. ~IF［ %位置↗ ~EQ %引用符 ］：

          1. %位置 ~INCBY 1
          2. ~RET ( %属性~名, %属性~値 )
          ◎ If the value of the byte at position is the value of b, then advance position to the next byte and abort the "get an attribute" algorithm. The attribute's name is the value of attribute name, and its value is the value of attribute value.
       3. ~ELSE ⇒ %属性~値 ~APPEND ~cp( `~byte小文字~化する$( %位置↗ ) ) ◎ Otherwise, if the value of the byte at position is in the range 0x41 (A) to 0x5A (Z), then append a code point to attribute value whose value is 0x20 more than the value of the byte at position. ◎ Otherwise, append a code point to attribute value whose value is the same as the value of the byte at position. ◎ Return to the step above labeled quote loop.
12. ~Assert： %位置↗ ~NIN { `空白~byte^i } ◎ （これらの段は後続の段で吸収されるので不要） ◎ If it is 0x3E (>) • Abort the get an attribute algorithm. The attribute's name is the value of attribute name, its value is the empty string. ◎ If it is in the range 0x41 (A) to 0x5A (Z) • Append a code point b+0x20 to attribute value (where b is the value of the byte at position). Advance position to the next byte. ◎ Anything else • Append a code point with the same value as the byte at position to attribute value. Advance position to the next byte.

13. ~WHILE 無条件：

    1. %位置↗ に応じて： ◎ Process the byte at position as follows:

       `空白~byte^i

       `3E^X (`>^bl) ◎ If it is 0x09 (HT), 0x0A (LF), 0x0C (FF), 0x0D (CR), 0x20 (SP), or 0x3E (>)

       ~RET ( %属性~名, %属性~値 ) ◎ Abort the get an attribute algorithm. The attribute's name is the value of attribute name and its value is the value of attribute value.

       ~AnyElse

       %属性~値 ~APPEND ~cp( `~byte小文字~化する$( %位置↗ ) ) ◎ If it is in the range 0x41 (A) to 0x5A (Z) • Append a code point b+0x20 to attribute value (where b is the value of the byte at position). ◎ Anything else • Append a code point with the same value as the byte at position to attribute value.

    2. %位置 ~INCBY 1 ◎ Advance position to the next byte and return to the previous step.

相互運用性のため、~UAは，上に述べたものと異なる結果を返すような予走査~algoを利用するべきでない。 （もし，そうする場合は、少なくとも我々に知らしめたし — 我々がこの~algoを改善して誰もが便益を得られるよう... ） ◎ For the sake of interoperability, user agents should not use a pre-scan algorithm that returns different results than the one described above. (But, if you do, please at least let us know, so that we can improve this algorithm and benefit everyone...)

12.2.3.3. 符号化法

~UAは、 `ENCODING$r 標準に定義される各種~符号化法 — 例えば前~節の表に挙げたもの — は~supportし~MUST。 他の符号化法は~supportしては~MUST_NOT。 ◎ User agents must support the encodings defined in the WHATWG Encoding standard, including, but not limited to, UTF-8, ISO-8859-2, ISO-8859-7, ISO-8859-8, windows-874, windows-1250, windows-1251, windows-1252, windows-1254, windows-1255, windows-1256, windows-1257, windows-1258, gb18030, Big5, ISO-2022-JP, Shift_JIS, EUC-KR, UTF-16BE, UTF-16LE, and x-user-defined. User agents must not support other encodings.

注記： 例えば、次の~supportは禁制される： CESU-8, UTF-7, BOCU-1, SCSU, EBCDIC, UTF-32 。 この仕様は、禁制されるどの符号化法も，~algo内で~supportしようと試みることはない。 そのような符号化法を~supportしたり利用した場合、予期されない挙動をもたらすことになる。 `CESU8$r `UTF7$r `BOCU1$r `SCSU$r ◎ The above prohibits supporting, for example, CESU-8, UTF-7, BOCU-1, SCSU, EBCDIC, and UTF-32. This specification does not make any attempt to support prohibited encodings in its algorithms; support and use of prohibited encodings would thus lead to unexpected behavior. [CESU8] [UTF7] [BOCU1] [SCSU]

12.2.3.4. 構文解析-中における符号化法の変更-法

~UAは、 `符号化法を変更する@ よう構文解析器から要求されたときは、所与の ( %新~符号化法 ) に対し，次の手続きを走らせ~MUST。 これが起こり得るのは、`符号化法を~sniffする~algo$にて，［ 符号化法を見出すのに失敗した場合／ 見出された符号化法は ~fileの実際の符号化法でなかった場合 ］である： ◎ When the parser requires the user agent to change the encoding, it must run the following steps. This might happen if the encoding sniffing algorithm described above failed to find a character encoding, or if it found a character encoding that was not the actual encoding of the file.

1. %現~符号化法 ~LET 入力~streamを解釈するために利用していた符号化法 ◎ ↓

2. ~IF［ %現~符号化法 は`~UTF-16$である ］ ⇒＃ `確度$ ~SET `確か^i； ~RET

   %新~符号化法 は無視する — それが~UTF-16でないならば、明らかに不正なので。

   ◎ If the encoding that is already being used to interpret the input stream is a UTF-16 encoding, then set the confidence to certain and return. The new encoding is ignored; if it was anything but the same encoding, then it would be clearly incorrect.
3. ~IF［ %新~符号化法 は`~UTF-16$である ］ ⇒ %新~符号化法 ~SET `UTF-8$enc ◎ If the new encoding is a UTF-16 encoding, then change it to UTF-8.
4. ~IF［ %新~符号化法 ~EQ `x-user-defined$enc ］ ⇒ %新~符号化法 ~SET `windows-1252$enc ◎ If the new encoding is x-user-defined, then change it to windows-1252.

5. ~IF［ %新~符号化法 は %現~符号化法 に一致するか等価である ］ ⇒＃ `確度$ ~SET `確か^i； ~RET ◎ If the new encoding is identical or equivalent to the encoding that is already being used to interpret the input stream, then set the confidence to certain and return.＼

   これは、次のときに起こる： ◎ This happens when＼

   • ［ ~file内に見出された符号化法~情報 ］は［ `符号化法を~sniffする~algo$が決定した符号化法 ］に合致するとき ◎ the encoding information found in the file matches what the encoding sniffing algorithm determined to be the encoding, and＼
   • 構文解析器が， 1 周回~目で［ `符号化法を~sniffする~algo$が，~~正しい符号化法を見出すのに失敗した ］場合の， 2 周回~目 ◎ in the second pass through the parser if the first pass found that the encoding sniffing algorithm described in the earlier section failed to find the right encoding.

6. ~UAの任意選択で — ~UAは 符号化法を “その場で変更する” ことを~supportするならば：

   1. %~byte列 ~LET この~algoを呼出した時点までに %現~符号化法 の復号器により変換された，入力~streamを成す~byte列
   2. ~IF［ %~byte列 に対する［ %現~符号化法, %新~符号化法 ］による~Unicode解釈は同じである ］ ⇒＃ `文書$の`符号化法$doc ~SET %新~符号化法； 入力~streamを変換するために利用する符号化法 ~SET %新~符号化法； `確度$ ~SET `確か^i； ~RET
   ◎ If all the bytes up to the last byte converted by the current decoder have the same Unicode interpretations in both the current encoding and the new encoding, and if the user agent supports changing the converter on the fly, then the user agent may change to the new converter for the encoding on the fly. Set the document's character encoding and the encoding used to convert the input stream to the new encoding, set the confidence to certain, and return.

7. 次のようにする下で，`文書$を再度`~navigate$する ⇒＃ `置換~可能化~flag$ ~SET ~ON, 同じ`~source閲覧文脈$を利用する, `確度$ ~SET `確か^i, 今度は`符号化法を~sniffする~algo$は飛ばす — 代わりに、単に，符号化法を %新~符号化法 に設定する ◎ Otherwise, navigate to the document again, with replacement enabled, and using the same source browsing context, but this time skip the encoding sniffing algorithm and instead just set the encoding to the new encoding and the confidence to certain.＼

   可能なときは，これは、［ ~network層に実際に接触することなく行われる ］べきである（~memoryからの~byte列が，構文解析し直されるべきである） — 例えば、当の文書が~cache可能でないものとされていても。 これが可能でないため，［ ~network層に接触することが［ `GET^bl 以外の~methodを利用する要請を繰返す ］ことを孕む ］ことになる場合、代わりに［ `確度$ ~SET `確か^i, %新~符号化法 は無視する ］とする — 資源は、誤解釈されることになる。 ~UAは、~app開発を援助するため，利用者にこの状況を通知して~MAY。 ◎ Whenever possible, this should be done without actually contacting the network layer (the bytes should be re-parsed from memory), even if, e.g., the document is marked as not being cacheable. If this is not possible and contacting the network layer would involve repeating a request that uses a method other than `GET`), then instead set the confidence to certain and ignore the new encoding. The resource will be misinterpreted. User agents may notify the user of the situation, to aid in application development.

注記： この~algoが呼出されるのは、［ `meta$e 要素~上に新たな符号化法が宣言されている ］ことが見出されたときに限られる。 ◎ This algorithm is only invoked when a new encoding is found declared on a meta element.

12.2.3.5. 入力~streamの前処理-法

`入力~stream@ は、［ 復号された`入力~byte~stream$として, または 入力~streamを直に操作する様々な~APIから ］~pushされてきた一連の文字からなる。 ◎ The input stream consists of the characters pushed into it as the input byte stream is decoded or from the various APIs that directly manipulate the input stream.

• `~surrogate$が生じたときは，常に `surrogate-in-input-stream$pE になるとする。 ◎ Any occurrences of surrogates are surrogate-in-input-stream parse errors.＼
• `非文字$が生じたときは，常に `noncharacter-in-input-stream$pE になるとする。 ◎ Any occurrences of noncharacters are noncharacter-in-input-stream parse errors and＼

• ［ `~ASCII空白$／ `0000^U ］以外の`制御文字$が生じたときは，常に `control-character-in-input-stream$pE になるとする。 ◎ any occurrences of controls other than ASCII whitespace and U+0000 NULL characters are control-character-in-input-stream parse errors.

  注記： `0000^U 文字の取扱いは、構文解析の後の段階にて起こり，当の文字が見出された所に基づいて変わる。 それらは無視されるか, ~security上の理由から `FFFD^U に置換される。 そのため、この取扱いは， ~token化~段階, 木~構築~段階 の両者に散らばっている。 ◎ The handling of U+0000 NULL characters varies based on where the characters are found and happens at the later stages of the parsing. They are either ignored or, for security reasons, replaced with a U+FFFD REPLACEMENT CHARACTER. This handling is, by necessity, spread across both the tokenization stage and the tree construction stage.

• 文字［ `000D^U ／ `000A^U ］は、特別に扱われ~MUST：

  1. ~CR の直後の ~LF は無視され~MUST
  2. すべての~CR は ~LF に変換され~MUST

  したがって，~HTML~DOM内では、すべての改行文字は ~LF で表現され，~CRは決して`~token化~段階$に入力されない。

  ◎ U+000D CARRIAGE RETURN (CR) characters and U+000A LINE FEED (LF) characters are treated specially. Any LF character that immediately follows a CR character must be ignored, and all CR characters must then be converted to LF characters. Thus, newlines in HTML DOMs are represented by LF characters, and there are never any CR characters in the input to the tokenization stage.

`次n入力~文字@ は、`入力~stream$内の［ まだ消費-されていない, かつ この節の要件により明示的に無視されていない ］文字のうち，最初のものを指す。 初期~時の`次n入力~文字$は、入力~内の最初の文字とする 【入力が空の場合、下に述べる ~EOF になる】 。 `現在の入力~文字@ は、最後に `消費-^i された文字とする。 ◎ The next input character is the first character in the input stream that has not yet been consumed or explicitly ignored by the requirements in this section. Initially, the next input character is the first character in the input. The current input character is the last character to have been consumed.

`挿入~地点@ は、［ ある文字 ／ 入力~streamの終端 ］の直前を指す位置であり、 `document.write()$m を利用して挿入される内容が実際に挿入される所である。 挿入~地点は、［ その直後の文字の位置 ］に相対的であり、入力~streamの中を指す絶対的~offsetではない。 初期~時には、挿入~地点は ε （未定義）とする。 ◎ The insertion point is the position (just before a character or just before the end of the input stream) where content inserted using document.write() is actually inserted. The insertion point is relative to the position of the character immediately after it, it is not an absolute offset into the input stream. Initially, the insertion point is undefined.

以下における記号 ~EOF は、`入力~stream$の終端を表現する概念的な文字であり，文字が消費され尽くしたことを表す。 構文解析器が ~scriptにより作成されたものである場合、（ `document.close()$m ~methodにより挿入される） `明示的な~EOF@ で，`入力~stream$は終端する。 ◎ The "EOF" character in the tables below is a conceptual character representing the end of the input stream. If the parser is a script-created parser, then the end of the input stream is reached when an explicit "EOF" character (inserted by the document.close() method) is consumed. Otherwise, the "EOF" character is not a real character in the stream, but rather the lack of any further characters.

12.2.4.1. 挿入~mode

これらの`挿入~mode$のうち［ `~head内$md ／ `~body内$md ／ `~table内$md ／ `~select内$md 【／ `~template内$md 】 ］は、他の~modeが様々な時点で これらの~modeへ先送りする点で特別である — すなわち，以下の~algoにて、ここに挙げたいずれかの~mode %m に対し， %m `用の規則を用いて@ %何か を行う と記される所では、~UAは， %m `挿入~mode$の節に述べる規則を利用し~MUST — %m 内の規則~自身が`挿入~mode$を他の~modeへ切替えない限り、`挿入~mode$は変更することなく。 ◎ Several of these modes, namely "in head", "in body", "in table", and "in select", are special, in that the other modes defer to them at various times. When the algorithm below says that the user agent is to do something "using the rules for the m insertion mode", where m is one of these modes, the user agent must use the rules described under the m insertion mode's section, but must leave the insertion mode unchanged unless the rules in m themselves switch the insertion mode to a new value.

挿入~modeが［ `~text$md ／ `~table~text内$md ］に切替えられるときは、 `元の挿入~mode@V も設定される。 これは、木~構築~段階が後で戻ることになる，挿入~modeを指す。 ◎ When the insertion mode is switched to "text" or "in table text", the original insertion mode is also set. This is the insertion mode to which the tree construction stage will return.

同様に，入子にされた `template$e 要素を構文解析するときには、 `~template挿入~mode~stack@ が利用される — それは 0 個~以上の`挿入~mode$からなる`~stack$であり†，初期~時には空とする。 ◎ Similarly, to parse nested template elements, a stack of template insertion modes is used. It is initially empty. The current template insertion mode is the insertion mode that was most recently added to the stack of template insertion modes. The algorithms in the sections below will push insertion modes onto this stack, meaning that the specified insertion mode is to be added to the stack, and pop insertion modes from the stack, which means that the most recently added insertion mode must be removed from the stack.

【† この訳では `Infra$r による`~stack$の定義を参照して、原文の記述を簡約している。 】

以下の手続きにて `挿入~modeを適切に再設定する@ ときは、`挿入~mode$を次の手続きを走らせた結果に設定し~MUST： ◎ When the steps below require the UA to reset the insertion mode appropriately, it means the UA must follow these steps:

1. %~stack ~LET `~open要素~stack$ ◎ ↓
2. ~Assert： %~stack は空でない ◎ ↓
3. %最後の ~LET ~F ◎ Let last be false.

4. %~stack 内の~EACH( %~node ) に対し，末尾から順に： ◎ Let node be the last node in the stack of open elements.

   1. ~IF［ %~node は %~stack の先頭の~nodeである ］：

      1. %最後の ~SET ~T
      2. ~IF［ %構文解析器 は `~HTML素片~用$である （`素片~事例$） ］ ⇒ %~node ~SET その~algoに渡された `文脈~要素$V
      ◎ Loop: If node is the first node in the stack of open elements, then set last to true, and, if the parser was originally created as part of the HTML fragment parsing algorithm (fragment case), set node to the context element passed to that algorithm.

   2. %~node の型に応じて： ◎ ↓

      `select$e ◎ If node is a select element, run these substeps:

      1. ~IF［ %~stack 内に次をいずれも満たす要素は在る ］：

         • `table$e である
         • %~stack 内で %~node より前に在る
         • %~stack 内の，要素より後, かつ %~node より前には、 `template$e ~nodeは無い

         …ならば ⇒ ~RET `~table内~select内$md

         ◎ If last is true, jump to the step below labeled done. ◎ Let ancestor be node. ◎ Loop: If ancestor is the first node in the stack of open elements, jump to the step below labeled done. ◎ Let ancestor be the node before ancestor in the stack of open elements. ◎ If ancestor is a template node, jump to the step below labeled done. ◎ If ancestor is a table node, switch the insertion mode to "in select in table" and return. ◎ Jump back to the step labeled loop.
      2. ~RET `~select内$md ◎ Done: Switch the insertion mode to "in select" and return.

      `td$e

      `th$e

      ~IF［ %最後の ~EQ ~F ］ ⇒ ~RET `~cell内$md ◎ If node is a td or th element and last is false, then switch the insertion mode to "in cell" and return.

      `tr$e

      ~RET `~row内$md ◎ If node is a tr element, then switch the insertion mode to "in row" and return.

      `tbody$e

      `thead$e

      `tfoot$e

      ~RET `~table~body内$md ◎ If node is a tbody, thead, or tfoot element, then switch the insertion mode to "in table body" and return.

      `caption$e

      ~RET `~caption内$md ◎ If node is a caption element, then switch the insertion mode to "in caption" and return.

      `colgroup$e

      ~RET `~column-group内$md ◎ If node is a colgroup element, then switch the insertion mode to "in column group" and return.

      `table$e

      ~RET `~table内$md ◎ If node is a table element, then switch the insertion mode to "in table" and return.

      `template$e

      ~RET `~template挿入~mode~stack$の最後の~item ◎ If node is a template element, then switch the insertion mode to the current template insertion mode and return.

      `head$e

      ~IF［ %最後の ~EQ ~F ］ ⇒ ~RET `~head内$md ◎ If node is a head element and last is false, then switch the insertion mode to "in head" and return.

      `body$e

      ~RET `~body内$md ◎ If node is a body element, then switch the insertion mode to "in body" and return.

      `frameset$e（`素片~事例$）

      ~RET `~frameset内$md ◎ If node is a frameset element, then switch the insertion mode to "in frameset" and return. (fragment case)

      `html$e

      ~RET ［ `~head要素~pointer$ ~EQ ~NULL（`素片~事例$）ならば `~headの前$md ／ ~ELSE_ `~headの後$md ］ ◎ If node is an html element, run these substeps: ◎ If the head element pointer is null, switch the insertion mode to "before head" and return. (fragment case) ◎ Otherwise, the head element pointer is not null, switch the insertion mode to "after head" and return.

   3. ~IF［ %最後の ~EQ ~T （`素片~事例$） ］ ⇒ ~RET `~body内$md ◎ If last is true, then switch the insertion mode to "in body" and return. (fragment case) ◎ Let node now be the node before node in the stack of open elements. ◎ Return to the step labeled loop.

12.2.4.2. ~open要素~stack

初期~時には `~open要素~stack@ は空とする。 この~stackは、末尾側（ downward† ）へ成長する — ~stackの先頭の~nodeは，~stackに最初に追加されたものであり、~stackの末尾の~nodeは，~stackに最も近過去に追加されたものである（ 誤入子な~tagを取扱う 一部として，~stackが~random~access的に操作されたときであっても）。 ◎ Initially, the stack of open elements is empty. The stack grows downwards; the topmost node on the stack is the first one added to the stack, and the bottommost node of the stack is the most recently added node in the stack (notwithstanding when the stack is manipulated in a random access fashion as part of the handling for misnested tags).

【† この語 downward, および原文に現れる［ bottommost, bottom ／ topmost, top ／ lower ］などの語は、［ この~stackが表現する，~nodeたちが成す入子 ］の “深さ” を反映することを意図して用いられているが、この訳では，一律に，通例の~listにおける順序関係を表す語（ 先頭, 〜のうち最初の, 末尾, 〜のうち最後の, 〜より後, 〜より前 ）を用いて表記する。 ~stackの bottom や top が［ ~listとしての~stack ］の先頭, 末尾のどちらかを指すか直感的でないことに加え、原文には，これら~list用の語（ first, last, after, before）も混用されていて，惑わされるので。 】

注記： `挿入~mode$ `~htmlの前$mdでは、 `html$e `文書~要素$が作成され，~stackに追加される。 ◎ The "before html" insertion mode creates the html document element, which is then added to the stack.

注記： `素片~事例$においては、`~open要素~stack$は，［ `~HTML素片の構文解析~algo$の一部として作成された `html$e 要素 ］を包含するように初期化される（`素片~事例$は`~htmlの前$md `挿入~mode$を飛ばす）。 ◎ In the fragment case, the stack of open elements is initialized to contain an html element that is created as part of that algorithm. (The fragment case skips the "before html" insertion mode.)

`html$e ~nodeは、どう作成されたものであれ，~stackの先頭の~nodeになる。 それが~stackから~popされるのは、構文解析器が 完遂したときに限られる。 ◎ The html node, however it is created, is the topmost node of the stack. It only gets popped off the stack when the parser finishes.

`現在の~node@ は、この`~open要素~stack$の末尾の~nodeを指す。 ◎ The current node is the bottommost node in this stack of open elements.

`現在の調整-済み~node@ は、［ %構文解析器 は `~HTML素片~用$であって `~open要素~stack$は唯一の要素からなる（`素片~事例$）ならば `文脈~要素$V ／ ~ELSE_ `現在の~node$ ］を指す。 ◎ The adjusted current node is the context element if the parser was created by the HTML fragment parsing algorithm and the stack of open elements has only one element in it (fragment case); otherwise, the adjusted current node is the current node.

`~open要素~stack$内の各 要素は、次のいずれかに分類される： ◎ Elements in the stack of open elements fall into the following categories:

`特別な要素@ ◎ Special

次に挙げる要素~型には、様々な~levelの特別な構文解析~規則がある：

• ~HTMLの `address$e, `applet$e, `area$e, `article$e, `aside$e, `base$e, `basefont$e, `bgsound$e, `blockquote$e, `body$e, `br$e, `button$e, `caption$e, `center$e, `col$e, `colgroup$e, `dd$e, `details$e, `dir$e, `div$e, `dl$e, `dt$e, `embed$e, `fieldset$e, `figcaption$e, `figure$e, `footer$e, `form$e, `frame$e, `frameset$e, `h6$e, `h6$e, `h6$e, `h6$e, `h6$e, `h6$e, `head$e, `header$e, `hgroup$e, `hr$e, `html$e, `iframe$e, `img$e, `input$e, `keygen$e, `li$e, `link$e, `listing$e, `main$e, `marquee$e, `menu$e, `meta$e, `nav$e, `noembed$e, `noframes$e, `noscript$e, `object$e, `ol$e, `p$e, `param$e, `plaintext$e, `pre$e, `script$e, `section$e, `select$e, `source$e, `style$e, `summary$e, `table$e, `tbody$e, `td$e, `template$e, `textarea$e, `tfoot$e, `th$e, `thead$e, `title$e, `tr$e, `track$e, `ul$e, `wbr$e, `xmp$e
• ~MathMLの `mi$e, `mo$e, `mn$e, `ms$e, `mtext$e, `annotation-xml$e
• ~SVGの `foreignObject$e, `desc$e, `title$e

◎ The following elements have varying levels of special parsing rules: HTML's address, applet, area, article, aside, base, basefont, bgsound, blockquote, body, br, button, caption, center, col, colgroup, dd, details, dir, div, dl, dt, embed, fieldset, figcaption, figure, footer, form, frame, frameset, h1, h2, h3, h4, h5, h6, head, header, hgroup, hr, html, iframe, img, input, keygen, li, link, listing, main, marquee, menu, meta, nav, noembed, noframes, noscript, object, ol, p, param, plaintext, pre, script, section, select, source, style, summary, table, tbody, td, template, textarea, tfoot, th, thead, title, tr, track, ul, wbr, xmp; MathML mi, MathML mo, MathML mn, MathML ms, MathML mtext, and MathML annotation-xml; and SVG foreignObject, SVG desc, and SVG title.

注記： `image^c 開始tag~tokenは、木を築くときに取扱われるが，この~list内にはない — それは要素ではなく， `img$e 要素に転換されるので。 ◎ An image start tag token is handled by the tree builder, but it is not in this list because it is not an element; it gets turned into an img element.

`整形~要素@ ◎ Formatting

次に挙げる~HTML要素は、`作動中の整形~要素~list$内に加えられることになる ⇒ `a$e, `b$e, `big$e, `code$e, `em$e, `font$e, `i$e, `nobr$e, `s$e, `small$e, `strike$e, `strong$e, `tt$e, `u$e ◎ The following HTML elements are those that end up in the list of active formatting elements: a, b, big, code, em, font, i, nobr, s, small, strike, strong, tt, and u.

`普通の要素@ ◎ Ordinary

~HTML文書の構文解析している間に見出された，他のすべての要素。 ◎ All other elements found while parsing an HTML document.

注記： 概して、`特別な要素$の［ 開始tag ／ 終了tag ］~tokenは，特定的な分岐で取扱われる一方で、`普通の要素$の~tokenは，［ “その他の開始tag” ／ “その他の終了tag” ］と記される分岐に仕分けられる。 また，木を築くときには、［ `~open要素~stack$内の特定0の要素が`特別$である ］かどうか検査する箇所がいくつかある。 ［ 開始tag ／ 終了tag ］~tokenが特定的な分岐で取扱われる要素は，他にもあるが（例： `option$e 要素）、他所では`普通の要素$として取扱われるので，`特別$とされない。 ◎ Typically, the special elements have the start and end tag tokens handled specifically, while ordinary elements' tokens fall into "any other start tag" and "any other end tag" clauses, and some parts of the tree builder check if a particular element in the stack of open elements is in the special category. However, some elements (e.g., the option element) have their start or end tag tokens handled specifically, but are still not in the special category, so that they get the ordinary handling elsewhere.

1. ~Assert： `html$e ~IN %S ◎ ↓

2. `~open要素~stack$内の~EACH( %~node ) に対し，末尾から順に： ◎ Initialize node to be the current node (the bottommost node of the stack).

   1. ~IF［ %~node は %~target条件 を満たす ］ ⇒ ~RET `在る^i ◎ If node is the target node, terminate in a match state.
   2. ~IF［ %~node の要素~型 ~IN %S ］ ⇒ ~RET `無い^i ◎ Otherwise, if node is one of the element types in list, terminate in a failure state.
3. ~Assert： ~stackの先頭は `html$e 要素なので、この段に達することは決してない ◎ Otherwise, set node to the previous entry in the stack of open elements and return to step 2. (This will never fail, since the loop will always terminate in the previous step if the top of the stack — an html element — is reached.)

上の “`視野~内$” 手続きに与える要素~型の集合 %S として、次のものが定義される： ◎ ↑↓

`既定の視野@ ◎ The stack of open elements is said to have a particular element in scope when it has that element in the specific scope consisting of the following element types:

`applet$e, `caption$e, `html$e, `table$e, `td$e, `th$e, `marquee$e, `object$e, `template$e ◎ applet caption html table td th marquee object template

`~MathML名前空間$に属する，次に挙げる要素~型 ⇒ `mi$e, `mo$e, `mn$e, `ms$e, `mtext$e, `annotation-xml$e ◎ template MathML mi MathML mo MathML mn MathML ms MathML mtext MathML annotation-xml

`~SVG名前空間$に属する，次に挙げる要素~型 ⇒ `foreignObject$e, `desc$e, `title$e ◎ SVG foreignObject SVG desc SVG title

`~list~item視野@ ◎ The stack of open elements is said to have a particular element in list item scope when it has that element in the specific scope consisting of the following element types:

`既定の視野$ ◎ All the element types listed above for the has an element in scope algorithm.

`ol$e,`ul$e ◎ ol in the HTML namespace ◎ ul in the HTML namespace

`~button視野@ ◎ The stack of open elements is said to have a particular element in button scope when it has that element in the specific scope consisting of the following element types:

`既定の視野$ ◎ All the element types listed above for the has an element in scope algorithm.

`button$e ◎ button in the HTML namespace

`~table視野@ ◎ The stack of open elements is said to have a particular element in table scope when it has that element in the specific scope consisting of the following element types:

`html$e, `table$e, `template$e ◎ html in the HTML namespace ◎ table in the HTML namespace ◎ template in the HTML namespace

`~select視野@ ◎ The stack of open elements is said to have a particular element in select scope when it has that element in the specific scope consisting of all element types except the following:

［ `optgroup$e, `option$e ］以外の，すべての要素~型（名前空間を問わず） ◎ • optgroup in the HTML namespace • option in the HTML namespace

どの時点であれ、`~open要素~stack$内の要素が，`文書$を成す木~内の他所へ移動されても, あるいは木から除去されても，~~特別な何かが起こることはない — 特に、この状況においても，~stackは変更されない。 その結果、もはや~DOM内にない~nodeに内容が付加されることもある — 変則的な効果は他にもあるが。 ◎ Nothing happens if at any time any of the elements in the stack of open elements are moved to a new location in, or removed from, the Document tree. In particular, the stack is not changed in this situation. This can cause, amongst other strange effects, content to be appended to nodes that are no longer in the DOM.

注記： 一部の事例（すなわち，誤入子な整形~要素を閉じるとき ）では、~stackは~random~access的に操作される。 ◎ In some cases (namely, when closing misnested formatting elements), the stack is manipulated in a random-access fashion.

12.2.4.3. 作動中の整形~要素からなる~list

`作動中の整形~要素~list@ は、誤入子な`整形~要素$~tagを取扱うために利用され，初期~時には空とする。 ◎ Initially, the list of active formatting elements is empty. It is used to handle mis-nested formatting element tags.

この~listは、一連の［ `整形~要素$／`~marker$ ］からなる。 `~marker@ は、［ `applet$e ／ `object$e ／ `marquee$e ／ `template$e ／ `td$e ／ `th$e ／ `caption$e ］要素に入るとき挿入され，［ 整形が，これらの要素の中へ “漏れる” ］のを防ぐために利用される。 ◎ The list contains elements in the formatting category, and markers. The markers are inserted when entering applet, object, marquee, template, td, th, and caption elements, and are used to prevent formatting from "leaking" into applet, object, marquee, template, td, th, and caption elements.

加えて、`作動中の整形~要素~list$内の各~要素には，それを `作成させた~token@ が結付けられる — 必要とされれば，その~token用の要素を更に作成できるように。 ◎ In addition, each element in the list of active formatting elements is associated with the token for which it was created, so that further elements can be created for that token if necessary.

以下の手続きにて `作動中の整形~要素~listに~pushする@ ときは、所与の ( `整形~要素$ %整形~要素 ) に対し，次の手続きを遂行し~MUST: ◎ When the steps below require the UA to push onto the list of active formatting elements an element element, the UA must perform the following steps:

1. %~list ~LET `作動中の整形~要素~list$

2. ~IF［ %~list 内に次を満たす要素が 3 個~以上ある ］…：

   • %整形~要素 と同じ［ ~tag名, 名前空間, 属性たち ］を有する
   • %~list 内には，要素より前に`~marker$はない

   ◎ If there are already three elements in the list of active formatting elements after the last marker, if any, or anywhere in the list if there are no markers, that have the same tag name, namespace, and attributes as element, then＼

   …ならば ⇒ 該当する要素のうち， %~list 内で最初のものを %~list から除去する ◎ remove the earliest such element from the list of active formatting elements.＼

   この段の目的においては： ◎ For these purposes,＼

   • 各~属性を比較するときは、要素が %構文解析器 により作成された時点のものを利用し~MUST。 ◎ the attributes must be compared as they were when the elements were created by the parser;＼
   • 2 つの要素が同じ属性たちを有するとは、互いのどの属性も［ 名前, 名前空間, 値 ］が一致するよう対にできることを意味する（属性の順序は問わない）。 ◎ two elements have the same attributes if all their parsed attributes can be paired such that the two attributes in each pair have identical names, namespaces, and values (the order of the attributes does not matter).

   注記： これがノアの方舟（Noah's Ark ）条項である — 各組は、つがいではなく，三つ組だが。 ◎ This is the Noah's Ark clause. But with three per family instead of two.

3. %~list に %整形~要素 を追加する ◎ Add element to the list of active formatting elements.

以下の手続きにて `作動中の整形~要素たちを再構築する@ ときは、次を走らせ~MUST： ◎ When the steps below require the UA to reconstruct the active formatting elements, the UA must perform the following steps:

1. %~list ~LET `作動中の整形~要素~list$ ◎ ↓
2. %開始~entry ~LET ε ◎ ↓

3. %~list 内の~EACH( %~entry ) に対し，最後の（最も近過去に追加された）~entryから順に：

   1. ~IF［ %~entry は`~marker$である ］~OR［ %~entry ~IN `~open要素~stack$ ］ ⇒ ~BREAK
   2. %開始~entry ~SET %~entry
   ◎ If there are no entries in the list of active formatting elements, then there is nothing to reconstruct; stop this algorithm. ◎ If the last (most recently added) entry in the list of active formatting elements is a marker, or if it is an element that is in the stack of open elements, then there is nothing to reconstruct; stop this algorithm. ◎ Let entry be the last (most recently added) element in the list of active formatting elements. ◎ Rewind: If there are no entries before entry in the list of active formatting elements, then jump to the step labeled create. ◎ Let entry be the entry one earlier than entry in the list of active formatting elements. ◎ If entry is neither a marker nor an element that is also in the stack of open elements, go to the step labeled rewind. ◎ Advance: Let entry be the element one later than entry in the list of active formatting elements.
4. ~IF［ %開始~entry ~EQ ε ］ ⇒ ~RET — 再構築するものは何もない ◎ ↑
5. %~list 内の %開始~entry 以降の~EACH( %~entry ) に対し， %開始~entry から順に ⇒ %~list 内の %~entry を次の結果に置換する ⇒ `~HTML要素を挿入する$( %~entry を`作成させた~token$ ) ◎ Create: Insert an HTML element for the token for which the element entry was created, to obtain new element. ◎ Replace the entry for entry in the list with an entry for new element. ◎ If the entry for new element in the list of active formatting elements is not the last entry in the list, return to the step labeled advance.

これにより、次に該当する要素のうち，まだ明示的に閉じられてないものすべては、再び開かれることになる ⇒ 現在の［［ `body^e, `cell^e, `caption^e ］のうち，最も近過去のもの ］内で開かれた整形~要素。 ◎ This has the effect of reopening all the formatting elements that were opened in the current body, cell, or caption (whichever is youngest) that haven't been explicitly closed.

注記： この仕様は、［ `作動中の整形~要素~list$を成す要素たちの順序は，常に時系列順（最も近過去に追加された要素が最後）になる ］ように書かれている。 ◎ The way this specification is written, the list of active formatting elements always consists of elements in chronological order with the least recently added element first and the most recently added element last (except for while steps 7 to 10 of the above algorithm are being executed, of course).

以下の手続きにて `作動中の整形~要素~listを最後の~markerまで~clearする@ ときは、次を遂行し~MUST： ◎ When the steps below require the UA to clear the list of active formatting elements up to the last marker, the UA must perform the following steps:

1. `作動中の整形~要素~list$ %~list 内の~EACH( %~entry ) に対し，最後の（最も近過去に追加された）~entryから順に： ◎ Let entry be the last (most recently added) entry in the list of active formatting elements.

   1. %~list から %~entry を除去する ◎ Remove entry from the list of active formatting elements.
   2. ~IF［ %~entry は`~marker$である ］ ⇒ ~BREAK ◎ If entry was a marker, then stop the algorithm at this point. The list has been cleared up to the last marker. ◎ Go to step 1.

12.2.4.4. 要素を指す~pointer

`~head要素~pointer@

初期~時は ~NULL とする。 ◎ Initially, the head element pointer and the form element pointer are both null.

`head$e 要素が（暗黙的／明示的いずれにせよ）構文解析された時点で，その~nodeを指すよう設定される。 ◎ Once a head element has been parsed (whether implicitly or explicitly) the head element pointer gets set to point to this node.

`~form要素~pointer@

初期~時は ~NULL とする。 ◎ ↑

［ 開かれている `form$e 要素 ］のうち，まだ終了tagには出くわしてないもの ］のうち，最後のものを指す。 ◎ The form element pointer points to the last form element that was opened and whose end tag has not yet been seen.＼

これは、歴史的~理由から、ひどく不良な~markupに面したとき，~form-controlを~formに所有させるために利用される。 ◎ It is used to make form controls associate with forms in the face of dramatically bad markup, for historical reasons.＼

これは、 `template$e 要素の内側では無視される。 ◎ It is ignored inside template elements.

12.2.4.5. 他の構文解析~状態~flag

`~scripting~flag@

%構文解析器 が作成された時点で、［ 次が満たされるならば `可能化^i ／ ~ELSE_ `不能化^i ］に設定される ⇒ %構文解析器 に結付けられている`文書$において `~scriptingは可能化されて$いる ◎ The scripting flag is set to "enabled" if scripting was enabled for the Document with which the parser is associated when the parser was created, and "disabled" otherwise.

注記： `~scripting~flag$は、 %構文解析器 が`~HTML素片~用$であるときでも，可能化され得る — その事例では `script$e 要素は実行しないが。 ◎ The scripting flag can be enabled even when the parser was originally created for the HTML fragment parsing algorithm, even though script elements don't execute in that case.

`~frameset-ok~flag@

%構文解析器 の作成-時には `ok^i に設定される。 ある種の~tokenに出くわしたとき，`not-ok^i になる。 ◎ The frameset-ok flag is set to "ok" when the parser is created. It is set to "not ok" after certain tokens are seen.

12.2.5.1. `~data^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0026^U

1. `戻先~状態$V ~SET `~data$st
2. `文字~参照$stに`切替える$

◎ Set the return state to the data state. Switch to the character reference state.

`003C^U

1. `~tag~open$stに`切替える$

◎ Switch to the tag open state.

`0000^U

1. `unexpected-null-character$pE
2. 新たな文字~token( `現在の入力~文字$ ) を発する

◎ This is an unexpected-null-character parse error. Emit the current input character as a character token.

~EOF

1. ~eof~tokenを発する

◎ Emit an end-of-file token.

~AnyElse

1. 新たな文字~token( `現在の入力~文字$ ) を発する

◎ Emit the current input character as a character token.

12.2.5.2. `~RCDATA^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0026^U

1. `戻先~状態$V ~SET `~RCDATA$st
2. `文字~参照$stに`切替える$

◎ Set the return state to the RCDATA state. Switch to the character reference state.

`003C^U

1. `~RCDATA~LTsign$stに`切替える$

◎ Switch to the RCDATA less-than sign state.

`0000^U

1. `unexpected-null-character$pE
2. 新たな文字~token( `FFFD^U ) を発する

◎ This is an unexpected-null-character parse error. Emit a U+FFFD REPLACEMENT CHARACTER character token.

~EOF

1. ~eof~tokenを発する

◎ Emit an end-of-file token.

~AnyElse

1. 新たな文字~token( `現在の入力~文字$ ) を発する

◎ Emit the current input character as a character token.

12.2.5.3. `~RAWTEXT^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`003C^U

1. `~RAWTEXT~LTsign$stに`切替える$

◎ Switch to the RAWTEXT less-than sign state.

`0000^U

1. `unexpected-null-character$pE
2. 新たな文字~token( `FFFD^U ) を発する

◎ This is an unexpected-null-character parse error. Emit a U+FFFD REPLACEMENT CHARACTER character token.

~EOF

1. ~eof~tokenを発する

◎ Emit an end-of-file token.

~AnyElse

1. 新たな文字~token( `現在の入力~文字$ ) を発する

◎ Emit the current input character as a character token.

12.2.5.4. `~script~data^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`003C^U

1. `~script~data~LTsign$stに`切替える$

◎ Switch to the script data less-than sign state.

`0000^U

1. `unexpected-null-character$pE
2. 新たな文字~token( `FFFD^U ) を発する

◎ This is an unexpected-null-character parse error. Emit a U+FFFD REPLACEMENT CHARACTER character token.

~EOF

1. ~eof~tokenを発する

◎ Emit an end-of-file token.

~AnyElse

1. 新たな文字~token( `現在の入力~文字$ ) を発する

◎ Emit the current input character as a character token.

12.2.5.5. `~PLAINTEXT^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0000^U

1. `unexpected-null-character$pE
2. 新たな文字~token( `FFFD^U ) を発する

◎ This is an unexpected-null-character parse error. Emit a U+FFFD REPLACEMENT CHARACTER character token.

~EOF

1. ~eof~tokenを発する

◎ Emit an end-of-file token.

~AnyElse

1. 新たな文字~token( `現在の入力~文字$ ) を発する

◎ Emit the current input character as a character token.

12.2.5.6. `~tag~open^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0021^U

1. `~markup宣言~open$stに`切替える$

◎ Switch to the markup declaration open state.

`002F^U

1. `終了tag~open$stに`切替える$

◎ Switch to the end tag open state.

`~ASCII英字$

1. 新たな開始tag~token( 空~文字列 ) を作成する
2. `~tag名$st内で`再消費-$する

◎ Create a new start tag token, set its tag name to the empty string. Reconsume in the tag name state.

`003F^U

1. `unexpected-question-mark-instead-of-tag-name$pE
2. 新たな~comment~token( 空~文字列 ) を作成する
3. `似非~comment$st内で`再消費-$する

◎ This is an unexpected-question-mark-instead-of-tag-name parse error. Create a comment token whose data is the empty string. Reconsume in the bogus comment state.

~EOF

1. `eof-before-tag-name$pE
2. 新たな文字~token( `003C^U ) を発する
3. ~eof~tokenを発する

◎ This is an eof-before-tag-name parse error. Emit a U+003C LESS-THAN SIGN character token and an end-of-file token.

~AnyElse

1. `invalid-first-character-of-tag-name$pE
2. 新たな文字~token( `003C^U ) を発する
3. `~data$st内で`再消費-$する

◎ This is an invalid-first-character-of-tag-name parse error. Emit a U+003C LESS-THAN SIGN character token. Reconsume in the data state.

12.2.5.7. `終了tag~open^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`~ASCII英字$

1. %~token ~LET 新たな終了tag~token()
2. `~tag名$st内で`再消費-$する

◎ Create a new end tag token, set its tag name to the empty string. Reconsume in the tag name state.

`003E^U

1. `missing-end-tag-name$pE
2. `~data$stに`切替える$

◎ This is a missing-end-tag-name parse error. Switch to the data state.

~EOF

1. `eof-before-tag-name$pE
2. 新たな文字~token( `003C^U ) を発する
3. 新たな文字~token( `002F^U ) を発する
4. ~eof~tokenを発する

◎ This is an eof-before-tag-name parse error. Emit a U+003C LESS-THAN SIGN character token, a U+002F SOLIDUS character token and an end-of-file token.

~AnyElse

1. `invalid-first-character-of-tag-name$pE
2. 新たな~comment~token( 空~文字列 ) を作成する
3. `似非~comment$st内で`再消費-$する

◎ This is an invalid-first-character-of-tag-name parse error. Create a comment token whose data is the empty string. Reconsume in the bogus comment state.

12.2.5.8. `~tag名^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0009^U

`000A^U

`000C^U

`0020^U

1. `属性~名の前$stに`切替える$

◎ Switch to the before attribute name state.

`002F^U

1. `自己閉じ開始tag$stに`切替える$

◎ Switch to the self-closing start tag state.

`003E^U

1. `~data$stに`切替える$
2. 現在の~tag~tokenを発する

◎ Switch to the data state. Emit the current tag token.

`~ASCII英大文字$

1. 現在の~tag~tokenの~tag名 ~APPEND `現在の入力~文字$に対応する小文字（文字の~cpに `0020^X を加算する）

◎ Append the lowercase version of the current input character (add 0x0020 to the character's code point) to the current tag token's tag name.

`0000^U

1. `unexpected-null-character$pE
2. 現在の~tag~tokenの~tag名 ~APPEND `FFFD^U character

◎ This is an unexpected-null-character parse error. Append a U+FFFD REPLACEMENT CHARACTER character to the current tag token's tag name.

~EOF

1. `eof-in-tag$pE
2. ~eof~tokenを発する

◎ This is an eof-in-tag parse error. Emit an end-of-file token.

~AnyElse

1. 現在の~tag~tokenの~tag名 ~APPEND `現在の入力~文字$

◎ Append the current input character to the current tag token's tag name.

12.2.5.9. `~RCDATA~LTsign^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`002F^U

1. `一時~buffer$V ~SET 空~文字列
2. `~RCDATA終了tag~open$stに`切替える$

◎ Set the temporary buffer to the empty string. Switch to the RCDATA end tag open state.

~AnyElse

1. 新たな文字~token( `003C^U ) を発する
2. `~RCDATA$st内で`再消費-$する

◎ Emit a U+003C LESS-THAN SIGN character token. Reconsume in the RCDATA state.

12.2.5.10. `~RCDATA終了tag~open^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`~ASCII英字$

1. %~token ~LET 新たな終了tag~token()
2. `~RCDATA終了tag名$st内で`再消費-$する

◎ Create a new end tag token, set its tag name to the empty string. Reconsume in the RCDATA end tag name state.

~AnyElse

1. 新たな文字~token( `003C^U ) を発する
2. 新たな文字~token( `002F^U ) を発する
3. `~RCDATA$st内で`再消費-$する

◎ Emit a U+003C LESS-THAN SIGN character token and a U+002F SOLIDUS character token. Reconsume in the RCDATA state.

12.2.5.11. `~RCDATA終了tag名^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0009^U

`000A^U

`000C^U

`0020^U

1. ~IF［ 現在の終了tag~tokenは`適切な終了tag~token$でない ］ ⇒ ~GOTO ~AnyElse
2. `属性~名の前$stに`切替える$

◎ If the current end tag token is an appropriate end tag token, then switch to the before attribute name state. Otherwise, treat it as per the "anything else" entry below.

`002F^U

1. ~IF［ 現在の終了tag~tokenは`適切な終了tag~token$でない ］ ⇒ ~GOTO ~AnyElse
2. `自己閉じ開始tag$stに`切替える$

◎ If the current end tag token is an appropriate end tag token, then switch to the self-closing start tag state. Otherwise, treat it as per the "anything else" entry below.

`003E^U

1. ~IF［ 現在の終了tag~tokenは`適切な終了tag~token$でない ］ ⇒ ~GOTO ~AnyElse
2. `~data$stに`切替える$
3. 現在の~tag~tokenを発する

◎ If the current end tag token is an appropriate end tag token, then switch to the data state and emit the current tag token. Otherwise, treat it as per the "anything else" entry below.

`~ASCII英大文字$

1. 現在の~tag~tokenの~tag名 ~APPEND `現在の入力~文字$に対応する小文字（文字の~cpに `0020^X を加算する）
2. `一時~buffer$V ~APPEND `現在の入力~文字$

◎ Append the lowercase version of the current input character (add 0x0020 to the character's code point) to the current tag token's tag name. Append the current input character to the temporary buffer.

`~ASCII英小文字$

1. 現在の~tag~tokenの~tag名 ~APPEND `現在の入力~文字$
2. `一時~buffer$V ~APPEND `現在の入力~文字$

◎ Append the current input character to the current tag token's tag name. Append the current input character to the temporary buffer.

~AnyElse

1. 新たな文字~token( `003C^U ) を発する
2. 新たな文字~token( `002F^U ) を発する
3. `一時~buffer$V 内の~EACH( %文字 ) に対し ⇒ 新たな文字~token( %文字 ) を発する
4. `~RCDATA$st内で`再消費-$する

◎ Emit a U+003C LESS-THAN SIGN character token, a U+002F SOLIDUS character token, and a character token for each of the characters in the temporary buffer (in the order they were added to the buffer). Reconsume in the RCDATA state.

12.2.5.12. `~RAWTEXT~LTsign^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`002F^U

1. `一時~buffer$V ~SET 空~文字列
2. `~RAWTEXT終了tag~open$stに`切替える$

◎ Set the temporary buffer to the empty string. Switch to the RAWTEXT end tag open state.

~AnyElse

1. 新たな文字~token( `003C^U ) を発する
2. `~RAWTEXT$st内で`再消費-$する

◎ Emit a U+003C LESS-THAN SIGN character token. Reconsume in the RAWTEXT state.

12.2.5.13. `~RAWTEXT終了tag~open^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`~ASCII英字$

1. %~token ~LET 新たな終了tag~token()
2. `~RAWTEXT終了tag名$st内で`再消費-$する

◎ Create a new end tag token, set its tag name to the empty string. Reconsume in the RAWTEXT end tag name state.

~AnyElse

1. 新たな文字~token( `003C^U ) を発する
2. 新たな文字~token( `002F^U ) を発する
3. `~RAWTEXT$st内で`再消費-$する

◎ Emit a U+003C LESS-THAN SIGN character token and a U+002F SOLIDUS character token. Reconsume in the RAWTEXT state.

12.2.5.14. `~RAWTEXT終了tag名^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0009^U

`000A^U

`000C^U

`0020^U

1. ~IF［ 現在の終了tag~tokenは`適切な終了tag~token$でない ］ ⇒ ~GOTO ~AnyElse
2. `属性~名の前$stに`切替える$

◎ If the current end tag token is an appropriate end tag token, then switch to the before attribute name state. Otherwise, treat it as per the "anything else" entry below.

`002F^U

1. ~IF［ 現在の終了tag~tokenは`適切な終了tag~token$でない ］ ⇒ ~GOTO ~AnyElse
2. `自己閉じ開始tag$stに`切替える$

◎ If the current end tag token is an appropriate end tag token, then switch to the self-closing start tag state. Otherwise, treat it as per the "anything else" entry below.

`003E^U

1. ~IF［ 現在の終了tag~tokenは`適切な終了tag~token$でない ］ ⇒ ~GOTO ~AnyElse
2. `~data$stに`切替える$
3. 現在の~tag~tokenを発する

◎ If the current end tag token is an appropriate end tag token, then switch to the data state and emit the current tag token. Otherwise, treat it as per the "anything else" entry below.

`~ASCII英大文字$

1. 現在の~tag~tokenの~tag名 ~APPEND `現在の入力~文字$に対応する小文字（文字の~cpに `0020^X を加算する）
2. `一時~buffer$V ~APPEND `現在の入力~文字$

◎ Append the lowercase version of the current input character (add 0x0020 to the character's code point) to the current tag token's tag name. Append the current input character to the temporary buffer.

`~ASCII英小文字$

1. 現在の~tag~tokenの~tag名 ~APPEND `現在の入力~文字$
2. `一時~buffer$V ~APPEND `現在の入力~文字$

◎ Append the current input character to the current tag token's tag name. Append the current input character to the temporary buffer.

~AnyElse

1. 新たな文字~token( `003C^U ) を発する
2. 新たな文字~token( `002F^U ) を発する
3. `一時~buffer$V 内の~EACH( %文字 ) に対し ⇒ 新たな文字~token( %文字 ) を発する
4. `~RAWTEXT$st内で`再消費-$する

◎ Emit a U+003C LESS-THAN SIGN character token, a U+002F SOLIDUS character token, and a character token for each of the characters in the temporary buffer (in the order they were added to the buffer). Reconsume in the RAWTEXT state.

12.2.5.15. `~script~data~LTsign^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`002F^U

1. `一時~buffer$V ~SET 空~文字列
2. `~script~data終了tag~open$stに`切替える$

◎ Set the temporary buffer to the empty string. Switch to the script data end tag open state.

`0021^U

1. `~script~data~escape始端$stに`切替える$
2. 新たな文字~token( `003C^U ) を発する
3. 新たな文字~token( `0021^U ) を発する

◎ Switch to the script data escape start state. Emit a U+003C LESS-THAN SIGN character token and a U+0021 EXCLAMATION MARK character token.

~AnyElse

1. 新たな文字~token( `003C^U ) を発する
2. `~script~data$st内で`再消費-$する

◎ Emit a U+003C LESS-THAN SIGN character token. Reconsume in the script data state.

12.2.5.16. `~script~data終了tag~open^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`~ASCII英字$

1. %~token ~LET 新たな終了tag~token()
2. `~script~data終了tag名$st内で`再消費-$する

◎ Create a new end tag token, set its tag name to the empty string. Reconsume in the script data end tag name state.

~AnyElse

1. 新たな文字~token( `003C^U ) を発する
2. 新たな文字~token( `002F^U ) を発する
3. `~script~data$st内で`再消費-$する

◎ Emit a U+003C LESS-THAN SIGN character token and a U+002F SOLIDUS character token. Reconsume in the script data state.

12.2.5.17. `~script~data終了tag名^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0009^U

`000A^U

`000C^U

`0020^U

1. ~IF［ 現在の終了tag~tokenは`適切な終了tag~token$でない ］ ⇒ ~GOTO ~AnyElse
2. `属性~名の前$stに`切替える$

◎ If the current end tag token is an appropriate end tag token, then switch to the before attribute name state. Otherwise, treat it as per the "anything else" entry below.

`002F^U

1. ~IF［ 現在の終了tag~tokenは`適切な終了tag~token$でない ］ ⇒ ~GOTO ~AnyElse
2. `自己閉じ開始tag$stに`切替える$

◎ If the current end tag token is an appropriate end tag token, then switch to the self-closing start tag state. Otherwise, treat it as per the "anything else" entry below.

`003E^U

1. ~IF［ 現在の終了tag~tokenは`適切な終了tag~token$でない ］ ⇒ ~GOTO ~AnyElse
2. `~data$stに`切替える$
3. 現在の~tag~tokenを発する

◎ If the current end tag token is an appropriate end tag token, then switch to the data state and emit the current tag token. Otherwise, treat it as per the "anything else" entry below.

`~ASCII英大文字$

1. 現在の~tag~tokenの~tag名 ~APPEND `現在の入力~文字$に対応する小文字（文字の~cpに `0020^X を加算する）
2. `一時~buffer$V ~APPEND `現在の入力~文字$

◎ Append the lowercase version of the current input character (add 0x0020 to the character's code point) to the current tag token's tag name. Append the current input character to the temporary buffer.

`~ASCII英小文字$

1. 現在の~tag~tokenの~tag名 ~APPEND `現在の入力~文字$
2. `一時~buffer$V ~APPEND `現在の入力~文字$

◎ Append the current input character to the current tag token's tag name. Append the current input character to the temporary buffer.

~AnyElse

1. 新たな文字~token( `003C^U ) を発する
2. 新たな文字~token( `002F^U ) を発する
3. `一時~buffer$V 内の~EACH( %文字 ) に対し ⇒ 新たな文字~token( %文字 ) を発する
4. `~script~data$st内で`再消費-$する

◎ Emit a U+003C LESS-THAN SIGN character token, a U+002F SOLIDUS character token, and a character token for each of the characters in the temporary buffer (in the order they were added to the buffer). Reconsume in the script data state.

12.2.5.18. `~script~data~escape始端^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`002D^U

1. `~script~data~escape始端~dash$stに`切替える$
2. 新たな文字~token( `002D^U ) を発する

◎ Switch to the script data escape start dash state. Emit a U+002D HYPHEN-MINUS character token.

~AnyElse

1. `~script~data$st内で`再消費-$する

◎ Reconsume in the script data state.

12.2.5.19. `~script~data~escape始端~dash^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`002D^U

1. `~script~data~escape済み~dash~dash$stに`切替える$
2. 新たな文字~token( `002D^U ) を発する

◎ Switch to the script data escaped dash dash state. Emit a U+002D HYPHEN-MINUS character token.

~AnyElse

1. `~script~data$st内で`再消費-$する

◎ Reconsume in the script data state.

12.2.5.20. `~script~data~escape済み^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`002D^U

1. `~script~data~escape済み~dash$stに`切替える$
2. 新たな文字~token( `002D^U ) を発する

◎ Switch to the script data escaped dash state. Emit a U+002D HYPHEN-MINUS character token.

`003C^U

1. `~script~data~escape済み~LTsign$stに`切替える$

◎ Switch to the script data escaped less-than sign state.

`0000^U

1. `unexpected-null-character$pE
2. 新たな文字~token( `FFFD^U ) を発する

◎ This is an unexpected-null-character parse error. Emit a U+FFFD REPLACEMENT CHARACTER character token.

~EOF

1. `eof-in-script-html-comment-like-text$pE
2. ~eof~tokenを発する

◎ This is an eof-in-script-html-comment-like-text parse error. Emit an end-of-file token.

~AnyElse

1. 新たな文字~token( `現在の入力~文字$ ) を発する

◎ Emit the current input character as a character token.

12.2.5.21. `~script~data~escape済み~dash^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`002D^U

1. `~script~data~escape済み~dash~dash$stに`切替える$
2. 新たな文字~token( `002D^U ) を発する

◎ Switch to the script data escaped dash dash state. Emit a U+002D HYPHEN-MINUS character token.

`003C^U

1. `~script~data~escape済み~LTsign$stに`切替える$

◎ Switch to the script data escaped less-than sign state.

`0000^U

1. `unexpected-null-character$pE
2. `~script~data~escape済み$stに`切替える$
3. 新たな文字~token( `FFFD^U ) を発する

◎ This is an unexpected-null-character parse error. Switch to the script data escaped state. Emit a U+FFFD REPLACEMENT CHARACTER character token.

~EOF

1. `eof-in-script-html-comment-like-text$pE
2. ~eof~tokenを発する

◎ This is an eof-in-script-html-comment-like-text parse error. Emit an end-of-file token.

~AnyElse

1. `~script~data~escape済み$stに`切替える$
2. 新たな文字~token( `現在の入力~文字$ ) を発する

◎ Switch to the script data escaped state. Emit the current input character as a character token.

12.2.5.22. `~script~data~escape済み~dash~dash^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`002D^U

1. 新たな文字~token( `002D^U ) を発する

◎ Emit a U+002D HYPHEN-MINUS character token.

`003C^U

1. `~script~data~escape済み~LTsign$stに`切替える$

◎ Switch to the script data escaped less-than sign state.

`003E^U

1. `~script~data$stに`切替える$
2. 新たな文字~token( `003E^U ) を発する

◎ Switch to the script data state. Emit a U+003E GREATER-THAN SIGN character token.

`0000^U

1. `unexpected-null-character$pE
2. `~script~data~escape済み$stに`切替える$
3. 新たな文字~token( `FFFD^U ) を発する

◎ This is an unexpected-null-character parse error. Switch to the script data escaped state. Emit a U+FFFD REPLACEMENT CHARACTER character token.

~EOF

1. `eof-in-script-html-comment-like-text$pE
2. ~eof~tokenを発する

◎ This is an eof-in-script-html-comment-like-text parse error. Emit an end-of-file token.

~AnyElse

1. `~script~data~escape済み$stに`切替える$
2. 新たな文字~token( `現在の入力~文字$ ) を発する

◎ Switch to the script data escaped state. Emit the current input character as a character token.

12.2.5.23. `~script~data~escape済み~LTsign^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`002F^U

1. `一時~buffer$V ~SET 空~文字列
2. `~script~data~escape済み終了tag~open$stに`切替える$

◎ Set the temporary buffer to the empty string. Switch to the script data escaped end tag open state.

`~ASCII英字$

1. `一時~buffer$V ~SET 空~文字列
2. 新たな文字~token( `003C^U ) を発する
3. `~script~data二重~escape始端$st内で`再消費-$する

◎ Set the temporary buffer to the empty string. Emit a U+003C LESS-THAN SIGN character token. Reconsume in the script data double escape start state.

~AnyElse

1. 新たな文字~token( `003C^U ) を発する
2. `~script~data~escape済み$st内で`再消費-$する

◎ Emit a U+003C LESS-THAN SIGN character token. Reconsume in the script data escaped state.

12.2.5.24. `~script~data~escape済み終了tag~open^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`~ASCII英字$

1. %~token ~LET 新たな終了tag~token()
2. `~script~data~escape済み終了tag名$st内で`再消費-$する

（ %~token はまだ発しないこと — %~token の詳細は，それが発される前に埋められることになる。）

◎ Create a new end tag token. Reconsume in the script data escaped end tag name state. (Don't emit the token yet; further details will be filled in before it is emitted.)

~AnyElse

1. 新たな文字~token( `003C^U ) を発する
2. 新たな文字~token( `002F^U ) を発する
3. `~script~data~escape済み$st内で`再消費-$する

◎ Emit a U+003C LESS-THAN SIGN character token and a U+002F SOLIDUS character token. Reconsume in the script data escaped state.

12.2.5.25. `~script~data~escape済み終了tag名^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0009^U

`000A^U

`000C^U

`0020^U

1. ~IF［ 現在の終了tag~tokenは`適切な終了tag~token$でない ］ ⇒ ~GOTO ~AnyElse
2. `属性~名の前$stに`切替える$

◎ If the current end tag token is an appropriate end tag token, then switch to the before attribute name state. Otherwise, treat it as per the "anything else" entry below.

`002F^U

1. ~IF［ 現在の終了tag~tokenは`適切な終了tag~token$でない ］ ⇒ ~GOTO ~AnyElse
2. `自己閉じ開始tag$stに`切替える$

◎ If the current end tag token is an appropriate end tag token, then switch to the self-closing start tag state. Otherwise, treat it as per the "anything else" entry below.

`003E^U

1. ~IF［ 現在の終了tag~tokenは`適切な終了tag~token$でない ］ ⇒ ~GOTO ~AnyElse
2. `~data$stに`切替える$
3. 現在の~tag~tokenを発する

◎ If the current end tag token is an appropriate end tag token, then switch to the data state and emit the current tag token. Otherwise, treat it as per the "anything else" entry below.

`~ASCII英大文字$

1. 現在の~tag~tokenの~tag名 ~APPEND `現在の入力~文字$に対応する小文字（文字の~cpに `0020^X を加算する）
2. `一時~buffer$V ~APPEND `現在の入力~文字$

◎ Append the lowercase version of the current input character (add 0x0020 to the character's code point) to the current tag token's tag name. Append the current input character to the temporary buffer.

`~ASCII英小文字$

1. 現在の~tag~tokenの~tag名 ~APPEND `現在の入力~文字$
2. `一時~buffer$V ~APPEND `現在の入力~文字$

◎ Append the current input character to the current tag token's tag name. Append the current input character to the temporary buffer.

~AnyElse

1. 新たな文字~token( `003C^U ) を発する
2. 新たな文字~token( `002F^U ) を発する
3. `一時~buffer$V 内の~EACH( %文字 ) に対し ⇒ 新たな文字~token( %文字 ) を発する
4. `~script~data~escape済み$st内で`再消費-$する

◎ Emit a U+003C LESS-THAN SIGN character token, a U+002F SOLIDUS character token, and a character token for each of the characters in the temporary buffer (in the order they were added to the buffer). Reconsume in the script data escaped state.

12.2.5.26. `~script~data二重~escape始端^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0009^U

`000A^U

`000C^U

`0020^U

`002F^U

`003E^U

1. ~IF［ `一時~buffer$V ~EQ `script^l ］：

   1. `~script~data二重~escape済み$stに`切替える$
   2. ~RET
2. `~script~data~escape済み$stに`切替える$
3. 新たな文字~token( `現在の入力~文字$ ) を発する

◎ If the temporary buffer is the string "script", then switch to the script data double escaped state. Otherwise, switch to the script data escaped state. Emit the current input character as a character token.

`~ASCII英大文字$

1. `一時~buffer$V ~APPEND `現在の入力~文字$に対応する小文字（文字の~cpに `0020^X を加算する）
2. 新たな文字~token( `現在の入力~文字$ ) を発する

◎ Append the lowercase version of the current input character (add 0x0020 to the character's code point) to the temporary buffer. Emit the current input character as a character token.

`~ASCII英小文字$

1. `一時~buffer$V ~APPEND `現在の入力~文字$
2. 新たな文字~token( `現在の入力~文字$ ) を発する

◎ Append the current input character to the temporary buffer. Emit the current input character as a character token.

~AnyElse

1. `~script~data~escape済み$st内で`再消費-$する

◎ Reconsume in the script data escaped state.

12.2.5.27. `~script~data二重~escape済み^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`002D^U

1. `~script~data二重~escape済み~dash$stに`切替える$
2. 新たな文字~token( `002D^U ) を発する

◎ Switch to the script data double escaped dash state. Emit a U+002D HYPHEN-MINUS character token.

`003C^U

1. `~script~data二重~escape済み~LTsign$stに`切替える$
2. 新たな文字~token( `003C^U ) を発する

◎ Switch to the script data double escaped less-than sign state. Emit a U+003C LESS-THAN SIGN character token.

`0000^U

1. `unexpected-null-character$pE
2. 新たな文字~token( `FFFD^U ) を発する

◎ This is an unexpected-null-character parse error. Emit a U+FFFD REPLACEMENT CHARACTER character token.

~EOF

1. `eof-in-script-html-comment-like-text$pE
2. ~eof~tokenを発する

◎ This is an eof-in-script-html-comment-like-text parse error. Emit an end-of-file token.

~AnyElse

1. 新たな文字~token( `現在の入力~文字$ ) を発する

◎ Emit the current input character as a character token.

12.2.5.28. `~script~data二重~escape済み~dash^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`002D^U

1. `~script~data二重~escape済み~dash~dash$stに`切替える$
2. 新たな文字~token( `002D^U ) を発する

◎ Switch to the script data double escaped dash dash state. Emit a U+002D HYPHEN-MINUS character token.

`003C^U

1. `~script~data二重~escape済み~LTsign$stに`切替える$
2. 新たな文字~token( `003C^U ) を発する

◎ Switch to the script data double escaped less-than sign state. Emit a U+003C LESS-THAN SIGN character token.

`0000^U

1. `unexpected-null-character$pE
2. `~script~data二重~escape済み$stに`切替える$
3. 新たな文字~token( `FFFD^U ) を発する

◎ This is an unexpected-null-character parse error. Switch to the script data double escaped state. Emit a U+FFFD REPLACEMENT CHARACTER character token.

~EOF

1. `eof-in-script-html-comment-like-text$pE
2. ~eof~tokenを発する

◎ This is an eof-in-script-html-comment-like-text parse error. Emit an end-of-file token.

~AnyElse

1. `~script~data二重~escape済み$stに`切替える$
2. 新たな文字~token( `現在の入力~文字$ ) を発する

◎ Switch to the script data double escaped state. Emit the current input character as a character token.

12.2.5.29. `~script~data二重~escape済み~dash~dash^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`002D^U

1. 新たな文字~token( `002D^U ) を発する

◎ Emit a U+002D HYPHEN-MINUS character token.

`003C^U

1. `~script~data二重~escape済み~LTsign$stに`切替える$
2. 新たな文字~token( `003C^U ) を発する

◎ Switch to the script data double escaped less-than sign state. Emit a U+003C LESS-THAN SIGN character token.

`003E^U

1. `~script~data$stに`切替える$
2. 新たな文字~token( `003E^U ) を発する

◎ Switch to the script data state. Emit a U+003E GREATER-THAN SIGN character token.

`0000^U

1. `unexpected-null-character$pE
2. `~script~data二重~escape済み$stに`切替える$
3. 新たな文字~token( `FFFD^U ) を発する

◎ This is an unexpected-null-character parse error. Switch to the script data double escaped state. Emit a U+FFFD REPLACEMENT CHARACTER character token.

~EOF

1. `eof-in-script-html-comment-like-text$pE
2. ~eof~tokenを発する

◎ This is an eof-in-script-html-comment-like-text parse error. Emit an end-of-file token.

~AnyElse

1. `~script~data二重~escape済み$stに`切替える$
2. 新たな文字~token( `現在の入力~文字$ ) を発する

◎ Switch to the script data double escaped state. Emit the current input character as a character token.

12.2.5.30. `~script~data二重~escape済み~LTsign^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`002F^U

1. `一時~buffer$V ~SET 空~文字列
2. `~script~data二重~escape終端$stに`切替える$
3. 新たな文字~token( `002F^U ) を発する

◎ Set the temporary buffer to the empty string. Switch to the script data double escape end state. Emit a U+002F SOLIDUS character token.

~AnyElse

1. `~script~data二重~escape済み$st内で`再消費-$する

◎ Reconsume in the script data double escaped state.

12.2.5.31. `~script~data二重~escape終端^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0009^U

`000A^U

`000C^U

`0020^U

`002F^U

`003E^U

1. ~IF［ `一時~buffer$V ~EQ `script^l ］：

   1. `~script~data~escape済み$stに`切替える$
   2. ~RET
2. `~script~data二重~escape済み$stに`切替える$
3. 新たな文字~token( `現在の入力~文字$ ) を発する

◎ If the temporary buffer is the string "script", then switch to the script data escaped state. Otherwise, switch to the script data double escaped state. Emit the current input character as a character token.

`~ASCII英大文字$

1. `一時~buffer$V ~APPEND `現在の入力~文字$ に対応する小文字（文字の~cpに `0020^X を加算する）
2. 新たな文字~token( `現在の入力~文字$ ) を発する

◎ Append the lowercase version of the current input character (add 0x0020 to the character's code point) to the temporary buffer. Emit the current input character as a character token.

`~ASCII英小文字$

1. `一時~buffer$V ~APPEND `現在の入力~文字$
2. 新たな文字~token( `現在の入力~文字$ ) を発する

◎ Append the current input character to the temporary buffer. Emit the current input character as a character token.

~AnyElse

1. `~script~data二重~escape済み$st内で`再消費-$する

◎ Reconsume in the script data double escaped state.

12.2.5.32. `属性~名の前^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0009^U

`000A^U

`000C^U

`0020^U

1. この文字は無視する

◎ Ignore the character.

`002F^U

`003E^U

~EOF

1. `属性~名の後$st内で`再消費-$する

◎ Reconsume in the after attribute name state.

`003D^U

1. `unexpected-equals-sign-before-attribute-name$pE
2. 現在の~tag~token内で新たな属性( 名前 ~SET `現在の入力~文字$, 値 ~SET 空~文字列 ) を開始する
3. `属性~名$stに`切替える$

◎ This is an unexpected-equals-sign-before-attribute-name parse error. Start a new attribute in the current tag token. Set that attribute's name to the current input character, and its value to the empty string. Switch to the attribute name state.

~AnyElse

1. 現在の~tag~token内で新たな属性( 名前 ~SET 空~文字列, 値 ~SET 空~文字列 ) を開始する
2. `属性~名$st内で`再消費-$する

◎ Start a new attribute in the current tag token. Set that attribute name and value to the empty string. Reconsume in the attribute name state.

12.2.5.33. `属性~名^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0009^U

`000A^U

`000C^U

`0020^U

`002F^U

`003E^U

~EOF

1. `属性~名の後$st内で`再消費-$する

◎ Reconsume in the after attribute name state.

`003D^U

1. `属性~値の前$stに`切替える$

◎ Switch to the before attribute value state.

`~ASCII英大文字$

1. 現在の属性の名前 ~APPEND `現在の入力~文字$ に対応する小文字（文字の~cpに `0020^X を加算する）

◎ Append the lowercase version of the current input character (add 0x0020 to the character's code point) to the current attribute's name.

`0000^U

1. `unexpected-null-character$pE
2. 現在の属性の名前 ~APPEND `FFFD^U

◎ This is an unexpected-null-character parse error. Append a U+FFFD REPLACEMENT CHARACTER character to the current attribute's name.

`0022^U

`0027^U

`003C^U

1. `unexpected-character-in-attribute-name$pE
2. ~GOTO ~AnyElse

◎ This is an unexpected-character-in-attribute-name parse error. Treat it as per the "anything else" entry below.

~AnyElse

1. 現在の属性の名前 ~APPEND `現在の入力~文字$

◎ Append the current input character to the current attribute's name.

~UAは，`属性~名$stから去るときには（および，適切になるなら、現在の~tag~tokenを発する前に）、現在の~tag~token上の属性たちの完全な名前どうしを比較し~MUST。 正確に同じ名前の属性が~token上にすでにある場合、 `duplicate-attribute$pE になり，新たな 【後から追加された】 属性は~tokenから除去され~MUST。 ◎ When the user agent leaves the attribute name state (and before emitting the tag token, if appropriate), the complete attribute's name must be compared to the other attributes on the same token; if there is already an attribute on the token with the exact same name, then this is a duplicate-attribute parse error and the new attribute must be removed from the token.

注記： ある属性が ~tokenからそのように除去された場合、それに対応する値は，あっても 構文解析器により後続して利用されることは決してなく、実質的に破棄される。 しかしながら，この仕方で属性を除去しても、~tokenizerの目的における “現在の属性” としての地位は変化しない。 ◎ If an attribute is so removed from a token, it, and the value that gets associated with it, if any, are never subsequently used by the parser, and are therefore effectively discarded. Removing the attribute in this way does not change its status as the "current attribute" for the purposes of the tokenizer, however.

12.2.5.34. `属性~名の後^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0009^U

`000A^U

`000C^U

`0020^U

1. この文字は無視する

◎ Ignore the character.

`002F^U

1. `自己閉じ開始tag$stに`切替える$

◎ Switch to the self-closing start tag state.

`003D^U

1. `属性~値の前$stに`切替える$

◎ Switch to the before attribute value state.

`003E^U

1. `~data$stに`切替える$
2. 現在の~tag~tokenを発する

◎ Switch to the data state. Emit the current tag token.

~EOF

1. `eof-in-tag$pE
2. ~eof~tokenを発する

◎ This is an eof-in-tag parse error. Emit an end-of-file token.

~AnyElse

1. 現在の~tag~token内で新たな属性( 名前 ~SET 空~文字列, 値 ~SET 空~文字列 ) を開始する
2. `属性~名$st内で`再消費-$する

◎ Start a new attribute in the current tag token. Set that attribute name and value to the empty string. Reconsume in the attribute name state.

12.2.5.35. `属性~値の前^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0009^U

`000A^U

`000C^U

`0020^U

1. この文字は無視する

◎ Ignore the character.

`0022^U

1. `二重引用符付き属性~値$stに`切替える$

◎ Switch to the attribute value (double-quoted) state.

`0027^U

1. `一重引用符付き属性~値$stに`切替える$

◎ Switch to the attribute value (single-quoted) state.

`003E^U

1. `missing-attribute-value$pE
2. `~data$stに`切替える$
3. 現在の~tag~tokenを発する

◎ This is a missing-attribute-value parse error. Switch to the data state. Emit the current tag token.

~AnyElse

1. `引用符無し属性~値$st内で`再消費-$する

◎ Reconsume in the attribute value (unquoted) state.

12.2.5.36. `二重引用符付き属性~値^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0022^U

1. `引用符付き属性~値の後$stに`切替える$

◎ Switch to the after attribute value (quoted) state.

`0026^U

1. `戻先~状態$V ~SET `二重引用符付き属性~値$st
2. `文字~参照$stに`切替える$

◎ Set the return state to the attribute value (double-quoted) state. Switch to the character reference state.

`0000^U

1. `unexpected-null-character$pE
2. 現在の属性の値 ~APPEND `FFFD^U

◎ This is an unexpected-null-character parse error. Append a U+FFFD REPLACEMENT CHARACTER character to the current attribute's value.

~EOF

1. `eof-in-tag$pE
2. ~eof~tokenを発する

◎ This is an eof-in-tag parse error. Emit an end-of-file token.

~AnyElse

1. 現在の属性の値 ~APPEND `現在の入力~文字$

◎ Append the current input character to the current attribute's value.

12.2.5.37. `一重引用符付き属性~値^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0027^U

1. `引用符付き属性~値の後$stに`切替える$

◎ Switch to the after attribute value (quoted) state.

`0026^U

1. `戻先~状態$V ~SET `一重引用符付き属性~値$st
2. `文字~参照$stに`切替える$

◎ Set the return state to the attribute value (single-quoted) state. Switch to the character reference state.

`0000^U

1. `unexpected-null-character$pE
2. 現在の属性の値 ~APPEND `FFFD^U

◎ This is an unexpected-null-character parse error. Append a U+FFFD REPLACEMENT CHARACTER character to the current attribute's value.

~EOF

1. `eof-in-tag$pE
2. ~eof~tokenを発する

◎ This is an eof-in-tag parse error. Emit an end-of-file token.

~AnyElse

1. 現在の属性の値 ~APPEND `現在の入力~文字$

◎ Append the current input character to the current attribute's value.

12.2.5.38. `引用符無し属性~値^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0009^U

`000A^U

`000C^U

`0020^U

1. `属性~名の前$stに`切替える$

◎ Switch to the before attribute name state.

`0026^U

1. `戻先~状態$V ~SET `引用符無し属性~値$st
2. `文字~参照$stに`切替える$

◎ Set the return state to the attribute value (unquoted) state. Switch to the character reference state.

`003E^U

1. `~data$stに`切替える$
2. 現在の~tag~tokenを発する

◎ Switch to the data state. Emit the current tag token.

`0000^U

1. `unexpected-null-character$pE
2. 現在の属性の値 ~APPEND `FFFD^U

◎ This is an unexpected-null-character parse error. Append a U+FFFD REPLACEMENT CHARACTER character to the current attribute's value.

`0022^U

`0027^U

`003C^U

`003D^U

`0060^U

1. `unexpected-character-in-unquoted-attribute-value$pE
2. ~GOTO ~AnyElse

◎ This is an unexpected-character-in-unquoted-attribute-value parse error. Treat it as per the "anything else" entry below.

~EOF

1. `eof-in-tag$pE
2. ~eof~tokenを発する

◎ This is an eof-in-tag parse error. Emit an end-of-file token.

~AnyElse

1. 現在の属性の値 ~APPEND `現在の入力~文字$

◎ Append the current input character to the current attribute's value.

12.2.5.39. `引用符付き属性~値の後^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0009^U

`000A^U

`000C^U

`0020^U

1. `属性~名の前$stに`切替える$

◎ Switch to the before attribute name state.

`002F^U

1. `自己閉じ開始tag$stに`切替える$

◎ Switch to the self-closing start tag state.

`003E^U

1. `~data$stに`切替える$
2. 現在の~tag~tokenを発する

◎ Switch to the data state. Emit the current tag token.

~EOF

1. `eof-in-tag$pE
2. ~eof~tokenを発する

◎ This is an eof-in-tag parse error. Emit an end-of-file token.

~AnyElse

1. `missing-whitespace-between-attributes$pE
2. `属性~名の前$st内で`再消費-$する

◎ This is a missing-whitespace-between-attributes parse error. Reconsume in the before attribute name state.

12.2.5.40. `自己閉じ開始tag^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`003E^U

1. 現在の~tag~tokenの`自己閉じ~flag$ ~SET ~ON
2. `~data$stに`切替える$
3. 現在の~tag~tokenを発する

◎ Set the self-closing flag of the current tag token. Switch to the data state. Emit the current tag token.

~EOF

1. `eof-in-tag$pE
2. ~eof~tokenを発する

◎ This is an eof-in-tag parse error. Emit an end-of-file token.

~AnyElse

1. `unexpected-solidus-in-tag$pE
2. `属性~名の前$st内で`再消費-$する

◎ This is an unexpected-solidus-in-tag parse error. Reconsume in the before attribute name state.

12.2.5.41. `似非~comment^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`003E^U

1. `~data$stに`切替える$
2. 現在の~comment~tokenを発する

◎ Switch to the data state. Emit the comment token.

~EOF

1. 現在の~comment~tokenを発する
2. ~eof~tokenを発する

◎ Emit the comment. Emit an end-of-file token.

`0000^U

1. `unexpected-null-character$pE
2. 現在の~comment~tokenの~data ~APPEND `FFFD^U

◎ This is an unexpected-null-character parse error. Append a U+FFFD REPLACEMENT CHARACTER character to the comment token's data.

~AnyElse

1. 現在の~comment~tokenの~data ~APPEND `現在の入力~文字$

◎ Append the current input character to the comment token's data.

12.2.5.42. `~markup宣言~open^st

次n少数の文字に応じて： ◎ If the next few characters are:

2 個の `002D^U ◎ Two U+002D HYPHEN-MINUS characters (-)

1. それらの文字を消費する
2. 新たな~comment~token( 空~文字列 ) を作成する
3. `~comment始端$stに`切替える$

◎ Consume those two characters, create a comment token whose data is the empty string, and switch to the comment start state.

`~ASCII大小無視$で `DOCTYPE^l に合致する ◎ ASCII case-insensitive match for the word "DOCTYPE"

1. それらの文字を消費する
2. `~DOCTYPE$stに`切替える$

◎ Consume those characters and switch to the DOCTYPE state.

文字列 `[CDATA[^l ◎ Case-sensitive match for the string "[CDATA[" (the five uppercase letters "CDATA" with a U+005B LEFT SQUARE BRACKET character before and after)

1. それらの文字を消費する ◎ Consume those characters.＼

2. ~IF［ `現在の調整-済み~node$がある ］~AND［ それは`~HTML名前空間$に属する要素でない ］：

   1. `~CDATAsec$stに`切替える$
   2. ~RET
   ◎ If there is an adjusted current node and it is not an element in the HTML namespace, then switch to the CDATA section state.＼
3. `cdata-in-html-content$pE ◎ Otherwise, this is a cdata-in-html-content parse error.＼
4. 新たな~comment~token( `[CDATA[^l ) を作成する ◎ Create a comment token whose data is the "[CDATA[" string.＼
5. `似非~comment$stに`切替える$ ◎ Switch to the bogus comment state.

~AnyElse

1. `incorrectly-opened-comment$pE
2. 新たな~comment~token( 空~文字列 ) を作成する
3. `似非~comment$stに`切替える$

（現在の状態~内では何も消費しないこと。）

◎ This is an incorrectly-opened-comment parse error. Create a comment token whose data is the empty string. Switch to the bogus comment state (don't consume anything in the current state).

12.2.5.43. `~comment始端^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`002D^U

1. `~comment始端~dash$stに`切替える$

◎ Switch to the comment start dash state.

`003E^U

1. `abrupt-closing-of-empty-comment$pE
2. `~data$stに`切替える$
3. 現在の~comment~tokenを発する

◎ This is an abrupt-closing-of-empty-comment parse error. Switch to the data state. Emit the comment token.

~AnyElse

1. `~comment$st内で`再消費-$する

◎ Reconsume in the comment state.

12.2.5.44. `~comment始端~dash^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`002D^U

1. `~comment終端$stに`切替える$

◎ Switch to the comment end state

`003E^U

1. `abrupt-closing-of-empty-comment$pE
2. `~data$stに`切替える$
3. 現在の~comment~tokenを発する

◎ This is an abrupt-closing-of-empty-comment parse error. Switch to the data state. Emit the comment token.

~EOF

1. `eof-in-comment$pE
2. 現在の~comment~tokenを発する
3. ~eof~tokenを発する

◎ This is an eof-in-comment parse error. Emit the comment token. Emit an end-of-file token.

~AnyElse

1. 現在の~comment~tokenの~data ~APPEND `002D^U
2. `~comment$st内で`再消費-$する

◎ Append a U+002D HYPHEN-MINUS character (-) to the comment token's data. Reconsume in the comment state.

12.2.5.45 `~comment^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`003C^U

1. 現在の~comment~tokenの~data ~APPEND `現在の入力~文字$
2. `~comment~LTsign$stに`切替える$

◎ Append the current input character to the comment token's data. Switch to the comment less-than sign state.

`002D^U

1. `~comment終端~dash$stに`切替える$

◎ Switch to the comment end dash state.

`0000^U

1. `unexpected-null-character$pE
2. 現在の~comment~tokenの~data ~APPEND `FFFD^U

◎ This is an unexpected-null-character parse error. Append a U+FFFD REPLACEMENT CHARACTER character to the comment token's data.

~EOF

1. `eof-in-comment$pE
2. 現在の~comment~tokenを発する
3. ~eof~tokenを発する

◎ This is an eof-in-comment parse error. Emit the comment token. Emit an end-of-file token.

~AnyElse

1. 現在の~comment~tokenの~data ~APPEND `現在の入力~文字$

◎ Append the current input character to the comment token's data.

12.2.5.46. `~comment~LTsign^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0021^U

1. 現在の~comment~tokenの~data ~APPEND `現在の入力~文字$
2. `~comment~LTsign~bang$stに`切替える$

◎ Append the current input character to the comment token's data. Switch to the comment less-than sign bang state.

`003C^U

1. 現在の~comment~tokenの~data ~APPEND `現在の入力~文字$

◎ Append the current input character to the comment token's data.

~AnyElse

1. `~comment$st内で`再消費-$する

◎ Reconsume in the comment state.

12.2.5.47. `~comment~LTsign~bang^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`002D^U

1. `~comment~LTsign~bang~dash$stに`切替える$

◎ Switch to the comment less-than sign bang dash state.

~AnyElse

1. `~comment$st内で`再消費-$する

◎ Reconsume in the comment state.

12.2.5.48. `~comment~LTsign~bang~dash^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`002D^U

1. `~comment~LTsign~bang~dash~dash$stに`切替える$

◎ Switch to the comment less-than sign bang dash dash state.

~AnyElse

1. `~comment終端~dash$st内で`再消費-$する

◎ Reconsume in the comment end dash state.

12.2.5.49. `~comment~LTsign~bang~dash~dash^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`003E^U

~EOF

1. `~comment終端$st内で`再消費-$する

◎ Reconsume in the comment end state.

~AnyElse

1. `nested-comment$pE
2. `~comment終端$st内で`再消費-$する

◎ This is a nested-comment parse error. Reconsume in the comment end state.

12.2.5.50. `~comment終端~dash^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`002D^U

1. `~comment終端$stに`切替える$

◎ Switch to the comment end state

~EOF

1. `eof-in-comment$pE
2. 現在の~comment~tokenを発する
3. ~eof~tokenを発する

◎ This is an eof-in-comment parse error. Emit the comment token. Emit an end-of-file token.

~AnyElse

1. 現在の~comment~tokenの~data ~APPEND `002D^U
2. `~comment$st内で`再消費-$する

◎ Append a U+002D HYPHEN-MINUS character (-) to the comment token's data. Reconsume in the comment state.

12.2.5.51. `~comment終端^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`003E^U

1. `~data$stに`切替える$
2. 現在の~comment~tokenを発する

◎ Switch to the data state. Emit the comment token.

`0021^U

1. `~comment終端~bang$stに`切替える$

◎ Switch to the comment end bang state.

`002D^U

1. 現在の~comment~tokenの~data ~APPEND `002D^U

◎ Append a U+002D HYPHEN-MINUS character (-) to the comment token's data.

~EOF

1. `eof-in-comment$pE
2. 現在の~comment~tokenを発する
3. ~eof~tokenを発する

◎ This is an eof-in-comment parse error. Emit the comment token. Emit an end-of-file token.

~AnyElse

1. 現在の~comment~tokenの~data ~APPEND `002D^U ~APPEND `002D^U
2. `~comment$st内で`再消費-$する

◎ Append two U+002D HYPHEN-MINUS characters (-) to the comment token's data. Reconsume in the comment state.

12.2.5.52. `~comment終端~bang^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`002D^U

1. 現在の~comment~tokenの~data ~APPEND `002D^U ~APPEND `0021^U
2. `~comment終端~dash$stに`切替える$

◎ Append two U+002D HYPHEN-MINUS characters (-) and a U+0021 EXCLAMATION MARK character (!) to the comment token's data. Switch to the comment end dash state.

`003E^U

1. `incorrectly-closed-comment$pE
2. `~data$stに`切替える$
3. 現在の~comment~tokenを発する

◎ This is an incorrectly-closed-comment parse error. Switch to the data state. Emit the comment token.

~EOF

1. `eof-in-comment$pE
2. 現在の~comment~tokenを発する
3. ~eof~tokenを発する

◎ This is an eof-in-comment parse error. Emit the comment token. Emit an end-of-file token.

~AnyElse

1. 現在の~comment~tokenの~data ~APPEND `002D^U ~APPEND `0021^U
2. `~comment$st内で`再消費-$する

◎ Append two U+002D HYPHEN-MINUS characters (-) and a U+0021 EXCLAMATION MARK character (!) to the comment token's data. Reconsume in the comment state.

12.2.5.53. `~DOCTYPE^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0009^U

`000A^U

`000C^U

`0020^U

1. `~DOCTYPE名の前$stに`切替える$

◎ Switch to the before DOCTYPE name state.

`003E^U

1. `~DOCTYPE名の前$st内で`再消費-$する

◎ Reconsume in the before DOCTYPE name state.

~EOF

1. `eof-in-doctype$pE
2. %~token ~LET 新たな~DOCTYPE~token
3. `過去互換強制~flag$ ~SET ~ON
4. %~token を発する
5. ~eof~tokenを発する

◎ This is an eof-in-doctype parse error. Create a new DOCTYPE token. Set its force-quirks flag to on. Emit the token. Emit an end-of-file token.

~AnyElse

1. `missing-whitespace-before-doctype-name$pE
2. `~DOCTYPE名の前$st内で`再消費-$する

◎ This is a missing-whitespace-before-doctype-name parse error. Reconsume in the before DOCTYPE name state.

12.2.5.54. `~DOCTYPE名の前^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0009^U

`000A^U

`000C^U

`0020^U

1. この文字は無視する

◎ Ignore the character.

`~ASCII英大文字$

1. %~token ~LET 新たな~DOCTYPE~token
2. %~token の名前 ~SET `現在の入力~文字$に対応する小文字（文字の~cpに `0020^X を加算する）
3. `~DOCTYPE名$stに`切替える$

◎ Create a new DOCTYPE token. Set the token's name to the lowercase version of the current input character (add 0x0020 to the character's code point). Switch to the DOCTYPE name state.

`0000^U

1. `unexpected-null-character$pE
2. %~token ~LET 新たな~DOCTYPE~token
3. %~token の名前 ~SET `FFFD^U
4. `~DOCTYPE名$stに`切替える$

◎ This is an unexpected-null-character parse error. Create a new DOCTYPE token. Set the token's name to a U+FFFD REPLACEMENT CHARACTER character. Switch to the DOCTYPE name state.

`003E^U

1. `missing-doctype-name$pE
2. %~token ~LET 新たな~DOCTYPE~token
3. `過去互換強制~flag$ ~SET ~ON
4. `~data$stに`切替える$
5. %~token を発する

◎ This is a missing-doctype-name parse error. Create a new DOCTYPE token. Set its force-quirks flag to on. Switch to the data state. Emit the token.

~EOF

1. `eof-in-doctype$pE
2. %~token ~LET 新たな~DOCTYPE~token
3. `過去互換強制~flag$ ~SET ~ON
4. %~token を発する
5. ~eof~tokenを発する

◎ This is an eof-in-doctype parse error. Create a new DOCTYPE token. Set its force-quirks flag to on. Emit the token. Emit an end-of-file token.

~AnyElse

1. %~token ~LET 新たな~DOCTYPE~token
2. %~token の名前 ~SET `現在の入力~文字$
3. `~DOCTYPE名$stに`切替える$

◎ Create a new DOCTYPE token. Set the token's name to the current input character. Switch to the DOCTYPE name state.

12.2.5.55. `~DOCTYPE名^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0009^U

`000A^U

`000C^U

`0020^U

1. `~DOCTYPE名の後$stに`切替える$

◎ Switch to the after DOCTYPE name state.

`003E^U

1. `~data$stに`切替える$
2. 現在の~DOCTYPE~tokenを発する

◎ Switch to the data state. Emit the current DOCTYPE token.

`~ASCII英大文字$

1. 現在の~DOCTYPE~tokenの名前 ~APPEND `現在の入力~文字$に対応する小文字（文字の~cpに `0020^X を加算する）

◎ Append the lowercase version of the current input character (add 0x0020 to the character's code point) to the current DOCTYPE token's name.

`0000^U

1. `unexpected-null-character$pE
2. 現在の~DOCTYPE~tokenの名前 ~APPEND `FFFD^U

◎ This is an unexpected-null-character parse error. Append a U+FFFD REPLACEMENT CHARACTER character to the current DOCTYPE token's name.

~EOF

1. `eof-in-doctype$pE
2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
3. 現在の~DOCTYPE~tokenを発する
4. ~eof~tokenを発する

◎ This is an eof-in-doctype parse error. Set the DOCTYPE token's force-quirks flag to on. Emit that DOCTYPE token. Emit an end-of-file token.

~AnyElse

1. 現在の~DOCTYPE~tokenの名前 ~APPEND `現在の入力~文字$

◎ Append the current input character to the current DOCTYPE token's name.

12.2.5.56. `~DOCTYPE名の後^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0009^U

`000A^U

`000C^U

`0020^U

1. この文字は無視する

◎ Ignore the character.

`003E^U

1. `~data$stに`切替える$
2. 現在の~DOCTYPE~tokenを発する

◎ Switch to the data state. Emit the current DOCTYPE token.

~EOF

1. `eof-in-doctype$pE
2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
3. 現在の~DOCTYPE~tokenを発する
4. ~eof~tokenを発する

◎ This is an eof-in-doctype parse error. Set the DOCTYPE token's force-quirks flag to on. Emit that DOCTYPE token. Emit an end-of-file token.

~AnyElse

1. ~IF［［ `現在の入力~文字$から開始する 6 個の文字~並び ］ ~EQ`大小無視$sub `PUBLIC^l ］：

   1. それらの文字を消費する
   2. `~DOCTYPE~public-keywordの後$stに`切替える$
   ◎ If the six characters starting from the current input character are an ASCII case-insensitive match for the word "PUBLIC", then consume those characters and switch to the after DOCTYPE public keyword state.

2. ~ELIF［［ `現在の入力~文字$から開始する 6 個の文字~並び ］ ~EQ`大小無視$sub `SYSTEM^l ］：

   1. それらの文字を消費する
   2. `~DOCTYPE~system-keywordの後$stに`切替える$
   ◎ Otherwise, if the six characters starting from the current input character are an ASCII case-insensitive match for the word "SYSTEM", then consume those characters and switch to the after DOCTYPE system keyword state.

3. ~ELSE：

   1. `invalid-character-sequence-after-doctype-name$pE
   2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
   3. `似非~DOCTYPE$st内で`再消費-$する
   ◎ Otherwise, this is an invalid-character-sequence-after-doctype-name parse error. Set the DOCTYPE token's force-quirks flag to on. Reconsume in the bogus DOCTYPE state.

12.2.5.57. `~DOCTYPE~public-keywordの後^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0009^U

`000A^U

`000C^U

`0020^U

1. `~DOCTYPE~publicIDの前$stに`切替える$

◎ Switch to the before DOCTYPE public identifier state.

`0022^U

1. `missing-whitespace-after-doctype-public-keyword$pE
2. 現在の~DOCTYPE~tokenの~publicID ~SET 空~文字列
3. `~DOCTYPE~publicID（二重引用符）$stに`切替える$

◎ This is a missing-whitespace-after-doctype-public-keyword parse error. Set the DOCTYPE token's public identifier to the empty string (not missing), then switch to the DOCTYPE public identifier (double-quoted) state.

`0027^U

1. `missing-whitespace-after-doctype-public-keyword$pE
2. 現在の~DOCTYPE~tokenの~publicID ~SET 空~文字列
3. `~DOCTYPE~publicID（一重引用符）$stに`切替える$

◎ This is a missing-whitespace-after-doctype-public-keyword parse error. Set the DOCTYPE token's public identifier to the empty string (not missing), then switch to the DOCTYPE public identifier (single-quoted) state.

`003E^U

1. `missing-doctype-public-identifier$pE
2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
3. `~data$stに`切替える$
4. 現在の~DOCTYPE~tokenを発する

◎ This is a missing-doctype-public-identifier parse error. Set the DOCTYPE token's force-quirks flag to on. Switch to the data state. Emit that DOCTYPE token.

~EOF

1. `eof-in-doctype$pE
2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
3. 現在の~DOCTYPE~tokenを発する
4. ~eof~tokenを発する

◎ This is an eof-in-doctype parse error. Set the DOCTYPE token's force-quirks flag to on. Emit that DOCTYPE token. Emit an end-of-file token.

~AnyElse

1. `missing-quote-before-doctype-public-identifier$pE
2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
3. `似非~DOCTYPE$st内で`再消費-$する

◎ This is a missing-quote-before-doctype-public-identifier parse error. Set the DOCTYPE token's force-quirks flag to on. Reconsume in the bogus DOCTYPE state.

12.2.5.58. `~DOCTYPE~publicIDの前^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0009^U

`000A^U

`000C^U

`0020^U

1. この文字は無視する

◎ Ignore the character.

`0022^U

1. 現在の~DOCTYPE~tokenの~publicID ~SET 空~文字列
2. `~DOCTYPE~publicID（二重引用符）$stに`切替える$

◎ Set the DOCTYPE token's public identifier to the empty string (not missing), then switch to the DOCTYPE public identifier (double-quoted) state.

`0027^U

1. 現在の~DOCTYPE~tokenの~publicID ~SET 空~文字列
2. `~DOCTYPE~publicID（一重引用符）$stに`切替える$

◎ Set the DOCTYPE token's public identifier to the empty string (not missing), then switch to the DOCTYPE public identifier (single-quoted) state.

`003E^U

1. `missing-doctype-public-identifier$pE
2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
3. `~data$stに`切替える$
4. 現在の~DOCTYPE~tokenを発する

◎ This is a missing-doctype-public-identifier parse error. Set the DOCTYPE token's force-quirks flag to on. Switch to the data state. Emit that DOCTYPE token.

~EOF

1. `eof-in-doctype$pE
2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
3. 現在の~DOCTYPE~tokenを発する
4. ~eof~tokenを発する

◎ This is an eof-in-doctype parse error. Set the DOCTYPE token's force-quirks flag to on. Emit that DOCTYPE token. Emit an end-of-file token.

~AnyElse

1. `missing-quote-before-doctype-public-identifier$pE
2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
3. `似非~DOCTYPE$st内で`再消費-$する

◎ This is a missing-quote-before-doctype-public-identifier parse error. Set the DOCTYPE token's force-quirks flag to on. Reconsume in the bogus DOCTYPE state.

12.2.5.59. `~DOCTYPE~publicID（二重引用符）^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0022^U

1. `~DOCTYPE~publicIDの後$stに`切替える$

◎ Switch to the after DOCTYPE public identifier state.

`0000^U

1. `unexpected-null-character$pE
2. 現在の~DOCTYPE~tokenの~publicID ~APPEND `FFFD^U

◎ This is an unexpected-null-character parse error. Append a U+FFFD REPLACEMENT CHARACTER character to the current DOCTYPE token's public identifier.

`003E^U

1. `abrupt-doctype-public-identifier$pE
2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
3. `~data$stに`切替える$
4. 現在の~DOCTYPE~tokenを発する

◎ This is an abrupt-doctype-public-identifier parse error. Set the DOCTYPE token's force-quirks flag to on. Switch to the data state. Emit that DOCTYPE token.

~EOF

1. `eof-in-doctype$pE
2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
3. 現在の~DOCTYPE~tokenを発する
4. ~eof~tokenを発する

◎ This is an eof-in-doctype parse error. Set the DOCTYPE token's force-quirks flag to on. Emit that DOCTYPE token. Emit an end-of-file token.

~AnyElse

1. 現在の~DOCTYPE~tokenの~publicID ~APPEND `現在の入力~文字$

◎ Append the current input character to the current DOCTYPE token's public identifier.

12.2.5.60. `~DOCTYPE~publicID（一重引用符）^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0027^U

1. `~DOCTYPE~publicIDの後$stに`切替える$

◎ Switch to the after DOCTYPE public identifier state.

`0000^U

1. `unexpected-null-character$pE
2. 現在の~DOCTYPE~tokenの~publicID ~APPEND `FFFD^U

◎ This is an unexpected-null-character parse error. Append a U+FFFD REPLACEMENT CHARACTER character to the current DOCTYPE token's public identifier.

`003E^U

1. `abrupt-doctype-public-identifier$pE
2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
3. `~data$stに`切替える$
4. 現在の~DOCTYPE~tokenを発する

◎ This is an abrupt-doctype-public-identifier parse error. Set the DOCTYPE token's force-quirks flag to on. Switch to the data state. Emit that DOCTYPE token.

~EOF

1. `eof-in-doctype$pE
2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
3. 現在の~DOCTYPE~tokenを発する
4. ~eof~tokenを発する

◎ This is an eof-in-doctype parse error. Set the DOCTYPE token's force-quirks flag to on. Emit that DOCTYPE token. Emit an end-of-file token.

~AnyElse

1. 現在の~DOCTYPE~tokenの~publicID ~APPEND `現在の入力~文字$

◎ Append the current input character to the current DOCTYPE token's public identifier.

12.2.5.61. `~DOCTYPE~publicIDの後^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0009^U

`000A^U

`000C^U

`0020^U

1. `~DOCTYPE~publicIDと~systemIDの合間$stに`切替える$

◎ Switch to the between DOCTYPE public and system identifiers state.

`003E^U

1. `~data$stに`切替える$
2. 現在の~DOCTYPE~tokenを発する

◎ Switch to the data state. Emit the current DOCTYPE token.

`0022^U

1. `missing-whitespace-between-doctype-public-and-system-identifiers$pE
2. 現在の~DOCTYPE~tokenの~systemID ~SET 空~文字列
3. `~DOCTYPE~systemID（二重引用符）$stに`切替える$

◎ This is a missing-whitespace-between-doctype-public-and-system-identifiers parse error. Set the DOCTYPE token's system identifier to the empty string (not missing), then switch to the DOCTYPE system identifier (double-quoted) state.

`0027^U

1. `missing-whitespace-between-doctype-public-and-system-identifiers$pE
2. 現在の~DOCTYPE~tokenの~systemID ~SET 空~文字列
3. `~DOCTYPE~systemID（一重引用符）$stに`切替える$

◎ This is a missing-whitespace-between-doctype-public-and-system-identifiers parse error. Set the DOCTYPE token's system identifier to the empty string (not missing), then switch to the DOCTYPE system identifier (single-quoted) state.

~EOF

1. `eof-in-doctype$pE
2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
3. 現在の~DOCTYPE~tokenを発する
4. ~eof~tokenを発する

◎ This is an eof-in-doctype parse error. Set the DOCTYPE token's force-quirks flag to on. Emit that DOCTYPE token. Emit an end-of-file token.

~AnyElse

1. `missing-quote-before-doctype-system-identifier$pE
2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
3. `似非~DOCTYPE$st内で`再消費-$する

◎ This is a missing-quote-before-doctype-system-identifier parse error. Set the DOCTYPE token's force-quirks flag to on. Reconsume in the bogus DOCTYPE state.

12.2.5.62. `~DOCTYPE~publicIDと~systemIDの合間^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0009^U

`000A^U

`000C^U

`0020^U

1. この文字は無視する

◎ Ignore the character.

`003E^U

1. `~data$stに`切替える$
2. 現在の~DOCTYPE~tokenを発する

◎ Switch to the data state. Emit the current DOCTYPE token.

`0022^U

1. 現在の~DOCTYPE~tokenの~systemID ~SET 空~文字列
2. `~DOCTYPE~systemID（二重引用符）$stに`切替える$

◎ Set the DOCTYPE token's system identifier to the empty string (not missing), then switch to the DOCTYPE system identifier (double-quoted) state.

`0027^U

1. 現在の~DOCTYPE~tokenの~systemID ~SET 空~文字列
2. `~DOCTYPE~systemID（一重引用符）$stに`切替える$

◎ Set the DOCTYPE token's system identifier to the empty string (not missing), then switch to the DOCTYPE system identifier (single-quoted) state.

~EOF

1. `eof-in-doctype$pE
2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
3. 現在の~DOCTYPE~tokenを発する
4. ~eof~tokenを発する

◎ This is an eof-in-doctype parse error. Set the DOCTYPE token's force-quirks flag to on. Emit that DOCTYPE token. Emit an end-of-file token.

~AnyElse

1. `missing-quote-before-doctype-system-identifier$pE
2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
3. `似非~DOCTYPE$st内で`再消費-$する

◎ This is a missing-quote-before-doctype-system-identifier parse error. Set the DOCTYPE token's force-quirks flag to on. Reconsume in the bogus DOCTYPE state.

12.2.5.63. `~DOCTYPE~system-keywordの後^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0009^U

`000A^U

`000C^U

`0020^U

1. `~DOCTYPE~systemIDの前$stに`切替える$

◎ Switch to the before DOCTYPE system identifier state.

`0022^U

1. `missing-whitespace-after-doctype-system-keyword$pE
2. 現在の~DOCTYPE~tokenの~systemID ~SET 空~文字列
3. `~DOCTYPE~systemID（二重引用符）$stに`切替える$

◎ This is a missing-whitespace-after-doctype-system-keyword parse error. Set the DOCTYPE token's system identifier to the empty string (not missing), then switch to the DOCTYPE system identifier (double-quoted) state.

`0027^U

1. `missing-whitespace-after-doctype-system-keyword$pE
2. 現在の~DOCTYPE~tokenの~systemID ~SET 空~文字列
3. `~DOCTYPE~systemID（一重引用符）$stに`切替える$

◎ This is a missing-whitespace-after-doctype-system-keyword parse error. Set the DOCTYPE token's system identifier to the empty string (not missing), then switch to the DOCTYPE system identifier (single-quoted) state.

`003E^U

1. `missing-doctype-system-identifier$pE
2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
3. `~data$stに`切替える$
4. 現在の~DOCTYPE~tokenを発する

◎ This is a missing-doctype-system-identifier parse error. Set the DOCTYPE token's force-quirks flag to on. Switch to the data state. Emit that DOCTYPE token.

~EOF

1. `eof-in-doctype$pE
2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
3. 現在の~DOCTYPE~tokenを発する
4. ~eof~tokenを発する

◎ This is an eof-in-doctype parse error. Set the DOCTYPE token's force-quirks flag to on. Emit that DOCTYPE token. Emit an end-of-file token.

~AnyElse

1. `missing-quote-before-doctype-system-identifier$pE
2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
3. `似非~DOCTYPE$st内で`再消費-$する

◎ This is a missing-quote-before-doctype-system-identifier parse error. Set the DOCTYPE token's force-quirks flag to on. Reconsume in the bogus DOCTYPE state.

12.2.5.64. `~DOCTYPE~systemIDの前^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0009^U

`000A^U

`000C^U

`0020^U

1. この文字は無視する

◎ Ignore the character.

`0022^U

1. 現在の~DOCTYPE~tokenの~systemID ~SET 空~文字列
2. `~DOCTYPE~systemID（二重引用符）$stに`切替える$

◎ Set the DOCTYPE token's system identifier to the empty string (not missing), then switch to the DOCTYPE system identifier (double-quoted) state.

`0027^U

1. 現在の~DOCTYPE~tokenの~systemID ~SET 空~文字列
2. `~DOCTYPE~systemID（一重引用符）$stに`切替える$

◎ Set the DOCTYPE token's system identifier to the empty string (not missing), then switch to the DOCTYPE system identifier (single-quoted) state.

`003E^U

1. `missing-doctype-system-identifier$pE
2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
3. `~data$stに`切替える$
4. 現在の~DOCTYPE~tokenを発する

◎ This is a missing-doctype-system-identifier parse error. Set the DOCTYPE token's force-quirks flag to on. Switch to the data state. Emit that DOCTYPE token.

~EOF

1. `eof-in-doctype$pE
2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
3. 現在の~DOCTYPE~tokenを発する
4. ~eof~tokenを発する

◎ This is an eof-in-doctype parse error. Set the DOCTYPE token's force-quirks flag to on. Emit that DOCTYPE token. Emit an end-of-file token.

~AnyElse

1. `missing-quote-before-doctype-system-identifier$pE
2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
3. `似非~DOCTYPE$st内で`再消費-$する

◎ This is a missing-quote-before-doctype-system-identifier parse error. Set the DOCTYPE token's force-quirks flag to on. Reconsume in the bogus DOCTYPE state.

12.2.5.65. `~DOCTYPE~systemID（二重引用符）^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0022^U

1. `~DOCTYPE~systemIDの後$stに`切替える$

◎ Switch to the after DOCTYPE system identifier state.

`0000^U

1. `unexpected-null-character$pE
2. 現在の~DOCTYPE~tokenの~systemID ~APPEND `FFFD^U

◎ This is an unexpected-null-character parse error. Append a U+FFFD REPLACEMENT CHARACTER character to the current DOCTYPE token's system identifier.

`003E^U

1. `abrupt-doctype-system-identifier$pE
2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
3. `~data$stに`切替える$
4. 現在の~DOCTYPE~tokenを発する

◎ This is an abrupt-doctype-system-identifier parse error. Set the DOCTYPE token's force-quirks flag to on. Switch to the data state. Emit that DOCTYPE token.

~EOF

1. `eof-in-doctype$pE
2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
3. 現在の~DOCTYPE~tokenを発する
4. ~eof~tokenを発する

◎ This is an eof-in-doctype parse error. Set the DOCTYPE token's force-quirks flag to on. Emit that DOCTYPE token. Emit an end-of-file token.

~AnyElse

1. 現在の~DOCTYPE~tokenの~systemID ~APPEND `現在の入力~文字$

◎ Append the current input character to the current DOCTYPE token's system identifier.

12.2.5.66. `~DOCTYPE~systemID（一重引用符）^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0027^U

1. `~DOCTYPE~systemIDの後$stに`切替える$

◎ Switch to the after DOCTYPE system identifier state.

`0000^U

1. `unexpected-null-character$pE
2. 現在の~DOCTYPE~tokenの~systemID ~APPEND `FFFD^U

◎ This is an unexpected-null-character parse error. Append a U+FFFD REPLACEMENT CHARACTER character to the current DOCTYPE token's system identifier.

`003E^U

1. `abrupt-doctype-system-identifier$pE
2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
3. `~data$stに`切替える$
4. 現在の~DOCTYPE~tokenを発する

◎ This is an abrupt-doctype-system-identifier parse error. Set the DOCTYPE token's force-quirks flag to on. Switch to the data state. Emit that DOCTYPE token.

~EOF

1. `eof-in-doctype$pE
2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
3. 現在の~DOCTYPE~tokenを発する
4. ~eof~tokenを発する

◎ This is an eof-in-doctype parse error. Set the DOCTYPE token's force-quirks flag to on. Emit that DOCTYPE token. Emit an end-of-file token.

~AnyElse

1. 現在の~DOCTYPE~tokenの~systemID ~APPEND `現在の入力~文字$

◎ Append the current input character to the current DOCTYPE token's system identifier.

12.2.5.67. `~DOCTYPE~systemIDの後^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`0009^U

`000A^U

`000C^U

`0020^U

1. この文字は無視する

◎ Ignore the character.

`003E^U

1. `~data$stに`切替える$
2. 現在の~DOCTYPE~tokenを発する

◎ Switch to the data state. Emit the current DOCTYPE token.

~EOF

1. `eof-in-doctype$pE
2. 現在の~DOCTYPE~tokenの`過去互換強制~flag$ ~SET ~ON
3. 現在の~DOCTYPE~tokenを発する
4. ~eof~tokenを発する

◎ This is an eof-in-doctype parse error. Set the DOCTYPE token's force-quirks flag to on. Emit that DOCTYPE token. Emit an end-of-file token.

~AnyElse

1. `unexpected-character-after-doctype-system-identifier$pE
2. `似非~DOCTYPE$st内で`再消費-$する （これは、現在の~DOCTYPE~tokenの`過去互換強制~flag$を ~ON にしない。）

◎ This is an unexpected-character-after-doctype-system-identifier parse error. Reconsume in the bogus DOCTYPE state. (This does not set the DOCTYPE token's force-quirks flag to on.)

12.2.5.68. `似非~DOCTYPE^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`003E^U

1. `~data$stに`切替える$
2. 現在の~DOCTYPE~tokenを発する

◎ Switch to the data state. Emit the DOCTYPE token.

`0000^U

1. `unexpected-null-character$pE
2. この文字は無視する

◎ This is an unexpected-null-character parse error. Ignore the character.

~EOF

1. 現在の~DOCTYPE~tokenを発する
2. ~eof~tokenを発する

◎ Emit the DOCTYPE token. Emit an end-of-file token.

~AnyElse

1. この文字は無視する

◎ Ignore the character.

12.2.5.69. `~CDATAsec^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`005D^U

1. `~CDATAsec~bracket$stに`切替える$

◎ Switch to the CDATA section bracket state.

~EOF

1. `eof-in-cdata$pE
2. ~eof~tokenを発する

◎ This is an eof-in-cdata parse error. Emit an end-of-file token.

~AnyElse

1. 新たな文字~token( `現在の入力~文字$ ) を発する

◎ Emit the current input character as a character token.

注記： `0000^U は、木~構築~段階にて，`外来~内容~内$md内の一部として取扱われる — それは、`~CDATAsec$が現れ得る唯一の箇所である ◎ U+0000 NULL characters are handled in the tree construction stage, as part of the in foreign content insertion mode, which is the only place where CDATA sections can appear.

12.2.5.70. `~CDATAsec~bracket^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`005D^U

1. `~CDATAsec終端$stに`切替える$

◎ Switch to the CDATA section end state.

~AnyElse

1. 新たな文字~token( `005D^U ) を発する
2. `~CDATAsec$st内で`再消費-$する

◎ Emit a U+005D RIGHT SQUARE BRACKET character token. Reconsume in the CDATA section state.

12.2.5.71. `~CDATAsec終端^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`005D^U

1. 新たな文字~token( `005D^U ) を発する

◎ Emit a U+005D RIGHT SQUARE BRACKET character token.

`003E^U

1. `~data$stに`切替える$

◎ Switch to the data state.

~AnyElse

1. 新たな文字~token( `005D^U ) を発する
2. 新たな文字~token( `005D^U ) を発する
3. `~CDATAsec$st内で`再消費-$する

◎ Emit two U+005D RIGHT SQUARE BRACKET character tokens. Reconsume in the CDATA section state.

12.2.5.72. `文字~参照^st

1. `一時~buffer$V ~SET 空~文字列 ~APPEND `0026^U ~APPEND `現在の入力~文字$ ◎ Set the temporary buffer to the empty string. Append a U+0026 AMPERSAND (&) character to the temporary buffer.＼

2. `次n入力~文字$を消費する： ◎ Consume the next input character:

   `~ASCII英数字$

   1. `有名~文字~参照$st内で`再消費-$する

   ◎ Reconsume in the named character reference state.

   `0023^U

   1. `一時~buffer$V ~APPEND `現在の入力~文字$
   2. `数的な文字~参照$stに`切替える$

   ◎ Append the current input character to the temporary buffer. Switch to the numeric character reference state.

   ~AnyElse

   1. `文字~参照として消費される~cpを一掃する$
   2. `戻先~状態$V 内で`再消費-$する

   ◎ Flush code points consumed as a character reference. Reconsume in the return state.

12.2.5.73. `有名~文字~参照^st

1. %識別子 ~LET 次の条件を満たすような，可能な限り最大~個数の文字を消費して得られる文字列 ⇒ 消費して得られた文字列 ~IN 次に挙げる文字列からなる集合：

   • `有名~文字~参照$ 一覧の 1 列目に挙げられている識別子に~semicolon（ `003B^U ）を付加したもの
   • 同じ一覧の 1 列目に挙げられている識別子のうち，“†” が付与されているもの（~markup内で~semicolonを省略しても有効になるもの）
   • 空~文字列

   【 この訳における有名~文字~参照の一覧は、~semicolonを省略している（ “†” に代えている）ため、この段の記述は，それに整合するように原文と違えている。 】

   ◎ Consume the maximum number of characters possible, with the consumed characters matching one of the identifiers in the first column of the named character references table (in a case-sensitive manner). Append each character to the temporary buffer when it's consumed.

2. ~IF［ %識別子 ~NEQ 空~文字列 ］ ◎ If there is a match

   1. %~semicolonなし ~LET ［ %識別子 の最後の文字 ~NEQ `003B^U ならば ~T ／ ~ELSE_ ~F ］ ◎ ↓
   2. ~IF［ 次がいずれも満たされる ］…：
      • 文字~参照は`属性の一部として消費されて$いる
      • %~semicolonなし ~EQ ~T
      • `次n入力~文字$ ~IN { `003D^U, `~ASCII英数字$ }

      …ならば ⇒ `一時~buffer$V ~APPEND %識別子 （これは、歴史的~理由による）

      ◎ If the character reference was consumed as part of an attribute, and the last character matched is not a U+003B SEMICOLON character (;), and the next input character is either a U+003D EQUALS SIGN character (=) or an ASCII alphanumeric, then, for historical reasons,＼ ◎ ↓↓flush code points consumed as a character reference and switch to the return state.

   3. ~ELSE： ◎ Otherwise:

      1. ~IF［ %~semicolonなし ~EQ ~T ］ ⇒ `missing-semicolon-after-character-reference$pE ◎ If the last character matched is not a U+003B SEMICOLON character (;), then this is a missing-semicolon-after-character-reference parse error.
      2. `一時~buffer$V ~SET `有名~文字~参照$ 一覧の 2 列目に与えられる， %識別子 に対応している 1 〜 2 個の文字 ◎ Set the temporary buffer to the empty string. Append one or two characters corresponding to the character reference name (as given by the second column of the named character references table) to the temporary buffer. ◎ ↓↓Flush code points consumed as a character reference. Switch to the return state.
3. `文字~参照として消費される~cpを一掃する$ ◎ ↑↓
4. ［ %識別子 ~NEQ 空~文字列 ならば `戻先~状態$V ／ ~ELSE_ `多義的amp$st ］に`切替える$ ◎ Otherwise • Flush code points consumed as a character reference. Switch to the ambiguous ampersand state.

12.2.5.74. `多義的amp^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`~ASCII英数字$

1. ~IF［ 文字~参照は`属性の一部として消費されて$いる ］ ⇒ 現在の属性の値 ~APPEND `現在の入力~文字$
2. ~ELSE ⇒ 新たな文字~token( `現在の入力~文字$ ) を発する

◎ If the character reference was consumed as part of an attribute, then append the current input character to the current attribute's value. Otherwise, emit the current input character as a character token.

`003B^U

1. `unknown-named-character-reference$pE
2. `戻先~状態$V 内で`再消費-$する

◎ This is an unknown-named-character-reference parse error. Reconsume in the return state.

~AnyElse

1. `戻先~状態$V 内で`再消費-$する

◎ Reconsume in the return state.

12.2.5.75. `数的な文字~参照^st

1. `文字~参照~code@V ~SET 0 ◎ Set the character reference code to zero (0).

2. `次n入力~文字$を消費する： ◎ Consume the next input character:

   `0078^U

   `0058^U

   1. `一時~buffer$V ~APPEND `現在の入力~文字$
   2. `~hexademical文字~参照~始端$stに`切替える$

   ◎ Append the current input character to the temporary buffer. Switch to the hexademical character reference start state.

   ~AnyElse

   1. `~decimal文字~参照~始端$st内で`再消費-$する

   ◎ Reconsume in the decimal character reference start state.

12.2.5.76. `~hexademical文字~参照~始端^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`~ASCII~hex数字$

1. `~hexademical文字~参照$st内で`再消費-$する

◎ Reconsume in the hexademical character reference state.

~AnyElse

1. `absence-of-digits-in-numeric-character-reference$pE
2. `文字~参照として消費される~cpを一掃する$
3. `戻先~状態$V 内で`再消費-$する

◎ This is an absence-of-digits-in-numeric-character-reference parse error. Flush code points consumed as a character reference. Reconsume in the return state.

12.2.5.77. `~decimal文字~参照~始端^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`~ASCII数字$

1. `~decimal文字~参照$st内で`再消費-$する

◎ Reconsume in the decimal character reference state.

~AnyElse

1. `absence-of-digits-in-numeric-character-reference$pE
2. `文字~参照として消費される~cpを一掃する$
3. `戻先~状態$V 内で`再消費-$する

◎ This is an absence-of-digits-in-numeric-character-reference parse error. Flush code points consumed as a character reference. Reconsume in the return state.

12.2.5.78. `~hexademical文字~参照^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`~ASCII~hex数字$

1. `文字~参照~code$V ~SET ( `文字~参照~code$V ~MUL 16 ) ~PLUS ( `現在の入力~文字$を 16 進数として解釈した結果の整数† )

† この整数は、`現在の入力~文字$が［ `~ASCII数字$ならば その~cpから`0030^X を減算した結果 ／ `~ASCII~hex数字（大文字）$ならば その~cpから`0037^X を減算した結果 ／ `~ASCII~hex数字（小文字）$ならば その~cpから`0057^X を減算した結果 ］になる。

◎ ASCII digit ◎ Multiply the character reference code by 16. Add a numeric version of the current input character (subtract 0x0030 from the character's code point) to the character reference code. ◎ ASCII upper hex digit ◎ Multiply the character reference code by 16. Add a numeric version of the current input character as a hexademical digit (subtract 0x0037 from the character's code point) to the character reference code. ◎ ASCII lower hex digit ◎ Multiply the character reference code by 16. Add a numeric version of the current input character as a hexademical digit (subtract 0x0057 from the character's code point) to the character reference code.

`003B^U

1. `数的な文字~参照~終端$stに`切替える$

◎ Switch to the numeric character reference end state.

~AnyElse

1. `missing-semicolon-after-character-reference$pE
2. `数的な文字~参照~終端$st内で`再消費-$する

◎ This is a missing-semicolon-after-character-reference parse error. Reconsume in the numeric character reference end state.

12.2.5.79. `~decimal文字~参照^st

`次n入力~文字$を消費する： ◎ Consume the next input character:

`~ASCII数字$

1. `文字~参照~code$V ~SET ( `文字~参照~code$V ~MUL 10 ) ~PLUS ( `現在の入力~文字$を 10 進数として解釈した結果の整数（文字の~cpから`0030^X を減算した結果） ) ◎ Multiply the character reference code by 10. Add a numeric version of the current input character (subtract 0x0030 from the character's code point) to the character reference code.

`003B^U

1. `数的な文字~参照~終端$stに`切替える$

◎ Switch to the numeric character reference end state.

~AnyElse

1. `missing-semicolon-after-character-reference$pE
2. `数的な文字~参照~終端$st内で`再消費-$する

◎ This is a missing-semicolon-after-character-reference parse error. Reconsume in the numeric character reference end state.

12.2.5.80. `数的な文字~参照~終端^st

1. `文字~参照~code$V （が指す符号位置）に応じて： ◎ Check the character reference code:

   `00^X

   1. `null-character-reference$pE
   2. `文字~参照~code$V ~SET `FFFD^X

   ◎ If the number is 0x00, then this is a null-character-reference parse error. Set the character reference code to 0xFFFD.

   `10FFFF^X を超える

   1. `character-reference-outside-unicode-range$pE
   2. `文字~参照~code$V ~SET `FFFD^X

   ◎ If the number is greater than 0x10FFFF, then this is a character-reference-outside-unicode-range parse error. Set the character reference code to 0xFFFD.

   `~surrogate$

   1. `surrogate-character-reference$pE
   2. `文字~参照~code$V ~SET `FFFD^X

   ◎ If the number is a surrogate, then this is a surrogate-character-reference parse error. Set the character reference code to 0xFFFD.

   `非文字$

   1. `noncharacter-character-reference$pE

   ◎ If the number is a noncharacter, then this is a noncharacter-character-reference parse error.

   `0D^X

   `~ASCII空白$以外の`制御文字$

   1. `control-character-reference$pE

   ◎ If the number is 0x0D, or a control that's not ASCII whitespace, then this is a control-character-reference parse error.＼

   下の表の 1 列目に現れる

   `文字~参照~code$V ~SET 現れた行の 2 列目の数 ◎ If the number is one of the numbers in the first column of the following table, then find the row with that number in the first column, and set the character reference code to the number in the second column of that row.

   数◎ Number	~cp◎ Code point
   `80^X	`20AC^X	EURO SIGN (€)
   `82^X	`201A^X	SINGLE LOW-9 QUOTATION MARK (‚)
   `83^X	`0192^X	LATIN SMALL LETTER F WITH HOOK (ƒ)
   `84^X	`201E^X	DOUBLE LOW-9 QUOTATION MARK („)
   `85^X	`2026^X	HORIZONTAL ELLIPSIS (…)
   `86^X	`2020^X	DAGGER (†)
   `87^X	`2021^X	DOUBLE DAGGER (‡)
   `88^X	`02C6^X	MODIFIER LETTER CIRCUMFLEX ACCENT (ˆ)
   `89^X	`2030^X	PER MILLE SIGN (‰)
   `8A^X	`0160^X	LATIN CAPITAL LETTER S WITH CARON (Š)
   `8B^X	`2039^X	SINGLE LEFT-POINTING ANGLE QUOTATION MARK (‹)
   `8C^X	`0152^X	LATIN CAPITAL LIGATURE OE (Œ)
   `8E^X	`017D^X	LATIN CAPITAL LETTER Z WITH CARON (Ž)
   `91^X	`2018^X	LEFT SINGLE QUOTATION MARK (‘)
   `92^X	`2019^X	RIGHT SINGLE QUOTATION MARK (’)
   `93^X	`201C^X	LEFT DOUBLE QUOTATION MARK (“)
   `94^X	`201D^X	RIGHT DOUBLE QUOTATION MARK (”)
   `95^X	`2022^X	BULLET (•)
   `96^X	`2013^X	EN DASH (–)
   `97^X	`2014^X	EM DASH (—)
   `98^X	`02DC^X	SMALL TILDE (˜)
   `99^X	`2122^X	TRADE MARK SIGN (™)
   `9A^X	`0161^X	LATIN SMALL LETTER S WITH CARON (š)
   `9B^X	`203A^X	SINGLE RIGHT-POINTING ANGLE QUOTATION MARK (›)
   `9C^X	`0153^X	LATIN SMALL LIGATURE OE (œ)
   `9E^X	`017E^X	LATIN SMALL LETTER Z WITH CARON (ž)
   `9F^X	`0178^X	LATIN CAPITAL LETTER Y WITH DIAERESIS (Ÿ)

2. `一時~buffer$V ~SET ~cp( `文字~参照~code$V ) ◎ Set the temporary buffer to the empty string. Append a code point equal to the character reference code to the temporary buffer.＼
3. `文字~参照として消費される~cpを一掃する$ ◎ Flush code points consumed as a character reference.＼
4. `戻先~状態$V に`切替える$ ◎ Switch to the return state.

12.2.6.1. ~nodeの作成-法と挿入-法

%構文解析器 は、ある~tokenを処理している間， `親を違える@ （ foster parenting ）のを 可能化-／不能化- することもある。 これは、次の~algoに影響する。 ◎ While the parser is processing a token, it can enable or disable foster parenting. This affects the following algorithm.

`適切な~node挿入-先@ は、所与の ( `上書き~target^i %~target ) に対し，次の手続きを走らせた結果で与えられる［ ある要素~内の位置 ］である： ◎ The appropriate place for inserting a node, optionally using a particular override target, is the position in an element returned by running the following steps: • If there was an override target specified, then let target be the override target. • Otherwise, let target be the current node.

1. %調整-済み挿入-先 ~LET %~target 内の末尾 ◎ ↓↓

2. ~IF［ `親を違える$のは可能化されている ］~AND［ %~target は［ `table$e ／ `tbody$e ／ `tfoot$e ／ `thead$e ／ `tr$e ］要素である ⇒ %調整-済み挿入-先 ~SET 次の下位手続きを走らせた結果： ◎ Determine the adjusted insertion location using the first matching steps from the following list: ◎ If foster parenting is enabled and target is a table, tbody, tfoot, thead, or tr element

   注記： 親を違えるのは、ある内容が~table内に誤入子にされたときに起こる。 ◎ Foster parenting happens when content is misnested in tables. ◎ Run these substeps:

   1. %~stack ~LET `~open要素~stack$ ◎ ↓
   2. %最後の~template ~LET %~stack 内に `template$e 要素が［ 在れば それらのうち最後のもの ／ 無ければ ε ］ ◎ Let last template be the last template element in the stack of open elements, if any.
   3. %最後の~table ~LET %~stack 内に `table$e 要素が［ 在れば それらのうち最後のもの ／ 無ければ ε ］ ◎ Let last table be the last table element in the stack of open elements, if any.
   4. ~IF［ %最後の~template ~NEQ ε ］ ⇒ ~IF［［ %最後の~table ~EQ ε ］~OR［［ %最後の~table ~NEQ ε ］~AND［ %最後の~template は %~stack 内で %最後の~table より後にある（より近過去に追加された） ］］］ ⇒ ~RET %最後の~template の`~template内容$内の末尾 ◎ If there is a last template and either there is no last table, or there is one, but last template is lower (more recently added) than last table in the stack of open elements, then: let adjusted insertion location be inside last template's template contents, after its last child (if any), and abort these substeps.
   5. ~IF［ %最後の~table ~EQ ε （`素片~事例$） ］ ⇒ ~RET %~stack の先頭の要素（ `html$e 要素）内の末尾 ◎ If there is no last table, then let adjusted insertion location be inside the first element in the stack of open elements (the html element), after its last child (if any), and abort these substeps. (fragment case)
   6. ~IF［ %最後の~table の親~node %親 はある ］ ⇒ ~RET %親 の内側の， %最後の~table の直前 ◎ If last table has a parent node, then let adjusted insertion location be inside last table's parent node, immediately before last table, and abort these substeps.
   7. ~RET［ %~stack 内で， %最後の~table の直前にある要素 ］内の末尾 ◎ Let previous element be the element immediately above last table in the stack of open elements. ◎ Let adjusted insertion location be inside previous element, after its last child (if any).

   注記： この下位手続きが孕まれているわけは、要素 — この事例では特に `table$e 要素 — が構文解析器により挿入された後でも，~scriptにより~DOM内のどこかへ移動されたり, まるごと~DOMから除去されることもあり得るためである。 ◎ These steps are involved in part because it's possible for elements, the table element in this case in particular, to have been moved by a script around in the DOM, or indeed removed from the DOM entirely, after the element was inserted by the parser.

3. ~IF［ %調整-済み挿入-先 が所属する~nodeは `template$e 要素である ］ ⇒ ~RET `template$e 要素の`~template内容$内の末尾 ◎ Otherwise • Let adjusted insertion location be inside target, after its last child (if any). ◎ If the adjusted insertion location is inside a template element, let it instead be inside the template element's template contents, after its last child (if any).
4. ~RET %調整-済み挿入-先 ◎ Return the adjusted insertion location.

以下の手続きにて `~tokenから要素を作成する@ ときは、所与の ( %~token, %名前空間, %意図される親 ) に対し，次を走らせ~MUST： ◎ When the steps below require the UA to create an element for a token in a particular given namespace and with a particular intended parent, the UA must run the following steps:

1. %文書 ~LET %意図される親 の`~node文書$ ◎ Let document be intended parent's node document.
2. %局所~名 ~LET %~token の~tag名 ◎ Let local name be the tag name of the token.
3. %is ~LET %~token 内に `is$a 属性が［ 在れば その値 ／ 無ければ ~NULL ］ ◎ Let is be the value of the "is" attribute in the given token, if such an attribute exists, or null otherwise.
4. %定義 ~LET `~custom要素~定義を検索する$( %文書, %所与の名前空間, %局所~名, %is ) ◎ Let definition be the result of looking up a custom element definition given document, given namespace, local name, and is.
5. %~scriptを実行する ~LET ~F
6. ~IF ［ %定義 ~NEQ ~NULL ］~AND［ %構文解析器 は `~HTML素片~用$でない ］ ⇒ %~scriptを実行する ~SET ~T ◎ If definition is non-null and the parser was not originally created for the HTML fragment parsing algorithm, then let will execute script be true. Otherwise, let it be false.

7. ~IF［ %~scriptを実行する ~EQ ~T ］： ◎ If will execute script is true, then:

   1. %文書 の`動的~markup挿入-時には投出する~counter$ ~INCBY 1 ◎ Increment document's throw-on-dynamic-markup-insertion counter.
   2. ~IF［ `~JS実行~文脈~stack$は空である ］ ⇒ `小task~checkpointを遂行する$ ◎ If the JavaScript execution context stack is empty, then perform a microtask checkpoint.
   3. `~custom要素~反応~stack$に新たな`要素~queue$を~pushする ◎ Push a new element queue onto the custom element reactions stack.
8. %同期~custom要素~flag ~LET %~scriptを実行する に応じて［ ~T ならば `同期~custom要素^i ／ ~F ならば ε ］ ◎ ↓

9. %要素 ~LET `要素を作成する$( %文書, %局所~名, %名前空間, ~NULL, %is, %同期~custom要素~flag ) ◎ Let element be the result of creating an element given document, localName, given namespace, null, and is. If will execute script is true, set the synchronous custom elements flag; otherwise, leave it unset.

   注記： これは、［ %~scriptを実行する ~EQ ~T ］ならば`~custom要素~構築子$を走らすことになる。 しかしながら，`動的~markup挿入-時には投出する~counter$は増やしたので、これにより，［ ~tokenizerの中に新たな文字が挿入される ／ 文書が吹飛ばされる ］ことはない。 ◎ This will cause custom element constructors to run, if will execute script is true. However, since we incremented the throw-on-dynamic-markup-insertion counter, this cannot cause new characters to be inserted into the tokenizer, or the document to be blown away.

10. %~token 内の ~EACH( %属性 ) に対し ⇒ %要素 に`属性を付加する$( %属性 ) ◎ Append each attribute in the given token to element.

    注記： これは、 `attributeChangedCallback^c 用の`~custom要素~callback反応を~enqueueする$こともある — それは（次~段にて）即時に走るかもしれない。 ◎ This can enqueue a custom element callback reaction for the attributeChangedCallback, which might run immediately (in the next step).

    注記： `is$a 属性は，`~custom化された組込みの要素$の`作成$elemを統治するが、関連する`~custom要素~構築子$を実行する間は，まだ無い — それは、この段にて，他の属性とともに付加されるので。 ◎ Even though the is attribute governs the creation of a customized built-in element, it is not present during the execution of the relevant custom element constructor; it is appended in this step, along with all other attributes.

11. ~IF［ %~scriptを実行する ~EQ ~T ］： ◎ If will execute script is true, then:

    1. %~queue ~LET `~custom要素~反応~stack$から`現在の要素~queue$を~popする （これは、上で~pushしたのと同じ`要素~queue$になる。） ◎ Let queue be the result of popping the current element queue from the custom element reactions stack. (This will be the same element queue as was pushed above.)
    2. `~custom要素~反応を呼出す$( %~queue ) ◎ Invoke custom element reactions in queue.
    3. %文書 の`動的~markup挿入-時には投出する~counter$ ~DECBY 1 ◎ Decrement document's throw-on-dynamic-markup-insertion counter.
12. ~IF［ %要素 は`~XMLNS名前空間$に属する `xmlns^a 属性を有していて，その値 ~EQ 要素の名前空間 ］ ⇒ `~perror$ ◎ If element has an xmlns attribute in the XMLNS namespace whose value is not exactly the same as the element's namespace, that is a parse error.＼
13. ~IF［ %要素 は`~XMLNS名前空間$に属する `xmlns:xlink^a 属性を有していて，その値 ~NEQ `~XLink名前空間$ ］ ⇒ `~perror$ ◎ Similarly, if element has an xmlns:xlink attribute in the XMLNS namespace whose value is not the XLink Namespace, that is a parse error.
14. ~IF［ %要素 は`再設定-可能な要素$である ］ ⇒ %要素 を`再設定する~algo$を呼出す （これは、要素の属性に基いて，要素の`値$と`~checkedness$を初期化する。） ◎ If element is a resettable element, invoke its reset algorithm. (This initializes the element's value and checkedness based on the element's attributes.)
15. %form ~LET `~form要素~pointer$ ◎ ↓

16. ~IF［ 次がすべて満たされる ］…：

    • %要素 は`~formに所有され得る要素$である
    • %form ~NEQ ~NULL
    • `~open要素~stack$内に `template$e 要素はない
    • ［ %要素 は`~listされる要素$でない ］~OR［ %要素 は `form$a 属性を有さない ］
    • ( %form, %意図される親 ) は同じ`木$内にある

    …ならば：

    1. %要素 の`~form所有者$ ~SET %form
    2. %要素 の`構文解析器挿入~flag$ ~SET ~ON
    ◎ If element is a form-associated element, the form element pointer is not null, there is no template element on the stack of open elements, element is either not listed or doesn't have a form attribute, and the intended parent is in the same tree as the element pointed to by the form element pointer, then associate element with the form element pointed to by the form element pointer and set element's parser inserted flag.
17. ~RET %要素 ◎ Return element.

以下の手続きにて `要素を挿入する@ ときは、所与の ( 開始tag~token %~token, 名前空間 %名前空間 （省略時は `~HTML名前空間$）) に対し，次の手続きを走らせ~MUST： ◎ When the steps below require the user agent to insert a foreign element for a token in a given namespace, the user agent must run these steps:

【 この訳では、原文による 2 つの手続き［ `外来の要素を挿入する@, `~HTML要素を挿入する@ ］を この手続きに集約して，命名を簡素化する（これらの手続きは、順に，この手続きにて %名前空間 を［ 明示的に与えた場合, 省略した場合 ］の挙動に一致する）。 】

1. %調整-済み挿入-先 ~LET `適切な~node挿入-先$( `現在の~node$ ) ◎ Let the adjusted insertion location be the appropriate place for inserting a node.
2. %要素 ~LET `~tokenから要素を作成する$( %~token, %名前空間, %調整-済み挿入-先 が所属する要素 ) ◎ Let element be the result of creating an element for the token in the given namespace, with the intended parent being the element in which the adjusted insertion location finds itself.

3. ~IF［ %要素 を %調整-済み挿入-先 に挿入-可能である 【下の注記を見よ】 ］： ◎ If it is possible to insert element at the adjusted insertion location, then:

   1. `~custom要素~反応~stack$に新たな`要素~queue$を~pushする ◎ Push a new element queue onto the custom element reactions stack.
   2. %要素 を %調整-済み挿入-先 に挿入する ◎ Insert element at the adjusted insertion location.
   3. %~queue ~LET `~custom要素~反応~stack$から`要素~queue$を~popする ◎ Pop the element queue from the custom element reactions stack, and＼
   4. `~custom要素~反応を呼出す$( %~queue ) ◎ invoke custom element reactions in that queue.

   注記： %調整-済み挿入-先 がそれ以上~要素を受容できない場合、 %要素 は弾き出される — 例えば、そこは すでに ある要素を子に有している`文書$内である場合。 【すなわち、挿入すると~DOM木に課される拘束を満たせなくなる場合。】 ◎ If the adjusted insertion location cannot accept more elements, e.g. because it's a Document that already has an element child, then element is dropped on the floor.

4. `~open要素~stack$に %要素 を~pushする ◎ Push element onto the stack of open elements so that it is the new current node.
5. ~RET %要素 ◎ Return element. ◎ ↑↑When the steps below require the user agent to insert an HTML element for a token, the user agent must insert a foreign element for the token, in the HTML namespace.

以下の手続きにて `~MathML属性たちを調整する@ ときは、所与の ( %~token ) に対し，次を走らす ⇒ %~token 内の ~EACH( %属性 ) に対し ⇒ ~IF［ %属性 の名前 ~EQ `definitionurl^l ］ ⇒ %属性 の名前 ~SET `definitionURL^l ◎ When the steps below require the user agent to adjust MathML attributes for a token, then, if the token has an attribute named definitionurl, change its name to definitionURL (note the case difference).

以下の手続きにて `~SVG属性たちを調整する@ ときは、所与の ( %~token ) に対し，次を走らす ⇒ %~token 内の ~EACH( %属性 )に対し ⇒ ~IF［ %属性 の名前 ~IN { 次の表の 1 列目に挙げる名前 } ］ ⇒ %属性 の名前 ~SET 同じ行の 2 列目に与えられる名前 （これは、名前に大文字を含むような~SVG属性の文字大小を修正する） ◎ When the steps below require the user agent to adjust SVG attributes for a token, then, for each attribute on the token whose attribute name is one of the ones in the first column of the following table, change the attribute's name to the name given in the corresponding cell in the second column. (This fixes the case of SVG attributes that are not all lowercase.)

以下の手続きにて~tokenを処理している間に， `文字を挿入する@ ときは、所与の ( %文字 ) に対し，次を走らせ~MUST： ◎ When the steps below require the user agent to insert a character while processing a token, the user agent must run the following steps:

1. %~data ~LET %文字 ◎ Let data be the characters passed to the algorithm, or, if no characters were explicitly specified, the character of the character token being processed.
2. %調整-済み挿入-先 ~LET `適切な~node挿入-先$( `現在の~node$ ) ◎ Let the adjusted insertion location be the appropriate place for inserting a node.

3. ~IF［ %調整-済み挿入-先 が所属する~nodeは`文書$である ］ ⇒ ~RET ◎ If the adjusted insertion location is in a Document node, then return.

   注記： ~DOMの~~制約により、 `Text$I ~nodeは，`文書$の子になれないので弾き出される。 ◎ The DOM will not let Document nodes have Text node children, so they are dropped on the floor.

4. ~IF［ %調整-済み挿入-先 の直前に `Text$I ~nodeはある ］ ⇒ その~nodeの~dataに %~data を付加する ◎ If there is a Text node immediately before the adjusted insertion location, then append data to that Text node's data.

5. ~ELSE ⇒ 次のようにされた新たな `Text$I ~nodeを %調整-済み挿入-先 に挿入する

   • %text の~data ~SET %~data
   • %text の`~node文書$ ~SET %調整-済み挿入-先 が所属する要素の`~node文書$
   ◎ Otherwise, create a new Text node whose data is data and whose node document is the same as that of the element in which the adjusted insertion location finds itself, and insert the newly created node at the adjusted insertion location.

A<script>
var %script = document.getElementsByTagName('script')[0];
document.body.removeChild(%script);
</script>B

A<script>
var %text = document.createTextNode('B');
document.body.appendChild(%text);
</script>C

A<script>
var %text = document.getElementsByTagName('script')[0].firstChild;
%text.data = 'B';
document.body.appendChild(%text);
</script>C

A<table>B<tr>C</tr>D</table>

A<table><tr> B</tr> C</table>

A<table><tr> B</tr> </em>C</table>

~UAは、文書の構文解析による変更に対しては，~DOM変異~eventは発火しては~MUST_NOT。 これには、［ `document.write()$m ／ `document.writeln()$m ］~callを利用して挿入される内容の構文解析も含まれる。 `UIEVENTS$r ◎ DOM mutation events must not fire for changes caused by the UA parsing the document. This includes the parsing of any content inserted using document.write() and document.writeln() calls. [UIEVENTS]

しかしながら，`変異~observer$は、発火する — WHATWG DOM Standard により要求されるように。 ◎ However, mutation observers do fire, as required by the WHATWG DOM Standard.

12.2.6.2. ~textのみを包含する要素の構文解析

［ `生~text要素の汎用~構文解析~algo@ ／ `~RCDATA要素の汎用~構文解析~algo@ ］は、所与の ( 開始tag~token %~token ) に対し，次を走らす： ◎ The generic raw text element parsing algorithm and the generic RCDATA element parsing algorithm consist of the following steps. These algorithms are always invoked in response to a start tag token.

1. `要素を挿入する$( %~token ) ◎ Insert an HTML element for the token.
2. %次n状態 ~LET ［ `生~text要素の汎用~構文解析~algo$に対しては `~RAWTEXT$st ／ `~RCDATA要素の汎用~構文解析~algo$に対しては `~RCDATA$st ］ ◎ If the algorithm that was invoked is the generic raw text element parsing algorithm, switch the tokenizer to the RAWTEXT state; otherwise the algorithm invoked was the generic RCDATA element parsing algorithm,＼
3. ~tokenizerを %次n状態 に`切替える$ ◎ switch the tokenizer to the RCDATA state.
4. `元の挿入~mode$V ~SET 現在の`挿入~mode$ ◎ Let the original insertion mode be the current insertion mode.
5. `挿入~mode$ ~SET `~text$md ◎ Then, switch the insertion mode to "text".

12.2.6.3. 暗黙の終了tagを有する要素を閉じるとき

以下の手続きにて `暗黙の終了tagたちを生成する@ ときは、所与の ( 要素~型 %除外-~node型 （省略時は ε ） ) に対し，次を走らせ~MUST ⇒ ~WHILE［ `現在の~node$の要素~型は［ `dd$e, `dt$e, `li$e, `optgroup$e, `option$e, `p$e, `rb$e, `rp$e, `rt$e, `rtc$e ］のいずれかであって %除外-~node型 ではない ］ ⇒ `~open要素~stack$から~popする ◎ When the steps below require the UA to generate implied end tags, then, while the current node is a dd element, a dt element, an li element, an optgroup element, an option element, a p element, an rb element, an rp element, an rt element, or an rtc element, the UA must pop the current node off the stack of open elements. ◎ If a step requires the UA to generate implied end tags but lists an element to exclude from the process, then the UA must perform the above steps as if that element was not in the above list.

以下の手続きにて `暗黙の終了tagすべてを生成する@ ときは、次を走らせ~MUST ⇒ ~WHILE［ `現在の~node$の要素~型は［ `caption$e, `colgroup$e, `dd$e, `dt$e, `li$e, `optgroup$e, `option$e, `p$e, `rb$e, `rp$e, `rt$e, `rtc$e, `tbody$e, `td$e, `tfoot$e, `th$e, `thead$e, `tr$e ］のいずれかである ］ ⇒ `~open要素~stack$から~popする ◎ When the steps below require the UA to generate all implied end tags thoroughly, then, while the current node is a caption element, a colgroup element, a dd element, a dt element, an li element, an optgroup element, an option element, a p element, an rb element, an rp element, an rt element, an rtc element, a tbody element, a td element, a tfoot element, a th element, a thead element, or a tr element, the UA must pop the current node off the stack of open elements.

12.2.6.X. 要素を閉じるとき

【 次に与える手続きは、以下を簡潔に記述するために，この訳に導入している。 これは、~DOMにおいて，当の要素とその子孫が成す木を “閉じる” ことに相当する。 】

所与の %条件 を満たす要素が `出るまで~open要素~stackから~popする@ ときは、次を走らす — ここで、 %条件 として：

• 単に 1 個以上の要素~型が与えられた場合（例： “`div^e 要素が出るまで…”）、 %条件 は “それらのうち, いずれかの要素~型である” と解釈する。
• 単にある要素~instanceが与えられた場合、 %条件 は “その要素と同じ~instance” と解釈する。

1. ~Assert： `~open要素~stack$内には %条件 を満たす要素はある

2. ~WHILE 無条件：

   1. %要素 ~LET `~open要素~stack$から~popした結果
   2. ~IF［ %要素 は %条件 を満たす ］ ⇒ ~BREAK

12.2.6.4. ~HTML内容~内の~tokenを構文解析するための規則

12.2.6.5. 外来~内容~内~token用の構文解析~規則

~UAは、外来~内容~内の~tokenを構文解析するための規則を適用するときは，現tokenを次に従って取扱わ~MUST： ◎ When the user agent is to apply the rules for parsing tokens in foreign content, the user agent must handle the token as follows:

文字~token { `0000^U } ◎ A character token that is U+0000 NULL

1. `~perror$
2. `文字を挿入する$( `FFFD^U )

◎ Parse error. Insert a U+FFFD REPLACEMENT CHARACTER character.

文字~token { `~ASCII空白$ } ◎ A character token that is one of U+0009 CHARACTER TABULATION, U+000A LINE FEED (LF), U+000C FORM FEED (FF), U+000D CARRIAGE RETURN (CR), or U+0020 SPACE

1. `文字を挿入する$( 現tokenの文字 )

◎ Insert the token's character.

その他の文字~token ◎ Any other character token

1. `文字を挿入する$( 現tokenの文字 ) ◎ Insert the token's character.
2. `~frameset-ok~flag$ ~SET `not-ok^i ◎ Set the frameset-ok flag to "not ok".

~comment~token ◎ A comment token

1. `~commentを挿入する$( 現token )

◎ Insert a comment.

~DOCTYPE~token ◎ A DOCTYPE token

1. `~perror$ — 現tokenは無視する

◎ Parse error. Ignore the token.

開始tag { `b^l, `big^l, `blockquote^l, `body^l, `br^l, `center^l, `code^l, `dd^l, `div^l, `dl^l, `dt^l, `em^l, `embed^l, `h1^l, `h2^l, `h3^l, `h4^l, `h5^l, `h6^l, `head^l, `hr^l, `i^l, `img^l, `li^l, `listing^l, `menu^l, `meta^l, `nobr^l, `ol^l, `p^l, `pre^l, `ruby^l, `s^l, `small^l, `span^l, `strong^l, `strike^l, `sub^l, `sup^l, `table^l, `tt^l, `u^l, `ul^l, `var^l, `font^l } ◎ A start tag whose tag name is one of: "b", "big", "blockquote", "body", "br", "center", "code", "dd", "div", "dl", "dt", "em", "embed", "h1", "h2", "h3", "h4", "h5", "h6", "head", "hr", "i", "img", "li", "listing", "menu", "meta", "nobr", "ol", "p", "pre", "ruby", "s", "small", "span", "strong", "strike", "sub", "sup", "table", "tt", "u", "ul", "var"

1. ~IF［ 現tokenの~tag名 ~EQ `font^l ］~AND［ 現tokenは名前 ［ `color^l ／ `face^l ／ `size^l ］の属性をいずれも有さない ］ ⇒ ~GOTO その他の開始tag ◎ A start tag whose tag name is "font", if the token has any attributes named "color", "face", or "size"
2. `~perror$ ◎ Parse error.
3. ~IF［ %構文解析器 は `~HTML素片~用$である （`素片~事例$） ］ ⇒ ~GOTO 下に述べる “その他の開始tag” ~entry ◎ If the parser was originally created for the HTML fragment parsing algorithm, then act as described in the "any other start tag" entry below. (fragment case) ◎ Otherwise:
4. `~open要素~stack$から~popする ◎ Pop an element from the stack of open elements, and then＼

5. ~WHILE 無条件：

   1. `~open要素~stack$から~popする
   2. ~IF［ `現在の~node$は［ `~MathML~text統合~地点$ ／ `~HTML統合~地点$ ／ `~HTML名前空間$に属する要素 ］である ⇒ ~BREAK
   ◎ keep popping more elements from the stack of open elements until the current node is a MathML text integration point, an HTML integration point, or an element in the HTML namespace.
6. 現tokenを再処理する ◎ Then, reprocess the token.

その他の開始tag ◎ Any other start tag

1. ~IF［ `現在の調整-済み~node$は`~MathML名前空間$に属する要素である ］ ⇒ `~MathML属性たちを調整する$( 現token ) （これは、~MathML属性に非~小文字が含まれている事例を修正する。） ◎ If the adjusted current node is an element in the MathML namespace, adjust MathML attributes for the token. (This fixes the case of MathML attributes that are not all lowercase.)

2. ~IF［ `現在の調整-済み~node$は`~SVG名前空間$に属する要素である ］~AND［ 現tokenの~tag名 ~IN { 次の~tableの 1 列目に挙げる名前 } ］ ⇒ 現tokenの~tag名 ~SET 名前が見出された行の 2 列目に与える名前 （これは、非~小文字を含む~SVG要素の事例を修正する。） ◎ If the adjusted current node is an element in the SVG namespace, and the token's tag name is one of the ones in the first column of the following table, change the tag name to the name given in the corresponding cell in the second column. (This fixes the case of SVG elements that are not all lowercase.)

   ~tag名◎ Tag name	要素~名◎ Element name
   `altglyph^c	`altGlyph^e
   `altglyphdef^c	`altGlyphDef^e
   `altglyphitem^c	`altGlyphItem^e
   `animatecolor^c	`animateColor^e
   `animatemotion^c	`animateMotion^e
   `animatetransform^c	`animateTransform^e
   `clippath^c	`clipPath^e
   `feblend^c	`feBlend^e
   `fecolormatrix^c	`feColorMatrix^e
   `fecomponenttransfer^c	`feComponentTransfer^e
   `fecomposite^c	`feComposite^e
   `feconvolvematrix^c	`feConvolveMatrix^e
   `fediffuselighting^c	`feDiffuseLighting^e
   `fedisplacementmap^c	`feDisplacementMap^e
   `fedistantlight^c	`feDistantLight^e
   `fedropshadow^c	`feDropShadow^e
   `feflood^c	`feFlood^e
   `fefunca^c	`feFuncA^e
   `fefuncb^c	`feFuncB^e
   `fefuncg^c	`feFuncG^e
   `fefuncr^c	`feFuncR^e
   `fegaussianblur^c	`feGaussianBlur^e
   `feimage^c	`feImage^e
   `femerge^c	`feMerge^e
   `femergenode^c	`feMergeNode^e
   `femorphology^c	`feMorphology^e
   `feoffset^c	`feOffset^e
   `fepointlight^c	`fePointLight^e
   `fespecularlighting^c	`feSpecularLighting^e
   `fespotlight^c	`feSpotLight^e
   `fetile^c	`feTile^e
   `feturbulence^c	`feTurbulence^e
   `foreignobject^c	`foreignObject^e
   `glyphref^c	`glyphRef^e
   `lineargradient^c	`linearGradient^e
   `radialgradient^c	`radialGradient^e
   `textpath^c	`textPath^e

3. ~IF［ `現在の調整-済み~node$は`~SVG名前空間$に属する要素である ］ ⇒ `~SVG属性たちを調整する$( 現token ) （これは、非~小文字を含む~SVG属性の事例を修正する。） ◎ If the adjusted current node is an element in the SVG namespace, adjust SVG attributes for the token. (This fixes the case of SVG attributes that are not all lowercase.)
4. `外来の属性たちを調整する$( 現token ) （これは、名前空間~付きの属性の利用 — 特に~SVGにおける~XLink — を修正する。） ◎ Adjust foreign attributes for the token. (This fixes the use of namespaced attributes, in particular XLink in SVG.)
5. `要素を挿入する$( 現token, `現在の調整-済み~node$が属する名前空間 ) ◎ Insert a foreign element for the token, in the same namespace as the adjusted current node.
6. ~IF［ 現tokenの`自己閉じ~flag$ ~EQ ~OFF ］ ⇒ ~RET ◎ If the token has its self-closing flag set, then run the appropriate steps from the following list:
7. `自己閉じ~flagを承認する$( 現token ) ◎ ↓
8. ~IF［ 現tokenの~tag名 ~EQ `script^l ］~AND［ `現在の~node$は`~SVG名前空間$に属する ］ ⇒ ~GOTO 終了tag { `script^l } ◎ If the token's tag name is "script", and the new current node is in the SVG namespace • Acknowledge the token's self-closing flag, and then act as described in the steps for a "script" end tag below.
9. `~open要素~stack$から~popする ◎ Otherwise • Pop the current node off the stack of open elements and acknowledge the token's self-closing flag.

終了tag { `script^l } ◎ An end tag whose tag name is "script",＼

1. ~IF［ `現在の~node$は ~SVG `~SVGscript$e 要素でない ］ ⇒ ~GOTO その他の終了tag ◎ if the current node is an SVG script element
2. `~open要素~stack$から~popする ◎ Pop the current node off the stack of open elements.
3. %旧~挿入~地点 ~LET現在の`挿入~地点$ ◎ Let the old insertion point have the same value as the current insertion point.＼
4. `挿入~地点$ ~LET `次n入力~文字$の直前 ◎ Let the insertion point be just before the next input character.
5. %構文解析器 の`~script入子~level$ ~INCBY 1 ◎ Increment the parser's script nesting level by one.＼
6. %構文解析器 の`静止~flag$ ~SET ~T ◎ Set the parser pause flag to true.

7. ~IF［ ~UAは~SVGを~supportする ］ ⇒ ~SVG規則に則って，`~SVG~script要素を処理する$ `SVG$r ◎ Process the SVG script element according to the SVG rules, if the user agent supports SVG. [SVG]

   注記： これにより ~tokenizerの中に新たな文字たちが挿入される ことになる場合でも、 %構文解析器 の`静止~flag$ ~EQ ~T なので， %構文解析器 は再入的に実行されない。 ◎ Even if this causes new characters to be inserted into the tokenizer, the parser will not be executed reentrantly, since the parser pause flag is true.

8. %構文解析器 の`~script入子~level$ ~DECBY 1 ◎ Decrement the parser's script nesting level by one.＼
9. ~IF［ %構文解析器 の`~script入子~level$ ~EQ 0 ］ ⇒ %構文解析器 の`静止~flag$ ~SET ~F ◎ If the parser's script nesting level is zero, then set the parser pause flag to false.
10. `挿入~地点$ ~SET %旧~挿入~地点 ◎ Let the insertion point have the value of the old insertion point. (In other words, restore the insertion point to its previous value. This value might be the "undefined" value.)

その他の終了tag ◎ Any other end tag ◎ Run these steps:

1. %~node ~LET `現在の~node$ ◎ Initialize node to be the current node (the bottommost node of the stack).
2. ~IF［ `~ASCII小文字~化する$( %~node の~tag名 ) ~NEQ 現tokenの~tag名 ］ ⇒ `~perror$ ◎ If node's tag name, converted to ASCII lowercase, is not the same as the tag name of the token, then this is a parse error.

3. ~WHILE 無条件： ◎ ↓

   1. ~IF［ %~node ~EQ `~open要素~stack$の先頭の要素 （`素片~事例$） ］ ⇒ ~RET ◎ Loop: If node is the topmost element in the stack of open elements, then return. (fragment case)

   2. ~IF［ `~ASCII小文字~化する$( %~node の~tag名 ) ~EQ 現tokenの~tag名 ］：

      1. %~node が`出るまで~open要素~stackから~popする$
      2. ~RET
      ◎ If node's tag name, converted to ASCII lowercase, is the same as the tag name of the token, pop elements from the stack of open elements until node has been popped from the stack, and then return.
   3. %~node ~SET `~open要素~stack$内で %~node の直前の~entry ◎ Set node to the previous entry in the stack of open elements.
   4. ~IF［ %~node は`~HTML名前空間$に属する要素である ］ ⇒ ~BREAK ◎ If node is not an element in the HTML namespace, return to the step labeled loop.
4. ［ ~HTML内容~内の~token 用の，現在の`挿入~mode$に対応する節 ］に与える規則に則って、現tokenを処理する ◎ Otherwise, process the token according to the rules given in the section corresponding to the current insertion mode in HTML content.

12.2.9.1. 誤入子な~tag：`<b><i></b></i>^c

次のような~markupは、~error含みの例として，最もよく論じられる： ◎ The most-often discussed example of erroneous markup is as follows:

<p>1<b>2<i>3</b>4</i>5</p>

この~markupの構文解析は、 `3^l までは素直に進む。 この時点での~DOMは、次の様な見かけになる： ◎ The parsing of this markup is straightforward up to the "3". At this point, the DOM looks like this:

• `html$e
  • `head$e
  • `body$e
    • `p$e
      • `#text$: 1
      • `b$e
        • `#text$: 2
        • `i$e
          • `#text$: 3

この時点で、`~open要素~stack$は 順に 5 個の要素 — `html$e, `body$e, `p$e, `b$e, `i$e — からなり，`作動中の整形~要素~list$は 2 個の要素 — `b$e, `i$e — からなり，`挿入~mode$は`~body内$mdになる。 ◎ Here, the stack of open elements has five elements on it: html, body, p, b, and i. The list of active formatting elements just has two: b and i. The insertion mode is "in body".

~tag名に `b^l を伴う終了tag~tokenを受取ったときには、`養子縁組~algo$が呼出される。 これは単純な事例であり、 %整形~要素 は `b$e 要素， %最遠の~block はない。 したがって`~open要素~stack$は 3 個の要素 — `html$e, `body$e, `p$e — からなる一方で，`作動中の整形~要素~list$は `i$e 要素 1 個だけからなる。 この時点では、~DOM木はまだ改変されない。 ◎ Upon receiving the end tag token with the tag name "b", the "adoption agency algorithm" is invoked. This is a simple case, in that the formatting element is the b element, and there is no furthest block. Thus, the stack of open elements ends up with just three elements: html, body, and p, while the list of active formatting elements has just one: i. The DOM tree is unmodified at this point.

次n~tokenは文字 `4^l であり、`作動中の整形~要素たちを再構築する$ — この事例では、 `i$e 要素だけ — を誘発する。 したがって， `Text$I ~node `4^l 用に新たな `i$e 要素が作成される。 `i^l に対する終了tag~tokenも受取った後には， `Text$I ~node `5^l も挿入され、~DOMは次の様になる： ◎ The next token is a character ("4"), triggers the reconstruction of the active formatting elements, in this case just the i element. A new i element is thus created for the "4" Text node. After the end tag token for the "i" is also received, and the "5" Text node is inserted, the DOM looks as follows:

• `html$e
  • `head$e
  • `body$e
    • `p$e
      • `#text$: 1
      • `b$e
        • `#text$: 2
        • `i$e
          • `#text$: 3
      • `i$e
        • `#text$: 4
      • `#text$: 5

12.2.9.2. 誤入子な~tag： `<b><p></b></p>^c

前~節に類似する事例： ◎ A case similar to the previous one is the following:

<b>1<p>2</b>3</p>

ここでの構文解析は、 `2^l の所までは素直に進む： ◎ Up to the "2" the parsing here is straightforward:

• `html$e
  • `head$e
  • `body$e
    • `b$e
      • `#text$: 1
      • `p$e
        • `#text$: 2

関心があるのは、~tag名に `b^l を伴う終了tag~tokenが構文解析されるときである。 ◎ The interesting part is when the end tag token with the tag name "b" is parsed.

その~tokenに出くわす前までは、`~open要素~stack$は 4 個の要素 — `html$e, `body$e, `b$e, `p$e — からなり，`作動中の整形~要素~list$は `b$e のみからなり，`挿入~mode$は`~body内$mdになる。 ◎ Before that token is seen, the stack of open elements has four elements on it: html, body, b, and p. The list of active formatting elements just has the one: b. The insertion mode is "in body".

~tag名に `b^l を伴う終了tag~tokenを受取るときには、前の例と同じく`養子縁組~algo$が呼出される。 しかしながら，今度の事例では %最遠の~block として `p$e 要素があるので、養子縁組~algoは飛ばされない。 ◎ Upon receiving the end tag token with the tag name "b", the "adoption agency algorithm" is invoked, as in the previous example. However, in this case, there is a furthest block, namely the p element. Thus, this time the adoption agency algorithm isn't skipped over.

%共通の先祖 は `body$e 要素。 概念的な “~bookmark” は`作動中の整形~要素~list$における `b$e の位置を~markするが、その~listを成す要素は 1 個だけなので、~bookmarkによる効果はたいしてない。 ◎ The common ancestor is the body element. A conceptual "bookmark" marks the position of the b in the list of active formatting elements, but since that list has only one element in it, the bookmark won't have much effect.

~algoが進捗するに伴い、 %~node は整形~要素 （ `b$e ）に設定され， %最後の~node は %最遠の~block（ `p$e ）に設定される。 ◎ As the algorithm progresses, node ends up set to the formatting element (b), and last node ends up set to the furthest block (p).

%最後の~node は、~DOMが次の様な見かけになるよう， %共通の先祖 に付加されることになる（移動される）： ◎ The last node gets appended (moved) to the common ancestor, so that the DOM looks like:

• `html$e
  • `head$e
  • `body$e
    • `b$e
      • `#text$: 1
    • `p$e
      • `#text$: 2

新たな `b$e 要素が作成され， `p$e 要素の子たちはそこに移動される： ◎ A new b element is created, and the children of the p element are moved to it:

• `html$e
  • `head$e
  • `body$e
    • `b$e
      • `#text$: 1
    • `p$e

• `b$e
  • `#text$: 2

最終的に，新たな `b$e 要素は、~DOMが次の様な見かけになるよう， `p$e 要素に付加される： ◎ Finally, the new b element is appended to the p element, so that the DOM looks like:

• `html$e
  • `head$e
  • `body$e
    • `b$e
      • `#text$: 1
    • `p$e
      • `b$e
        • `#text$: 2

`b$e 要素は、 `3^l が構文解析されるときに `p$e 要素に付加されるよう，［ `作動中の整形~要素~list$, `~open要素~stack$ ］から除去される： ◎ The b element is removed from the list of active formatting elements and the stack of open elements, so that when the "3" is parsed, it is appended to the p element:

• `html$e
  • `head$e
  • `body$e
    • `b$e
      • `#text$: 1
    • `p$e
      • `b$e
        • `#text$: 2
      • `#text$: 3

12.2.9.3. ~table内の予期されない~markup

~tableにおける~errorの取扱いは、歴史的~理由から，とりわけ変則的である。 例えば、次の~markupを考える： ◎ Error handling in tables is, for historical reasons, especially strange. For example, consider the following markup:

<table><b><tr><td>aaa</td></tr>bbb</table>ccc

上の様な強調されている `b$e 要素の開始tagは，~tableの内側には直には許容されないので、構文解析器はこの事例に対しては，要素を~tableの前に置くように取扱う（これは、`親を違える$と呼ばれる）。 これは、~DOM木を精査すれば見つかる — それは `table$e 要素の開始tagに出くわした直後に~~現れるので： ◎ The highlighted b element start tag is not allowed directly inside a table like that, and the parser handles this case by placing the element before the table. (This is called foster parenting.) This can be seen by examining the DOM tree as it stands just after the table element's start tag has been seen:

• `html$e
  • `head$e
  • `body$e
    • `table$e

`b$e 要素の開始tagに出くわした直後には、次の様になる： ◎ ...and then immediately after the b element start tag has been seen:

• `html$e
  • `head$e
  • `body$e
    • `b$e
    • `table$e

この時点では、`~open要素~stack$は［ `html$e, `body$e, `table$e, `b$e ］要素からなり（結果の~DOM木に関わらず，この順序になる），`作動中の整形~要素~list$は `b$e 要素のみからなり，`挿入~mode$は`~table内$mdになる。 ◎ At this point, the stack of open elements has on it the elements html, body, table, and b (in that order, despite the resulting DOM tree); the list of active formatting elements just has the b element in it; and the insertion mode is "in table".

`tr$e 開始tagは、 `b$e 要素を~stackから~popさせ， `tbody$e 開始tagが黙示されることになる — 次の `tbody$e と `tr$e 要素は素直に取扱われ，構文解析器が挿入~mode［ `~table~body内$md, `~row内$md ］を経るように導く。 結果の~DOMは、次の様になる： ◎ The tr start tag causes the b element to be popped off the stack and a tbody start tag to be implied; the tbody and tr elements are then handled in a rather straight-forward manner, taking the parser through the "in table body" and "in row" insertion modes, after which the DOM looks as follows:

• `html$e
  • `head$e
  • `body$e
    • `b$e
    • `table$e
      • `tbody$e
        • `tr$e

ここでの`~open要素~stack$は［ `html$e, `body$e, `table$e, `tbody$e, `tr$e ］要素からなり，`作動中の整形~要素~list$は依然として `b$e 要素のみからなり，`挿入~mode$は`~row内$mdになる。 ◎ Here, the stack of open elements has on it the elements html, body, table, tbody, and tr; the list of active formatting elements still has the b element in it; and the insertion mode is "in row".

`td$e 要素を木に置いた後、その開始tag~tokenは，`作動中の整形~要素~list$に`~marker$を置く（それはまた，`~cell内$mdに切替える）。 ◎ The td element start tag token, after putting a td element on the tree, puts a marker on the list of active formatting elements (it also switches to the "in cell" insertion mode).

• `html$e
  • `head$e
  • `body$e
    • `b$e
    • `table$e
      • `tbody$e
        • `tr$e
          • `td$e

この`~marker$は、［ 文字~token列 `aaa^l に出くわしたとき、［ それによる結果の `Text$I ~nodeを保持するために `b$e 要素を作成する ］ことはない ］ことを意味する： ◎ The marker means that when the "aaa" character tokens are seen, no b element is created to hold the resulting Text node:

• `html$e
  • `head$e
  • `body$e
    • `b$e
    • `table$e
      • `tbody$e
        • `tr$e
          • `td$e
            • `#text$: aaa

終了tagたちは，素直に取扱われ、それらを取扱った後には，`~open要素~stack$は［ `html$e, `body$e, `table$e, `tbody$e ］要素からなり，`作動中の整形~要素~list$は 依然として `b$e 要素のみからなり（`~marker$は `td^l 終了tag~tokenによりすでに除去されている），`挿入~mode$は`~table~body内$mdになる。 ◎ The end tags are handled in a straight-forward manner; after handling them, the stack of open elements has on it the elements html, body, table, and tbody; the list of active formatting elements still has the b element in it (the marker having been removed by the "td" end tag token); and the insertion mode is "in table body".

したがって見出されるのは、文字~token列 `bbb^l になる。 これらは`~table~text内$mdの利用を誘発する（ `元の挿入~mode$V を`~table~body内$mdに設定して）。 この文字~token列は収集され、次n~token（ `table$e 要素の終了tag）に出くわしたときには，~groupとして処理される。 それらには~space以外も混じっているので、`~table内$mdにおける “~AnyElse” 規則に従って取扱われる — それは、`親を違える$下で，`~body内$mdに先送りする。 ◎ Thus it is that the "bbb" character tokens are found. These trigger the "in table text" insertion mode to be used (with the original insertion mode set to "in table body"). The character tokens are collected, and when the next token (the table element end tag) is seen, they are processed as a group. Since they are not all spaces, they are handled as per the "anything else" rules in the "in table" insertion mode, which defer to the "in body" insertion mode but with foster parenting.

`作動中の整形~要素たちを再構築する$ときには、`親を違える$ように `b$e 要素が作成され， `Text$I ~node `bbb^l はそれに付加される： ◎ When the active formatting elements are reconstructed, a b element is created and foster parented, and then the "bbb" Text node is appended to it:

• `html$e
  • `head$e
  • `body$e
    • `b$e
    • `b$e
      • `#text$: bbb
    • `table$e
      • `tbody$e
        • `tr$e
          • `td$e
            • `#text$: aaa

`~open要素~stack$は［ `html$e, `body$e, `table$e, `tbody$e, 新たな `b$e ］要素からなり（ここでも，順序は結果の木には合致しないことに注意！）， `作動中の整形~要素~list$は 新たな `b$e 要素からなり，`挿入~mode$は依然として `~table~body内$mdになる。 ◎ The stack of open elements has on it the elements html, body, table, tbody, and the new b (again, note that this doesn't match the resulting tree!); the list of active formatting elements has the new b element in it; and the insertion mode is still "in table body".

文字~token列が `bbb^l に代えて`~ASCII空白$のみからなっていた場合、単に `tbody$e 要素に付加されることになる。 ◎ Had the character tokens been only ASCII whitespace instead of "bbb", then that ASCII whitespace would just be appended to the tbody element.

最終的に `table$e は、終了tag `table^l により閉じられる。 これは，`~open要素~stack$から `table$e 要素までの~nodeすべてを~popさせるが，`作動中の整形~要素~list$には影響しないので、 `table^e の後にある文字~token列 `ccc^l は，今度は `table^e の後に もう一つ作成される `b$e 要素~内に置かれる： ◎ Finally, the table is closed by a "table" end tag. This pops all the nodes from the stack of open elements up to and including the table element, but it doesn't affect the list of active formatting elements, so the "ccc" character tokens after the table result in yet another b element being created, this time after the table:

• `html$e
  • `head$e
  • `body$e
    • `b$e
    • `b$e
      • `#text$: bbb
    • `table$e
      • `tbody$e
        • `tr$e
          • `td$e
            • `#text$: aaa
    • `b$e
      • `#text$: ccc

12.2.9.4. 構文解析されている頁を改変する~script

次の~markupを考える。 この例においては、“内縁” 文書（ `~URL$ `https://example.com/inner^l ）は，別の “外縁” 文書（ `~URL$ `https://example.com/outer^l ）内で `iframe$e の内容として具現化されているとする： ◎ Consider the following markup, which for this example we will assume is the document with URL https://example.com/inner, being rendered as the content of an iframe in another document with the URL https://example.com/outer:

<div id=a>
 <script>
  var %div = document.getElementById('a');
  parent.document.body.appendChild(%div);
 </script>
 <script>
  alert(document.URL);
 </script>
</div>

<script>
 alert(document.URL);
</script>

1 個目の `script^l 終了tagまでの，~scriptが構文解析される前の結果は、比較的~素直に進む： ◎ Up to the first "script" end tag, before the script is parsed, the result is relatively straightforward:

• `html$e
  • `head$e
  • `body$e
    • `div$e `id$a="`a^c"
      • `#text$:
      • `script$e
        • `#text$: var %div = document.getElementById('a'); ⏎ parent.document.body.appendChild(%div);

が、~scriptが構文解析された後では， `div$e 要素とその子 `script$e 要素は去る： ◎ After the script is parsed, though, the div element and its child script element are gone:

• `html$e
  • `head$e
  • `body$e

去ったそれらは、この時点で，前述の 外縁`閲覧文脈$の`文書$内にある。 しかしながら，`~open要素~stack$は依然として `div$e 要素を包含する。 ◎ They are, at this point, in the Document of the aforementioned outer browsing context. However, the stack of open elements still contains the div element.

したがって， 2 個目の `script$e 要素が構文解析されるとき、それは 外縁 `文書$の中に挿入される。 ◎ Thus, when the second script element is parsed, it is inserted into the outer Document object.

構文解析器が作成したものとは異なる`文書$用に構文解析されるものは，実行されないので、 1 個目の~alertは示されない。 ◎ Those parsed into different Documents than the one the parser was created for do not execute, so the first alert does not show.

`div$e 要素の終了tagが構文解析されたなら、 `div$e 要素は~stackから~popされるので， 3 個目の `script$e 要素は内縁 `文書$内にある： ◎ Once the div element's end tag is parsed, the div element is popped off the stack, and so the next script element is in the inner Document:

• `html$e
  • `head$e
  • `body$e
    • `script$e
      • `#text$: alert(document.URL);

この~scriptが実行される結果、 `https://example.com/inner^l を示す~alertが生じる。 ◎ This script does execute, resulting in an alert that says "https://example.com/inner".

12.2.9.5. 複数の文書にまたがって移動する~scriptの実行

前~節の例から更に詳しく、 2 個目の `script$e 要素は外部~scriptである（すなわち， `src$a 属性を有する）事例を考える。 要素は作成-時点では構文解析器の`文書$内にはなかったので、この外部~scriptは~downloadすらされない。 ◎ Elaborating on the example in the previous section, consider the case where the second script element is an external script (i.e. one with a src attribute). Since the element was not in the parser's Document when it was created, that external script is not even downloaded.

`src$a 属性を有する `script$e 要素が 通常のように 構文解析器の`文書$の中へ構文解析されつつ， その外部~scriptの~download中に 要素が別の文書へ移動された場合、~downloadは継続されるが，~scriptは実行されない。 ◎ In a case where a script element with a src attribute is parsed normally into its parser's Document, but while the external script is being downloaded, the element is moved to another document, the script continues to download, but does not execute.

注記： 一般に、 `script$e 要素を`文書$間で移動することは，不良な実施と見なされる。 ◎ In general, moving script elements between Documents is considered a bad practice.

12.2.9.6. 閉じられてない整形~要素

次の~markupに、入子にされた整形~要素（ `b$e など）が — それを包含する要素が閉じられても — 収集され，適用され続けることになる様子を示す。 ただし、過度の重複は棄てられる。 ◎ The following markup shows how nested formatting elements (such as b) get collected and continue to be applied even as the elements they are contained in are closed, but that excessive duplicates are thrown away.

<!DOCTYPE html>
<p><b class=x><b class=x><b><b class=x><b class=x><b>X
<p>X
<p><b><b class=x><b>X
<p></b></b></b></b></b></b>X

結果の~DOM木は、次の様になる： ◎ The resulting DOM tree is as follows:

• DOCTYPE: `html^c
• `html$e
  • `head$e
  • `body$e
    • `p$e
      • `b$e `class$a="`x^c"
        • `b$e `class$a="`x^c"
          • `b$e
            • `b$e `class$a="`x^c"
              • `b$e `class$a="`x^c"
                • `b$e
                  • `#text$: X⏎
    • `p$e
      • `b$e `class$a="`x^c"
        • `b$e
          • `b$e `class$a="`x^c"
            • `b$e `class$a="`x^c"
              • `b$e
                • `#text$: X⏎
    • `p$e
      • `b$e `class$a="`x^c"
        • `b$e
          • `b$e `class$a="`x^c"
            • `b$e `class$a="`x^c"
              • `b$e
                • `b$e
                  • `b$e `class$a="`x^c"
                    • `b$e
                      • `#text$: X⏎
    • `p$e
      • `#text$: X⏎

この~markup内の 2 個目の `p$e 要素は，明示的な `b$e 要素を持たないが、結果の~DOM内では，要素の `X^l の前にて 3 個までの各~種類の整形~要素（この事例では、 `class^a 属性を有する 3 個の `b$e 要素と, 有さない 2 個の `b$e 要素）が再構築されることになる様子に注意。 ◎ Note how the second p element in the markup has no explicit b elements, but in the resulting DOM, up to three of each kind of formatting element (in this case three b elements with the class attribute, and two unadorned b elements) get reconstructed before the element's "X".

この地点までに 9 個の `b$e 開始tagに出くわしたが、このことは，［ 最後の段落において、`作動中の整形~要素~list$内で完全に~clearする必要があるのは， 6 個の `b$e 終了tagに限られる ］ことを意味するのにも注意。 ◎ Also note how this means that in the final paragraph only six b end tags are needed to completely clear the list of active formatting elements, even though nine b start tags have been seen up to this point.