CSS Font Loading Module Level 3

【この訳に固有の表記規約】

この訳の，~algoや定義の記述に利用されている各種記号（ ~LET, 此れ, ~IF, ~THROW, 等々）の意味や定義の詳細は，~SYMBOL_DEF_REFを~~参照されたし。

語 `~promise@ は、 `Promise$I ~obj（次~節）の略記である。

“~obj %O に対する %O . `someSlot^sl という表記は、 “%O の `someSlot^sl 内部~slot” の略記である。

原文に利用されている HTML 用語は W3C 版 HTML を参照しているが、ここでは WHATWG HTML を参照するように置換している。

1.1. 値

この仕様は、 ECMAScript 6 に定義される `Promise$I を利用する。 HTML5Rocks にて，格好の `Promise^I の入門的な紹介 （ 日本語訳 ）を読める。 ◎ This specification uses Promises, which are defined in ECMAScript 6. HTML5Rocks has some good tutorial material introducing Promises.

1.2. ~task源

この仕様において，`~taskを~queueする$ときに利用する`~task源$は、 "font loading" ~task源である。 ◎ Whenever this specification queues a task, it queues it onto the "font loading" task source.

2.1. 構築子

`FontFace(family, source, descriptors )@m ~methodの被~call時には、次の手続きを実行する： ◎ When the FontFace(family, source, descriptors) method is called, execute these steps:

1. %~font~face ~LET 新たな `FontFace$I ~obj
2. %~font~face の `status$m 属性 ~SET `unloaded^l
3. %状態s~promise ~LET `新たな~promise$
4. %~font~face . `FontStatusPromise$sl ~SET %状態s~promise ◎ Let font face be a fresh FontFace object. Set font face’s status attribute to "unloaded", Set its internal [[FontStatusPromise]] slot to a fresh pending Promise object.

