MIME 型の sniff 法 — MIME Sniffing

%~byte列[ %m `+〜@ %個数 ] と記された所では、 所与の ( `~byte列$ %~byte列, 負でない整数 %m, 負でない整数 %個数 ) に対し，次に従って得られる %~byte列 の部分~byte列を返す：

1. ~IF［ %m ~GTE %~byte列 の`長さ$byte ］ ⇒ ~RET 空~byte列
2. ~RET %~byte列 を成す，［ 0 から数えて %m 番の~byte ］から %個数 個まで（ %個数 に満たない場合は %~byte列 の末尾まで）の~byteが成す，同順の`~byte列$

`~MIME型$ %~MIME型 の `~essence@ は、 次の連結を返す ⇒＃ %~MIME型 の`型$, `002F^U, %~MIME型 の`下位型$ ◎ The essence of a MIME type mimeType is mimeType’s type, followed by U+002F (/), followed by mimeType’s subtype.

`~supportされる~MIME型を最小~化する@ ~algoは、 所与の ( `~MIME型$ %~MIME型 ) に対し，`~ASCII文字列$を返す： ◎ To minimize a supported MIME type given a MIME type mimeType, run these steps. They return an ASCII string.

1. ~IF［ %~MIME型 は`~JS~MIME型$である ］ ⇒ ~RET `text/javascript^l ◎ If mimeType is a JavaScript MIME type, then return "text/javascript".
2. ~IF［ %~MIME型 は`~JSON~MIME型$である ］ ⇒ ~RET `application/json^l ◎ If mimeType is a JSON MIME type, then return "application/json".

3. ~IF［ %~MIME型 の`~essence$ ~EQ `image/svg+xml^l ］ ⇒ ~RET `image/svg+xml^l ◎ If mimeType’s essence is "image/svg+xml", then return "image/svg+xml".

   注記： ~SVGは、 他の`~XML~MIME型$と判別するに価する。 ◎ SVG is worth distinguishing from other XML MIME types.

4. ~IF［ %~MIME型 は`~XML~MIME型$である ］ ⇒ ~RET `application/xml^l ◎ If mimeType is an XML MIME type, then return "application/xml".
5. ~IF［ %~MIME型 は`~UAにより~supportされて$いる ］ ⇒ ~RET %~MIME型 の`~essence$ ◎ If mimeType is supported by the user agent, then return mimeType’s essence.
6. ~RET 空~文字列 ◎ Return the empty string.

注記： この~algoの目標は、［ 異なる処理~model — GIF や PNG 用のそれなど — を伴う~MIME型どうし ］を~call元が判別することを許容する一方で，［ それ以外に供する情報は，アリな限り抑える ］ことにある。 ◎ The goal of this algorithm is to allow the caller to distinguish MIME types with different processing models, such as those for GIF and PNG, but otherwise provide as little information as possible.

`~MIME型を構文解析する@ ~algoは、 所与の ( 文字列 %入力 ) に対し： ◎ To parse a MIME type, given a string input, run these steps:

1. %入力 から頭部, 尾部を成す`~HTTP空白$並びを除去する ◎ Remove any leading and trailing HTTP whitespace from input.
2. %位置 ~LET %入力 の先頭を指している`位置~変数$ ◎ Let position be a position variable for input, initially pointing at the start of input.
3. %型 ~LET %入力 内の %位置 から `002F^U 以外の`符号位置~並びを収集する$ ◎ Let type be the result of collecting a sequence of code points that are not U+002F (/) from input, given position.
4. ~IF［ %型 ~EQ 空~文字列 ］~OR［ %型 を成す符号位置に`~HTTP~token符号位置$でないものがある ］ ⇒ ~RET `失敗^i ◎ If type is the empty string or does not solely contain HTTP token code points, then return failure.
5. ~IF［ %位置↗ ~EQ ε ］ ⇒ ~RET `失敗^i ◎ If position is past the end of input, then return failure.
6. %位置 ~INCBY 1 （これは `002F^U を飛ばす。） ◎ Advance position by 1. (This skips past U+002F (/).)
7. %下位型 ~LET %入力 内の %位置 から`003B^U 以外の`符号位置~並びを収集する$ ◎ Let subtype be the result of collecting a sequence of code points that are not U+003B (;) from input, given position.
8. %下位型 から尾部を成す`~HTTP空白$並びを除去する ◎ Remove any trailing HTTP whitespace from subtype.
9. ~IF［ %下位型 ~EQ 空~文字列 ］~OR［ %下位型 を成す符号位置に`~HTTP~token符号位置$でないものがある ］ ⇒ ~RET `失敗^i ◎ If subtype is the empty string or does not solely contain HTTP token code points, then return failure.
10. %~MIME型 ~LET 新たな`~MIME型~record$ — その ⇒＃ `型$ ~SET `~ASCII小文字~化する$( %型 ), `下位型$ ~SET `~ASCII小文字~化する$( %下位型 ) ◎ Let mimeType be a new MIME type record whose type is type, in ASCII lowercase, and subtype is subtype, in ASCII lowercase.

11. ~WHILE［ %位置↗ ~NEQ ε ］： ◎ While position is not past the end of input:

    1. %位置 ~INCBY 1 （これは `003B^U を飛ばす。） ◎ Advance position by 1. (This skips past U+003B (;).)

    2. %入力 内の %位置 から`~HTTP空白$からなる`符号位置~並びを収集する$ ◎ Collect a sequence of code points that are HTTP whitespace from input given position.

       注記： これは、 `~ASCII空白$に代えて`~HTTP空白$が利用されることを除いて，`~ASCII空白を読飛ばす$のと概ね等価になる。 ◎ This is roughly equivalent to skip ASCII whitespace, except that HTTP whitespace is used rather than ASCII whitespace.

    3. %~parameter名 ~LET %入力 内の %位置 から { `003B^U, `003D^U } 以外の`符号位置~並びを収集する$ ◎ Let parameterName be the result of collecting a sequence of code points that are not U+003B (;) or U+003D (=) from input, given position.
    4. %~parameter名 ~SET `~ASCII小文字~化する$( %~parameter名 ) ◎ Set parameterName to parameterName, in ASCII lowercase. ◎ If position is not past the end of input, then:
    5. ~IF［ %位置↗ ~EQ `003B^U ］ ⇒ ~CONTINUE ◎ If the code point at position within input is U+003B (;), then continue.
    6. %位置 ~INCBY 1 （これは `003D^U を飛ばす。） ◎ Advance position by 1. (This skips past U+003D (=).)
    7. ~IF［ %位置↗ ~EQ ε ］ ⇒ ~BREAK ◎ If position is past the end of input, then break.
    8. %~parameter値 ~LET ~NULL ◎ Let parameterValue be null.

    9. ~IF［ %位置↗ ~EQ `0022^U ］： ◎ If the code point at position within input is U+0022 ("), then:

       1. %~parameter値 ~SET `~HTTP引用符付き文字列を収集する$( %入力, %位置, `値を抽出する^i ) ◎ Set parameterValue to the result of collecting an HTTP quoted string from input, given position and true.

       2. %入力 内の %位置 から `003B^U 以外の`符号位置~並びを収集する$ ◎ Collect a sequence of code points that are not U+003B (;) from input, given position.

          `text/html;charset="shift_jis"iso-2022-jp^mt が与えられた場合の結果は、 `text/html;charset=shift_jis^mt になる。 ◎ Given text/html;charset="shift_jis"iso-2022-jp you end up with text/html;charset=shift_jis.

    10. ~ELSE： ◎ Otherwise:

        1. %~parameter値 ~SET %入力 内の %位置 から `003B^U 以外の`符号位置~並びを収集する$ ◎ Set parameterValue to the result of collecting a sequence of code points that are not U+003B (;) from input, given position.
        2. %~parameter値 から尾部を成す`~HTTP空白$並びを除去する ◎ Remove any trailing HTTP whitespace from parameterValue.
        3. ~IF［ %~parameter値 ~EQ 空~文字列 ］ ⇒ ~CONTINUE ◎ If parameterValue is the empty string, then continue.

    11. ~IF［ ~AND↓ ］… ◎ If all of the following are true

        • %~parameter名 ~NEQ 空~文字列 ◎ parameterName is not the empty string
        • %~parameter名 を成すどの符号位置も`~HTTP~token符号位置$である ◎ parameterName solely contains HTTP token code points
        • %~parameter値 を成すどの符号位置も`~HTTP引用符付き文字列~token符号位置$である ◎ parameterValue solely contains HTTP quoted-string token code points
        • %~MIME型 の`~parameter群$[ %~parameter名 ] ~EQ ε ◎ mimeType’s parameters[parameterName] does not exist

        …ならば ⇒ %~MIME型 の`~parameter群$[ %~parameter名 ] ~SET %~parameter値 ◎ then set mimeType’s parameters[parameterName] to parameterValue.

12. ~RET %~MIME型 ◎ Return mimeType.

`~byte列から~MIME型を構文解析する@ ~algoは、 所与の ( `~byte列$ %入力 ) に対し： ◎ To parse a MIME type from bytes, given a byte sequence input, run these steps:

1. %文字列 ~LET `同型に復号する$( %入力 ) ◎ Let string be input, isomorphic decoded.
2. ~RET `~MIME型を構文解析する$( %文字列 ) ◎ Return the result of parse a MIME type with string.

`~MIME型を直列化する@ ~algoは、 所与の ( `~MIME型$ %~MIME型 ) に対し： ◎ To serialize a MIME type, given a MIME type mimeType, run these steps:

1. %直列化 ~LET 空~文字列 ◎ ↓
2. %直列化 に次を順に付加する ⇒＃ %~MIME型 の`型$, `002F^U, %~MIME型 の`下位型$ ◎ Let serialization be the concatenation of mimeType’s type, U+002F (/), and mimeType’s subtype.

3. %~MIME型 の`~parameter群$を成す ~EACH( %名 → %値 ) に対し： ◎ For each name → value of mimeType’s parameters:

   1. %直列化 に次を順に付加する ⇒＃ `003B^U, %名, `003D^U ◎ Append U+003B (;) to serialization. ◎ Append name to serialization. ◎ Append U+003D (=) to serialization.

   2. ~IF［ %値 を成す符号位置に`~HTTP~token符号位置$でないものがある ］~OR［ %値 ~EQ 空~文字列 ］：

      1. %直列化 に `0022^U を付加する

      2. %値 を成す ~EACH( 符号位置 %C ) に対し，順に：

         1. ~IF［ %C ~IN { `0022^U, `005C^U } ］ ⇒ %直列化 に `005C^U を付加する
         2. %直列化 に %C を付加する
      3. %直列化 に `0022^U を付加する
      ◎ If value does not solely contain HTTP token code points or value is the empty string, then: • Precede each occurrence of U+0022 (") or U+005C (\) in value with U+005C (\). • Prepend U+0022 (") to value. • Append U+0022 (") to value.
   3. ~ELSE ⇒ %直列化 に %値 を付加する ◎ Append value to serialization.
4. ~RET %直列化 ◎ Return serialization.

`~MIME型を~byte列に直列化する@ ~algoは、 所与の ( `~MIME型$ %~MIME型 ) に対し ⇒ ~RET `同型に符号化する$( `~MIME型を直列化する$( %~MIME型 ) ) ◎ To serialize a MIME type to bytes, given a MIME type mimeType, run these steps: • Let stringSerialization be the result of serialize a MIME type with mimeType. • Return stringSerialization, isomorphic encoded.

`給された~MIME型を検出する~algo@ は、 所与の ( `資源$ %資源 ) に対し，［ `~MIME型$／ ε（未定義） ］を返す： ◎ To determine the supplied MIME type of a resource, user agents must use the following supplied MIME type detection algorithm:

1. %給された型 ~LET ε 【！ ＊~NULL 】 ◎ Let supplied-type be null.

2. ~IF［ %資源 は~HTTPを介して検索取得された ］： ◎ If the resource is retrieved via HTTP, execute the following steps:

   1. ~IF［ %資源 には 1 個~以上の `Content-Type$h ~headerが結付けられている ］： ◎ If one or more Content-Type headers are associated with the resource, execute the following steps:

      1. %給された型 ~SET %資源 に結付けられた最後の `Content-Type$h ~headerの値 ◎ Set supplied-type to the value of the last Content-Type header associated with the resource.

         注記： ~file拡張子は、 ~HTTPを介して検索取得された %資源 に`給された~MIME型$を決定するときには，利用されない — 容易に偽装されるので、 それらには依拠できない。 ◎ File extensions are not used to determine the supplied MIME type of a resource retrieved via HTTP because they are unreliable and easily spoofed.

      2. ~IF［ %給された型 ~IN { 次に挙げる値 } ］… ◎ Set the check-for-apache-bug flag if supplied-type is exactly equal to one of the values in the following table:

         • `text/plain^lX
         • `text/plain; charset=ISO-8859-1^lX
         • `text/plain; charset=iso-8859-1^lX
         • `text/plain; charset=UTF-8^lX

         …ならば ⇒ %資源 の`~Apache~bugを検査するか$ ~SET ~T

         ◎ Bytes in Hexadecimal Bytes in ASCII ◎ 74 65 78 74 2F 70 6C 61 69 6E text/plain ◎ 74 65 78 74 2F 70 6C 61 69 6E 3B 20 63 68 61 72 73 65 74 3D 49 53 4F 2D 38 38 35 39 2D 31 text/plain; charset=ISO-8859-1 ◎ 74 65 78 74 2F 70 6C 61 69 6E 3B 20 63 68 61 72 73 65 74 3D 69 73 6F 2D 38 38 35 39 2D 31 text/plain; charset=iso-8859-1 ◎ 74 65 78 74 2F 70 6C 61 69 6E 3B 20 63 68 61 72 73 65 74 3D 55 54 46 2D 38 text/plain; charset=UTF-8

         注記： `給された~MIME型を検出する~algo$は、 これらに正確に一致する`~byte列$を検出する — 一部の古い~Apacheには ~bugがあり、 `~MIME型$を認識できない~fileを~serveするときに、 これらいずれかの `Content-Type$h ~headerを給するので。 ◎ The supplied MIME type detection algorithm detects these exact byte sequences because some older installations of Apache contain a bug that causes them to supply one of these Content-Type headers when serving files with unrecognized MIME types.

   `HTTP-SEMANTICS$r ◎ [HTTP-SEMANTICS]

3. ~IF［ %資源 は ~file~systemから直に検索取得された ］ ⇒ %給された型 ~SET ~file~systemにより供される`~MIME型$ ◎ If the resource is retrieved directly from the file system, set supplied-type to the MIME type provided by the file system.
4. ~IF［ %資源 は 別の~protocol（~FTP `FTP$r など）を介して検索取得された ］~AND［ その~protocolにより決定される`~MIME型$ %型 はある ］ ⇒ %給された型 ~SET %型 ◎ If the resource is retrieved via another protocol (such as FTP), set supplied-type to the MIME type as determined by that protocol, if any. [FTP]
5. ~IF［ %給された型 は`~MIME型$でない ］ ⇒ ~RET ε （“未定義”） ◎ If supplied-type is not a MIME type, the supplied MIME type is undefined. ◎ Abort these steps.
6. ~RET %給された型 ◎ The supplied MIME type is supplied-type.

`資源~headerを読取る@ ~algoは 所与の ( `資源$ %資源 ) に対し： ◎ To read the resource header, perform the following steps:

1. %~buffer ~LET 空な`~byte列$ ◎ Let buffer be a byte sequence.

2. ~OR↓ が満たされるまで、 %資源 を成す`~byte列$を %~buffer の中へ読取る： ◎ Read bytes of the resource into buffer until one of the following conditions is met:

   • %資源 の終端まで達した ◎ the end of the resource is reached.
   • %~buffer の`長さ$byte ~GTE 1445 ◎ the number of bytes in buffer is greater than or equal to 1445.
   • ~UAにより決定される適度な量の時間が経過した ◎ a reasonable amount of time has elapsed, as determined by the user agent.

   注記： ［ %~buffer の`長さ$byte ~GTE 1445 ］の場合、 `~MIME型を~sniffする~algo$は，大方の事例において決定的になる。 しかしながら，ある種の要因（低速な接続など）により、 ~UAは適度な量の時間~内に 1445 `~byte$を読取れないこともある。 ◎ If the number of bytes in buffer is greater than or equal to 1445, the MIME type sniffing algorithm will be deterministic for the majority of cases. ◎ However, certain factors (such as a slow connection) may prevent the user agent from reading 1445 bytes in a reasonable amount of time.

3. ~RET %~buffer ◎ The resource header is buffer.

注記： `資源~header$を決定する必要があるのは、 `資源$ごとに一回に限られる。 ◎ The resource header need only be determined once per resource.

`画像~型~pattern照合~algo@ は、［ 所与の`~byte列$が`画像~MIME型$を成す どの`~byte~pattern$に合致するか ］を決定するときに利用される — それは、 所与の ( `~byte列$ %入力 ) に対し： ◎ To determine which image MIME type byte pattern a byte sequence input matches, if any, use the following image type pattern matching algorithm:

1. 下に与える表tを成す ~EACH( ~row %~row ) に対し，挙げられた順に： ◎ Execute the following steps for each row row in the following table:

   1. %~patternに合致したか ~LET `~pattern照合~algo$( %入力, %~row を成す 1, 2, 3 列目の値 ) ◎ Let patternMatched be the result of the pattern matching algorithm given input, the value in the first column of row, the value in the second column of row, and the value in the third column of row.
   2. ~IF［ %~patternに合致したか ~EQ ~T ］ ⇒ ~RET %~row を成す 4 列目の値 ◎ If patternMatched is true, return the value in the fourth column of row.

   `~byte~pattern$	`~pattern~mask$	無視される頭部`~byte$たち	`画像~MIME型$	注記
   `00 00 01 00^X	`FF FF FF FF^X	なし	`image/x-icon^mt	`Windows Icon^i 符丁 ◎ A Windows Icon signature.
   `00 00 02 00^X	`FF FF FF FF^X	なし	`image/x-icon^mt	`Windows Cursor^i 符丁 ◎ A Windows Cursor signature.
   `42 4D^X	`FF FF^X	なし	`image/bmp^mt	`BMP^i 符丁を表す， `BM^l ◎ The string "BM", a BMP signature.
   `47 49 46 38 37 61^X	`FF FF FF FF FF FF^X	なし	`image/gif^mt	`GIF^i 符丁を表す， `GIF87a^bl ◎ The string "GIF87a", a GIF signature.
   `47 49 46 38 39 61^X	`FF FF FF FF FF FF^X	なし	`image/gif^mt	`GIF^i 符丁を表す， `GIF89a^bl ◎ The string "GIF89a", a GIF signature.
   `52 49 46 46 00 00 00 00 57 45 42 50 56 50^X	`FF FF FF FF 00 00 00 00 FF FF FF FF FF FF^X	なし	`image/webp^mt	次の連結 ⇒＃ `RIFF^bl, 4 個の`~byte$, `WEBPVP^bl ◎ The string "RIFF" followed by four bytes followed by the string "WEBPVP".
   `89 50 4E 47 0D 0A 1A 0A^X	`FF FF FF FF FF FF FF FF^X	なし	`image/png^mt	`PNG^i 符丁を表す，次の連結 ⇒＃ 1 個の~error検査-用`~byte$, `PNG^bl, `CR^smb, `LF^smb, `SUB^smb, `LF^smb ◎ An error-checking byte followed by the string "PNG" followed by CR LF SUB LF, the PNG signature.
   `FF D8 FF^X	`FF FF FF^X	なし	`image/jpeg^mt	次の連結 ⇒＃ `JPEG Start of Image^i ~marker, 別の~markerの指示子を成す 1 個の`~byte$ ◎ The JPEG Start of Image marker followed by the indicator byte of another marker.

2. ~RET ε （“未定義”） ◎ Return undefined.

`音声動画~型~pattern照合~algo@ は、［ 所与の`~byte列$が`音声動画~MIME型$を成す どの`~byte~pattern$に合致するか ］を決定するときに利用される — それは、 所与の ( `~byte列$ %入力 ) に対し： ◎ To determine which audio or video MIME type byte pattern a byte sequence input matches, if any, use the following audio or video type pattern matching algorithm:

1. 下に与える表tを成す ~EACH( ~row %~row ) に対し，挙げられた順に： ◎ Execute the following steps for each row row in the following table:

   1. %~patternに合致したか ~LET `~pattern照合~algo$( %入力, %~row を成す 1, 2, 3 列目の値 ) ◎ Let patternMatched be the result of the pattern matching algorithm given input, the value in the first column of row, the value in the second column of row, and the value in the third column of row.
   2. ~IF［ %~patternに合致したか ~EQ ~T ］ ⇒ ~RET %~row を成す 4 列目の値 ◎ If patternMatched is true, return the value in the fourth column of row.

   `~byte~pattern$	`~pattern~mask$	無視される頭部`~byte$	`音声動画~MIME型$	注記
   `46 4F 52 4D 00 00 00 00 41 49 46 46^X	`FF FF FF FF 00 00 00 00 FF FF FF FF^X	なし	`audio/aiff^mt	`AIFF^i 符丁を表す，次の連結 ⇒＃ `FORM^bl 4 個の`~byte$, `AIFF^bl ◎ The string "FORM" followed by four bytes followed by the string "AIFF", the AIFF signature.
   `49 44 33^X	`FF FF FF^X	なし	`audio/mpeg^mt	`ID3v2-tagged MP3^i 符丁を表す， `ID3^bl ◎ The string "ID3", the ID3v2-tagged MP3 signature.
   `4F 67 67 53 00^X	`FF FF FF FF FF^X	なし	`application/ogg^mt	`Ogg container^i 符丁を表す，次の連結 ⇒＃ `OggS^bl, `NUL^smb ◎ The string "OggS" followed by NUL, the Ogg container signature.
   `4D 54 68 64 00 00 00 06^X	`FF FF FF FF FF FF FF FF^X	なし	`audio/midi^mt	`MIDI^i 符丁を表す，次の連結 ⇒＃ `MThd^bl, 32 ~bit（~big-endian）で数 6 を表現している 4 個の`~byte$ ◎ The string "MThd" followed by four bytes representing the number 6 in 32 bits (big-endian), the MIDI signature.
   `52 49 46 46 00 00 00 00 41 56 49 20^X	`FF FF FF FF 00 00 00 00 FF FF FF FF^X	なし	`video/avi^mt	`AVI^i 符丁を表す，次の連結 ⇒＃ `RIFF^bl, 4 個の`~byte$, `AVI ^bl ◎ The string "RIFF" followed by four bytes followed by the string "AVI ", the AVI signature.
   `52 49 46 46 00 00 00 00 57 41 56 45^X	`FF FF FF FF 00 00 00 00 FF FF FF FF^X	なし	`audio/wave^mt	`WAVE^i 符丁を表す，次の連結 ⇒＃ `RIFF^bl, 4 個の`~byte$, `WAVE^bl ◎ The string "RIFF" followed by four bytes followed by the string "WAVE", the WAVE signature.

2. ~IF［ %入力 は`~MP4用の符丁に合致する$ ］ ⇒ ~RET `video/mp4^l ◎ If input matches the signature for MP4, return "video/mp4".
3. ~IF［ %入力 は`~WebM用の符丁に合致する$ ］ ⇒ ~RET `video/webm^l ◎ If input matches the signature for WebM, return "video/webm".
4. ~IF［ %入力 は`~ID3なしの~MP3用の符丁に合致する$ ］ ⇒ ~RET `audio/mpeg^l ◎ If input matches the signature for MP3 without ID3, return "audio/mpeg".
5. ~RET ε （“未定義”） ◎ Return undefined.

`~MP4用の符丁に合致する@ か否かを決定する~algoは、 所与の ( `~byte列$ %~byte列 ) に対し： ◎ To determine whether a byte sequence matches the signature for MP4, use the following steps: • Let sequence be the byte sequence to be matched, where sequence[s] is byte s in sequence and sequence[0] is the first byte in sequence.

1. %長さ ~LET %~byte列 の`長さ$byte ◎ Let length be the number of bytes in sequence.
2. ~IF［ %長さ ~LT 12 ］ ⇒ ~RET ~F ◎ If length is less than 12, return false.
3. %~box~size ~LET %~byte列[ 0 `+〜$ 4 ] を~big-endianによる無符号 32-bit 整数に解釈した結果 ◎ Let box-size be the four bytes from sequence[0] to sequence[3], interpreted as a 32-bit unsigned big-endian integer.
4. ~IF［ %長さ ~LT %~box~size ］~OR［ %~box~size ~MOD 4 ~NEQ 0 ］ ⇒ ~RET ~F ◎ If length is less than box-size or if box-size modulo 4 is not equal to 0, return false.
5. ~IF［ %~byte列[ 4 `+〜$ 4 ] ~NEQ `ftyp^lX ］ ⇒ ~RET ~F ◎ If the four bytes from sequence[4] to sequence[7] are not equal to 0x66 0x74 0x79 0x70 ("ftyp"), return false.
6. ~IF［ %~byte列[ 8 `+〜$ 3 ] ~EQ `mp4^lX ］ ⇒ ~RET ~T ◎ If the three bytes from sequence[8] to sequence[10] are equal to 0x6D 0x70 0x34 ("mp4"), return true.

7. %読取った~byte数 ~LET 16 ◎ Let bytes-read be 16.

   注記： これは、 “`major brand^en” を成す~version番号に対応する 4 個の `~byte$を無視する。 ◎ This ignores the four bytes that correspond to the version number of the "major brand".

8. ~WHILE［ %読取った~byte数 ~LT %~box~size ］： ◎ While bytes-read is less than box-size, continuously loop through these steps:

   1. ~IF［ %~byte列[ %読取った~byte数 `+〜$ 3 ] ~EQ `mp4^lX ］ ⇒ ~RET ~T ◎ If the three bytes from sequence[bytes-read] to sequence[bytes-read + 2] are equal to 0x6D 0x70 0x34 ("mp4"), return true.
   2. %読取った~byte数 ~INCBY 4 ◎ Increment bytes-read by 4.
9. ~RET ~F ◎ Return false.

`~WebM用の符丁に合致する@ か否かを決定する~algoは、 所与の ( `~byte列$ %~byte列 ) に対し： ◎ To determine whether a byte sequence matches the signature for WebM, use the following steps: • Let sequence be the byte sequence to be matched, where sequence[s] is byte s in sequence and sequence[0] is the first byte in sequence.

【 以下，この~algoを成す内容は、 未訳。 】

`~ID3なしの~MP3用の符丁に合致する@ か否かを決定する~algoは、 所与の ( `~byte列$ %~byte列 ) に対し： ◎ To determine whether a byte sequence matches the signature for MP3 without ID3, use the following steps: • Let sequence be the byte sequence to be matched, where sequence[s] is byte s in sequence and sequence[0] is the first byte in sequence.

【 以下，この~algoを成す内容は、 未訳。 】

`~font型~pattern照合~algo@ は、［ 所与の`~byte列$が`~font~MIME型$を成す どの`~byte~pattern$に合致するか ］を決定するときに利用される — それは、 所与の ( `~byte列$ %入力 ) に対し： ◎ To determine which font MIME type byte pattern a byte sequence input matches, if any, use the following font type pattern matching algorithm:

1. 下に与える表tを成す ~EACH( ~row %~row ) に対し，挙げられた順に： ◎ Execute the following steps for each row row in the following table:

   1. %~patternに合致したか ~LET `~pattern照合~algo$( %入力, %~row を成す 1, 2, 3 列目の値 ) ◎ Let patternMatched be the result of the pattern matching algorithm given input, the value in the first column of row, the value in the second column of row, and the value in the third column of row.
   2. ~IF［ %~patternに合致したか ~EQ ~T ］ ⇒ ~RET %~row を成す 4 列目の値 ◎ If patternMatched is true, return the value in the fourth column of row.

   `~byte~pattern$	`~pattern~mask$	無視される頭部`~byte$たち	`~font~MIME型$	注記
   `00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 4C 50^X	`00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FF FF^X	なし	`application/vnd.ms-fontobject^mt	`Embedded OpenType^i 符丁を表す，次の連結 ⇒＃ 34 個の`~byte$, `LP^bl ◎ 34 bytes followed by the string "LP", the Embedded OpenType signature.
   `00 01 00 00^X	`FF FF FF FF^X	なし	`font/ttf^mt	`TrueType^i 符丁を表す，~version番号 1.0 を表現している 4 個の`~byte$ ◎ 4 bytes representing the version number 1.0, a TrueType signature.
   `4F 54 54 4F^X	`FF FF FF FF^X	なし	`font/otf^mt	`OpenType^i 符丁を表す， `OTTO^bl ◎ The string "OTTO", the OpenType signature.
   `74 74 63 66^X	`FF FF FF FF^X	なし	`font/collection^mt	`TrueType Collection^i 符丁を表す， `ttcf^bl ◎ The string "ttcf", the TrueType Collection signature.
   `77 4F 46 46^X	`FF FF FF FF^X	なし	`font/woff^mt	`Web Open Font Format 1.0^i 符丁を表す， `wOFF^bl ◎ The string "wOFF", the Web Open Font Format 1.0 signature.
   `77 4F 46 32^X	`FF FF FF FF^X	なし	`font/woff2^mt	`Web Open Font Format 2.0^i 符丁を表す， `wOF2^bl ◎ The string "wOF2", the Web Open Font Format 2.0 signature.

2. ~RET ε （“未定義”） ◎ Return undefined.

`~archive型~pattern照合~algo@ は、［ 所与の`~byte列$が`~archive~MIME型$を成す どの`~byte~pattern$に合致するか ］を決定するときに利用される — それは、 所与の ( `~byte列$ %入力 ) に対し： ◎ To determine which archive MIME type byte pattern a byte sequence input matches, if any, use the following archive type pattern matching algorithm:

1. 下に与える表tを成す ~EACH( ~row %~row ) に対し，挙げられた順に： ◎ Execute the following steps for each row row in the following table:

   1. %~patternに合致したか ~LET `~pattern照合~algo$( %入力, %~row を成す 1, 2, 3 列目の値 ) ◎ Let patternMatched be the result of the pattern matching algorithm given input, the value in the first column of row, the value in the second column of row, and the value in the third column of row.
   2. ~IF［ %~patternに合致したか ~EQ ~T ］ ⇒ ~RET %~row を成す 4 列目の値 ◎ If patternMatched is true, return the value in the fourth column of row.

   `~byte~pattern$	`~pattern~mask$	無視される頭部`~byte$たち	`~archive~MIME型$	注記
   `1F 8B 08^X	`FF FF FF^X	なし	`application/x-gzip^mt	`GZIP^i ~archive符丁 ◎ The GZIP archive signature.
   `50 4B 03 04^X	`FF FF FF FF^X	なし	`application/zip^mt	`ZIP^i ~archive符丁を表す，次の連結 ⇒＃ `PK^bl, `ETX^smb, `EOT^smb ◎ The string "PK" followed by ETX EOT, the ZIP archive signature.
   `52 61 72 21 1A 07 00^X	`FF FF FF FF FF FF FF^X	なし	`application/x-rar-compressed^mt	`RAR 4.x^i ~archive符丁を表す，次の連結 ⇒＃ `Rar!^bl, `SUB^smb, `BEL^smb, `NUL^smb ◎ The string "Rar!" followed by SUB BEL NUL, the RAR 4.x archive signature.

2. ~RET ε （“未定義”） ◎ Return undefined.

`未知な~MIME型を識別する規則@ は、［ 未知な`~MIME型$を伴う`資源$に`算出される~MIME型$ ］を決定するときに利用される — それは、 所与の ( `資源~header$ %資源~header, 真偽値 `~script可否を~sniffするか@V ~DF ~F ) に対し，`~MIME型$を返す （ %~script可否を~sniffするか は、 `~script可能~MIME型$用に~sniffするかどうか決定するために利用される）： ◎ The sniff-scriptable flag is used by the rules for identifying an unknown MIME type to determine whether to sniff for scriptable MIME types. ◎ If the setting of the sniff-scriptable flag is not specified when calling the rules for identifying an unknown MIME type, the sniff-scriptable flag must default to unset. ◎ To determine the computed MIME type of a resource resource with an unknown MIME type, execute the following rules for identifying an unknown MIME type:

1. ~IF［ `~script可否を~sniffするか$V ~EQ ~T ］ ⇒ 下に与える表tを成す ~EACH( ~row %~row ) に対し，挙げられた順に： ◎ If the sniff-scriptable flag is set, execute the following steps for each row row in the following table:

   1. %~patternに合致したか ~LET `~pattern照合~algo$( %資源~header, %~row を成す 1, 2, 3 列目の値 ) ◎ Let patternMatched be the result of the pattern matching algorithm given resource’s resource header, the value in the first column of row, the value in the second column of row, and the value in the third column of row.
   2. ~IF［ %~patternに合致したか ~EQ ~T ］ ⇒ ~RET %~row を成す 4 列目の値 ◎ If patternMatched is true, return the value in the fourth column of row.

   `~byte~pattern$	`~pattern~mask$	無視される頭部`~byte$たち	`算出される~MIME型$	注記
   `3C 21 44 4F 43 54 59 50 45 20 48 54 4D 4C ~tagT^X	`FF FF DF DF DF DF DF DF DF FF DF DF DF DF FF^X	`空白~byte$	`text/html^mt	次の連結 ⇒＃ 大小無視 `<!DOCTYPE HTML^bl , `~tag-terminating~byte$ ◎ The case-insensitive string "<!DOCTYPE HTML" followed by a tag-terminating byte.
   `3C 48 54 4D 4C ~tagT^X	`FF DF DF DF DF FF^X	`空白~byte$	`text/html^mt	次の連結 ⇒＃ 大小無視 `<HTML^bl , `~tag-terminating~byte$ ◎ The case-insensitive string "<HTML" followed by a tag-terminating byte.
   `3C 48 45 41 44 ~tagT^X	`FF DF DF DF DF FF^X	`空白~byte$	`text/html^mt	次の連結 ⇒＃ 大小無視 `<HEAD^bl , `~tag-terminating~byte$ ◎ The case-insensitive string "<HEAD" followed by a tag-terminating byte.
   `3C 53 43 52 49 50 54 ~tagT^X	`FF DF DF DF DF DF DF FF^X	`空白~byte$	`text/html^mt	次の連結 ⇒＃ 大小無視 `<SCRIPT^bl, `~tag-terminating~byte$ ◎ The case-insensitive string "<SCRIPT" followed by a tag-terminating byte.
   `3C 49 46 52 41 4D 45 ~tagT^X	`FF DF DF DF DF DF DF FF^X	`空白~byte$	`text/html^mt	次の連結 ⇒＃ 大小無視 `<IFRAME^bl, `~tag-terminating~byte$ ◎ The case-insensitive string "<IFRAME" followed by a tag-terminating byte.
   `3C 48 31 ~tagT^X	`FF DF FF FF^X	`空白~byte$	`text/html^mt	次の連結 ⇒＃ 大小無視 `<H1^bl, `~tag-terminating~byte$ ◎ The case-insensitive string "<H1" followed by a tag-terminating byte.
   `3C 44 49 56 ~tagT^X	`FF DF DF DF FF^X	`空白~byte$	`text/html^mt	次の連結 ⇒＃ 大小無視 `<DIV^bl, `~tag-terminating~byte$ ◎ The case-insensitive string "<DIV" followed by a tag-terminating byte.
   `3C 46 4F 4E 54 ~tagT^X	`FF DF DF DF DF FF^X	`空白~byte$	`text/html^mt	次の連結 ⇒＃ 大小無視 `<FONT^bl, `~tag-terminating~byte$ ◎ The case-insensitive string "<FONT" followed by a tag-terminating byte.
   `3C 54 41 42 4C 45 ~tagT^X	`FF DF DF DF DF DF FF^X	`空白~byte$	`text/html^mt	次の連結 ⇒＃ 大小無視 `<TABLE^bl, `~tag-terminating~byte$ ◎ The case-insensitive string "<TABLE" followed by a tag-terminating byte.
   `3C 41 ~tagT^X	`FF DF FF^X	`空白~byte$	`text/html^mt	次の連結 ⇒＃ 大小無視 `<A^bl, `~tag-terminating~byte$ ◎ The case-insensitive string "<A" followed by a tag-terminating byte.
   `3C 53 54 59 4C 45 ~tagT^X	`FF DF DF DF DF DF FF^X	`空白~byte$	`text/html^mt	次の連結 ⇒＃ 大小無視 `<STYLE^bl, `~tag-terminating~byte$ ◎ The case-insensitive string "<STYLE" followed by a tag-terminating byte.
   `3C 54 49 54 4C 45 ~tagT^X	`FF DF DF DF DF DF FF^X	`空白~byte$	`text/html^mt	次の連結 ⇒＃ 大小無視 `<TITLE^bl, `~tag-terminating~byte$ ◎ The case-insensitive string "<TITLE" followed by a tag-terminating byte.
   `3C 42 ~tagT^X	`FF DF FF^X	`空白~byte$	`text/html^mt	次の連結 ⇒＃ 大小無視 `<B^bl, `~tag-terminating~byte$ ◎ The case-insensitive string "<B" followed by a tag-terminating byte.
   `3C 42 4F 44 59 ~tagT^X	`FF DF DF DF DF FF^X	`空白~byte$	`text/html^mt	次の連結 ⇒＃ 大小無視 `<BODY^bl, `~tag-terminating~byte$ ◎ The case-insensitive string "<BODY" followed by a tag-terminating byte.
   `3C 42 52 ~tagT^X	`FF DF DF FF^X	`空白~byte$	`text/html^mt	次の連結 ⇒＃ 大小無視 `<BR^bl, `~tag-terminating~byte$ ◎ The case-insensitive string "<BR" followed by a tag-terminating byte.
   `3C 50 ~tagT^X	`FF DF FF^X	`空白~byte$	`text/html^mt	次の連結 ⇒＃ 大小無視 `<P^bl, `~tag-terminating~byte$ ◎ The case-insensitive string "<P" followed by a tag-terminating byte.
   `3C 21 2D 2D ~tagT^X	`FF FF FF FF FF^X	`空白~byte$	`text/html^mt	次の連結 ⇒＃ `<!--^bl, `~tag-terminating~byte$ ◎ The string "<!--" followed by a tag-terminating byte.
   `3C 3F 78 6D 6C^X	`FF FF FF FF FF^X	`空白~byte$	`text/xml^mt	`<?xml^bl ◎ The string "<?xml".
   `25 50 44 46 2D^X	`FF FF FF FF FF^X	なし	`application/pdf^mt	`PDF^i 符丁を表す， `%PDF-^bl ◎ The string "%PDF-", the PDF signature.

2. 下に与える表tを成す ~EACH( ~row %~row ) に対し，挙げられた順に： ◎ Execute the following steps for each row row in the following table:

   1. %~patternに合致したか ~LET `~pattern照合~algo$( %資源~header, %~row を成す 1, 2, 3 列目の値 ) ◎ Let patternMatched be the result of the pattern matching algorithm given resource’s resource header, the value in the first column of row, the value in the second column of row, and the value in the third column of row.
   2. ~IF［ %~patternに合致したか ~EQ ~T ］ ⇒ ~RET %~row を成す 4 列目の値 ◎ If patternMatched is true, return the value in the fourth column of row.

   `~byte~pattern$	`~pattern~mask$	無視される頭部`~byte$たち	`算出される~MIME型$	注記
   `25 21 50 53 2D 41 64 6F 62 65 2D^X	`FF FF FF FF FF FF FF FF FF FF FF^X	なし	`application/postscript^mt	`PostScript^i 符丁を表す， `%!PS-Adobe-^bl ◎ The string "%!PS-Adobe-", the PostScript signature.
   `FE FF 00 00^X	`FF FF 00 00^X	なし	`text/plain^mt	~UTF-16BE~BOM ◎ UTF-16BE BOM
   `FF FE 00 00^X	`FF FF 00 00^X	なし	`text/plain^mt	~UTF-16LE~BOM ◎ UTF-16LE BOM
   `EF BB BF 00^X	`FF FF FF 00^X	なし	`text/plain^mt	~UTF-8~BOM ◎ UTF-8 BOM

   ~UAは、 追加的な`~MIME型$を~supportするためとして，この表tを暗黙的に拡張してもヨイ。 ◎ User agents may implicitly extend this table to support additional MIME types.

   しかしながら，~UAは、［ この表t内にすでに在る，`算出される~MIME型$ ］用に追加的な`~byte~pattern$を含ませて，この表tを暗黙的に拡張するベキでない — そうすると、 特権拡大の脆弱性が導入されかねないので。 ◎ However, user agents should not implicitly extend this table to include additional byte patterns for any computed MIME type already present in this table, as doing so could introduce privilege escalation vulnerabilities.

   ~UAは、 この表tを拡張するときには，いかなる特権拡大の脆弱性も導入してはナラナイ。 ◎ User agents must not introduce any privilege escalation vulnerabilities when extending this table.

3. %合致した型 ~LET `画像~型~pattern照合~algo$( %資源~header ) ◎ Let matchedType be the result of executing the image type pattern matching algorithm given resource’s resource header.
4. ~IF［ %合致した型 ~NEQ ε ］ ⇒ ~RET %合致した型 ◎ If matchedType is not undefined, return matchedType.
5. %合致した型 ~SET `音声動画~型~pattern照合~algo$( %資源~header ) ◎ Set matchedType to the result of executing the audio or video type pattern matching algorithm given resource’s resource header.
6. ~IF［ %合致した型 ~NEQ ε ］ ⇒ ~RET %合致した型 ◎ If matchedType is not undefined, return matchedType.
7. %合致した型 ~SET `~archive型~pattern照合~algo$( %資源~header ) ◎ Set matchedType to the result of executing the archive type pattern matching algorithm given resource’s resource header.
8. ~IF［ %合致した型 ~NEQ ε ］ ⇒ ~RET %合致した型 ◎ If matchedType is not undefined, return matchedType.
9. ~IF［ %資源~header を成すどの~byteも`~binary~data~byte$でない ］ ⇒ ~RET `text/plain^l ◎ If resource’s resource header contains no binary data bytes, return "text/plain".
10. ~RET `application/octet-stream^l ◎ Return "application/octet-stream".

`資源は~textか~binaryかを判別する規則@ は、［ 所与の~binary`資源$が素な~textとして誤labelされたかどうか ］を決定するときに利用される — それは、 所与の ( `~byte列$ %資源~header ) に対し，`~MIME型$を返す： ◎ To determine whether a binary resource has been mislabeled as plain text, execute the following rules for distinguishing if a resource is text or binary: • Let length be the number of bytes in the resource header.

1. ~RET［ ~OR↓ が満たされるならば `text/plain^l ／ ~ELSE_ `application/octet-stream^l ］： ◎ ↓

   • %資源~header[ 0 `+〜$ 2 ] ~IN { `FE FF^X （ ~UTF-16BE~BOM）, `FF FE^X （ ~UTF-16LE~BOM ） } ◎ If length is greater than or equal to 2 and the first 2 bytes of the resource header are equal to 0xFE 0xFF (UTF-16BE BOM) or 0xFF 0xFE (UTF-16LE BOM), the computed MIME type is "text/plain". • Abort these steps.
   • %資源~header[ 0 `+〜$ 3 ] ~EQ `EF BB BF^X （ ~UTF-8~BOM ） ◎ If length is greater than or equal to 3 and the first 3 bytes of the resource header are equal to 0xEF 0xBB 0xBF (UTF-8 BOM), the computed MIME type is "text/plain". • Abort these steps.
   • %資源~header を成すどの~byteも`~binary~data~byte$でない ◎ If the resource header contains no binary data bytes, the computed MIME type is "text/plain". • Abort these steps. ◎ The computed MIME type is "application/octet-stream".

   `資源は~textか~binaryかを判別する規則$は、 決して［ `算出される~MIME型$は，`~script可能~MIME型$であるものと決定しない ］ことが必要不可欠である — そうすることは、 特権拡大~攻撃を許容することになり得るので。 ◎ It is critical that the rules for distinguishing if a resource is text or binary never determine the computed MIME type to be a scriptable MIME type, as this could allow a privilege escalation attack.

`画像を特定的に~sniffするための規則@ は、［ `画像~MIME型$を伴う`資源$に`算出される~MIME型$ ］を決定するときに利用される — それは、 `~MIME型$を返す： ◎ To determine the computed MIME type of a resource with an image MIME type, execute the following rules for sniffing images specifically:

1. ~IF［ `給された~MIME型$は`~XML~MIME型$である ］ ⇒ ~RET `給された~MIME型$ ◎ If the supplied MIME type is an XML MIME type, the computed MIME type is the supplied MIME type. ◎ Abort these steps.
2. %合致した画像~型 ~LET `画像~型~pattern照合~algo$( `資源~header$ ) ◎ Let image-type-matched be the result of executing the image type pattern matching algorithm with the resource header as the byte sequence to be matched.
3. ~IF［ %合致した画像~型 ~NEQ ε ］ ⇒ ~RET %合致した画像~型 ◎ If image-type-matched is not undefined, the computed MIME type is image-type-matched. ◎ Abort these steps.
4. ~RET `給された~MIME型$ ◎ The computed MIME type is the supplied MIME type.

`音声や動画を特定的に~sniffするための規則@ は、［ `音声動画~MIME型$を伴う`資源$に`算出される~MIME型$ ］を決定するときに利用され，`~MIME型$を返す： ◎ To determine the computed MIME type of a resource with an audio or video MIME type, execute the following rules for sniffing audio and video specifically:

1. ~IF［ `給された~MIME型$は`~XML~MIME型$である ］ ⇒ ~RET `給された~MIME型$ ◎ If the supplied MIME type is an XML MIME type, the computed MIME type is the supplied MIME type. ◎ Abort these steps.
2. %合致した音声動画~型 ~LET `音声動画~型~pattern照合~algo$( `資源~header$ ) ◎ Let audio-or-video-type-matched be the result of executing the audio or video type pattern matching algorithm with the resource header as the byte sequence to be matched.
3. ~IF［ %合致した音声動画~型 ~NEQ ε ］ ⇒ ~RET %合致した音声動画~型 ◎ If audio-or-video-type-matched is not undefined, the computed MIME type is audio-or-video-type-matched. ◎ Abort these steps.
4. ~RET `給された~MIME型$ ◎ The computed MIME type is the supplied MIME type.

`~plugin文脈~内で~sniffするための規則@ は、 ~plugin文脈~内で，［ `~fetch$された`資源$に`算出される~MIME型$ ］を決定するときに利用され，`~MIME型$を返す： ◎ To determine the computed MIME type of a resource fetched in a plugin context, execute the following rules for sniffing in a plugin context:

1. ~IF［ `給された~MIME型$ ~EQ ε ］ ⇒ ~RET `application/octet-stream^l ◎ If the supplied MIME type is undefined, the computed MIME type is "application/octet-stream".
2. ~RET `給された~MIME型$ ◎ The computed MIME type is the supplied MIME type.

`~style文脈~内で~sniffするための規則@ は、 ~style文脈~内で，［ `~fetch$された`資源$に`算出される~MIME型$ ］を決定するときに利用され，`~MIME型$を返す： ◎ To determine the computed MIME type of a resource fetched in a style context, execute the following rules for sniffing in a style context:

1. ~IF［ `給された~MIME型$ ~EQ ε ］ ⇒ … ◎ If the supplied MIME type is undefined, ….
2. ~RET `給された~MIME型$ ◎ The computed MIME type is the supplied MIME type.

`~script文脈~内で~sniffするための規則@ は、 ~script文脈~内で，［ `~fetch$された`資源$に`算出される~MIME型$ ］を決定するときに利用され，`~MIME型$を返す： ◎ To determine the computed MIME type of a resource fetched in a script context, execute the following rules for sniffing in a script context:

1. ~IF［ `給された~MIME型$ ~EQ ε ］ ⇒ … ◎ If the supplied MIME type is undefined, ….
2. ~RET `給された~MIME型$ ◎ The computed MIME type is the supplied MIME type.

`~fontを特定的に~sniffするための規則@ は、［ `~font~MIME型$を伴う`資源$に`算出される~MIME型$ ］を決定するときに利用され，`~MIME型$を返す： ◎ To determine the computed MIME type of a resource with a font MIME type, execute the following rules for sniffing fonts specifically:

1. ~IF［ `給された~MIME型$は`~XML~MIME型$である ］ ⇒ ~RET `給された~MIME型$ ◎ If the supplied MIME type is an XML MIME type, the computed MIME type is the supplied MIME type. ◎ Abort these steps.
2. %合致した~font型 ~LET `~font型~pattern照合~algo$( `資源~header$ ) ◎ Let font-type-matched be the result of executing the font type pattern matching algorithm with the resource header as the byte sequence to be matched.
3. ~IF［ %合致した~font型 ~NEQ ε ］ ⇒ ~RET %合致した~font型 ◎ If font-type-matched is not undefined, the computed MIME type is font-type-matched. ◎ Abort these steps.
4. ~RET `給された~MIME型$ ◎ The computed MIME type is the supplied MIME type.