5. 各~引数を`文法に則って構文解析する$：

   1. • %family を構文解析する
      • %descriptors の各 `FontFaceDescriptors$I ~memberは， `font-face$at 規則の対応する記述子の文法に則って構文解析する。
      • %source 引数は，それが `CSSOMString$I ならば， `font-face$at 規則の `src^d 記述子の文法に則って構文解析する。
      ◎ Parse the family argument, and the members of the descriptors argument, according to the grammars of the corresponding descriptors of the CSS @font-face rule. If the source argument is a CSSOMString, parse it according to the grammar of the CSS src descriptor of the @font-face rule.＼

   2. ~IF［ 前~段のいずれかの構文解析-に失敗した ］：

      1. `SyntaxError^E 例外で %状態s~promise を`却下する$
      2. %~font~face の対応している各種~属性 ~SET 空~文字列
      3. %~font~face の `status$m 属性 ~SET `error^l
      ◎ If any of them fail to parse correctly, reject font face’s [[FontStatusPromise]] with a DOMException named "SyntaxError", set font face’s corresponding attributes to the empty string, and set font face’s status attribute to "error".＼
   3. ~ELSE ⇒ %~font~face の対応する各種~属性 ~SET 構文解析された結果の各~値を直列化した結果 ◎ Otherwise, set font face’s corresponding attributes to the serialization of the parsed values.

   注記： %source 引数に `http://example.com/myFont.woff^l の様な裸の~urlを渡しても働かないことになる — 少なくとも， `url(http://example.com/myFont.woff)^l の様に `url()$css 関数で包装する必要がある。 この不便さの引き換えに，次が可能になる：

   • 複数の~fallback~fontを指定する。
   • 各~fallback~fontに対し，その型を指定する。
   • 局所~fontを容易に参照する。

   ◎ Note: Note that this means that passing a naked url as the source argument, like "http://example.com/myFont.woff", won’t work - it needs to be at least wrapped in a url() function, like "url(http://example.com/myFont.woff)". In return for this inconvenience, you get to specify multiple fallbacks, specify the type of font each fallback is, and refer to local fonts easily.

   基底~urlを定義して、相対~urlを解決できるようにする必要がある。 文書の~urlにするべきか？ ~workerについてもそうするのが正しいのか？ あるいは~worker~urlを利用すべきか？ それは常に定義されているのか？ ◎ Need to define the base url, so relative urls can resolve. Should it be the url of the document? Is that correct for workers too, or should they use their worker url? Is that always defined?

6. ~RET %~font~face — ただし，以降の手続きも並列的に続行する： ◎ Return font face.＼
7. ~IF［ %~font~face の `status$m ~EQ `error^l ］ ⇒ ~RET ◎ If font face’s status is "error", terminate this algorithm; otherwise, complete the rest of these steps asynchronously.
8. ~IF［ %source は `CSSOMString$I である ］ ⇒ %~font~face . `Urls$sl ~SET %source ◎ If the source argument was a CSSOMString, set font face’s internal [[Urls]] slot to the string.
9. ~ELSE（ %source は `BinaryData$I である） ⇒ %~font~face . `Data$sl ~SET %source ◎ If the source argument was a BinaryData, set font face’s internal [[Data]] slot to the passed argument.
10. %~data ~LET %~font~face . `Data$sl ◎ ↓
11. ~IF［ %~data ~EQ ~NULL ］ ⇒ ~RET ◎ If font face’s [[Data]] slot is not null,＼

12. 次を走らす`~taskを~queueする$： ◎ queue a task to run the following steps synchronously:

    1. %~font~face の `status$m 属性 ~SET `loading^l ◎ Set font face’s status attribute to "loading".

    2. %~font~face を`含む$ような ~EACH ( `FontFaceSet$I ~obj %~face~set ) に対し： ◎ For each FontFaceSet font face is in:

       1. ~IF［ %~face~set . `LoadingFonts$sl は空である ］ ⇒ `~loadingに切替える$( %~face~set ) ◎ If the FontFaceSet’s [[LoadingFonts]] list is empty, switch the FontFaceSet to loading.
       2. %~face~set . `LoadingFonts$sl に %~font~face を付加する ◎ Append font face to the FontFaceSet’s [[LoadingFonts]] list.

13. %~data を~fontとして構文解析するよう試みる — 完了した時点で，次を走らす`~taskを~queueする$： ◎ Asynchronously, attempt to parse the data in it as a font. When this is completed, successfully or not, queue a task to run the following steps synchronously:

    1. ~IF［ 構文解析に成功した（ %~font~face は今や構文解析された~fontを表現する ） ］： ◎ If the load was successful, font face now represents the parsed font;＼

       1. %~font~face で %状態s~promise を`解決する$ 【この段は次の段より後にするべき？（下の “却下-” も同様）】 ◎ fulfill font face’s [[FontStatusPromise]] with font face,＼
       2. %~font~face の `status$m 属性 ~SET `loaded^l ◎ and set its status attribute to "loaded".

       3. %~font~face を`含む$ような ~EACH ( `FontFaceSet$I ~obj %~face~set ) に対し： ◎ For each FontFaceSet font face is in:

          1. %~face~set . `LoadedFonts$sl に %~font~face を追加する ◎ Add font face to the FontFaceSet’s [[LoadedFonts]] list.
          2. %~face~set . `LoadingFonts$sl から %~font~face を除去する ◎ Remove font face from the FontFaceSet’s [[LoadingFonts]] list.＼
          3. ~IF［ %~face~set . `LoadingFonts$sl は空である ］ ⇒ `~load済みに切替える$( %~face~set ) ◎ If font was the last item in that list (and so the list is now empty), switch the FontFaceSet to loaded.

    2. ~ELSE（構文解析に失敗した）： ◎ Otherwise,＼

       1. `SyntaxError^E 例外で %状態s~promise を`却下する$ ◎ reject font face’s [[FontStatusPromise]] with a DOMException named "SyntaxError" and＼
       2. %~font~face の `status$m 属性 ~SET `error^l ◎ set font face’s status attribute to "error".

       3. %~font~face を`含む$ような ~EACH ( `FontFaceSet$I ~obj %~face~set ) に対し： ◎ For each FontFaceSet font face is in:

          1. %~face~set . `FailedFonts$sl に %~font~face を追加する ◎ Add font face to the FontFaceSet’s [[FailedFonts]] list.
          2. %~face~set . `LoadingFonts$sl から %~font~face を除去する ◎ Remove font face from the FontFaceSet’s [[LoadingFonts]] list.＼
          3. ~IF［ %~face~set . `LoadingFonts$sl は空である ］ ⇒ `~load済みに切替える$( %~face~set ) ◎ If font was the last item in that list (and so the list is now empty), switch the FontFaceSet to loaded.

注記： 新たに構築された `FontFace^I ~objは、当の［ 文書 ／ ~worker~thread ］に対する文脈に結付けられている `FontFaceSet^I 【`~font~source$】 に自動的に追加されることはない。 このことは、新たに構築された~fontは~preloadされ得るが、それを実際に利用できるのは， `FontFaceSet^I に明示的に追加された後になることを意味する。 `FontFaceSet^I についてのより完全な記述は、以降の節を見よ。 ◎ Note: Newly constructed FontFace objects are not automatically added to the FontFaceSet associated with a document or a context for a worker thread. This means that while newly constructed fonts can be preloaded, they cannot actually be used until they are explicitly added to a FontFaceSet. See the following section for a more complete description of FontFaceSet.

2.2. `load()^m ~method

`FontFace$I の `load()$m ~methodは、~urlに基づく~font~faceに対し，その~font~dataを要請して~loadするよう強制する。 ~binary~dataから構築された~fontや［ ~load中にある／~load済みの ］~fontに対しては何もしない。 ◎ The load() method of FontFace forces a url-based font face to request its font data and load. For fonts constructed from binary data, or fonts that are already loading or loaded, it does nothing.

`load()@m ~methodの被~call時には、次の手続きを実行する： ◎ When the load() method is called, execute these steps:

1. %状態s~promise ~LET 此れ . `FontStatusPromise$sl ◎ ↓
2. ~IF［ 此れ . `Urls$sl ~EQ ~NULL ］~OR［ 此れの `status$m 属性 ~NEQ `unloaded^l ］ ⇒ ~RET %状態s~promise ◎ Let font face be the FontFace object on which this method was called. ◎ If font face’s [[Urls]] slot is null, or its status attribute is anything other than "unloaded", return font face’s [[FontStatusPromise]] and abort these steps.
3. 此れの `status$m 属性 ~SET `loading^l ◎ Otherwise, set font face’s status attribute to "loading",＼
4. ~RET %状態s~promise — ただし，以降の手続きも並列的に続行する： ◎ return font face’s [[FontStatusPromise]], and continue executing the rest of this algorithm asynchronously.
5. 此れの `Urls$sl ~slotの値を利用して、［ それが `font-face$at 規則の `src$d 記述子の値であった ］かのように，［ `CSS-FONTS-3$r による定義に従って~fontを~loadする ］ことを試みる ◎ Using the value of font face’s [[Urls]] slot, attempt to load a font as defined in [CSS-FONTS-3], as if it was the value of a @font-face rule’s src descriptor.

6. ~load演算の完了-時には、次を走らす`~taskを~queueする$： ◎ When the load operation completes, successfully or not, queue a task to run the following steps synchronously:

   1. ~IF［ ~loadする試みは失敗した ］： ◎ If the attempt to load fails,＼

      1. `NetworkError^E 例外で %状態s~promise を`却下する$ 【この段は次の段より後にするべき？（下の “解決-” も同様）】 ◎ reject font face’s [[FontStatusPromise]] with a DOMException whose name is "NetworkError" and＼
      2. 此れの `status$m 属性 ~SET `error^l ◎ set font face’s status attribute to "error".

      3. 此れを`含む$ような ~EACH ( `FontFaceSet$I ~obj %~face~set ) に対し： ◎ For each FontFaceSet font face is in:

         1. %~face~set . `FailedFonts$sl に此れを追加する ◎ Add font face to the FontFaceSet’s [[FailedFonts]] list.
         2. %~face~set . `LoadingFonts$sl から此れを除去する ◎ Remove font face from the FontFaceSet’s [[LoadingFonts]] list.＼
         3. ~IF［ %~face~set . `LoadingFonts$sl は空である ］ ⇒ `~load済みに切替える$( %~face~set ) ◎ If font was the last item in that list (and so the list is now empty), switch the FontFaceSet to loaded.

   2. ~ELSE（~loadは成功した — 此れは今や~load済みの~fontを表現する）： ◎ Otherwise, font face now represents the loaded font;＼

      1. 此れで %状態s~promise を`解決する$ ◎ fulfill font face’s [[FontStatusPromise]] with font face and＼
      2. 此れの `status$m 属性 ~SET `loaded^l ◎ set font face’s status attribute to "loaded".

      3. 此れを`含む$ような ~EACH ( `FontFaceSet$I ~obj %~face~set ) に対し： ◎ For each FontFaceSet font face is in:

         1. %~face~set . `LoadedFonts$sl に此れを追加する ◎ Add font face to the FontFaceSet’s [[LoadedFonts]] list.
         2. %~face~set . `LoadingFonts$sl から此れを除去する ◎ Remove font face from the FontFaceSet’s [[LoadingFonts]] list.＼
         3. ~IF［ %~face~set . `LoadingFonts$sl は空である ］ ⇒ `~load済みに切替える$( %~face~set ) ◎ If font was the last item in that list (and so the list is now empty), switch the FontFaceSet to loaded.

~UAは、所与の~font~faceが 頁~上の何かを描画するために必要とされることを決定したときに自前で~font~loadを起動できる。 これが起きたときは、ここに述べた対応する `FontFace$I の `load()$m ~methodが~callされたかのように動作し~MUST。 ◎ User agents can initiate font loads on their own, whenever they determine that a given font face is necessary to render something on the page. When this happens, they must act as if they had called the corresponding FontFace’s load() method described here.

注記： ~UAには、同じ生成元に属する頁~上にて，同じ~fontを重ねて~downloadするのを避けるため、 “~font~cache” を活用するものもある。 複数の `FontFace$I ~objが、その~font~cache内の同じ~entryに対応付けられ得る。 このことは、 `FontFace$I ~objを~loadし始める時機は，それが `FontFaceSet$I 内にない場合でも予期できないことを意味する — 同じ~font~dataを指している他の `FontFace$I ~objが，（おそらく，別の頁~上で）すでに~load済みかもしれないので。 ◎ Note: Some UAs utilize a "font cache" which avoids having to download the same font multiple times on a page or on multiple pages within the same origin. Multiple FontFace objects can be mapped to the same entry in the font cache, which means that a FontFace object might start loading unexpectedly, even if it’s not in a FontFaceSet, because some other FontFace object pointing to the same font data (perhaps on a different page entirely!) has been loaded.

2.3. `font-face^at 規則との相互作用

`font-face$at 規則は、対応する `FontFace$I ~objを自動的に定義する — それは、その規則が構文解析されたとき，自動的に，文書の`~font~source$内に置かれる。 そのような `FontFace$I ~objは `~CSSに接続されて@ いるといい、その規則を指して，~objの`接続-先$という。 ◎ A CSS @font-face rule automatically defines a corresponding FontFace object, which is automatically placed in the document’s font source when the rule is parsed. This FontFace object is CSS-connected.

`~CSSに接続されて$いる `FontFace$I ~objの［ `family$m, `style$m, `weight$m, `stretch$m, `unicodeRange$m, `variant$m, `featureSettings$m ］属性は、その`接続-先$規則~内の対応する記述子と同じ値に設定される。 この［ `font-face$at 規則, `FontFace$I ~obj ］の間には二方向の接続がある： 規則~内の各種~記述子に対する どのような変更も，~objの対応する属性に即時に反映され、その逆も同様になる。 ◎ The FontFace object corresponding to a @font-face rule has its family, style, weight, stretch, unicodeRange, variant, and featureSettings attributes set to the same value as the corresponding descriptors in the @font-face rule. There is a two-way connection between the two: any change made to a @font-face descriptor is immediately reflected in the corresponding FontFace attribute, and vice versa.

`FontFace^I ~objが 文書~間で転送されたときには、`~CSSに接続され$なくなる。 ◎ When a FontFace is transferred between documents, it’s no longer CSS-connected.

`FontFace$I ~objの `Urls$sl 内部~slotは、 `font-face$at 規則の `src$d 記述子の値に設定され， `src$d 記述子に加えられる変更を反映する。 ◎ The internal [[Urls]] slot of the FontFace object is set to the value of the @font-face rule’s src descriptor, and reflects any changes made to the src descriptor.

他の場合、 `font-face$at 規則により作成される `FontFace$I ~objは、手動で作成されたものと一致する。 【 “他の場合”とは？ この文は何を意味する？】 ◎ Otherwise, a FontFace object created by a CSS @font-face rule is identical to one created manually.

`~CSSに接続されて$いる `FontFace$I ~objは、次が生じたときには，その`接続-先$ %規則 への接続を絶って`~CSSに接続され$なくされ~MUST： ◎ ↓

• %規則 が文書から除去されたとき。 この接続は、どのような手段をもってしても~~回復できない（同じ `font-face$at 規則を再度~stylesheetに追加した場合、それを`接続-先$とする新たな `FontFace$I ~objが作成されることになる）。 ◎ If a @font-face rule is removed from the document, its corresponding FontFace object is no longer CSS-connected. The connection is not restorable by any means (but adding the @font-face back to the stylesheet will create a brand new FontFace object which is CSS-connected).
• %規則 の `src^d 記述子が新たな値に変更されたとき。 この場合、新たな `src^d を反映するような 新たな `FontFace$I ~objを作成した上で，その`接続-先$を %規則 にし~MUST。（また、`~font~source$においても，古い~objは除去して，新たな `FontFace$I ~objを追加することになる）。 ◎ If a @font-face rule has its src descriptor changed to a new value, the original connected FontFace object must stop being CSS-connected. A new FontFace reflecting its new src must be created and CSS-connected to the @font-face. (This will also remove the old and add the new FontFace objects from any font sources they appear in.)

3.1. 各種~event

`FontFaceSet^I ~objは、次に挙げる~event~handlerを（および，対応する~event~handler~event型も），~IDL属性として~supportし~MUST： ◎ The following are the event handlers (and their corresponding event handler event types) that must be supported by FontFaceSet objects as IDL attributes:

`~loadingに切替える@ ときは、所与の ( `FontFaceSet$I ~obj %~face~set ) に対し，次の手続きを走らせ~MUST： ◎ When asked to switch the FontFaceSet to loading for a given FontFaceSet, the user agent must run the following steps:

1. %~face~set の `~status1$m 属性 ~SET `loading^l ◎ Let font face set be the given FontFaceSet. ◎ Set the status attribute of font face set to "loading".
2. ~IF［ %~face~set . `ReadyPromise$sl が保持している~promiseはすでに`解決され$ている ］ ⇒ %~face~set . `ReadyPromise$sl ~SET `新たな~promise$ ◎ If font face set’s [[ReadyPromise]] slot currently holds a fulfilled promise, replace it with a fresh pending promise.
3. 次を走らす`~taskを~queueする$ ⇒ `~font~load~eventを発火する$( %~face~set, `loading$et ) ◎ Queue a task to fire a font load event named loading at font face set.

以下に与える手続きの目的においては、各 `FontFaceSet$I ~objには， `環境渋滞中~flag@ （初期時は ~OFF ）が結付けられているとする。 ◎ ↓↓

`~load済みに切替える@ ときは、所与の ( `FontFaceSet$I ~obj %~face~set ) に対し，次の手続きを走らせ~MUST： ◎ When asked to switch the FontFaceSet to loaded for a given FontFaceSet, the user agent must run the following steps:

1. ~IF［ %~face~set は`環境待ち$にある ］：

   1. %~face~set の`環境渋滞中~flag$ ~SET ~ON
   2. ~RET
   ◎ Let font face set be the given FontFaceSet. ◎ If font face set is pending on the environment, mark it as stuck on the environment, and exit this algorithm.
2. %~face~set の `~status1$m 属性 ~SET `loaded^l ◎ Set font face set’s status attribute to "loaded".
3. %~face~set で［ %~face~set . `ReadyPromise$sl ］を`解決する$ ◎ Fulfill font face set’s [[ReadyPromise]] attribute’s value with font face set.

4. 次を走らす`~taskを~queueする$： ◎ Queue a task to perform the following steps synchronously:

   1. `~load済みの~fontたち^V ~LET %~face~set . `LoadedFonts$sl （空の場合もある） ◎ Let loaded fonts be the (possibly empty) contents of font face set’s [[LoadedFonts]] slot.
   2. `失敗した~fontたち^V ~LET %~face~set . `FailedFonts$sl （空の場合もある） ◎ Let failed fonts be the (possibly empty) contents of font face set’s [[FailedFonts]] slot.
   3. `LoadedFonts$sl ~slot ~SET 空~list ◎ ↓
   4. `FailedFonts$sl ~slot ~SET 空~list ◎ Reset the [[LoadedFonts]] and [[FailedFonts]] slots to empty lists.
   5. `~font~load~eventを発火する$( %~face~set, `loadingdone$et, `~load済みの~fontたち^V ) ◎ Fire a font load event named loadingdone at font face set with loaded fonts.
   6. ~IF［ `失敗した~fontたち^V は空でない ］ ⇒ `~font~load~eventを発火する$( %~face~set, `loadingerror$et, `失敗した~fontたち^V ) ◎ If font face set’s failed fonts is non-empty, fire a font load event named loadingerror at font face set with failed fonts.

~UAは，［ `環境待ち$にあった `FontFaceSet$I ~obj %~face~set ］が`環境待ち$でなくなったときは、次の手続きを走らせ~MUST： ◎ Whenever a FontFaceSet goes from pending on the environment to not pending on the environment, the user agent must run the following steps:

1. ~IF［ %~face~set の`環境渋滞中~flag$ ~EQ ~ON ］~AND［ %~face~set . `LoadingFonts$sl は空である ］ ⇒ `~load済みに切替える$( %~face~set ) ◎ If the FontFaceSet is stuck on the environment and its [[LoadingFonts]] list is empty, switch the FontFaceSet to loaded.
2. %~face~set の`環境渋滞中~flag$ ~SET ~OFF ◎ If the FontFaceSet is stuck on the environment, unmark it as such.

1. %解析結果 ~LET `font$p ~propの~CSS値~構文を利用して %~font を構文解析した結果 ◎ Parse font using the CSS value syntax of the font property.＼
2. ~IF［ 前段で構文~errorが生じた ］ ⇒ ~RET ( 構文~error, … ) ◎ If a syntax error occurs, return a syntax error.
3. ~IF［ %解析結果 は `~CSS全域~keyword$である ］ ⇒ ~RET ( 構文~error, … ) ◎ If the parsed value is a CSS-wide keyword, return a syntax error.
4. %解析結果 内のすべての相対~長さを，対応する~propの初期~値を基準に絶対化する（例えば `bolder^v の様な相対~font~weightは、初期~値 `normal^v を基準に評価される。） ◎ Absolutize all relative lengths against the initial values of the corresponding properties. (For example, a relative font weight like bolder is evaluated against the initial value normal.) ◎ If text was not explicitly provided, let it be a string containing a single space character (U+0020 SPACE).
5. %~font~family~list ~LET %解析結果 内の~font~familyの~list ◎ Let font family list be the list of font families parsed from font,＼
6. %~font~style ~LET %解析結果 内の他の~font~style属性 ◎ and font style be the other font style attributes parsed from font.
7. `可用な~font~faces^V ~LET %~source 内の~font~faceたち ◎ Let available font faces be the font faces within source.＼
8. ~IF［ %~system~font許容~flag ~EQ ~ON ］ ⇒ `可用な~font~faces^V にすべての~system~fontを追加する ◎ If the allow system fonts flag is specified, add all system fonts to available font faces.
9. `合致した~font~faces^V ~LET 空~list ◎ Let matched font faces initially be an empty list.

10. %~font~family~list 内の ~EACH ( %~family ) に対し ⇒ `合致した~font~faces^V に次を追加する ⇒ `~font照合$規則を利用して、 `可用な~font~faces^V 内の~font~faceのうち，次を満たすものを選定した結果 ⇒ ［ %~family に属する ］~AND［ %~font~style に合致する ］

    （ `unicodeRange$m 属性の利用は，複数の~font~faceが選定され得ることを意味する。）

    ◎ For each family in font family list, use the font matching rules to select the font faces from available font faces that match the font style, and add them to matched font faces. The use of the unicodeRange attribute means that this may be more than just a single font face.
11. `見出された~faceあり^V ~SET［ `合致した~font~faces^V は空ならば ~F ／ ~ELSE_ ~T ］ ◎ If matched font faces is empty, set the found faces flag to false. Otherwise, set it to true.

12. `合致した~font~faces^V 内の ~EACH ( %~font~face ) に対し ⇒ ~IF［ %~text 内のどの文字の符号位置も %~font~face に定義されている `unicode-range$d に含まれていない† ］ ⇒ `合致した~font~faces^V から %~font~face を除去する

    【† この条件の `unicode-range$d は、`有効~文字~map$とされるべきであろう。 】

    ◎ For each font face in matched font faces, if its defined unicode-range does not include the codepoint of at least one character in text, remove it from the list.
13. ~RET ( `合致した~font~faces^V, `見出された~faceあり^V ) ◎ Return matched font faces and the found faces flag.

3.2. `load()^m ~method

`FontFaceSet$I の `~load1()$m ~methodは、所与の~font~list内のすべての~fontが，~loadされ可用になったかどうかを決定する。 ~font~list内に まだ~loadされていない~download可能な~fontがある場合、~UAは それらの各~fontに対し，~loadを起動することになる。 この~methodは、`~promise$を返す。 それは、 すべての~fontが~loadされ，利用される準備ができたときに`解決され$、 いずれかの~fontを適正に~loadするのに失敗したときは，`却下され$る。 ◎ The load() method of FontFaceSet will determine whether all fonts in the given font list have been loaded and are available. If any fonts are downloadable fonts and have not already been loaded, the user agent will initiate the load of each of these fonts. It returns a Promise, which is fulfilled when all of the fonts are loaded and ready to be used, or rejected if any font failed to load properly.

`~load1(font, text)@m ~methodの被~call時には、次の手続きを実行する： ◎ When the load( font, text ) method is called, execute these steps:

1. %~promise ~LET 新たに作成された~promise~obj。 ◎ Let font face set be the FontFaceSet object this method was called on. Let promise be a newly-created promise object.
2. ~RET %~promise — ただし、以下の手続きは並列的に走らす。 ◎ Return promise. Complete the rest of these steps asynchronously.
3. ( %~font~face~list, … ) ~LET 次を与える下で，此れから`合致する~font~faces$を見出した結果 ⇒ ( %font, %text, ~OFF ) ◎ Find the matching font faces from font face set using the font and text arguments passed to the function, and let font face list be the return value (ignoring the found faces flag).

4. ~IF［ %~font~face~list ~EQ 構文~error ］：

   1. `SyntaxError^E 例外で %~promise を`却下する$
   2. ~RET
   ◎ If a syntax error was returned, reject promise with a SyntaxError exception and terminate these steps.

5. 次を走らす`~taskを~queueする$： ◎ Queue a task to run the following steps synchronously:

   1. %~promise~list ~LET 空~list ◎ ↓

   2. %~font~face~list 内の ~EACH ( %~font~face ) に対し：

      1. %~font~face の `load()$m ~methodを~callする
      2. %~promise~list に %~font~face の `FontStatusPromise$sl を付加する
      ◎ For all of the font faces in the font face list, call their load() method.
   3. ［ %~promise~list を`すべてを待機-$した結果 ］で %~promise を`解決する$ ◎ Resolve promise with the result of waiting for all of the [[FontStatusPromise]]s of each font face in the font face list, in order.

3.3. `check()^m ~method

`FontFaceSet$I 上の `check()$m ~methodは、［ 供された~textを，特定0の~font~listで “安全に” 描画できる（後で “~fontが入替わる” ことはない）かどうか ］を決定する。 この~methodは、 ( ~text, ~font ) の組み合わせが与えられた下で，［ ~textを描画する際に［ ~unloadされた ／ 現在~load中にある ］~fontを利用しようと試みられることはない ］ならば ~T を返し、他の場合は ~F を返す。 ◎ The check() method of FontFaceSet will determine whether you can "safely" render some provided text with a particular font list, such that it won’t cause a "font swap" later. If the given text/font combo will render without attempting to use any unloaded or currently-loading fonts, this method will return true; otherwise, it returns false.

`check(font, text)@m ~methodの被~call時には、次を実行する： ◎ When the check( font, text) method is called, execute these steps:

1. ( %~font~face~list, `見出された~faceあり^V ) ~LET 次を与える下で，此れから`合致する~font~faces$を見出した結果 ⇒ ( %font, %text, ~ON ) ◎ Let font face set be the FontFaceSet object this method was called on. ◎ Find the matching font faces from font face set using the font and text arguments passed to the function, and including system fonts, and let font face list be the returned list of font faces, and found faces be the returned found faces flag.＼
2. ~IF［ %~font~face~list ~EQ 構文~error ］ ⇒ ~THROW `SyntaxError^E ◎ If a syntax error was returned, throw a SyntaxError exception and terminate these steps.
3. ~IF［ `見出された~faceあり^V ~EQ ~F ］ ⇒ ~THROW `XXX error^E 【正式な~error名は未策定の模様】 ◎ If found faces is false, throw an XXX error and abort this algorithm.
4. ~IF［ %~font~face~list 内に ~system~fontでない, かつ［ `status$m 属性 ~NEQ `loaded^l ］なる~fontがある ］ ⇒ ~RET ~F ◎ If font face list is empty, or all fonts in the font face list either have a status attribute of "loaded" or are system fonts, return true. Otherwise, return false.
5. ~RET ~T ◎ ↑

3.4. `ready^m 属性

~loadされる~fontの個数は，所与の~text片に利用されている~fontの個数に依存するので、~fontを~loadする必要があるかどうかは 既知でない事例もある。 `ready$m 属性は、［ 文書が~fontを~loadし終えたときに解決される`~promise$ ］を返す。 これにより，作者は、~load中の~fontに影響され得る内容を精査するに先立って，どの~fontが~loadされたか追跡し続けなくとも済むようになる。 ◎ Because the number of fonts loaded depends on the how many fonts are used for a given piece of text, in some cases whether fonts need to be loaded or not may not be known. The ready attribute contains a Promise which is resolved when the document is done loading fonts, which provides a way for authors to avoid having to keep track of which fonts have or haven’t been loaded before examining content which may be affected by loading fonts.

3.5. ~CSS ~font~loading／照合との相互作用

~UAは、［ `~font照合$~algo `CSS-FONTS-3$r を自動的に走らせた結果の，合致する~font~faces ］と［［ 文書に対する`~font~source$内の~font, および局所~font~face ］からなる集合 ］とを、精確に一致させ~MUST。 ◎ When the font matching algorithm in [CSS-FONTS-3] is run automatically by the user-agent, the set of font faces it matches over must be precisely the set of fonts in the font source for the document, plus any local font faces.

~UAは、~font~faceを~loadする必要が生じたときは、対応している `FontFace$I ~objの `load()$m ~methodを~callして，そうし~MUST。 ◎ When a user-agent needs to load a font face, it must do so by calling the load() method of the corresponding FontFace object.

（これは、 【その~methodに定義されている】 同じ~algoを走らせ~MUSTことを意味する — 当の~objの `load^m ~prop内に現在~格納されている値そのものを~callするのでなく） ◎ (This means it must run the same algorithm, not literally call the value currently stored in the load property of the object.)

document.styleSheets[0].insertRule(
  "@font-face { font-family: newfont; src: url(newfont.woff); }", 0);
document.body.style.fontFamily = "newfont, serif";

var %f = new FontFace("newfont", "url(newfont.woff)");
document.fonts.add(%f);
document.body.style.fontFamily = "newfont, serif";

var f = new FontFace("newfont", "url(newtest.woff)", {});

/* 
新たな {{FontFace}} は {{FontFaceSet}} には追加されないので、
`font-family^p ~propは、それを見れない
— 代わりに `serif^v が利用されることになる。
◎
new {{FontFace}} not added to {{FontFaceSet}}, so the 'font-family' property can’t see it, and serif will be used instead
 */
document.body.style.fontFamily = "newfont, serif";

var %f = new FontFace("newfont", "url(newfont.woff)", {});
%f.load().then(function (%loadedFace) {
  document.fonts.add(%loadedFace);
  document.body.style.fontFamily = "newfont, serif";
});

4.1. ~workerにおける `FontFaceSources^I

~worker文書における`~font~source$は、初期~時は空とする。 ◎ Within a Worker document, the font source is initially empty.

注記： `FontFace$I ~objは、通常通り構築したり追加でき，~workerの中での~CSS`~font照合$に影響する（例えば `OffscreenCanvas$I の中で~textを描くときなど）。 ◎ Note: FontFace objects can be constructed and added to it as normal, which affects CSS font-matching within the worker (such as, for example, drawing text into a OffscreenCanvas).

4.2. `font-face^at 規則との相互作用

文書の`~font~source$の`~set~entries$は、初期~時には，［ 文書の~stylesheet内のある `font-face$at 規則を`接続-先$とする `FontFace$I ~obj ］たちで拡充され~MUST — それらの規則の文書~順序で。 `font-face$at 規則が~stylesheet［ に追加-／から除去- ］されるに伴い，あるいは ［ `font-face$at 規則を包含している~stylesheet ］が文書［ に追加-／から除去- ］されるに伴い、それを`接続-先$とする どの `FontFace$I ~objも，この順序を保守するように，文書の`~font~source$［ に追加-／から除去- ］され~MUST。 ◎ The set entries for a document’s font source must be initially populated with all the CSS-connected FontFace objects from all of the CSS @font-face rules in the document’s stylesheets, in document order. As @font-face rules are added or removed from a stylesheet, or stylesheets containing @font-face rules are added or removed, the corresponding CSS-connected FontFace objects must be added or removed from the document’s font source, and maintain this ordering.

手動で追加された `FontFace$I ~objの順序は、`~CSSに接続されて$いるそれらの後で~MUST。 【`反復~順序$を見よ。】 ◎ Any manually-added FontFace objects must be ordered after the CSS-connected ones.

`FontFaceSet$I ~objの `add()$m ~methodの被~call時には、渡された `FontFace$I ~objが`~CSSに接続されて$いて，すでに~set内にある場合、演算は何もしては~MUST_NOT。 他の場合、 `InvalidModificationError$E を投出し~MUST。 ◎ When a FontFaceSet object’s add() method is called with a CSS-connected FontFace object, if the object is already in the set, the operation must be a no-op; otherwise, the operation must do nothing, and throw an InvalidModificationError.

`FontFaceSet$I ~objの `delete()$m ~methodの被~call時には、渡された `FontFace$I ~objが`~CSSに接続されて$いる場合は，何もせず ~F を返さ~MUST。 ◎ When a FontFaceSet object’s delete() method is called with a CSS-connected FontFace object, the operation must be a no-op, and return false.

注記： 作者は、除去された `FontFace$I ~objへの参照を — それが`~font~source$から自動的に除去されたものであっても — 依然として保守できる。 `font-face^at 規則との相互作用 節 に指定されるように、当の~objは除去された時点で`~CSSに接続され$なくなるが。 ◎ Note: Authors can still maintain references to a removed FontFace, even if it’s been automatically removed from a font source. As specified in §2.3 Interaction with CSS’s @font-face Rule, though, the FontFace is no longer CSS-connected at that point.

注記： この仕様の将来~versionでは、局所~fontに対しても［ 相互作用する／照会する ］仕方を定義することが期待されている。 ◎ Note: It is expected that a future version of this specification will define ways of interacting with and querying local fonts as well.