Web IDL — JavaScript 言語束縛

~JS値 %V を `any$T 型の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value V is converted to an IDL any value by running the following algorithm:

1. ~RET %V に応じて： ◎ ↓

   • `undefined^jv ⇒ ~RET 一意な `undefined$T ~IDL値 ◎ If V is undefined, then return the unique undefined IDL value.
   • `null^jv ⇒ ~RET `null^V `object$T`​?^T 参照 ◎ If V is null, then return the null object? reference.
   • `Boolean$jt である ⇒ 同じ真偽-値を表現する `boolean$T 値 ◎ If V is a Boolean, then return the boolean value that represents the same truth value.
   • `Number$jt である ⇒ `unrestricted double＠#js-unrestricted-double§T に従って， %V を `unrestricted double$T 値に変換した結果 ◎ If V is a Number, then return the result of converting V to an unrestricted double.
   • `BigInt$jt である ⇒ `bigint＠#js-bigint§T に従って， %V を `bigint$T 値に変換した結果 ◎ If V is a BigInt, then return the result of converting V to a bigint.
   • `String$jt である ⇒ `DOMString＠#js-DOMString§T に従って， %V を `DOMString$T 値に変換した結果 ◎ If V is a String, then return the result of converting V to a DOMString.
   • `Symbol$jt である ⇒ `symbol＠#js-symbol§T に従って， %V を `symbol$T 値に変換した結果 ◎ If V is a Symbol, then return the result of converting V to a symbol.
   • `Object$jt である ⇒ %V を参照する~IDL `object$T 値 ◎ If V is an Object, then return an IDL object value that references V.

~JS値 %V を `undefined$T 型の`~IDL値に変換する$ときは ⇒ ~RET 一意な `undefined$T 値（ %V は無視する） ◎ A JavaScript value V is converted to an IDL undefined value by returning the unique undefined value, ignoring V.

~IDL `undefined$T 値を`~JS値に変換する$ときは ⇒ ~RET ~JS `undefined^jv 値 ◎ The unique IDL undefined value is converted to the JavaScript undefined value.

~JS値 %V を `boolean$T 型の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value V is converted to an IDL boolean value by running the following algorithm:

1. %x ~LET `ToBoolean$A( %V ) の算出-結果 ◎ Let x be the result of computing ToBoolean(V).
2. ~RET ［ ~JS `Boolean^jt 値 %x ］と同じ真偽-値を表現する~IDL `boolean$T 値 ◎ Return the IDL boolean value that is the one that represents the same truth value as the JavaScript Boolean value x.

~JS値 %V を `整数~型$ %T の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value V is converted to an IDL _T_ value by running the following algorithm:

1. %x ~LET ~ABRUPT `ConvertToInt$A( %V, %T ) ◎ Let x be ? ConvertToInt(V, _N_, "signed|unsigned").
2. ~RET %x と同じ数量-値を表現する，%T 型の~IDL値 ◎ Return the IDL _T_ value that represents the same numeric value as x.

~IDL`整数~型$ %T の値 %V を`~JS値に変換する$ときは、 %T に応じて：

`long long$T

`unsigned long long$T

%V に最も近い数量-値を表現する `Number^jt 値 ⇒ 2 数が等距離にある場合は，`仮数が偶数になる方^emを選ぶとする

%V が範囲 { %最小 〜 %最大 }~FN に入るならば、 その値 は %V と正確に同じ値を表現できることになる。

他の整数~型

%V と同じ数量-値を表現する `Number^jt 値。

その値は 範囲 { %最小 〜 %最大 }~FN に入る整数になる。

~FN 上の %最小, %最大 は、 次節の `ConvertToInt$A にて与えられる。

◎ The result of converting an IDL _T_ value to a JavaScript value is a Number value that represents the closest numeric value to the _T_, choosing the numeric value with an even significand if there are two equally close values. If the _T_ is in the range [_MIN_, _MAX_], then the Number will be able to represent exactly the same value as the _T_. ◎ Number that represents the same numeric value as the IDL _T_ value. The Number value will be an integer in the range [_MIN_, _MAX_].

~JS値 %V を `float$T 型の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value V is converted to an IDL float value by running the following algorithm:

1. %x ~LET ~ABRUPT `ToNumber$A( %V ) ◎ Let x be ? ToNumber(V).
2. %S ~LET ［ −0 を除く有限 IEEE 754 単精度 浮動小数点~値が成す集合に， 2 つの特別な値 { 2`128^sup, −2`128^sup } を追加した集合 ］ ◎ Let S be the set of finite IEEE 754 single-precision floating point values except −0, but with two special values added: 2^128 and −2^128.
3. %y ~LET %S の中で %x に最も近い数量-値 ⇒ 2 数が等距離にある場合は，`仮数が偶数になる方^emを選ぶとする ⇒ この目的においては， 2 つの特別な値 2`128^sup, −2`128^sup の仮数は偶数と見なされる。 ◎ Let y be the number in S that is closest to x, selecting the number with an even significand if there are two equally close values. (The two special values 2^128 and −2^128 are considered to have even significands for this purpose.)
4. ~IF［ %y ~IN { 2`128^sup, −2`128^sup } ］ ⇒ `~THROW$ `TypeError$jt ◎ If y is 2^128 or −2^128, then throw a TypeError.
5. ~IF［ %y ~EQ +0 ］~AND［ %x ~LT 0 ］ ⇒ ~RET −0 ◎ If y is +0 and x is negative, return −0.
6. ~RET %y ◎ Return y.

~JS値 %V を `unrestricted float$T 型の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value V is converted to an IDL unrestricted float value by running the following algorithm:

1. ~IF［ %x ~EQ `NaN^jv ］ ⇒ ~RET ［ ~bit~pattern `7fc00000^X の IEEE 754 NaN 値 `IEEE-754$r ］を表現する~IDL `unrestricted float$T 値 ◎ If x is NaN, then return the IDL unrestricted float value that represents the IEEE 754 NaN value with the bit pattern 0x7fc00000 [IEEE-754].
2. ~IF［ %y ~EQ 2`128^sup ］ ⇒ ~RET +∞ ◎ If y is 2^128, return +∞.
3. ~IF［ %y ~EQ −2`128^sup ］ ⇒ ~RET −∞ ◎ If y is −2^128, return −∞.

~IDL `unrestricted float$T 値 %V を`~JS値に変換する$ための~algoは： ◎ The result of converting an IDL unrestricted float value to a JavaScript value is a Number:

1. ~IF［ %V ~EQ NaN ］ ⇒ ~RET `NaN^jv ◎ If the IDL unrestricted float value is a NaN, then the Number value is NaN.
2. ~RET %V と同じ数量-値を表現する（~~唯一の） `Number^jt 値 ◎ Otherwise, the Number value is the one that represents the same numeric value as the IDL unrestricted float value.

~JS値 %V を `double$T 型の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value V is converted to an IDL double value by running the following algorithm:

1. ~RET ［ %x と同じ数量-値 ］を表現する~IDL `double$T 値 ◎ Return the IDL double value that represents the same numeric value as x.

~JS値 %V を `unrestricted double$T 型の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value V is converted to an IDL unrestricted double value by running the following algorithm:

1. ~IF［ %x ~EQ `NaN^jv ］ ⇒ ~RET ［ ~bit~pattern `7ff8000000000000^X の IEEE 754 NaN 値 `IEEE-754$r ］を表現する~IDL `unrestricted double$T 値 ◎ If x is NaN, then return the IDL unrestricted double value that represents the IEEE 754 NaN value with the bit pattern 0x7ff8000000000000 [IEEE-754].
2. ~RET ［ %x と同じ数量-値 ］を表現する~IDL `unrestricted double$T 値 ◎ Return the IDL unrestricted double value that represents the same numeric value as x.

~IDL `unrestricted double$T 値 %V を`~JS値に変換する$ための~algoは： ◎ The result of converting an IDL unrestricted double value to a JavaScript value is a Number:

1. ~IF［ %V ~EQ NaN ］ ⇒ ~RET `NaN^jv ◎ If the IDL unrestricted double value is a NaN, then the Number value is NaN.
2. ~RET %V と同じ数量-値を表現する（~~唯一の） `Number^jt 値 ◎ Otherwise, the Number value is the one that represents the same numeric value as the IDL unrestricted double value.

~JS値 %V を `bigint$T 型の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value V is converted to an IDL bigint value by running the following algorithm:

1. %x ~LET ~ABRUPT `ToBigInt$A( %V ) ◎ Let x be ? ToBigInt(V).
2. ~RET %x と同じ数量-値を表現する，型 `bigint$T の~IDL値 ◎ Return the IDL bigint value that represents the same numeric value as x.

~IDL `bigint$T 値 %V を`~JS値に変換する$ときは ⇒ ~RET %V と同じ数量-値を表現する `BigInt$jt 値 ◎ The result of converting an IDL bigint value to a JavaScript value is a BigInt: • Return the BigInt value that represents the same numeric value as the IDL bigint value.

~JS値 %V を~IDL［ `数量-型$ %T, `bigint$T 型 ］ `いずれかの型の~IDL値に変換する@ ~algoは： ◎ A JavaScript value V is converted to an IDL numeric type T or bigint value by running the following algorithm:

1. %x ~LET ~ABRUPT `ToNumeric$A( %V ) ◎ Let x be ? ToNumeric(V).
2. ~IF［ %x は `BigInt$jt である ］ ⇒ ~RET %x と同じ数量-値を表現する，型 `bigint$T の~IDL値 ◎ If x is a BigInt, then • Return the IDL bigint value that represents the same numeric value as x.
3. ~Assert： %x は `Number$jt である ◎ Assert: x is a Number.
4. ~RET `~IDL値に変換する$【！`~JS値に変換する$】( %x, %T ) ◎ Return the result of converting x to T.

~JS値 %V を `DOMString$T 型の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value V is converted to an IDL DOMString value by running the following algorithm:

1. ~IF［ %V ~EQ `null^jv ］~AND［ `LegacyNullToEmptyString$x `拡張d属性が結付けられ$た~IDL型への変換である ］ ⇒ ~RET 空~文字列を表現する `DOMString$T 値 ◎ If V is null and the conversion is to an IDL type associated with the [LegacyNullToEmptyString] extended attribute, then return the DOMString value that represents the empty string.
2. %x ~LET ~ABRUPT `ToString$A( %V ) ◎ Let x be ? ToString(V).
3. ~RET ［ その~JS `String^jt 値 %x が表現するものと同じ，`符号単位$並び ］を表現する~IDL `DOMString$T 値 ◎ Return the IDL DOMString value that represents the same sequence of code units as the one the JavaScript String value x represents.

~JS値 %V を `ByteString$T 型の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value V is converted to an IDL ByteString value by running the following algorithm:

1. %x ~LET ~ABRUPT `ToString$A( %V ) ◎ Let x be ? ToString(V).
2. ~IF［ %x の中に 値 ~GT 255 なる`要素$eSがある ］ ⇒ `~THROW$ `TypeError$jt ◎ If the value of any element of x is greater than 255, then throw a TypeError.
3. ~RET ［［ 各~要素の値 ~SET %x の対応する要素の値 ］にされた， 長さ ~EQ %x の長さ ］の~IDL `ByteString$T 値 ◎ Return an IDL ByteString value whose length is the length of x, and where the value of each element is the value of the corresponding element of x.

~JS値 %V を `USVString$T 型の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value V is converted to an IDL USVString value by running the following algorithm:

1. %文字列 ~LET `~IDL値に変換する$( %V, `DOMString$T ) ◎ Let string be the result of converting V to a DOMString.
2. ~RET %文字列 を`~scalar値~文字列に変換-$した結果の~IDL `USVString$T 値 ◎ Return an IDL USVString value that is the result of converting string to a sequence of scalar values.

~IDL `USVString$T 値 %V を`~JS値に変換する$ときは ⇒ ~RET %V ◎ The result of converting an IDL USVString value S to a JavaScript value is S.

~JS値 %V を `object$T 型の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value V is converted to an IDL object value by running the following algorithm:

1. ~IF［ %V は `Object$jt でない ］ ⇒ `~THROW$ `TypeError$jt ◎ If V is not an Object, then throw a TypeError.
2. ~RET %V と同じ~objを参照する~IDL `object$T 値 ◎ Return the IDL object value that is a reference to the same object as V.

~JS値 %V を `symbol$T 型の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value V is converted to an IDL symbol value by running the following algorithm:

1. ~IF［ %V は `Symbol$jt でない ］ ⇒ `~THROW$ `TypeError$jt ◎ If V is not a Symbol, then throw a TypeError.
2. ~RET %V と同じ~symbolを参照する~IDL `symbol$T 値 ◎ Return the IDL symbol value that is a reference to the same symbol as V.

~JS値 %V を `~ifc型$ %I の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value V is converted to an IDL interface type value by running the following algorithm (where I is the interface):

1. ~IF［ %V は %I を`実装-$する ］ ⇒ ~RET その~platform~objへの参照を表現する，~IDL`~ifc型$の値 ◎ If V implements I, then return the IDL interface type value that represents a reference to that platform object.
2. `~THROW$ `TypeError$jt ◎ Throw a TypeError.

~JS値 %V を `~callback~ifc型$の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value V is converted to an IDL callback interface type value by running the following algorithm:

1. ~RET %V への参照を表現し, `~callback文脈$として`現任な設定群~obj$を伴う，~IDL`~callback~ifc型$の値 ◎ Return the IDL callback interface type value that represents a reference to V, with the incumbent settings object as the callback context.

~JS値 %~js辞書 を`辞書~型$ %D の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value jsDict is converted to an IDL dictionary type value by running the following algorithm (where D is the dictionary type):

1. ~IF［ %~js辞書 は `Object$jt でない ］~AND［ %~js辞書 ~NIN { `undefined^jv, `null^jv } ］ ⇒ `~THROW$ `TypeError$jt ◎ If jsDict is not an Object and jsDict is neither undefined nor null, then throw a TypeError.
2. %~idl辞書 ~LET 型 %D の辞書を表現している新たな`有順序~map$ ◎ Let idlDict be an empty ordered map, representing a dictionary of type D.

3. ［ %D, %D が`継承した辞書~群$ ］を成す ~EACH( %辞書 ) に対し，先祖から継承-順に： ◎ Let dictionaries be a list consisting of D and all of D’s inherited dictionaries, in order from least to most derived. ◎ For each dictionary dictionary in dictionaries, in order:

   1. %辞書 上に宣言された ~EACH( 辞書~mb %~mb ) に対し，~mbの`識別子$の辞書式~順序で： ◎ For each dictionary member member declared on dictionary, in lexicographical order:

      1. %~key ~LET %~mb の`識別子$ ◎ Let key be the identifier of member.
      2. %~js~mb値 ~LET `undefined^jv ◎ ↓
      3. ~IF［ %~js辞書 は `Object$jt である ］ ⇒ %~js~mb値 ~SET ~ABRUPT `Get$A( %~js辞書, %~key ) ◎ If jsDict is either undefined or null, then: • Let jsMemberValue be undefined. ◎ Otherwise, • Let jsMemberValue be ? Get(jsDict, key).
      4. ~IF［ %~js~mb値 ~NEQ `undefined^jv ］ ⇒ %~idl辞書[ %~key ] ~SET `~IDL値に変換する$( %~js~mb値, %~mb に宣言された型 ) ◎ If jsMemberValue is not undefined, then: • Let idlMemberValue be the result of converting jsMemberValue to an IDL value whose type is the type member is declared to be of. • Set idlDict[key] to idlMemberValue.
      5. ~ELIF［ %~mb には`既定~値$diC %d が指定されている ］ ⇒ %~idl辞書[ %~key ] ~SET %d ◎ Otherwise, if jsMemberValue is undefined but member has a default value, then: • Let idlMemberValue be member’s default value. • Set idlDict[key] to idlMemberValue.
      6. ~ELIF［ %~mb は`要求され$diCる ］ ⇒ `~THROW$ `TypeError$jt ◎ Otherwise, if jsMemberValue is undefined and member is required, then throw a TypeError.
4. ~RET %~idl辞書 ◎ Return idlDict.

~IDL辞書 %D 型の値 %V を `Object^jt 型の`~JS値に変換する$ための~algoは： ◎ An IDL dictionary value V is converted to a JavaScript Object value by running the following algorithm (where D is the dictionary):

1. %O ~LET `OrdinaryObjectCreate$A( `Object.prototype$jI ) ◎ Let O be OrdinaryObjectCreate(%Object.prototype%).
2. 1. 1. %~key ~LET %~mb の`識別子$ ◎ Let key be the identifier of member.
      2. %~idl値 ~LET %V[ %~key ] ◎ ↓
      3. ~IF［ %~idl値 ~EQ ε ］ ⇒ ~CONTINUE ◎ If V[key] exists, then: ◎ Let idlValue be V[key].
      4. %~js値 ~LET `~JS値に変換する$( %~idl値 ) ◎ Let value be the result of converting idlValue to a JavaScript value.
      5. ~NOABRUPT `CreateDataPropertyOrThrow$A( %O, %~key, %~js値 ) ◎ Perform ! CreateDataPropertyOrThrow(O, key, value).

      注記： %~mb に`既定~値$diCが指定されている場合、 常に %V[ %~key ] ~NEQ ε になる。 ◎ Recall that if member has a default value, then key will always exist in V.

3. ~RET %O ◎ Return O.

~JS値 %V を`列挙$型 %E の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value V is converted to an IDL enumeration type value as follows (where E is the enumeration):

1. %S ~LET ~ABRUPT `ToString$A( %V ) ◎ Let S be the result of calling ? ToString(V).
2. ~IF［ %S は %E の`列挙~値$のいずれでもない ］ ⇒ `~THROW$ `TypeError$jt ◎ If S is not one of E’s enumeration values, then throw a TypeError.
3. ~RET 型 %E の， %S に等しい列挙~値 ◎ Return the enumeration value of type E that is equal to S.

~JS値 %V を`~callback関数~型$の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value V is converted to an IDL callback function type value by running the following algorithm:

1. ~IF［ ~OR↓ ］…

   • `IsCallable$A( %V ) ~EQ ~T
   • この~algoは、 次を満たす`属性$へ代入することに因り遂行されている ⇒ ［ `~nullable$な`~callback関数$型である ］~AND［ `LegacyTreatNonObjectAsNull$x が注釈されている ］

   …ならば ⇒ ~RET %V が表現するものと同じ~objを表現し, `~callback文脈$として`現任な設定群~obj$を伴う，~IDL`~callback関数~型$の値

   ◎ If the result of calling IsCallable(V) is false and the conversion to an IDL value is not being performed due to V being assigned to an attribute whose type is a nullable callback function that is annotated with [LegacyTreatNonObjectAsNull], then throw a TypeError. ◎ Return the IDL callback function type value that represents a reference to the same object that V represents, with the incumbent settings object as the callback context.
2. `~THROW$ `TypeError$jt ◎ ↑

~JS値 %V を型 `~varT?^T の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value V is converted to an IDL nullable type T? value (where T is the inner type) as follows:

1. ~IF［ ~AND↓ ］…

   • %V は `Object$jt でない
   • この~algoは、 次を満たす`属性$へ代入することに因り遂行されている ⇒ ［ `~nullable$な`~callback関数$型である【！missing id="dfn-nullable"】 ］~AND［ `LegacyTreatNonObjectAsNull$x が注釈されている ］

   …ならば ⇒ ~RET 型 `~varT?^T の値 `null^V

   ◎ If V is not an Object, and the conversion to an IDL value is being performed due to V being assigned to an attribute whose type is a nullable callback function that is annotated with [LegacyTreatNonObjectAsNull], then return the IDL nullable type T? value null.
2. ~IF［ %V ~EQ `undefined^jv ］~AND［ %T は`~undefinedを内包する$ ］ ⇒ ~RET 一意な `undefined$T 値 ◎ Otherwise, if V is undefined, and T includes undefined, return the unique undefined value.
3. ~IF［ %V ~IN { `null^jv, `undefined^jv } ］ ⇒ ~RET 型 `~varT?^T の値 `null^V ◎ Otherwise, if V is null or undefined, then return the IDL nullable type T? value null.
4. ~RET `~IDL値に変換する$( %V, %T ) ◎ Otherwise, return the result of converting V using the rules for the inner IDL type T.

~JS値 %V を`~sequence_T$ 型の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value V is converted to an IDL sequence<T> value as follows:

1. ~IF［ %V は `Object$jt でない ］ ⇒ `~THROW$ `TypeError$jt ◎ If V is not an Object, throw a TypeError.
2. %~method ~LET ~ABRUPT `GetMethod$A( %V, `Symbol.iterator$jI ) ◎ Let method be ? GetMethod(V, %Symbol.iterator%).
3. ~IF［ %~method ~EQ `undefined^jv ］ ⇒ `~THROW$ `TypeError$jt ◎ If method is undefined, throw a TypeError.
4. ~RET `可反復から連列を作成する$( %T, %V, %~method ) ◎ Return the result of creating a sequence from V and method.

`~sequence_T$ 型の~IDL連列~値 %S を `Array^jt 型の`~JS値に変換する$ための~algoは： ◎ An IDL sequence value S of type sequence<T> is converted to a JavaScript Array object as follows:

1. %n ~LET %S の長さ ◎ Let n be the length of S.
2. %A ~LET 式 `[]^c で作成されるものと同じ，新たな `Array^jt ~obj ◎ Let A be a new Array object created as if by the expression [].

3. ~EACH( %i ~IN { 0 〜 %n ~MINUS 1 } ) に対し： ◎ Initialize i to be 0. ◎ While i < n:

   1. %E ~LET `~JS値に変換する$( %S [ %i ] ) ◎ Let V be the value in S at index i. ◎ Let E be the result of converting V to a JavaScript value.
   2. %P ~LET ~NOABRUPT `ToString$A( %i ) ◎ Let P be the result of calling ! ToString(i).
   3. ~NOABRUPT `CreateDataPropertyOrThrow$A( %A, %P, %E ) ◎ Perform ! CreateDataPropertyOrThrow(A, P, E). ◎ ↑↑Set i to i + 1.
4. ~RET %A ◎ Return A.

[Exposed=Window]
interface Canvas {

  sequence<DOMString> getSupportedImageCodecs();

  undefined drawPolygon(sequence<double> %coordinates);
  sequence<double> getLastDrawnPolygon();

  /* ... */
};

/* 
`Canvas^T の~instanceを得する。
その `getSupportedImageCodecs()^M は、
2 個の `DOMString^T 値
`image/png^l, `image/svg+xml^l
からなる連列を返すとする。
◎
Obtain an instance of Canvas. Assume that getSupportedImageCodecs() returns a sequence with two DOMString values: "image/png" and "image/svg+xml".
 */
var %canvas = getCanvas();

/* 
長さ 2 の `Array^jt ~obj：
◎
An Array object of length 2.
 */
var %supportedImageCodecs = %canvas.getSupportedImageCodecs();

/* 
`image/png^l に評価される：
◎
Evaluates to "image/png".
 */
%supportedImageCodecs[0];

/* 
%canvas`.getSupportedImageCodecs()^c が~callされる度に，新たな `Array^jt object が返される。
したがって，返された `Array^jt を改変しても，後続な関数~callで返される値には影響しないことになる：
◎
Each time canvas.getSupportedImageCodecs() is called, it returns a new Array object.  Thus modifying the returned Array will not affect the value returned from a subsequent call to the function.
 */
%supportedImageCodecs[0] = `image/jpeg^l;

/*  */
%canvas.getSupportedImageCodecs()[0];

/* 
各~callに対し，新たな `Array^jt ~objが返されるので、
これは `false^jv に評価される：
◎
This evaluates to false, since a new Array object is returned each call.
 */
%canvas.getSupportedImageCodecs() == %canvas.getSupportedImageCodecs();

/* 
数量-値の `Array^jt は...
◎
An Array of Numbers...
 */
var %a = [0, 0, 100, 0, 50, 62.5];

/* 
...は、
`sequence<double>^T を期待する~platform~objに渡せる：
◎
...can be passed to a platform object expecting a sequence<double>.
 */
%canvas.drawPolygon(%a);

/* 
各~要素は、
最初に `ToNumber$A() を~callすることにより，
`double^T に変換される。
したがって，次の~callは、
`drawPolygon()^M が返る前に `hi^l が alert されることを除き，
前のものと等価になる：
◎
Each element will be converted to a double by first calling ToNumber(). So the following call is equivalent to the previous one, except that "hi" will be alerted before drawPolygon() returns.
 */
%a = [
    false,
    "",
    { valueOf: function() { alert("hi"); return 100; } },
    0,
    "50",
    new Number(62.5)
];
%canvas.drawPolygon(%a);

/* 
`Array^jt は実質的には値により渡されるので、
`drawPolygon()^M に渡された `Array^jt を改変しても，
`Canvas^T に効果が及ぶことはないことが保証される：
◎
Modifying an Array that was passed to drawPolygon() is guaranteed not to have an effect on the Canvas, since the Array is effectively passed by value.
 */
%a[4] = 20;
var %b = %canvas.getLastDrawnPolygon();

alert(%b[4]);    /* 
これは `50^l を alert することになる。
◎
This would alert "50".
 */

~JS値 %V を `~async_sequence_T$ 型の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value V is converted to an IDL async_sequence<T> value as follows:

1. %~method ~LET ~ABRUPT `GetMethod$A( %V【！obj】, `Symbol.asyncIterator$jI ) ◎ Let method be ? GetMethod(obj, %Symbol.asyncIterator%).

2. ~IF［ %~method ~EQ `undefined^jv ］： ◎ If method is undefined:

   1. %同期c~method ~SET ~ABRUPT `GetMethod$A( %V【！obj】, `Symbol.iterator$jI ) ◎ Set syncMethod to ? GetMethod(obj, %Symbol.iterator%).
   2. ~IF［ %同期c~method ~EQ `undefined^jv ］ ⇒ `~THROW$ `TypeError$jt ◎ If syncMethod is undefined, throw a TypeError.
   3. ~RET 新たな`非同期c連列$ — その ⇒＃ `~obj$aS ~SET %V, `~method$aS ~SET %同期c~method, `種別$aS ~SET `同期c^C ◎ Return an IDL async sequence value with object set to V, method set to syncMethod, and type set to "sync".
3. ~RET 新たな`非同期c連列$ — その ⇒＃ `~obj$aS ~SET %V, `~method$aS ~SET %~method, `種別$aS ~SET `非同期c^C ◎ Return an IDL async sequence value with object set to V, method set to method, and type set to "async".

~IDL `~async_sequence_T$ 型の値 %V を `Object^jt 型の`~JS値に変換する$ための~algoは： ◎ An IDL async_sequence<T> value V is converted to a JavaScript object as follows:

1. ~RET %V の`~obj$aS ◎ Return V’s object.

interface I {
  Promise<DOMString> concatN(async_sequence<DOMString> %strings, unsigned long %maxN);
};

~JS値 %O を `~record_KV$ 型の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value O is converted to an IDL record<K, V> value as follows:

1. ~IF［ %O は `Object$jt でない ］ ⇒ `~THROW$ `TypeError$jt ◎ If O is not an Object, throw a TypeError.
2. %結果 ~LET 新たな空な`~record_KV$ 値 ◎ Let result be a new empty instance of record<K, V>.
3. %~key群 ~LET ~ABRUPT %O.`OwnPropertyKeys^sl() ◎ Let keys be ? O.[[OwnPropertyKeys]]().

4. %~key群 を成す ~EACH( %~key ) に対し： ◎ For each key of keys:

   1. %記述子 ~LET ~ABRUPT %O.`GetOwnProperty^sl( %~key ) ◎ Let desc be ? O.[[GetOwnProperty]](key).

   2. ~IF［ %記述子 ~NEQ `undefined^jv ］~AND［ %記述子.`Enumerable^sl ~EQ `true^jv ］： ◎ If desc is not undefined and desc.[[Enumerable]] is true:

      1. %有型~key ~LET `~IDL値に変換する$( %~key, %K ) ◎ Let typedKey be key converted to an IDL value of type K.
      2. %値 ~LET ~ABRUPT `Get$A( %O, %~key ) ◎ Let value be ? Get(O, key).
      3. %有型~値 ~LET `~IDL値に変換する$( %値, %V ) ◎ Let typedValue be value converted to an IDL value of type V.

      4. %結果[ %有型~key ] ~SET %有型~値 ◎ Set result[typedKey] to typedValue.

         注記： %K が `USVString$T で %~key が対を成さない~surrogateを包含している場合、 %有型~key は，すでに %結果 内にあり得る。 ◎ Note: It’s possible that typedKey is already in result, if K is USVString and key contains unpaired surrogates.

5. ~RET %結果 ◎ Return result.

~IDL `record$T 値 %D を`~JS値に変換する$ための~algoは： ◎ An IDL record<…> value D is converted to a JavaScript value as follows:

1. %結果 ~LET `OrdinaryObjectCreate$A( `Object.prototype$jI ) ◎ Let result be OrdinaryObjectCreate(%Object.prototype%).

2. %D を成す ~EACH( %~key → %値 ) に対し： ◎ For each key → value of D:

   1. %~js~key ~LET `~JS値に変換する$( %~key ) ◎ Let jsKey be key converted to a JavaScript value.
   2. %~js値 ~LET `~JS値に変換する$( %値 ) ◎ Let jsValue be value converted to a JavaScript value.
   3. %作成したか ~LET ~NOABRUPT `CreateDataProperty$A( %結果, %~js~key, %~js値 ) ◎ Let created be ! CreateDataProperty(result, jsKey, jsValue).
   4. ~Assert： %作成したか ~EQ `true^jv ◎ Assert: created is true.
3. ~RET %結果 ◎ Return result.

let %proto = {a: 3, b: 4};
let %obj = {__proto__: proto, d: 5, c: 6}
Object.defineProperty(%obj, "e", {value: 7, enumerable: false});
let %result = identity(%obj);
console.assert(%result.a === undefined);
console.assert(%result.b === undefined);
console.assert(%result.e === undefined);
let %entries = Object.entries(%result);
console.assert(%entries[0][0] === "d");
console.assert(%entries[0][1] === 5);
console.assert(%entries[1][0] === "c");
console.assert(%entries[1][1] === 6);

~JS値 %V を `~promise_T$ 型の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value V is converted to an IDL Promise<T> value as follows:

1. %~promise能力 ~LET ~ABRUPT `NewPromiseCapability$A( `Promise$jI ) ◎ Let promiseCapability be ? NewPromiseCapability(%Promise%).
2. ~ABRUPT `Call$A( %~promise能力.`Resolve^sl, `undefined^jv , « %V » ) ◎ Perform ? Call(promiseCapability.[[Resolve]], undefined, « V »).
3. ~RET %~promise能力 ◎ Return promiseCapability.

interface I {
  Promise<undefined> delay(unrestricted double ms);
};

interface I {
  Promise<undefined> validatedDelay(unrestricted double ms);
};

interface I {
  Promise<any> addDelay(Promise<any> promise, unrestricted double ms);
};

interface Environment {
  readonly attribute Promise<undefined> ready;
};

interface I {
  Promise<undefined> addBookmark();
};

interface I {
  Promise<sequence<Response>> batchRequest(sequence<USVString> urls);
};

~JS値 %V を`共用体~型$ %U の`~IDL値に変換する$ための~algoは： ◎ To convert a JavaScript value V to an IDL union type value is done as follows:

1. ~IF［ %U は`~undefinedを内包する$ ］~AND［ %V ~EQ `undefined^jv ］ ⇒ ~RET 一意な `undefined$T 値 ◎ If the union type includes undefined and V is undefined, then return the unique undefined value.
2. ~IF［ %V ~IN { `null^jv, `undefined^jv } ］~AND［ %U は`~nullable型を内包する$ ］ ⇒ ~RET ~IDL値 `null^V ◎ If the union type includes a nullable type and V is null or undefined, then return the IDL value null.
3. %型~群 ~LET %U の`平坦~化~mb型~群$ ◎ Let types be the flattened member types of the union type.

4. ~IF［ %V ~IN { `null^jv, `undefined^jv } ］： ◎ If V is null or undefined, then:

   1. ~IF［ %型~群 に`辞書~型$が含まれている ］ ⇒ ~RET `~IDL値に変換する$( %V, その辞書~型 ) ◎ If types includes a dictionary type, then return the result of converting V to that dictionary type.

5. ~IF［ %V は `~platform~objである$ ］： ◎ If V is a platform object, then:

   1. ~IF［ %型~群 に %V が`実装-$する`~ifc型$が含まれている ］ ⇒ ~RET ~obj %V への参照である~IDL値 ◎ If types includes an interface type that V implements, then return the IDL value that is a reference to the object V.
   2. ~IF［ %型~群 に `object$T が含まれている ］ ⇒ ~RET ~obj %V への参照である~IDL値 ◎ If types includes object, then return the IDL value that is a reference to the object V.

6. ~IF［ %V は `Object$jt である ］~AND［ %V は `ArrayBufferData^sl `内部~slot$を有する ］：

   1. %配列~buffer型 ~LET `IsSharedArrayBuffer$A( %V ) の結果に応じて ⇒＃ `true^jv ならば `SharedArrayBuffer$T ／ `false^jv ならば `ArrayBuffer$T
   2. ~IF［ %型~群 に %配列~buffer型 が含まれている ］ ⇒ ~RET `~IDL値に変換する$( %V, %配列~buffer型 )
   ◎ If V is an Object, V has an [[ArrayBufferData]] internal slot, and IsSharedArrayBuffer(V) is false, then: • If types includes ArrayBuffer, then return the result of converting V to ArrayBuffer. • If types includes object, then return the IDL value that is a reference to the object V. ◎ If V is an Object, V, has an [[ArrayBufferData]] internal slot, and IsSharedArrayBuffer(V) is true, then: • If types includes SharedArrayBuffer, then return the result of converting V to SharedArrayBuffer. • If types includes object, then return the IDL value that is a reference to the object V.

7. ~IF［ %V は `Object$jt である ］~AND［ %V は `DataView^sl `内部~slot$を有する ］： ◎ If V is an Object and V has a [[DataView]] internal slot, then:

   1. ~IF［ %型~群 に `DataView$T が含まれている ］ ⇒ ~RET `~IDL値に変換する$( %V, `DataView$T ) ◎ If types includes DataView, then return the result of converting V to DataView.

8. ~IF［ %V は `Object$jt である ］~AND［ %V は `TypedArrayName^sl `内部~slot$を有する ］： ◎ If V is an Object and V has a [[TypedArrayName]] internal slot, then:

   1. ~IF［ %型~群 に［ `有型~配列~型$であって，［ その名前 ~EQ %V の `TypedArrayName^sl `内部~slot$の値 ］を満たすもの ］が含まれている ］ ⇒ ~RET `~IDL値に変換する$( %V, その型 ) ◎ If types includes a typed array type whose name is the value of V’s [[TypedArrayName]] internal slot, then return the result of converting V to that type.

9. ~IF［ `IsCallable$A( %V ) ~EQ ~T ］： ◎ If IsCallable(V) is true, then:

   1. ~IF［ %型~群 に`~callback関数$型が含まれている ］ ⇒ ~RET `~IDL値に変換する$( %V, その~callback関数~型 ) ◎ If types includes a callback function type, then return the result of converting V to that callback function type.

10. ~IF［ %V は `Object$jt である ］： ◎ If V is an Object, then:

    1. ~IF［ %型~群 に`非同期c連列~型$が含まれている ］： ◎ If types includes an async sequence type, then

       1. ~IF［ %型~群 に`文字列~型$は含まれていない ］~OR［ %V は `StringData^sl `内部~slot$を有さない ］： ◎ If types does not include a string type or V does not have a [[StringData]] internal slot, then

          1. %非同期c~method ~LET ~ABRUPT `GetMethod$A( %V, `Symbol.asyncIterator$jI ) ◎ Let asyncMethod be ? GetMethod(V, %Symbol.asyncIterator%).
          2. ~IF［ %非同期c~method ~NEQ `undefined^jv ］ ⇒ ~RET 新たな`非同期c連列$ — その ⇒＃ `~obj$aS ~SET %V, `~method$aS ~SET %同期c~method, `種別$aS ~SET `非同期c^C ◎ If asyncMethod is not undefined, return an IDL async sequence value with object set to V, method set to syncMethod, and type set to "async".
          3. %同期c~method ~LET ~ABRUPT `GetMethod$A( %V, `Symbol.iterator$jI ) ◎ Let syncMethod be ? GetMethod(V, %Symbol.iterator%).
          4. ~IF［ %同期c~method ~NEQ `undefined^jv ］ ⇒ ~RET 新たな`非同期c連列$ — その ⇒＃ `~obj$aS ~SET %V, `~method$aS ~SET %同期c~method, `種別$aS ~SET `同期c^C ◎ If syncMethod is not undefined, return an IDL async sequence value with object set to V, method set to syncMethod, and type set to "sync".

    2. ~IF［ %型~群 に`連列~型$ %T が含まれている ］： ◎ If types includes a sequence type, then

       1. ~IF［ %~method ~NEQ `undefined^jv ］ ⇒ ~RET `可反復から連列を作成する$( %T, %V, %~method ) ◎ If method is not undefined, return the result of creating a sequence of that type from V and method.

    3. ~IF［ %型~群 に`凍結d配列~型$ %T が含まれている ］： ◎ If types includes a frozen array type, then

       1. ~IF［ %~method ~NEQ `undefined^jv ］ ⇒ ~RET `可反復から凍結d配列を作成する$( %T, %V, %~method ) ◎ If method is not undefined, return the result of creating a frozen array of that type from V and method.
    4. ~IF［ %型~群 に`辞書~型$が含まれている ］ ⇒ ~RET `~IDL値に変換する$( %V, その型 ) ◎ If types includes a dictionary type, then return the result of converting V to that dictionary type.
    5. ~IF［ %型~群 に`~record型$が含まれている ］ ⇒ ~RET `~IDL値に変換する$( %V, その型 ) ◎ If types includes a record type, then return the result of converting V to that record type.
    6. ~IF［ %型~群 に`~callback~ifc型$が含まれている ］ ⇒ ~RET `~IDL値に変換する$( %V, その型 ) ◎ If types includes a callback interface type, then return the result of converting V to that callback interface type.

11. ~IF［ %V は `Boolean$jt である ］： ◎ If V is a Boolean, then:

    1. ~IF［ %型~群 に `boolean$T が含まれている ］ ⇒ ~RET `~IDL値に変換する$( %V, `boolean$T ) ◎ If types includes boolean, then return the result of converting V to boolean.

12. ~IF［ %V は `Number$jt である ］： ◎ If V is a Number, then:

    1. ~IF［ %型~群 に`数量-型$が含まれている ］ ⇒ ~RET `~IDL値に変換する$( %V, その`数量-型$ ) ◎ If types includes a numeric type, then return the result of converting V to that numeric type.

13. ~IF［ %V は `BigInt$jt である ］： ◎ If V is a BigInt, then:

    1. ~IF［ %型~群 に `bigint$T が含まれている ］ ⇒ ~RET `~IDL値に変換する$( %V, `bigint$T ) ◎ If types includes bigint, then return the result of converting V to bigint.
14. ~IF［ %型~群 に`文字列~型$が含まれている ］ ⇒ ~RET `~IDL値に変換する$( %V, その型 ) ◎ If types includes a string type, then return the result of converting V to that type.
15. ~IF［ %型~群 に［ `bigint$T, `数量-型$ ］が含まれている ］ ⇒ ~RET %V を その`いずれかの型の~IDL値に変換する$ ◎ If types includes a numeric type and bigint, then return the result of converting V to either that numeric type or bigint.

~JS値 %V を`ArrayBuffer$T 型の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value V is converted to an IDL ArrayBuffer value by running the following algorithm:

1. ~IF［ ~OR↓ ］…

   • %V は `Object$jt でない
   • %V は `ArrayBufferData^sl `内部~slot$を有さない
   • `IsSharedArrayBuffer$A( %V ) ~EQ `true^jv
   • ［ `AllowResizable$x `拡張d属性が結付けられ$た~IDL型への変換でない ］~AND［ `IsFixedLengthArrayBuffer$A( %V ) ~EQ `false^jv ］

   …ならば ⇒ `~THROW$ `TypeError$jt

   ◎ If V is not an Object, or V does not have an [[ArrayBufferData]] internal slot, then throw a TypeError. ◎ If IsSharedArrayBuffer(V) is true, then throw a TypeError. ◎ If the conversion is not to an IDL type associated with the [AllowResizable] extended attribute, and IsFixedLengthArrayBuffer(V) is false, then throw a TypeError.
2. ~RET %V と同じ~objへの参照である~IDL `ArrayBuffer$T 値 ◎ Return the IDL ArrayBuffer value that is a reference to the same object as V.

~JS値 %V を`SharedArrayBuffer$T 型の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value V is converted to an IDL SharedArrayBuffer value by running the following algorithm:

1. ~IF［ ~OR↓ ］…

   • %V は `Object$jt でない
   • %V は `ArrayBufferData^sl `内部~slot$を有さない
   • `IsSharedArrayBuffer$A( %V ) ~EQ `false^jv

   …ならば ⇒ `~THROW$ `TypeError$jt

   ◎ If V is not an Object, or V does not have an [[ArrayBufferData]] internal slot, then throw a TypeError. ◎ If IsSharedArrayBuffer(V) is false, then throw a TypeError. ◎ If the conversion is not to an IDL type associated with the [AllowResizable] extended attribute, and IsFixedLengthArrayBuffer(V) is false, then throw a TypeError.
2. ~RET %V と同じ~objへの参照である~IDL `SharedArrayBuffer$T 値 ◎ Return the IDL SharedArrayBuffer value that is a reference to the same object as V.

~JS値 %V を `DataView$T 型の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value V is converted to an IDL DataView value by running the following algorithm:

1. ~IF［ ~OR↓ ］…

   • %V は `Object$jt でない
   • %V は `DataView^sl `内部~slot$を有さない
   • ［ `AllowShared$x `拡張d属性が結付けられ$た~IDL型への変換でない ］~AND［ `IsSharedArrayBuffer$A( %V.`ViewedArrayBuffer^sl ) ~EQ `true^jv ］
   • ［ `AllowResizable$x `拡張d属性が結付けられ$た~IDL型への変換でない ］~AND［ `IsFixedLengthArrayBuffer$A( %V.`ViewedArrayBuffer^sl ) ~EQ `false^jv ］

   …ならば ⇒ `~THROW$ `TypeError$jt

   ◎ If V is not an Object, or V does not have a [[DataView]] internal slot, then throw a TypeError. ◎ If the conversion is not to an IDL type associated with the [AllowShared] extended attribute, and IsSharedArrayBuffer(V.[[ViewedArrayBuffer]]) is true, then throw a TypeError. ◎ If the conversion is not to an IDL type associated with the [AllowResizable] extended attribute, and IsFixedLengthArrayBuffer(V.[[ViewedArrayBuffer]]) is false, then throw a TypeError.
2. ~RET %V と同じ~objへの参照である~IDL `DataView$T 値 ◎ Return the IDL DataView value that is a reference to the same object as V.

~JS値 %V を いずれかの`有型~配列~型$【！Int8Array, …】 %T の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value V is converted to an IDL Int8Array, Int16Array, Int32Array, Uint8Array, Uint16Array, Uint32Array, Uint8ClampedArray, BigInt64Array, BigUint64Array, Float16Array, Float32Array, or Float64Array value by running the following algorithm: • Let T be the IDL type V is being converted to.

1. ~IF［ ~OR↓ ］…

   • %V は `Object$jt でない
   • %V は `TypedArrayName^sl `内部~slot$を有さない
   • %V の `TypedArrayName^sl `内部~slot$の値 ~NEQ %T の名前

   …ならば ⇒ `~THROW$ `TypeError$jt

   ◎ If V is not an Object, or V does not have a [[TypedArrayName]] internal slot with a value equal to T’s name, then throw a TypeError. ◎ If the conversion is not to an IDL type associated with the [AllowShared] extended attribute, and IsSharedArrayBuffer(V.[[ViewedArrayBuffer]]) is true, then throw a TypeError. ◎ If the conversion is not to an IDL type associated with the [AllowResizable] extended attribute, and IsFixedLengthArrayBuffer(V.[[ViewedArrayBuffer]]) is false, then throw a TypeError.
2. ~RET %V と同じ~objへの参照である~IDL %T 型~値 ◎ Return the IDL value of type T that is a reference to the same object as V.

`~buffer~sourceを作成する@ ~algoは、 所与の ( `~buffer~source型$ %T, ［ `~byte列$／負でない整数 ］ %~byte列または長さ, `~realm$ %~realm ) に対し：

1. %~buffer型 ~LET %T に応じて ⇒＃ `SharedArrayBuffer$T ならば %T ／ ~ELSE_ `ArrayBuffer$T
2. %長さ ~LET %~byte列または長さ に応じて ⇒＃ `~byte列$であるならば`~byte列$の`長さ$byte ／ 整数であるならば %~byte列または長さ

3. %~js配列~buffer ~LET %~buffer型 に応じて：

   • `SharedArrayBuffer$T ⇒ ~ABRUPT `AllocateSharedArrayBuffer$A( %~realm.`SharedArrayBuffer$jIsl, %長さ )
   • `ArrayBuffer$T ⇒ ~ABRUPT `AllocateArrayBuffer$A( %~realm.`ArrayBuffer$jIsl, %長さ )

   【 ~JS仕様に則って、 ここで割振られた~bufferを成す各~byteは， すべて 0 に初期化される。 ~bufferを割振ることに失敗した場合、 `RangeError$jE が投出される。 】

4. %配列~buffer ~LET `~IDL値に変換する$( %~js配列~buffer, %~buffer型 )
5. ~IF［ %~byte列または長さ は`~byte列$である ］ ⇒ `配列~bufferの中へ~byte列を書込む$( %配列~buffer, %~byte列または長さ )
6. ~IF［ %T は`~buffer型$である ］ ⇒ ~RET %配列~buffer
7. ~Assert： %T は`~buffer~view型$である
8. ~Assert： ［ %T ~EQ `DataView$T ］~OR［ %長さ `modulo$op ( %T の`要素~size$eS ) ~EQ 0 ］
9. %構築子 ~LET %~realm.`Intrinsics^sl からの［ %T 用の適切な構築子 ］
10. %~js~view ~LET ~NOABRUPT `Construct$A( %構築子, « %~js配列~buffer » )
11. ~RET `~IDL値に変換する$( %~js~view, %T )

【 この~algoは、 原文では %T ~EQ ［ `ArrayBuffer$T の場合 ／ `SharedArrayBuffer$T の場合 ／ `ArrayBufferView$T の場合 ］の 3 つに分けて定義されているが， この訳では 1 つに統合することにする。 】【 %~byte列または長さ は、 原文では，~byte列しかとらない %~byte列 として定義されるが、 この訳では，［ ~byte列を書込むことなく~buffer~sourceを作成する事例 ］にも利用できるよう拡張する。 】

◎ To create an ArrayBuffer from a byte sequence bytes in a realm realm: • Let jsArrayBuffer be ? AllocateArrayBuffer(realm.[[Intrinsics]].[[%ArrayBuffer%]], bytes’s length). • Let arrayBuffer be the result of converting jsArrayBuffer to an IDL value of type ArrayBuffer. • Write bytes into arrayBuffer. • Return arrayBuffer. ◎ To create a SharedArrayBuffer from a byte sequence bytes in a realm realm: • Let jsSharedArrayBuffer be ? AllocateSharedArrayBuffer(realm.[[Intrinsics]].[[%SharedArrayBuffer%]], bytes’s length). • Let sharedArrayBuffer be the result of converting jsSharedArrayBuffer to an IDL value of type SharedArrayBuffer. • Write bytes into sharedArrayBuffer. • Return sharedArrayBuffer. ◎ To create one of the ArrayBufferView types from a byte sequence bytes in a realm realm: • Assert: if the type is not DataView, then bytes’s length modulo the element size of that type is 0. • Let arrayBuffer be the result of creating an ArrayBuffer from bytes in realm. • Let jsArrayBuffer be the result of converting arrayBuffer to a JavaScript value. • Let constructor be the appropriate constructor from realm.[[Intrinsics]] for the type of ArrayBufferView being created. • Let jsView be ! Construct(constructor, « jsArrayBuffer »). • Return the result of converting jsView into the given type.

`~buffer~source型$の~instance %~buffer~source に `保持された~byte列の複製を取得する@ ~algoは： ◎ To get a copy of the bytes held by the buffer source given a buffer source type instance bufferSource:

1. %~js~buffer~source ~LET `~JS値に変換する$( %~buffer~source ) ◎ Let jsBufferSource be the result of converting bufferSource to a JavaScript value.
2. %~js配列~buffer ~LET %~js~buffer~source ◎ Let jsArrayBuffer be jsBufferSource.
3. %~offset ~LET 0 ◎ Let offset be 0.
4. %長さ ~LET 0 ◎ Let length be 0.

5. ~IF［ %~js~buffer~source は `ViewedArrayBuffer^sl `内部~slot$を有する ］： ◎ If jsBufferSource has a [[ViewedArrayBuffer]] internal slot, then:

   1. %~js配列~buffer ~SET %~js~buffer~source.`ViewedArrayBuffer^sl ◎ Set jsArrayBuffer to jsBufferSource.[[ViewedArrayBuffer]].
   2. %~offset ~SET %~js~buffer~source.`ByteOffset^sl ◎ Set offset to jsBufferSource.[[ByteOffset]].
   3. %長さ ~SET %~js~buffer~source.`ByteLength^sl ◎ Set length to jsBufferSource.[[ByteLength]].

6. ~ELSE： ◎ Otherwise:

   1. ~Assert： %~js~buffer~source は［ `ArrayBuffer$jt ／ `SharedArrayBuffer$jt【！T】 ］~objである ◎ Assert: jsBufferSource is an ArrayBuffer or SharedArrayBuffer object.
   2. %長さ ~SET %~js~buffer~source.`ArrayBufferByteLength^sl ◎ Set length to jsBufferSource.[[ArrayBufferByteLength]].
7. %~byte列 ~LET 空な`~byte列$ ◎ ↓
8. ~IF［ `IsDetachedBuffer$A( %~js配列~buffer ) ~EQ `true^jv ］ ⇒ ~RET %~byte列 ◎ If IsDetachedBuffer(jsArrayBuffer) is true, then return the empty byte sequence. ◎ Let bytes be a new byte sequence of length equal to length.
9. ~EACH( %i ~IN { 0 〜 %長さ ~MINUS 1 } ) に対し，昇順に ⇒ %~byte列 に次の結果を付加する ⇒ `GetValueFromBuffer$A( %~js配列~buffer, %i, `Uint8^jt, `true^jv, `Unordered^i ) ◎ For i in the range offset to offset + length − 1, inclusive, set bytes[i − offset] to GetValueFromBuffer(jsArrayBuffer, i, Uint8, true, Unordered).
10. ~Assert： %~byte列 の`長さ$byte ~EQ %長さ ◎ ↑
11. ~RET %~byte列 ◎ Return bytes.

`~buffer~source型$の~instance %~buffer~source の `~byte長さ@BS は、 次の手続きの結果を返す： ◎ The byte length of a buffer source type instance bufferSource is the value returned by the following steps:

1. %~js~buffer~source ~LET `~JS値に変換する$( %~buffer~source ) ◎ Let jsBufferSource be the result of converting bufferSource to a JavaScript value.
2. ~IF［ %~js~buffer~source は `ViewedArrayBuffer^sl 内部~slotを有する ］ ⇒ ~RET %~js~buffer~source.`ByteLength^sl ◎ If jsBufferSource has a [[ViewedArrayBuffer]] internal slot, then return jsBufferSource.[[ByteLength]].
3. ~RET %~js~buffer~source.`ArrayBufferByteLength^sl ◎ Return jsBufferSource.[[ArrayBufferByteLength]].

`~buffer~source型$の~instance %~buffer~source の `下層~buffer@BS は、 次の手続きの結果を返す： ◎ The underlying buffer of a buffer source type instance bufferSource is the value returned by the following steps:

1. ~IF［ %~buffer~source は`~buffer型$の~instanceである ］ ⇒ ~RET %~buffer~source ◎ If bufferSource is a buffer type instance, then return bufferSource.
2. %~js~buffer~view ~LET `~JS値に変換する$( %~buffer~source ) ◎ Let jsBufferView be the result of converting bufferSource to a JavaScript value.
3. %~js~buffer ~LET %~js~buffer~view.`ViewedArrayBuffer^sl ◎ Let jsBuffer be jsBufferView.[[ViewedArrayBuffer]].
4. ~IF［ `IsSharedArrayBuffer$A( %~js~buffer ) ~EQ `false^jv ］ ⇒ ~RET `~IDL値に変換する$( %~js~buffer, `ArrayBuffer$T ) ◎ If IsSharedArrayBuffer(jsBuffer) is false, then return the result of converting jsBuffer to an IDL value of type ArrayBuffer.
5. ~RET `~IDL値に変換する$( %~js~buffer, `SharedArrayBuffer$T ) ◎ Return the result of converting jsBuffer to an IDL value of type SharedArrayBuffer.

`配列~bufferの中へ~byte列を書込む@ ~algoは、 所与の ( `~buffer型$の~instance %配列~buffer, `~byte列$ %~byte列, 負でない整数 %開始-時の~offset ~DF 0 ) に対し： ◎ To write a byte sequence bytes into a buffer type instance arrayBuffer, optionally given a startingOffset (default 0):

1. %~js配列~buffer ~LET `~JS値に変換する$( %配列~buffer ) ◎ Let jsArrayBuffer be the result of converting arrayBuffer to a JavaScript value.
2. ~Assert： %開始-時の~offset ~PLUS %~byte列 の`長さ$byte ~LTE %~js配列~buffer.`ArrayBufferByteLength^sl ◎ Assert: bytes’s length ≤ jsArrayBuffer.[[ArrayBufferByteLength]] − startingOffset.
3. ~EACH( %i ~IN { 0 〜 %~byte列 の`長さ$byte ~MINUS 1 } ) に対し，昇順に ⇒ `SetValueInBuffer$A( %~js配列~buffer, %i, `Uint8^jt, %~byte列[ %i ], `true^jv, `Unordered^i) ◎ For i in the range startingOffset to startingOffset + bytes’s length − 1, inclusive, perform SetValueInBuffer(jsArrayBuffer, i, Uint8, bytes[i - startingOffset], true, Unordered).

`配列~buffer~viewの中へ~byte列を書込む@ ~algoは、 所与の ( `ArrayBufferView$T %~view, `~byte列$ %~byte列, 負でない整数 %開始-時の~offset ~DF 0 ) に対し： ◎ To write a byte sequence bytes into an ArrayBufferView view, optionally given a startingOffset (default 0):

1. %~js~view ~LET `~JS値に変換する$( %~view ) ◎ Let jsView be the result of converting view to a JavaScript value.
2. %長さ ~LET %~byte列 の`長さ$byte ◎ ↓
3. ~Assert： %開始-時の~offset ~PLUS %長さ ~LTE %~js~view.`ByteLength^sl ◎ Assert: bytes’s length ≤ jsView.[[ByteLength]] − startingOffset.
4. ~Assert： ［ %型 は `DataView$T である ］~OR［ %長さ `modulo$op ( %~view の型の`要素~size$eS ) ~EQ 0 ］ ◎ Assert: if view is not a DataView, then bytes’s length modulo the element size of view’s type is 0.
5. %配列~buffer ~LET `~IDL値に変換する$( %~js~view.`ViewedArrayBuffer^sl, `ArrayBuffer$T ) ◎ Let arrayBuffer be the result of converting jsView.[[ViewedArrayBuffer]] to an IDL value of type ArrayBuffer.
6. `配列~bufferの中へ~byte列を書込む$( %配列~buffer, %~byte列, %~js~view.`ByteOffset^sl ~PLUS %開始-時の~offset ) ◎ Write bytes into arrayBuffer with startingOffset set to jsView.[[ByteOffset]] + startingOffset.

`配列~bufferを切離す@ ~algoは、 所与の ( `ArrayBuffer$T %配列~buffer ) に対し： ◎ To detach an ArrayBuffer arrayBuffer:

1. %~js配列~buffer ~LET `~JS値に変換する$( %配列~buffer ) ◎ Let jsArrayBuffer be the result of converting arrayBuffer to a JavaScript value.
2. ~ABRUPT `DetachArrayBuffer$A( %~js配列~buffer ) ◎ Perform ? DetachArrayBuffer(jsArrayBuffer).

注記： これは、［ %~js配列~buffer は `ArrayBufferDetachKey^sl を有していて， それは `undefined^jv 以外の値をとる場合 ］に例外を投出することになる — `WebAssembly.Memory＠https://webassembly.github.io/spec/js-api/#memory$M の `buffer＠https://webassembly.github.io/spec/js-api/#dom-memory-buffer$M 属性の値を伴う事例など `WASM-JS-API-1$r 。 ◎ This will throw an exception if jsArrayBuffer has an [[ArrayBufferDetachKey]] that is not undefined, such as is the case with the value of WebAssembly.Memory’s buffer attribute. [WASM-JS-API-1]

注記： すでに`切離されて$いる~bufferを切離しても，何もしない。 ◎ Detaching a buffer that is already detached is a no-op.

所与の `~buffer~source型$の~instance %~buffer~source が `切離されて@ ［ いる／いない ］とは、 次の手続きが［ ~T ／ ~F ］を返すことをいう： ◎ A buffer source type instance bufferSource is detached if the following steps return true:

1. %~js配列~buffer ~LET `~JS値に変換する$( %~buffer~source ) ◎ Let jsArrayBuffer be the result of converting bufferSource to a JavaScript value.
2. ~IF［ %~js配列~buffer は `ViewedArrayBuffer^sl 内部~slotを有する ］ ⇒ %~js配列~buffer ~SET %~js配列~buffer.`ViewedArrayBuffer^sl ◎ If jsArrayBuffer has a [[ViewedArrayBuffer]] internal slot, then set jsArrayBuffer to jsArrayBuffer.[[ViewedArrayBuffer]].
3. ~RET ~IS［ `IsDetachedBuffer$A( %~js配列~buffer ) ~EQ `true^jv ］ ◎ Return IsDetachedBuffer(jsArrayBuffer).

所与の `~buffer~source型$の~instance %~buffer~source が `転送-可能@BS ［ である／でない ］とは、 次の手続きが［ ~T ／ ~F ］を返すことをいう： ◎ A buffer source type instance bufferSource is transferable if the following steps return true:

1. %~js配列~buffer ~LET `~JS値に変換する$( %~buffer~source ) ◎ Let jsArrayBuffer be the result of converting bufferSource to a JavaScript value.
2. ~IF［ %~js配列~buffer は `ViewedArrayBuffer^sl 内部~slotを有する ］ ⇒ %~js配列~buffer ~SET %~js配列~buffer.`ViewedArrayBuffer^sl ◎ If jsArrayBuffer has a [[ViewedArrayBuffer]] internal slot, then set jsArrayBuffer to jsArrayBuffer.[[ViewedArrayBuffer]].

3. ~RET ~IS［ ~AND↓ ］：

   • `IsSharedArrayBuffer$A( %~js配列~buffer ) ~NEQ `true^jv
   • `IsDetachedBuffer$A( %~js配列~buffer ) ~NEQ `true^jv
   • %~js配列~buffer.`ArrayBufferDetachKey^sl ~EQ `undefined^jv
   ◎ If IsSharedArrayBuffer(jsArrayBuffer) is true, then return false. ◎ If IsDetachedBuffer(jsArrayBuffer) is true, then return false. ◎ If jsArrayBuffer.[[ArrayBufferDetachKey]] is not undefined, then return false. ◎ Return true.

`配列~bufferを転送する@ ~algoは、 所与の ( `ArrayBuffer$T %配列~buffer, `~realm$ %宛先~realm ~DF ε ) に対し： ◎ To transfer an ArrayBuffer arrayBuffer, optionally given a realm targetRealm:

1. %~js配列~buffer ~LET `~JS値に変換する$( %配列~buffer ) ◎ Let jsArrayBuffer be the result of converting arrayBuffer to a JavaScript value.
2. ~IF［ `IsDetachedBuffer$A( %~js配列~buffer ）~EQ ~F ］ ⇒ `~THROW$ `TypeError$jt ◎ If IsDetachedBuffer(jsArrayBuffer) is false, then throw a TypeError.
3. %配列~buffer~data ~LET %~js配列~buffer.`ArrayBufferData^sl ◎ Let arrayBufferData be jsArrayBuffer.[[ArrayBufferData]].
4. %配列~buffer~byte長さ ~LET %~js配列~buffer.`ArrayBufferByteLength^sl ◎ Let arrayBufferByteLength be jsArrayBuffer.[[ArrayBufferByteLength]].
5. ~ABRUPT `DetachArrayBuffer$A( %~js配列~buffer ) ◎ Perform ? DetachArrayBuffer(jsArrayBuffer).
6. ~IF［ %宛先~realm ~EQ ε ］ ⇒ %宛先~realm ~LET `現在の~realm$ ◎ If targetRealm is not given, let targetRealm be the current realm.
7. %~js転送-済み ~LET ~ABRUPT `AllocateArrayBuffer$A( %宛先~realm.`ArrayBuffer$jIsl, 0 ) ◎ Let jsTransferred be ? AllocateArrayBuffer(targetRealm.[[Intrinsics]].[[%ArrayBuffer%]], 0).
8. %~js転送-済み.`ArrayBufferData^sl ~SET %配列~buffer~data ◎ Set jsTransferred.[[ArrayBufferData]] to arrayBufferData.
9. %~js転送-済み.`ArrayBufferByteLength^sl ~SET %配列~buffer~byte長さ ◎ Set jsTransferred.[[ArrayBufferByteLength]] to arrayBufferByteLength.
10. ~RET `~IDL値に変換する$( %~js転送-済み, `ArrayBuffer$T ) ◎ Return the result of converting jsTransferred to an IDL value of type ArrayBuffer.

~JS値 %V を `~FrozenArray_T$ 型の`~IDL値に変換する$ための~algoは： ◎ A JavaScript value V is converted to an IDL FrozenArray<T> value by running the following algorithm:

1. %値~群 ~LET `~IDL値に変換する$( %V, ~sequence_T ) ◎ Let values be the result of converting V to IDL type sequence<T>.
2. ~RET `凍結d配列を作成する$( %値~群 ) ◎ Return the result of creating a frozen array from values.

`凍結d配列を作成する@ ~algoは、 所与の ( %T 型の値たちが成す連列 %S ) に対し： ◎ To create a frozen array from a sequence of values of type T, follow these steps:

1. %配列 ~LET `~JS値に変換する$( %S ) ◎ Let array be the result of converting the sequence of values of type T to a JavaScript value.
2. ~NOABRUPT `SetIntegrityLevel$A( %配列, `frozen^l ) ◎ Perform ! SetIntegrityLevel(array, "frozen").
3. ~RET %配列 ◎ Return array.

~JS言語束縛における，観測-可能な配列~属性を`~backしている~list$は、 所与の ( `~platform~obj$ %~obj, 属性 %属性 ) に対し，次の~algoが返す`~list$になる： ◎ The backing list for an observable array attribute in the JavaScript binding, given a platform object obj and an attribute attribute, is the list returned by the following algorithm:

1. ~Assert： %~obj は`正則~属性$ %属性 を伴う`~ifc$を`実装-$する ◎ Assert: obj implements an interface with the regular attribute attribute.
2. %観測-可能な配列 ~LET %~obj の %属性 を`~backしている観測-可能な配列~exotic~obj$ ◎ Let oa be obj’s backing observable array exotic object for attribute.
3. ~RET %観測-可能な配列.`ProxyHandler^sl.`BackingList^sl ◎ Return oa.[[ProxyHandler]].[[BackingList]].

所与の ( 構成子 %C, 何か %H ) の `交差~公開~集合@ は、 次に従って定義される： ◎ The exposure set intersection of a construct C and interface-or-null H is defined as follows:

1. ~Assert： %C は次に挙げるいずれかである ⇒＃ `~ifc~mb$ ／ `~ifc~mixin~mb$ ／ `~ns~mb$ ／ `部分的な~ifc$ ／ `部分的な~ifc~mixin$ ／ `部分的な~ns$ ／ `~ifc~mixin$ ◎ Assert: C is an interface member, interface mixin member, namespace member, partial interface, partial interface mixin, partial namespace, or interface mixin.
2. ~Assert： %H は［ `~ifc$ ／ ~NULL ］である。 ◎ Assert: H is an interface or null.
3. ~IF［ %H ~EQ ~NULL ］ ⇒ ~RET %C の`自前の公開~集合$ ◎ If H is null, return C’s own exposure set.
4. ~IF［ %C の`自前の公開~集合$ ~EQ `*^c ］ ⇒ ~RET %H の`公開~集合$ ◎ If C’s own exposure set is *, return H’s exposure set.
5. ~IF［ %H の`公開~集合$ ~EQ `*^c ］ ⇒ ~RET %C の`自前の公開~集合$ ◎ If H’s exposure set is *, return C’s own exposure set.
6. ~RET `交差集合$( %C の`自前の公開~集合$, %H の`公開~集合$ ) ◎ Return the intersection of C’s own exposure set and H’s exposure set.

所与の構成子 %C の `公開~集合@ を取得するときは、 次の手続きを走らす： ◎ To get the exposure set of a construct C, run the following steps:

1. ~Assert： %C は次に挙げるいずれかである ⇒＃ `~ifc$ ／ `~callback~ifc$ ／ `~ns$ ／ `~ifc~mb$ ／ `~ifc~mixin~mb$ ／ `~ns~mb$ ◎ Assert: C is an interface, callback interface, namespace, interface member, interface mixin member, or namespace member.
2. %H ~LET ［ %C は`~ifc~mixin~mb$であるならば %C の`~host~ifc$ ／ ~ELSE_ ~NULL ］ ◎ Let H be C’s host interface if C is an interface mixin member, or null otherwise.

3. ~IF［ %C は［ `~ifc~mb$ ／ `~ifc~mixin~mb$ ／ `~ns~mb$ ］である ］： ◎ If C is an interface member, interface mixin member, or namespace member, then:

   1. ~IF［ %C 上に `Exposed$x `拡張d属性$は指定されている ］ ⇒ ~RET ( %C, %H ) の`交差~公開~集合$ ◎ If the [Exposed] extended attribute is specified on C, return the exposure set intersection of C and H.
   2. %C ~SET %C を宣言している［ `~ifc$ ／ `部分的な~ifc$ ／ `~ifc~mixin$ ／ `部分的な~ifc~mixin$ ／ `~ns$ ／ `部分的な~ns$ ］ ◎ Set C to the interface, partial interface, interface mixin, partial interface mixin, namespace, or partial namespace C is declared on.

4. ~IF［ %C は［ `部分的な~ifc$ ／ `部分的な~ifc~mixin$ ／ `部分的な~ns$ ］である ］： ◎ If C is a partial interface, partial interface mixin, or partial namespace, then:

   1. ~IF［ %C 上に `Exposed$x `拡張d属性$は指定されている ］ ⇒ ~RET ( %C, %H ) の`交差~公開~集合$ ◎ If the [Exposed] extended attribute is specified on C, return the exposure set intersection of C and H.
   2. %C ~SET %C の元の［ `~ifc$ ／ `~ifc~mixin$ ／ `~ns$ ］定義 ◎ Set C to the original interface, interface mixin, or namespace definition of C.

5. ~IF［ %C は`~ifc~mixin$である ］： ◎ If C is an interface mixin, then:

   1. ~Assert： %H ~NEQ ~NULL ◎ Assert: H is not null.
   2. ~IF［ %C 上に `Exposed$x `拡張d属性$は指定されている ］ ⇒ ~RET ( %C, %H ) の`交差~公開~集合$ ◎ If the [Exposed] extended attribute is specified on C, return the exposure set intersection of C and H.
   3. %C ~SET %H ◎ Set C to H.
6. ~Assert： %C は次に挙げるいずれかである ⇒＃ `~ifc$ ／ `~callback~ifc$ ／ `~ns$ ◎ Assert: C is an interface, callback interface or namespace.
7. ~Assert： %C 上に `Exposed$x `拡張d属性$は指定されている ◎ Assert: The [Exposed] extended attribute is specified on C.
8. ~RET %C の`自前の公開~集合$ ◎ Return C’s own exposure set.

所与の［ `~ifc$ ／ `~callback~ifc$ ／ `~ns$ ／ `~mb$ ］ %構成子 は、 次の手続きが ~T を返すならば，`~realm$ %~realm 内に `公開されて@ いるとされる： ◎ An interface, callback interface, namespace, or member construct is exposed in a given realm realm if the following steps return true:

1. ~IF［ %構成子 の`公開~集合$ ~NEQ `*^c ］~AND［ %~realm.`GlobalObject^sl は、 %構成子 の`公開~集合$を成す どの~ifcも実装していない ］ ⇒ ~RET ~F ◎ If construct’s exposure set is not *, and realm.[[GlobalObject]] does not implement an interface that is in construct’s exposure set, then return false.
2. ~IF［ %~realm の`設定群~obj$は`~secureな文脈$enVでない ］~AND［ %構成子 は `SecureContext$x 上で`条件付きで公開されて$いる ］ ⇒ ~RET ~F ◎ If realm’s settings object is not a secure context, and construct is conditionally exposed on [SecureContext], then return false.
3. ~IF［ %~realm の`設定群~obj$の`非同一-生成元~能力は隔離されるか？$enV ~EQ ~F ］~AND［ %構成子 は `CrossOriginIsolated$x 上で`条件付きで公開されて$いる ］ ⇒ ~RET ~F ◎ If realm’s settings object’s cross-origin isolated capability is false, and construct is conditionally exposed on [CrossOriginIsolated], then return false.
4. ~RET ~T ◎ Return true.

所与の［ `~ifc$ ／ `~callback~ifc$ ／ `~ns$ ／ `~mb$ ］ %構成子 は、 次の手続きが ~T を返すならば，所与の`拡張d属性$ %公開~条件 上で `条件付きで公開されて@ いるとされる： ◎ An interface, callback interface, namespace, or member construct is conditionally exposed on a given extended attribute exposure condition if the following steps return true:

1. ~Assert： %構成子 は次に挙げるいずれかである ⇒＃ `~ifc$ ／ `~callback~ifc$ ／ `~ns$ ／ `~ifc~mb$ ／ `~ifc~mixin~mb$ ／ `~ns~mb$ ◎ Assert: construct is an interface, callback interface, namespace, interface member, interface mixin member, or namespace member.
2. %H ~LET ［ %構成子 は`~ifc~mixin~mb$であるならば %構成子 の`~host~ifc$ ／ ~ELSE_ ~NULL ］ ◎ Let H be construct’s host interface if construct is an interface mixin member, or null otherwise.

3. ~IF［ %構成子 は［ `~ifc~mb$ ／ `~ifc~mixin~mb$ ／ `~ns~mb$ ］である ］： ◎ If construct is an interface member, interface mixin member, or namespace member, then:

   1. ~IF［ %構成子 上に %公開~条件 `拡張d属性$は指定されている ］ ⇒ ~RET ~T ◎ If the exposure condition extended attribute is specified on construct, then return true.
   2. %構成子 ~SET %構成子 を宣言している［ `~ifc$ ／ `部分的な~ifc$ ／ `~ifc~mixin$ ／ `部分的な~ifc~mixin$ ／ `~ns$ ／ `部分的な~ns$ ］ ◎ Otherwise, set construct to be the interface, partial interface, interface mixin, partial interface mixin, namespace, or partial namespace construct is declared on.

4. ~IF［ %構成子 は［ `部分的な~ifc$ ／ `部分的な~ifc~mixin$ ／ `部分的な~ns$ ］である ］： ◎ If construct is a partial interface, partial interface mixin, or partial namespace, then:

   1. ~IF［ %構成子 上に %公開~条件 `拡張d属性$は指定されている ］ ⇒ ~RET ~T ◎ If the exposure condition extended attribute is specified on construct, then return true.
   2. %構成子 ~SET %構成子 の元の［ `~ifc$ ／ `~ifc~mixin$ ／ `~ns$ ］定義 ◎ Otherwise, set construct to be the original interface, interface mixin, or namespace definition of construct.

5. ~IF［ %構成子 は`~ifc~mixin$である ］： ◎ If construct is an interface mixin, then:

   1. ~IF［ %構成子 上に %公開~条件 `拡張d属性$は指定されている ］ ⇒ ~RET ~T ◎ If the exposure condition extended attribute is specified on construct, then return true.
   2. %構成子 ~SET %H ◎ Otherwise, set construct to H.
6. ~Assert： %構成子 は次に挙げるいずれかである ⇒＃ `~ifc$ ／ `~callback~ifc$ ／ `~ns$ ◎ Assert: construct is an interface, callback interface or namespace.
7. ~IF［ %構成子 上に %公開~条件 `拡張d属性$は指定されている ］ ⇒ ~RET ~T ◎ If the exposure condition extended attribute is specified on construct, then return true.
8. ~RET ~F ◎ Otherwise, return false.

[Exposed=Window, Global=Window]
interface Window {
  /* ... */
};

/* 
`SharedWorkerGlobalScope^T と `DedicatedWorkerGlobalScope^T
の両者に同じ識別子 `Worker^l を利用する
— 両者は `Exposed^x 拡張d属性からまとめて指せるようになる：
◎
By using the same identifier Worker for both SharedWorkerGlobalScope and DedicatedWorkerGlobalScope, both can be addressed in an [Exposed] extended attribute at once.
 */
[Exposed=Worker, Global=Worker]
interface SharedWorkerGlobalScope : WorkerGlobalScope {
  /* ... */
};

[Exposed=Worker, Global=Worker]
interface DedicatedWorkerGlobalScope : WorkerGlobalScope {
  /* ... */
};

/* 
`Dimensions^T は、
~main~thread上でも, ~workerの中でも可用になる：
◎
Dimensions is available for use in workers and on the main thread.
 */
[Exposed=(Window,Worker)]
interface Dimensions {
  constructor(double %width, double %height);
  readonly attribute double %width;
  readonly attribute double %height;
};

/* 
`WorkerNavigator^T は、
~workerの中に限り可用になる
— ~workerの大域~scopeの中で `WorkerNavigator^T を評価したときは~ifc~objを得られる一方で、
~main~thread上でそうしたときは `ReferenceError^jE になる：
◎
WorkerNavigator is only available in workers.  Evaluating WorkerNavigator in the global scope of a worker would give you its interface object, while doing so on the main thread will give you a ReferenceError.
 */
[Exposed=Worker]
interface WorkerNavigator {
  /* ... */
};

/* 
`Node^T は、
~main~thread上に限り可用になる
— ~workerの大域~scopeの中で `Node^T を評価したときは `ReferenceError^jE になる：
◎
Node is only available on the main thread.  Evaluating Node in the global scope of a worker would give you a ReferenceError.
 */
[Exposed=Window]
interface Node {
  /* ... */
};

/* 
`MathUtils^T は、
~main~thread上でも, ~workerの中でも可用になる：
◎
MathUtils is available for use in workers and on the main thread.
 */
[Exposed=(Window,Worker)]
namespace MathUtils {
  double someComplicatedFunction(double %x, double %y);
};

/* 
`WorkerUtils^T は、
~workerの中に限り可用になる
— ~workerの大域~scopeの中で `WorkerUtils^T を評価したときは その~ns~objを得られる一方で、
~main~thread上でそうしたときは `ReferenceError^jE になる：
◎
WorkerUtils is only available in workers.  Evaluating WorkerUtils in the global scope of a worker would give you its namespace object, while doing so on the main thread will give you a ReferenceError.
 */
[Exposed=Worker]
namespace WorkerUtils {
  undefined setPriority(double %x);
};

/* 
`NodeUtils^T は、
~main~thread上に限り可用になる
— ~workerの大域~scopeの中で `Node^T を評価したときは `ReferenceError^jE になる：
◎
NodeUtils is only available in the main thread.  Evaluating NodeUtils in the global scope of a worker would give you a ReferenceError.
 */
[Exposed=Window]
namespace NodeUtils {
  DOMString getAllText(Node %node);
};

`~ifc$用の`~ifc~obj$は、 以下に従って作成される — `~ifc~objを作成する@ ~algoは、 所与の ( `~ifc$ %I, `識別子$ %識別子, `~realm$ %~realm ) に対し： ◎ The interface object for a given interface I with identifier id and in realm realm is created as follows:

1. %手続き ~LET ［ %I は`構築子を上書きする手続き$を備えるならば それ／ ~ELSE_ 次に与える手続き ］ ◎ Let steps be I’s overridden constructor steps if they exist, or the following steps otherwise:

   1. ~IF［ %I は`構築子~演算$を伴って宣言されてない ］ ⇒ `~THROW$ `TypeError$jt ◎ If I was not declared with a constructor operation, then throw a TypeError.
   2. ~IF［ `NewTarget$ ~EQ `undefined^jv ］ ⇒ `~THROW$ `TypeError$jt ◎ If NewTarget is undefined, then throw a TypeError.
   3. %引数~群 ~LET 渡された引数たちからなる~list ◎ Let args be the passed arguments.
   4. %S ~LET %I の構築子~用の`有効-多重定義~集合を算出する$( `識別子$ %識別子, 引数個数 %n ) ◎ Let id be the identifier of interface I. 原文削除漏れ ◎ Compute the effective overload set for constructors with identifier id on interface I and with argument count n, and let S be the result.
   5. <%構築子, %値~群> ~LET ( %S, %引数~群 ) を`多重定義~解決~algo$に渡した結果 ◎ Let <constructor, values> be the result of passing S and args to the overload resolution algorithm.
   6. %object ~LET `~ifcを実装する新たな~objを作成する$( %I, %~realm, `NewTarget$ ) ◎ Let object be the result of internally creating a new object implementing I, with realm and NewTarget.
   7. %構築子 の`構築子~手続き$を［ `this$V として %object, 引数~list %値~群 ］を与える下で遂行する ◎ Perform the constructor steps of constructor with object as this and values as the argument values.
   8. %O ~LET `~JS値に変換する$( %object ) ◎ Let O be object, converted to a JavaScript value.
   9. ~Assert： %O は %I を`実装-$する~objである ◎ Assert: O is an object that implements I.
   10. ~Assert： %O.`Realm^sl ~EQ %~realm ◎ Assert: O.[[Realm]] is realm.
   11. ~RET %O ◎ Return O.
2. %構築子~原型 ~LET %~realm.`Function.prototype$jIsl ◎ Let constructorProto be realm.[[Intrinsics]].[[%Function.prototype%]].
3. ~IF［ %I は他の~ifc %P を継承する ］ ⇒ %構築子~原型 ~SET %~realm に属する %P 用の`~ifc~obj$ ◎ If I inherits from some other interface P, then set constructorProto to the interface object of P in realm.
4. %偽造-不能~obj ~LET `OrdinaryObjectCreate$A( `null^jv ) ◎ Let unforgeables be OrdinaryObjectCreate(null).
5. `偽造-不能な正則~演算を定義する$( %I, %偽造-不能~obj, %~realm ) ◎ Define the unforgeable regular operations of I on unforgeables, given realm.
6. `偽造-不能な正則~属性を定義する$( %I, %偽造-不能~obj, %~realm ) ◎ Define the unforgeable regular attributes of I on unforgeables, given realm.

7. %F.`Unforgeables^sl ~SET %偽造-不能~obj ◎ Set F.[[Unforgeables]] to unforgeables.

   注記： この~objは、 利用元~codeには決して公開されず，次を確保するために限り存在する ⇒ 偽造-不能な~mbを伴う~ifcのすべて~instanceは、［ `属性~取得子を作成する$／`属性~設定子を作成する$／`演算~関数を作成する$ ］のそれぞれに対し，同じ~JS関数~objを利用する ◎ Note: this object is never exposed to user code. It exists only to ensure all instances of an interface with an unforgeable member use the same JavaScript function objects for attribute getters, attribute setters and operation functions.

8. %長さ ~LET 0 ◎ Let length be 0.

9. ~IF［ %I は`構築子~演算$を伴って宣言された ］： ◎ If I was declared with a constructor operation, then

   1. %S ~LET %I の構築子~用の`有効-多重定義~集合を算出する$( `識別子$ %識別子, 引数個数 0 ) ◎ Compute the effective overload set for constructors with identifier id on interface I and with argument count 0, and let S be the result.
   2. %長さ ~SET %S 内の各~entryの引数~listの長さのうち，最小 ◎ Set length to the length of the shortest argument list of the entries in S.
10. %F ~LET `CreateBuiltinFunction$A( %手続き, %長さ, %識別子, « `Unforgeables^sl », %~realm, %構築子~原型 ) ◎ Let F be CreateBuiltinFunction(steps, length, id, « [[Unforgeables]] », realm, constructorProto).
11. %proto ~LET `~ifc原型~objを作成する$( %I, %~realm ) ◎ Let proto be the result of creating an interface prototype object of interface I in realm.
12. ~NOABRUPT `DefinePropertyOrThrow$A( %F, `prototype^l, `FFF-proto^desc ) ◎ Perform ! DefinePropertyOrThrow(F, "prototype", PropertyDescriptor{[[Value]]: proto, [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false}).
13. `定数を定義する$( %I, %F, %~realm ) ◎ Define the constants of interface I on F given realm.
14. `静的~属性を定義する$( %I, %F, %~realm ) ◎ Define the static attributes of interface I on F given realm.
15. `静的~演算を定義する$( %I, %F, %~realm ) ◎ Define the static operations of interface I on F given realm.
16. ~RET %F ◎ Return F.

`~ifc$用の`旧来の~factory関数$は、 以下に従って作成される — `旧来の~factory関数を作成する@ ~algoは、 所与の ( `~ifc$ %I, `識別子$ %識別子, `~realm$ %~realm ) に対し： ◎ The legacy factory function with identifier id for a given interface I in realm realm is created as follows:

1. %識別子 ~LET `旧来の~factory関数$の`識別子$fF ◎ ↑

2. %手続き ~LET 次に与える手続き： ◎ Let steps be the following steps:

   1. %S ~LET %I の旧来の~factory関数~用の`有効-多重定義~集合を算出する$( `識別子$ %識別子, 引数個数 %n ) ◎ Compute the effective overload set for legacy factory functions with identifier id on interface I and with argument count n, and let S be the result.
   2. ~RET %O ◎ Return O.
3. %S ~LET %I の旧来の~factory関数~用の`有効-多重定義~集合を算出する$( `識別子$ %識別子, 引数個数 0 ) ◎ Compute the effective overload set for legacy factory functions with identifier id on interface I and with argument count 0, and let S be the result.
4. %長さ ~LET %S 内の各~entryの引数~listの長さのうち，最小 ◎ Let length be the length of the shortest argument list of the entries in S.
5. %F ~LET `CreateBuiltinFunction$A( %手続き, %長さ, %識別子, « », %~realm ) ◎ Let F be CreateBuiltinFunction(steps, length, id, « », realm).
6. %proto ~LET %~realm 内で %I を成す`~ifc原型~obj$ ◎ Let proto be the interface prototype object of interface I in realm.

`~ifc原型~objを作成する@ ~algoは、 所与の ( `~ifc$ %~ifc, `~realm$ %~realm ) に対し，`~ifc原型~obj$を作成して返す： ◎ The interface prototype object for a given interface interface and realm realm is created as follows:

1. %原型 ~LET ~NULL ◎ Let proto be null.
2. ~IF［ %~ifc は `Global$x `拡張d属性$を伴って宣言された ］~AND［ %~ifc は`有名~propを~support$する ］ ⇒ %原型 ~SET `有名~prop群~objを作成する$( %~ifc, %~realm ) ◎ If interface is declared with the [Global] extended attribute, and interface supports named properties, then set proto to the result of creating a named properties object for interface and realm.
3. ~ELIF［ %~ifc は別の~ifc %B を`継承-$するように宣言された ］ ⇒ %原型 ~SET %~realm 内の %B 用の`~ifc原型~obj$ ◎ Otherwise, if interface is declared to inherit from another interface, then set proto to the interface prototype object in realm of that inherited interface.
4. ~ELIF［ %~ifc は `DOMException$T `~ifc$である ］ ⇒ %原型 ~SET %~realm.`Error.prototype$jIsl ◎ Otherwise, if interface is the DOMException interface, then set proto to realm.[[Intrinsics]].[[%Error.prototype%]].
5. ~ELSE ⇒ %原型 ~SET %~realm.`Object.prototype$jIsl ◎ Otherwise, set proto to realm.[[Intrinsics]].[[%Object.prototype%]].
6. ~Assert： %原型 は `Object$jt である ◎ Assert: proto is an Object.
7. %~ifc原型~obj ~LET ~NULL ◎ Let interfaceProtoObj be null.
8. ~IF［ %~realm の`大域~原型鎖は変異-可能か$ ~EQ ~T ］ ⇒ %~ifc原型~obj ~SET `OrdinaryObjectCreate$A( %原型 ) ◎ If realm’s is global prototype chain mutable is true, then: • Set interfaceProtoObj to OrdinaryObjectCreate(proto).

9. ~ELIF［ %~ifc の`自身も含む継承した~ifc群$を成すある~ifcは、 `Global$x `拡張d属性$を伴って宣言された 【！declared with..., or %I が`継承した~ifc群$】 ］： ◎ Otherwise, if interface is declared with the [Global] extended attribute, or interface is in the set of inherited interfaces of an interface that is declared with the [Global] extended attribute, then:

   1. %~ifc原型~obj ~SET `MakeBasicObject$A( « `Prototype^sl, `Extensible^sl » ) ◎ Set interfaceProtoObj to MakeBasicObject(« [[Prototype]], [[Extensible]] »).
   2. %~ifc原型~obj.`Prototype^sl ~SET %原型 ◎ Set interfaceProtoObj.[[Prototype]] to proto.
   3. %~ifc原型~obj を成す［ `変異-不能な原型~exotic~obj$に特有な各 内部~method ］を［ `ECMA-262$r `変異-不能な原型~exotic~obj＠~TC39#sec-immutable-prototype-exotic-object§に指定される各 定義 ］に設定する ◎ Set the internal methods of interfaceProtoObj which are specific to immutable prototype exotic objects to the definitions specified in ECMA-262 Immutable prototype exotic objects.
10. ~ELSE ⇒ %~ifc原型~obj ~SET `OrdinaryObjectCreate$A( %原型 ) ◎ Otherwise, set interfaceProtoObj to OrdinaryObjectCreate(proto).

11. ~IF［ %~ifc のある`~mb$は `Unscopable$x `拡張d属性$を伴って宣言された ］： ◎ If interface has any member declared with the [Unscopable] extended attribute, then:

    1. %~scope不能~obj ~LET `OrdinaryObjectCreate$A( `null^jv ) ◎ Let unscopableObject be OrdinaryObjectCreate(null).

    2. %~ifc に`公開されて$いる, かつ `Unscopable$x `拡張d属性$を伴って宣言された ~EACH( `~mb$ %~mb ) に対し： ◎ For each exposed member member of interface that is declared with the [Unscopable] extended attribute:

       1. %識別子 ~LET %~mb の`識別子$ ◎ Let id be member’s identifier.
       2. ~NOABRUPT `CreateDataPropertyOrThrow$A( %~scope不能~obj, %識別子, `true^jv ) ◎ Perform ! CreateDataPropertyOrThrow(unscopableObject, id, true).
    3. %記述子 ~LET `FFT-~scope不能~obj^desc ◎ Let desc be the PropertyDescriptor{[[Value]]: unscopableObject, [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true}.
    4. ~NOABRUPT `DefinePropertyOrThrow$A( %~ifc原型~obj, `Symbol.toStringTag$jI, %記述子 ) ◎ Perform ! DefinePropertyOrThrow(interfaceProtoObj, %Symbol.unscopables%, desc).

12. ~IF［ %~ifc は `Global$x `拡張d属性$を伴って宣言されてない ］： ◎ If interface is not declared with the [Global] extended attribute, then:

    1. `正則~属性を定義する$( %~ifc, %~ifc原型~obj, %~realm ) ◎ Define the regular attributes of interface on interfaceProtoObj given realm.
    2. `正則~演算を定義する$( %~ifc, %~ifc原型~obj, %~realm ) ◎ Define the regular operations of interface on interfaceProtoObj given realm.
    3. `反復子~methodを定義する$( %~ifc, %~ifc原型~obj, %~realm ) ◎ Define the iteration methods of interface on interfaceProtoObj given realm.
    4. `非同期~反復子~methodを定義する$( %~ifc, %~ifc原型~obj, %~realm ) ◎ Define the asynchronous iteration methods of interface on interfaceProtoObj given realm.
13. `定数を定義する$( %~ifc, %~ifc原型~obj, %~realm ) ◎ Define the constants of interface on interfaceProtoObj given realm.

14. ~IF［ %~ifc には `LegacyNoInterfaceObject$x `拡張d属性$は指定されていない ］： ◎ If the [LegacyNoInterfaceObject] extended attribute was not specified on interface, then:

    1. %構築子 ~LET %~realm 内で %~ifc を成す`~ifc~obj$ ◎ Let constructor be the interface object of interface in realm.
    2. %記述子 ~LET `TFT-構築子^desc ◎ Let desc be the PropertyDescriptor{[[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true, [[Value]]: constructor}.
    3. ~NOABRUPT `DefinePropertyOrThrow$A( %~ifc原型~obj, `constructor^l, %記述子 ) ◎ Perform ! DefinePropertyOrThrow(interfaceProtoObj, "constructor", desc).
15. ~RET %~ifc原型~obj ◎ Return interfaceProtoObj.

[Exposed=Window,
 LegacyNoInterfaceObject]
interface Foo {
};

partial interface Window {
  attribute Foo foo;
};

`有名~prop群~objを作成する@ ~algoは、 所与の ( `~ifc$ %~ifc, `~realm$ %~realm ) に対し，`有名~prop群~obj$を作成して返す： ◎ The named properties object for a given interface interface and realm realm, is created as follows:

1. %原型 ~LET ~NULL ◎ Let proto be null.
2. ~IF［ %~ifc は別の~ifc %B を`継承-$するように宣言された ］ ⇒ %原型 ~SET %~realm 内の %B 用の`~ifc原型~obj$ ◎ If interface is declared to inherit from another interface, then set proto to the interface prototype object in realm for the inherited interface.
3. %~obj ~LET `MakeBasicObject$A( « `Prototype^sl, `Extensible^sl » ) ◎ Let obj be MakeBasicObject(« [[Prototype]], [[Extensible]] »).
4. %~obj の ⇒＃ .`GetOwnProperty^sl ~SET `GetOwnProperty＠#named-properties-object-getownproperty§sl に指定される手続き； .`DefineOwnProperty^sl ~SET `DefineOwnProperty＠#named-properties-object-defineownproperty§sl に指定される手続き； .`Delete^sl ~SET `Delete＠#named-properties-object-delete§sl に指定される手続き； .`SetPrototypeOf^sl ~SET `SetPrototypeOf＠#named-properties-object-setprototypeof§sl に指定される手続き； .`PreventExtensions^sl ~SET `PreventExtensions＠#named-properties-object-preventextensions§sl に指定される手続き ◎ Set obj.[[GetOwnProperty]] as specified in § 3.7.4.1 [[GetOwnProperty]]. ◎ Set obj.[[DefineOwnProperty]] as specified in § 3.7.4.2 [[DefineOwnProperty]]. ◎ Set obj.[[Delete]] as specified in § 3.7.4.3 [[Delete]]. ◎ Set obj.[[SetPrototypeOf]] as specified in § 3.7.4.4 [[SetPrototypeOf]]. ◎ Set obj.[[PreventExtensions]] as specified in § 3.7.4.5 [[PreventExtensions]].
5. %~obj.`Prototype^sl ~SET %原型 ◎ Set obj.[[Prototype]] to proto.
6. ~RET %~obj ◎ Return obj.

`定数を定義する@ ~algoは、 所与の ( ［ `~ifc$／`~callback~ifc$／`~ns$ ］ %定義, %~target, `~realm$ %~realm ) に対し： ◎ To define the constants of interface, callback interface, or namespace definition on target, given realm realm, run the following steps:

1. %定義 を成す`~mb$のうち，`定数$である ~EACH( %定数 ) に対し： ◎ For each constant const that is a member of definition:

   1. ~IF［ %定数 は%~realm 内に`公開されて$いない ］ ⇒ ~CONTINUE ◎ If const is not exposed in realm, then continue.
   2. %値 ~LET `~JS値に変換する$( %定数 の~IDL値 ) ◎ Let value be the result of converting const’s IDL value to a JavaScript value.
   3. %記述子 ~LET `FTF-値^desc ◎ Let desc be the PropertyDescriptor{[[Writable]]: false, [[Enumerable]]: true, [[Configurable]]: false, [[Value]]: value}.
   4. %識別子 ~LET %定数 の`識別子$ ◎ Let id be const’s identifier.
   5. ~NOABRUPT `DefinePropertyOrThrow$A( %~target, %識別子, %記述子 ) ◎ Perform ! DefinePropertyOrThrow(target, id, desc).

`正則~属性を定義する@ ~algoは、 所与の ( `~ifc$／`~ns$ %定義, %~target, `~realm$ %~realm ) に対し： ◎ To define the regular attributes of interface or namespace definition on target, given realm realm, run the following steps:

1. %属性~群 ~LET ［ %定義 を成す`~mb$のうち，`正則~属性$である, かつ `偽造-不能$でないもの ］からなる`~list$ ◎ Let attributes be the list of regular attributes that are members of definition. ◎ Remove from attributes all the attributes that are unforgeable.
2. `属性を定義する$( %属性~群, %定義, %~target, %~realm ) ◎ Define the attributes attributes of definition on target given realm.

`静的~属性を定義する@ ~algoは、 所与の ( `~ifc$／`~ns$ %定義, %~target, `~realm$ %~realm ) に対し： ◎ To define the static attributes of interface or namespace definition on target, given realm realm, run the following steps:

1. %属性~群 ~LET ［ %定義 を成す`~mb$のうち，`静的~属性$であるもの ］からなる`~list$ ◎ Let attributes be the list of static attributes that are members of definition.

`偽造-不能な正則~属性を定義する@ ~algoは、 所与の ( `~ifc$／`~ns$ %定義, %~target, `~realm$ %~realm ) に対し： ◎ To define the unforgeable regular attributes of interface or namespace definition on target, given realm realm, run the following steps:

1. %属性~群 ~LET ［ %定義 を成す`~mb$のうち，`正則~属性$である, かつ `偽造-不能$であるもの ］からなる`~list$ ◎ Let attributes be the list of unforgeable regular attributes that are members of definition.

`属性を定義する@ ~algoは、 所与の ( %属性~群, `~ifc$／`~ns$ %定義, %~target, `~realm$ %~realm ) に対し： ◎ To define the attributes attributes of interface or namespace definition on target given realm realm, run the following steps:

1. %属性~群 を成す ~EACH( `属性$ %属性 ) に対し： ◎ For each attribute attr of attributes:

   1. ~IF［ %属性 は %~realm 内に`公開されて$いない ］ ⇒ ~CONTINUE ◎ If attr is not exposed in realm, then continue.
   2. %取得子 ~LET `属性~取得子を作成する$( %属性, %定義, %~realm ) ◎ Let getter be the result of creating an attribute getter given attr, definition, and realm.

   3. %設定子 ~LET `属性~設定子を作成する$( %属性, %定義, %~realm ) ◎ Let setter be the result of creating an attribute setter given attr, definition, and realm.

      注記： `属性~設定子を作成する$~algoは、 %属性 は`読専$である場合には `undefined^jv を返す。 ◎ Note: the algorithm to create an attribute setter returns undefined if attr is read only.

   4. %~configure可能 ~LET ［ %属性 は`偽造-不能$であるならば `false^jv ／ ~ELSE_ `true^jv ］ ◎ Let configurable be false if attr is unforgeable and true otherwise.
   5. %記述子 ~LET { [[Getter]]: %取得子, [[Setter]]: %設定子, [[Enumerable]]: `true^jv, [[Configurable]]: %~configure可能 } ◎ Let desc be the PropertyDescriptor{[[Getter]]: getter, [[Setter]]: setter, [[Enumerable]]: true, [[Configurable]]: configurable}.
   6. %識別子 ~LET %属性 の`識別子$ ◎ Let id be attr’s identifier.
   7. ~NOABRUPT `DefinePropertyOrThrow$A( %~target, %識別子, %記述子 ) ◎ Perform ! DefinePropertyOrThrow(target, id, desc).
   8. ~IF［ %属性 の型は型~引数 %T を伴う`観測-可能な配列~型$である ］ ⇒ %~target の %属性 を`~backしている観測-可能な配列~exotic~obj$ ~SET %~realm 内に`観測-可能な配列~exotic~objを作成する$( ↓ ) ⇒＃ %T, %属性 用の`観測-可能な配列~属性の有index値を設定する$~algo, %属性 用の`観測-可能な配列~属性の有index値を削除する$~algo ◎ If attr’s type is an observable array type with type argument T, then set target’s backing observable array exotic object for attr to the result of creating an observable array exotic object in realm, given T, attr’s set an indexed value algorithm, and attr’s delete an indexed value algorithm.

`属性~取得子を作成する@ ~algoは、 所与の ( `属性$ %属性, ［`~ifc$／`~ns$］ %target, `~realm$ %~realm ) に対し： ◎ The attribute getter is created as follows, given an attribute attribute, a namespace or interface target, and a realm realm:

1. %手続き ~LET 以下を走らす手続き — ただし，手続きの中で`例外が投出された$ときは、 その下に与える手続きを走らすとする： ◎ Let steps be the following series of steps: ◎ Try running the following steps:

   1. %~idl~obj ~LET `null^V ◎ Let idlObject be null.

   2. ~IF［ %target は`~ifc$である ］~AND［ %属性 は`正則~属性$である ］： ◎ If target is an interface, and attribute is a regular attribute:

      1. %~js値 ~LET `this^jv 値 ◎ ↓

      2. ~IF［ %~js値 ~IN { `null^jv, `undefined^jv } ］ ⇒ %~js値 ~SET %~realm の`大域~obj$ ◎ Let jsValue be the this value, if it is not null or undefined, or realm’s global object otherwise.＼

         （［ この大域~objが %target を実装しない ］かつ［ %属性 には `LegacyLenientThis$x は指定されていない ］場合、 数~段~先で `TypeError$jE が生じることになる。） ◎ (This will subsequently cause a TypeError in a few steps, if the global object does not implement target and [LegacyLenientThis] is not specified.)

      3. ~IF［ %~js値 は `~platform~objである$ ］ ⇒ `~security検査を遂行する$( %~js値, %属性 の`識別子$, `取得子^C ) ◎ If jsValue is a platform object, then perform a security check, passing jsValue, attribute’s identifier, and "getter".

      4. ~IF［ %~js値 は %target を`実装-$しない ］： ◎ If jsValue does not implement target, then:

         1. ~IF［ %属性 には `LegacyLenientThis$x `拡張d属性$が指定されている ］ ⇒ ~RET `undefined^jv ◎ If attribute was specified with the [LegacyLenientThis] extended attribute, then return undefined.
         2. `~THROW$ `TypeError$jt ◎ Otherwise, throw a TypeError.
      5. ~IF［ %属性 の型は`観測-可能な配列~型$である ］ ⇒ ~RET %~js値 の %属性 を`~backしている観測-可能な配列~exotic~obj$ ◎ If attribute’s type is an observable array type, then return jsValue’s backing observable array exotic object for attribute.
      6. %~idl~obj ~SET %~js値 への参照を表現する，~IDL`~ifc型$の値 ◎ Set idlObject to the IDL interface type value that represents a reference to jsValue.
   3. %R ~LET %属性 の`取得子~手続き$を［ `this$V として %~idl~obj ］を与える下で走らせた結果 ◎ Let R be the result of running the getter steps of attribute with idlObject as this.
   4. ~RET （ %属性 に宣言された型から）`~JS値に変換する$( %R ) ◎ Return the result of converting R to a JavaScript value of the type attribute is declared as.

   上で`例外が投出された$ときは、 その例外 %E に対し： ◎ And then, if an exception E was thrown:

   1. ~IF［ %属性 の型は`~promise型$である ］ ⇒ ~RET ~NOABRUPT `Call$A( `Promise.reject$jI, `Promise$jI, « %E » ) ◎ If attribute’s type is a promise type, then return ! Call(%Promise.reject%, %Promise%, «E»).
   2. `~THROW$ %E ◎ Otherwise, end these steps and allow the exception to propagate.
2. %名前 ~LET 次を順に`連結する$ ⇒＃ 文字列 `get^l, `0020^U ~SPACE, %属性 の`識別子$ ◎ Let name be the string "get " prepended to attribute’s identifier.
3. %F ~LET `CreateBuiltinFunction$A( %手続き, 0, %名前, « », %~realm ) ◎ Let F be CreateBuiltinFunction(steps, 0, name, « », realm).

`属性~設定子を作成する@ ~algoは、 所与の ( `属性$ %属性, `~ns$または`~ifc$ %target, `~realm$ %~realm ) に対し： ◎ The attribute setter is created as follows, given an attribute attribute, a namespace or interface target, and a realm realm:

1. ~IF［ %target は`~ns$である ］： ◎ If target is a namespace:

   1. ~Assert： %属性 は`読専$である ◎ Assert: attribute is read only.
   2. ~RET `undefined^jv ◎ Return undefined.
2. ~IF［ %属性 は`読専$である ］~AND［ %属性 は［ `LegacyLenientSetter$x, `PutForwards$x, `Replaceable$x ］いずれの`拡張d属性$も伴わない ］ ⇒ ~RET `undefined^jv — `属性~設定子$ 関数は無い。 ◎ If attribute is read only and does not have a [LegacyLenientSetter], [PutForwards] or [Replaceable] extended attribute, return undefined; there is no attribute setter function.
3. ~Assert： %属性 の型は`~promise型$でない ◎ Assert: attribute’s type is not a promise type.

4. %手続き ~LET 以下を遂行する手続き： ◎ Let steps be the following series of steps:

   1. %V ~LET `undefined^jv ◎ Let V be undefined.
   2. ~IF［ 1 個以上の引数が渡された ］ ⇒ %V ~SET 渡された最初の引数の値 ◎ If any arguments were passed, then set V to the value of the first argument passed.
   3. %識別子 ~LET %属性 の`識別子$ ◎ Let id be attribute’s identifier.

   4. ~IF［ %属性 は`正則~属性$である ］： ◎ If attribute is a regular attribute:

      2. ~IF［ %~js値 は `~platform~objである$ ］ ⇒ `~security検査を遂行する$( %~js値, %識別子, `設定子^C ) ◎ If jsValue is a platform object, then perform a security check, passing jsValue, id, and "setter".
      3. %~thisは妥当か ~LET ~IS［ %~js値 は %target を`実装-$する ］ ◎ Let validThis be true if jsValue implements target, or false otherwise.
      4. ~IF［ %~thisは妥当か ~EQ ~F ］~AND［ %属性 には `LegacyLenientThis$x `拡張d属性$は指定されていない ］ ⇒ `~THROW$ `TypeError$jt ◎ If validThis is false and attribute was not specified with the [LegacyLenientThis] extended attribute, then throw a TypeError.

      5. ~IF［ %属性 は `Replaceable$x 拡張d属性を伴って宣言された ］： ◎ If attribute is declared with the [Replaceable] extended attribute, then:

         1. ~ABRUPT `CreateDataPropertyOrThrow$A( %~js値, %識別子, %V ) ◎ Perform ? CreateDataPropertyOrThrow(jsValue, id, V).
         2. ~RET `undefined^jv ◎ Return undefined.
      6. ~IF［ %~thisは妥当か ~EQ ~F ］ ⇒ ~RET `undefined^jv ◎ If validThis is false, then return undefined.
      7. ~IF［ %属性 は `LegacyLenientSetter$x 拡張d属性を伴って宣言された ］ ⇒ ~RET `undefined^jv ◎ If attribute is declared with a [LegacyLenientSetter] extended attribute, then return undefined.

      8. ~IF［ %属性 は `PutForwards$x 拡張d属性を伴って宣言された ］： ◎ If attribute is declared with a [PutForwards] extended attribute, then:

         1. %Q ~LET ~ABRUPT `Get$A( %~js値, %識別子 ) ◎ Let Q be ? Get(jsValue, id).
         2. ~IF［ %Q は `Object$jt でない ］ ⇒ `~THROW$ `TypeError$jt ◎ If Q is not an Object, then throw a TypeError.
         3. %回送-~ID ~LET `PutForwards$x 拡張d属性の識別子~引数 ◎ Let forwardId be the identifier argument of the [PutForwards] extended attribute.
         4. ~ABRUPT `Set$A( %Q, %回送-~ID, %V, `false^jv ) ◎ Perform ? Set(Q, forwardId, V, false).
         5. ~RET `undefined^jv ◎ Return undefined.

      9. ~IF［ %属性 の型は 型~引数 %T を伴う`観測-可能な配列~型$である ］： ◎ If attribute’s type is an observable array type with type argument T:

         1. %新たな値~群 ~LET `~IDL値に変換する$( %V, `連列~型$ ) ◎ Let newValues be the result of converting V to an IDL value of type sequence<T>.
         2. %観測-可能な配列 ~LET %~idl~obj の %属性 を`~backしている観測-可能な配列~exotic~obj$ ◎ Let oa be idlObject’s attribute’s backing observable array exotic object.
         3. `観測-可能な配列~exotic~objの長さを設定する$( %観測-可能な配列.`ProxyHandler^sl, 0 ) ◎ Set the length of oa.[[ProxyHandler]] to 0.

         4. ~EACH( %i ~IN { 0 〜 %新たな値~群 の`~size$ ~MINUS 1 } ) に対し，昇順に： ◎ Let i be 0. ◎ While i < newValues’s size:

            【！原文抜け %i += 1 】
            1. %観測-可能な配列.`ProxyHandler^sl.`SetAlgorithm^sl( %新たな値~群[ %i ], %i ) ◎ Perform the algorithm steps given by oa.[[ProxyHandler]].[[SetAlgorithm]], given newValues[i] and i.
            2. %観測-可能な配列.`ProxyHandler^sl.`BackingList^sl に %新たな値~群[ %i ] を`付加する$ ◎ Append newValues[i] to oa.[[ProxyHandler]].[[BackingList]].
         5. ~RET `undefined^jv ◎ Return undefined.
   5. %~idl値 ~LET ε ◎ Let idlValue be determined as follows:

   6. ~IF［ %属性 の型 は`列挙$である ］： ◎ attribute’s type is an enumeration

      1. %S ~LET ~ABRUPT `ToString$A( %V ) ◎ Let S be ? ToString(V).
      2. ~IF［ %S は `列挙~値$のいずれでもない ］ ⇒ ~RET `undefined^jv ◎ If S is not one of the enumeration’s values, then return undefined.
      3. %~idl値 ~SET %S に等しい列挙~値 ◎ Otherwise, idlValue is the enumeration value equal to S.
   7. ~ELSE ⇒ %~idl値 ~SET `~IDL値に変換する$( %V, %属性 の型 ) ◎ Otherwise • idlValue is the result of converting V to an IDL value of attribute’s type.
   8. %属性 の`設定子~手続き$を［ `this$V として %~idl~obj, `所与の値$として %~idl値 ］を与える下で遂行する ◎ Perform the setter steps of attribute, with idlObject as this and idlValue as the given value.
   9. ~RET `undefined^jv ◎ Return undefined
5. %名前 ~LET 次を順に`連結する$ ⇒＃ 文字列 `set^l, `0020^U ~SPACE, %識別子 ◎ Let name be the string "set " prepended to id.
6. %F ~LET `CreateBuiltinFunction$A( %手続き, 1, %名前, « », %~realm ) ◎ Let F be CreateBuiltinFunction(steps, 1, name, « », realm).

`正則~演算を定義する@ ~algoは、 所与の ( `~ifc$／`~ns$ %定義, %~target, `~realm$ %~realm ) に対し： ◎ To define the regular operations of interface or namespace definition on target, given realm realm, run the following steps:

1. %演算~群 ~LET ［ %定義 を成す`~mb$のうち，`正則~演算$である, かつ `偽造-不能$でないもの ］からなる`~list$ ◎ Let operations be the list of regular operations that are members of definition. ◎ Remove from operations all the operations that are unforgeable.
2. `演算を定義する$( %演算~群, %定義, %~target, %~realm ) ◎ Define the operations operations of definition on target given realm.

`静的~演算を定義する@ ~algoは、 所与の ( `~ifc$／`~ns$ %定義, %~target, `~realm$ %~realm ) に対し： ◎ To define the static operations of interface or namespace definition on target, given realm realm, run the following steps:

1. %演算~群 ~LET ［ %定義 を成す`~mb$のうち，`静的~演算$であるもの ］からなる`~list$ ◎ Let operations be the list of static operations that are members of definition.

`偽造-不能な正則~演算を定義する@ ~algoは、 所与の ( `~ifc$／`~ns$ %定義, %~target, `~realm$ %~realm ) に対し： ◎ To define the unforgeable regular operations of interface or namespace definition on target, given realm realm, run the following steps:

1. %演算~群 ~LET ［ %定義 を成す`~mb$のうち，`正則~演算$である, かつ `偽造-不能$であるもの ］からなる`~list$ ◎ Let operations be the list of unforgeable regular operations that are members of definition.

`演算を定義する@ ~algoは、 所与の ( %演算~群, `~ifc$／`~ns$ %定義, %~target, `~realm$ %~realm ) に対し： ◎ To define the operations operations of interface or namespace definition on target, given realm realm, run the following steps:

1. %演算~群 を成す ~EACH( `演算$ %演算 ) に対し： ◎ For each operation op of operations:

   1. ~IF［ %演算 は %~realm 内に`公開されて$いない ］ ⇒ ~CONTINUE ◎ If op is not exposed in realm, then continue.
   2. %~method ~LET `演算~関数を作成する$( %演算, %定義, %~realm ) ◎ Let method be the result of creating an operation function given op, definition, and realm.
   3. %M ~LET ［ %演算 は`偽造-不能$であるならば `false^jv ／ ~ELSE_ `true^jv ］ ◎ Let modifiable be false if op is unforgeable and true otherwise.
   4. %記述子 ~LET `MTM-method^desc ◎ Let desc be the PropertyDescriptor{[[Value]]: method, [[Writable]]: modifiable, [[Enumerable]]: true, [[Configurable]]: modifiable}.
   5. %識別子 ~LET %演算 の`識別子$ ◎ Let id be op’s identifier.
   6. ~NOABRUPT `DefinePropertyOrThrow$A( %~target, %識別子, %記述子 ) ◎ Perform ! DefinePropertyOrThrow(target, id, desc).

`演算~関数を作成する@ ~algoは、 所与の ( `演算$ %op, `~ns$または`~ifc$ %target, `~realm$ %~realm ) に対し： ◎ To create an operation function, given an operation op, a namespace or interface target, and a realm realm:

1. %識別子 ~LET %op の`識別子$ ◎ Let id be op’s identifier.

2. %手続き ~LET 所与の ( 関数~引数~list %引数~群 ) に対し，次を走らす手続き — ただし，手続きの中で`例外が投出された$ときは、 その下に与える手続きを走らすとする： ◎ Let steps be the following series of steps, given function argument values args: ◎ Try running the following steps:

   1. ~IF［ %target は`~ifc$である ］~AND［ %op は`静的~演算$でない ］： ◎ If target is an interface, and op is not a static operation:

      1. （この大域~objが %target を実装しない場合、 数~段~先で `TypeError$jE が生じることになる。） ◎ (This will subsequently cause a TypeError in a few steps, if the global object does not implement target.)

      2. ~IF［ %~js値 は `~platform~objである$ ］ ⇒ `~security検査を遂行する$( %~js値, %識別子, `~method^C ) ◎ If jsValue is a platform object, then perform a security check, passing jsValue, id, and "method".
      3. ~IF［ %~js値 は ~ifc %target を`実装-$しない ］ ⇒ `~THROW$ `TypeError$jt ◎ If jsValue does not implement the interface target, throw a TypeError.

   2. %S ~LET %target の［ %op が［ 正則~演算ならば`正則~演算$ ／ 静的~演算ならば`静的~演算$ ］］用の`有効-多重定義~集合を算出する$( `識別子$ %識別子, 引数個数 %n ) ◎ Compute the effective overload set for regular operations (if op is a regular operation) or for static operations (if op is a static operation) with identifier id on target and with argument count n, and let S be the result.

   3. <%演算, %値~群> ~LET ( %S, %引数~群 ) を`多重定義~解決~algo$に渡した結果 ◎ Let <operation, values> be the result of passing S and args to the overload resolution algorithm.
   4. %R ~LET ~NULL ◎ Let R be null.

   5. ~IF［ %演算 は `Default$x 拡張d属性を伴って宣言された ］： ◎ If operation is declared with a [Default] extended attribute, then:

      1. ~Assert： %演算 は`既定の~method手続きを有する$ ◎ Assert: operation has default method steps.
      2. %R ~SET %演算 用の`既定の~method手続き$を［ `this$V として %~idl~obj, 引数~list %値~群 ］を与える下で走らせた結果 ◎ Set R to the result of running the default method steps for operation, with idlObject as this and values as the argument values.

   6. ~ELSE ⇒ %R ~SET %演算 用の`~method手続き$を［ `this$V として %~idl~obj, 引数~list %値~群 ］を与える下で走らせた結果 ◎ Otherwise, set R to the result of running the method steps of operation, with idlObject as this and values as the argument values.

   7. ~RET `~JS値に変換する$( %R ) ◎ Return R, converted to a JavaScript value.

      %R は %op の返り値に宣言された型の~IDL値と見做される。 [`課題 #674＠~WEBIDLissue/674$] ◎ R is assumed to be an IDL value of the type op is declared to return. [whatwg/webidl Issue #674]

   1. ~IF［ %op の`返り値~型$は `~promise型$である ］ ⇒ ~RET ~NOABRUPT `Call$A( `Promise.reject$jI, `Promise$jI, « %E » ) ◎ If op has a return type that is a promise type, then return ! Call(%Promise.reject%, %Promise%, «E»).
3. %S ~LET %target の［ %op が［ 正則~演算ならば`正則~演算$ ／ 静的~演算ならば`静的~演算$ ］］用の`有効-多重定義~集合を算出する$( `識別子$ %識別子, 引数個数 0 ) ◎ Compute the effective overload set for regular operations (if op is a regular operation) or for static operations (if op is a static operation) with identifier id on target and with argument count 0, and let S be the result.
4. %長さ ~LET %S 内の各~entryの引数~listの長さのうち，最小 ◎ Let length be the length of the shortest argument list in the entries in S.
5. %F ~LET `CreateBuiltinFunction$A( %手続き, %長さ, %識別子, « », %~realm ) ◎ Let F be CreateBuiltinFunction(steps, length, id, « », realm).

[Exposed=Window]
interface A {
  [Default] object toJSON();
  attribute DOMString a;
};

[Exposed=Window]
interface B : A {
  attribute DOMString b;
};

[Exposed=Window]
interface C : B {
  [Default] object toJSON();
  attribute DOMString c;
};

{
    "a": "...",
    "c": "..."
}

{
    "a": "..."
}

[Exposed=Window]
interface D {
  attribute DOMString d;
};

interface mixin M {
  [Default] object toJSON();
  attribute DOMString m;
};

D includes M;

{
    "d": "...",
    "m": "..."
}

`反復子~methodを定義する@ ~algoは、 所与の ( `~ifc$ %定義, %~target, `~realm$ %~realm ) に対し： ◎ To define the iteration methods of interface definition on target, given realm realm, run the following steps:

1. ~IF［ %定義 は`有index~prop取得子$を有する ］： ◎ If definition has an indexed property getter, then:

   1. `DefineMethodProperty$A( %~target, `Symbol.iterator$jI, `Array.prototype.values$jI, `false^jv ) ◎ Perform DefineMethodProperty(target, %Symbol.iterator%, %Array.prototype.values%, false).

   2. ~IF［ %定義 は`値~反復子$を有する ］： ◎ If definition has a value iterator, then:

      1. ~NOABRUPT `CreateDataPropertyOrThrow$A( %~target, `entries^l, `Array.prototype.entries$jI ) ◎ Perform ! CreateDataPropertyOrThrow(target, "entries", %Array.prototype.entries%).
      2. ~NOABRUPT `CreateDataPropertyOrThrow$A( %~target, `keys^l, `Array.prototype.keys$jI ) ◎ Perform ! CreateDataPropertyOrThrow(target, "keys", %Array.prototype.keys%).
      3. ~NOABRUPT `CreateDataPropertyOrThrow$A( %~target, `values^l, `Array.prototype.values$jI ) ◎ Perform ! CreateDataPropertyOrThrow(target, "values", %Array.prototype.values%).
      4. ~NOABRUPT `CreateDataPropertyOrThrow$A( %~target, `forEach^l, `Array.prototype.forEach$jI ) ◎ Perform ! CreateDataPropertyOrThrow(target, "forEach", %Array.prototype.forEach%).

2. ~ELIF［ %定義 は`~pair反復子$を有する ］： ◎ Otherwise, if definition has a pair iterator, then:

   1. ［ `Symbol.iterator$jI ~method, `entries^jp ~method ］を定義する： ◎ Define the %Symbol.iterator% and entries methods:

      1. 1. %~js値 ~LET ~ABRUPT `ToObject$A( `this^jv 値 ) ◎ Let jsValue be ? ToObject(this value).
         2. ~IF［ %~js値 は`~platform~objである$ ］ ⇒ `~security検査を遂行する$( %~js値, "`Symbol.iterator^jI", `~method^C ) ◎ If jsValue is a platform object, then perform a security check, passing jsValue, "%Symbol.iterator%", and "method".
         3. ~IF［ %~js値 は %定義 を`実装-$しない ］ ⇒ `~THROW$ `TypeError$jt ◎ If jsValue does not implement definition, then throw a TypeError.
         4. ~RET %定義 用の新たな`既定の反復子~obj$ — その ⇒＃ `~target$dI ~SET %~js値, `種類$dI ~SET `key+value^l, `~index$dI ~SET 0 ◎ Return a newly created default iterator object for definition, with jsValue as its target, "key+value" as its kind, and index set to 0.
      2. %F ~LET `CreateBuiltinFunction$A( %手続き, 0, `entries^l, « », %~realm ) ◎ Let F be CreateBuiltinFunction(steps, 0, "entries", « », realm).
      3. `DefineMethodProperty$A( %~target, `Symbol.iterator$jI, %F, `false^jv ) ◎ Perform DefineMethodProperty(target, %Symbol.iterator%, F, false).
      4. ~NOABRUPT `CreateDataPropertyOrThrow$A( %~target, `entries^l, %F ) ◎ Perform ! CreateDataPropertyOrThrow(target, "entries", F).

   2. `keys^jp ~methodを定義する： ◎ Define the keys method:

      1. 1. ~IF［ %~js値 は`~platform~objである$ ］ ⇒ `~security検査を遂行する$( %~js値, `keys^l, `~method^C ) ◎ If jsValue is a platform object, then perform a security check, passing jsValue, "keys", and "method".
         2. ~RET %定義 用の新たな`既定の反復子~obj$ — その ⇒＃ `~target$dI ~SET %~js値, `種類$dI ~SET `key^l, `~index$dI ~SET 0 ◎ Return a newly created default iterator object for definition, with jsValue as its target, "key" as its kind, and index set to 0.
      2. %F ~LET `CreateBuiltinFunction$A( %手続き, 0, `keys^l, « », %~realm ) ◎ Let F be CreateBuiltinFunction(steps, 0, "keys", « », realm).
      3. ~NOABRUPT `CreateDataPropertyOrThrow$A( %~target, `keys^l, %F ) ◎ Perform ! CreateDataPropertyOrThrow(target, "keys", F).

   3. `values^jp ~methodを定義する： ◎ Define the values method:

      1. 1. ~IF［ %~js値 は`~platform~objである$ ］ ⇒ `~security検査を遂行する$( %~js値, `values^l, `~method^C ) ◎ If jsValue is a platform object, then perform a security check, passing jsValue, "values", and "method".
         2. ~RET %定義 用の新たな`既定の反復子~obj$ — その ⇒＃ `~target$dI ~SET %~js値, `種類$dI ~SET `value^l, `~index$dI ~SET 0 ◎ Return a newly created default iterator object for definition, with jsValue as its target, "value" as its kind, and index set to 0.
      2. %F ~LET `CreateBuiltinFunction$A( %手続き, 0, `values^l, « », %~realm ) ◎ Let F be CreateBuiltinFunction(steps, 0, "values", « », realm).
      3. ~NOABRUPT `CreateDataPropertyOrThrow$A( %~target, `values^l, %F ) ◎ Perform ! CreateDataPropertyOrThrow(target, "values", F).

   4. `forEach^jp ~methodを定義する： ◎ Define the forEach method:

      1. %手続き ~LET 所与の関数~引数~値 ( %~callback, %~this引数 ) に対し，次を走らす手続き： ◎ Let steps be the following series of steps, given function argument values callback and thisArg:

         1. ~IF［ %~js値 は`~platform~objである$ ］ ⇒ `~security検査を遂行する$( %~js値, `forEach^l, `~method^C ) ◎ If jsValue is a platform object, then perform a security check, passing jsValue, "forEach", and "method".
         2. %~idl~callback ~LET `~IDL値に変換する$( %~callback, `Function$T ) ◎ Let idlCallback be callback, converted to a Function.
         3. %~idl~obj ~LET %~js値 への参照を表現する~IDL`~ifc型$の値 ◎ Let idlObject be the IDL interface type value that represents a reference to jsValue.
         4. %~pair群 ~LET %~idl~obj の`反復される値~pair群$ ◎ Let pairs be idlObject’s list of value pairs to iterate over.
         5. %i ~LET 0 ◎ Let i be 0.

         6. ~WHILE［ %i ~LT %~pair群 の`~size$ ］： ◎ While i < pairs’s size:

            1. %~pair ~LET %~pair群[ %i ] ◎ Let pair be pairs[i].
            2. `~callback関数を呼出す$( %~idl~callback, 次に与える~list, %~this引数 ) ⇒ « %~pair の`値$vP, %~pair の`~key$vP, %~idl~obj » ◎ Invoke idlCallback with « pair’s value, pair’s key, idlObject » and with thisArg as the callback this value.
            3. %~pair群 ~SET %~idl~obj の現在の`反復される値~pair群$ （【前~段により】変化したかもしれない。） ◎ Set pairs to idlObject’s current list of value pairs to iterate over. (It might have changed.)
            4. %i ~INCBY 1 ◎ Set i to i + 1.
      2. %F ~LET `CreateBuiltinFunction$A( %手続き, 1, `forEach^l, « », %~realm ) ◎ Let F be CreateBuiltinFunction(steps, 1, "forEach", « », realm).
      3. ~NOABRUPT `CreateDataPropertyOrThrow$A( %~target, `forEach^l, %F ) ◎ Perform ! CreateDataPropertyOrThrow(target, "forEach", F).

`非同期~反復子~methodを定義する@ ~algoは、 所与の ( `~ifc$ %定義, %~target, 所与の`~realm$ %~realm ) に対し： ◎ To define the asynchronous iteration methods of interface definition on target, given realm realm, run the following steps:

1. ~IF［ %定義 は`非同期に可反復な宣言$【！(of either sort)】を有さない ］ ⇒ ~RET ◎ If definition does not have an an asynchronously iterable declaration (of either sort), then return.
2. ~Assert： %定義 は`有index~prop取得子$も`可反復~宣言$も有さない ◎ Assert: definition does not have an indexed property getter or an iterable declaration.

3. ~IF［ %定義 は`~pairを非同期に可反復な宣言$を有する ］： ◎ If definition has a pair asynchronously iterable declaration, then＼

   （この段は、 `Symbol.asyncIterator$jI, `entries^jp 両~methodを定義する） ◎ define the %Symbol.asyncIterator% and entries methods:

   1. %手続き ~LET 所与の ( 関数~引数~list %引数~群 ) に対し，次を走らす手続き： ◎ Let steps be the following series of steps, given function argument values args:

      1. ~IF［ %~js値 は`~platform~objである$ ］ ⇒ `~security検査を遂行する$( %~js値, "`Symbol.asyncIterator^jI", `~method^C ) ◎ If jsValue is a platform object, then perform a security check, passing jsValue, "%Symbol.asyncIterator%", and "method".
      2. %~idl引数~群 ~LET `非同期~反復子~method用の引数を変換する$( %引数~群 ) ◎ Let idlArgs be the result of converting arguments for an asynchronous iterator method given args.
      3. %反復子 ~LET %定義 用の新たな`既定の非同期~反復子~obj$ — その ⇒＃ `~target$aI ~SET %~idl~obj, `種類$aI ~SET `key+value^l, `完遂したか$aI ~SET ~F ◎ Let iterator be a newly created default asynchronous iterator object for definition with idlObject as its target, "key+value" as its kind, and is finished set to false.
      4. ~IF［ %定義 用の`非同期~反復子の初期化~手続き$は存在する ］ ⇒ その手続き( %~idl~obj, %反復子, %~idl引数~群 ) ◎ Run the asynchronous iterator initialization steps for definition with idlObject, iterator, and idlArgs, if any such steps exist.
      5. ~RET %反復子 ◎ Return iterator.
   2. %F ~LET `CreateBuiltinFunction$A( %手続き, 0, `entries^l, « », %~realm ) ◎ Let F be CreateBuiltinFunction(steps, 0, "entries", « », realm).
   3. `DefineMethodProperty$A( %~target, `Symbol.asyncIterator$jI, %F, `false^jv ) ◎ Perform DefineMethodProperty(target, %Symbol.asyncIterator%, F, false).

4. ~IF［ %定義 は`~pairを非同期に可反復な宣言$を有する ］： ◎ If definition has a pair asynchronously iterable declaration, then＼

   （この段は、 `keys^jp ~methodを定義する） ◎ define the keys method:

   1. 1. ~IF［ %~js値 は`~platform~objである$ ］ ⇒ `~security検査を遂行する$( %~js値, `keys^l, `~method^C ) ◎ If jsValue is a platform object, then perform a security check, passing jsValue, "keys", and "method".
      2. %反復子 ~LET %定義 用の新たな`既定の非同期~反復子~obj$ — その ⇒＃ `~target$aI ~SET %~idl~obj, `種類$aI ~SET `key^l, `完遂したか$aI ~SET ~F ◎ Let iterator be a newly created default asynchronous iterator object for definition with idlObject as its target, "key" as its kind, and is finished set to false.
      3. ~RET %反復子 ◎ Return iterator.
   2. %F ~LET `CreateBuiltinFunction$A( %手続き, 0, `keys^l, « », %~realm ) ◎ Let F be CreateBuiltinFunction(steps, 0, "keys, « », realm).
   3. ~NOABRUPT `CreateDataPropertyOrThrow$A( %~target, `keys^l, %F ) ◎ Perform ! CreateDataPropertyOrThrow(target, "keys", F).

5. （この段は、 `values^jp ~methodを — および，場合によっては `Symbol.asyncIterator$jI も — 定義する）： ◎ Define the values, and possibly %Symbol.asyncIterator%, methods:

   1. 1. ~IF［ %~js値 は`~platform~objである$ ］ ⇒ `~security検査を遂行する$( %~js値, `values^l, `~method^C ) ◎ If jsValue is a platform object, then perform a security check, passing jsValue, "values", and "method".
      2. %反復子 ~LET %定義 用の新たな`既定の非同期~反復子~obj$ — その ⇒＃ `~target$aI ~SET %~idl~obj, `種類$aI ~SET `value^l, `完遂したか$aI ~SET ~F ◎ Let iterator be a newly created default asynchronous iterator object for definition with idlObject as its target, "value" as its kind, and is finished set to false.
      3. ~RET %反復子 ◎ Return iterator.
   2. %F ~LET `CreateBuiltinFunction$A( %手続き, 0, `values^l, « », %~realm ) ◎ Let F be CreateBuiltinFunction(steps, 0, "values", « », realm).
   3. ~IF［ %定義 は`値を非同期に可反復な宣言$を有する ］ ⇒ ~NOABRUPT `DefineMethodProperty$A( %~target, `Symbol.asyncIterator$jI, %F, `false^jv ) ◎ If definition has a value asynchronously iterable declaration, then perform ! DefineMethodProperty(target, %Symbol.asyncIterator%, F, false).

`非同期~反復子~method用の引数を変換する@ ~algoは、 所与の ( %定義, %~js引数~群 ) に対し： ◎ To convert arguments for an asynchronous iterator method,＼

1. ~Assert ⇒＃ %定義 は`非同期に可反復な宣言$を有する`~ifc$である／ %~js引数~群 は~JS値たちが成す`~list$である ◎ given an interface definition that has an asynchronously iterable declaration and a list of JavaScript values args:
2. %~idl引数~群 ~LET 新たな`~list$ ◎ Let idlArgs be an empty list.
3. %引数~宣言~list ~LET %定義 の`非同期に可反復な宣言$の引数~宣言たちが成す同順の~list （引数が宣言されてないならば空） ◎ ↓

4. ~EACH( %i ~IN { 0 〜 %引数~宣言~list の`~size$ ~MINUS 1 } ) に対し，昇順に：

   1. %~idl値 ~LET `missing$C
   2. ~IF［ %i ~LT %~js引数~群 の`~size$ ］~AND［ %~js引数~群[ %i ] ~NEQ `undefined^jv ］ ⇒ %~idl値 ~SET `~IDL値に変換する$( %~js引数~群[ %i ], %引数~宣言~list[ %i ] )
   3. ~ELIF［ %引数~宣言~list[ %i ] は`既定~値$を伴う ］ ⇒ %~idl値 ~SET その既定~値
   4. %~idl引数~群 に %~idl値 を`付加する$
   ◎ Let argCount be the number of arguments of definition’s asynchronously iterable declaration, or 0 if the asynchronously iterable declaration does not have an argument list. ◎ Let i be 0. ◎ While i < argCount: • If i ≥ args’s size, or if args[i] is undefined, then: •• If the argument to the asynchronously iterable declaration at index i is declared with a default value, then append that default value to idlArgs. •• Otherwise, append to idlArgs the special value "missing". • Otherwise, append to idlArgs the result of converting args[i] to the IDL type given in the asynchronously iterable declaration’s argument list at index i. • Set i to i + 1.
5. ~RET %~idl引数~群 ◎ Return idlArgs.

注記： これは、 本質的には［ 許容される多重定義は無く, すべての引数は随意である事例 ］用の，超越的に特化された`多重定義~解決~algo$を成す。 ◎ This is essentially a hyper-specialization of the overload resolution algorithm for the case where no overloads are allowed and all arguments are optional.

`Global$x `拡張d属性$を伴う`~ifc$を実装する`~platform~obj$ %O の `SetPrototypeOf^sl 内部~methodが，~JS言語~値 %V で~callされたときは、 次を走らす： ◎ When the [[SetPrototypeOf]] internal method of a platform object O that implements an interface with the [Global] extended attribute is called with JavaScript language value V, the following step is taken:

`旧来の~platform~obj$ %O の `GetOwnProperty^sl 内部~methodは、 ( ~prop名 %P ) を引数に~callされたときには，次に従って挙動するモノトスル： ◎ The [[GetOwnProperty]] internal method of every legacy platform object O must behave as follows when called with property name P:

1. ~RET ~ABRUPT `LegacyPlatformObjectGetOwnProperty$A( %O, %P, `false^jv ) ◎ Return ? LegacyPlatformObjectGetOwnProperty(O, P, false).

`旧来の~platform~obj$ %O の `Set^sl 内部~methodは、 ( ~prop名 %P, 値 %V, ~JS言語~値 %Receiver ) を引数に~callされたときには，次に従って挙動するモノトスル： ◎ The [[Set]] internal method of every legacy platform object O must behave as follows when called with property name P, value V, and JavaScript language value Receiver:

1. ~IF［ %O ~EQ %Receiver ］： ◎ If O and Receiver are the same object, then:

   1. ~IF［ %O が`実装-$する ある~ifcは`有index~prop設定子$を伴う ］~AND［ %P は`配列~indexで$ある ］： ◎ If O implements an interface with an indexed property setter and P is an array index, then:

      1. %O 上で`有index~prop設定子を呼出す$( %P, %V ) ◎ Invoke the indexed property setter on O with P and V.
      2. ~RET `true^jv ◎ Return true.

   2. ~IF［ %O が`実装-$する ある~ifcは`有名~prop設定子$を伴う ］~AND［ %P は `String$jt である ］： ◎ If O implements an interface with a named property setter and P is a String, then:

      1. %O 上で`有名~prop設定子を呼出す$( %P, %V ) ◎ Invoke the named property setter on O with P and V.
      2. ~RET `true^jv ◎ Return true.
2. %自前の記述子 ~LET ~ABRUPT `LegacyPlatformObjectGetOwnProperty$A( %O, %P, `true^jv ) ◎ Let ownDesc be ? LegacyPlatformObjectGetOwnProperty(O, P, true).
3. ~ABRUPT `OrdinarySetWithOwnDescriptor$A( %O, %P, %V, %Receiver, %自前の記述子 ) ◎ Perform ? OrdinarySetWithOwnDescriptor(O, P, V, Receiver, ownDesc).

`旧来の~platform~obj$ %O の `DefineOwnProperty^sl 内部~methodは、 ( ~prop~key %P, `~pdesc$ %記述子 ) を伴って~callされたときは，次の手続きに従うモノトスル： ◎ When the [[DefineOwnProperty]] internal method of a legacy platform object O is called with property key P and Property Descriptor Desc, the following steps must be taken:

1. ~IF［ %O は`有index~propを~support$する ］~AND［ %P は `配列~indexで$ある ］： ◎ If O supports indexed properties and P is an array index, then:

   1. ~IF［ `IsDataDescriptor$A( %記述子 ) を~callした結果 ~EQ `false^jv ］ ⇒ ~RET `false^jv ◎ If the result of calling IsDataDescriptor(Desc) is false, then return false.
   2. ~IF［ %O が`実装-$する どの~ifcも，`有index~prop設定子$を伴わない ］ ⇒ ~RET `false^jv ◎ If O does not implement an interface with an indexed property setter, then return false.
   3. %O 上で`有index~prop設定子を呼出す$( %P, %記述子.`Value^sl ) ◎ Invoke the indexed property setter on O with P and Desc.[[Value]].
   4. ~RET `true^jv ◎ Return true.

2. ~IF［ ~AND↓ ］… ◎ If＼

   • %O は`有名~propを~support$する ◎ O supports named properties,＼
   • %O は `Global$x `拡張d属性$を伴う`~ifc$を`実装-$しない ◎ O does not implement an interface with the [Global] extended attribute,＼
   • %P は `String$jt である ◎ P is a String,＼
   • %P は %O の`偽造-不能な~prop名$でない ◎ and P is not an unforgeable property name of O, then:
   • ［ %O が`実装-$する ある~ifcは `LegacyOverrideBuiltIns$x `拡張d属性$を伴う ］~OR［ %O は 名前 %P の自前の~propを有さない ］ ◎ • ↓ Let creating be true if P is not a supported property name, and false otherwise. ◎ • If O implements an interface with the [LegacyOverrideBuiltIns] extended attribute or O does not have an own property named P,＼

   …ならば： ◎ then:

   1. ~IF［ %P は %O が`~supportする~prop名$でない ］~AND［ %O が`実装-$する どの~ifcも，`有名~prop設定子$を伴わない ］ ⇒ ~RET `false^jv ◎ • If creating is false and O does not implement an interface with a named property setter, then return false.

   2. ~IF［ %O が`実装-$する ある~ifcは`有名~prop設定子$を伴う ］： ◎ • If O implements an interface with a named property setter, then:

      1. %O 上で`有名~prop設定子を呼出す$( %P, %記述子.`Value^sl ) ◎ • Invoke the named property setter on O with P and Desc.[[Value]].
      2. ~RET `true^jv ◎ • Return true.
3. ~RET ~NOABRUPT `OrdinaryDefineOwnProperty$A( %O, %P, %記述子 ) ◎ Return ! OrdinaryDefineOwnProperty(O, P, Desc).

`旧来の~platform~obj$ %O の `Delete^sl 内部~methodは、 ~prop名 %P を伴って~callされたときには，次に従って挙動するモノトスル。 ◎ The [[Delete]] internal method of every legacy platform object O must behave as follows when called with property name P.

1. 1. %~index ~LET ~NOABRUPT `ToUint32$A( %P ) ◎ Let index be the result of calling ! ToUint32(P).
   2. ~IF［ %~index は %O が`~supportする~prop~index$でない ］ ⇒ ~RET `true^jv ◎ If index is not a supported property index, then return true.

2. ~IF［ %O は`有名~propを~support$する ］~AND［ %O は `Global$x `拡張d属性$を伴う`~ifc$を`実装-$しない ］~AND［ `有名~propは可視か？$( %P, %O ) ~EQ ~T ］： ◎ If O supports named properties, O does not implement an interface with the [Global] extended attribute and the result of calling the named property visibility algorithm with property name P and object O is true, then:

   1. ~IF［ %O が`実装-$する どの~ifcも，`有名~prop削除子$を伴わない ］ ⇒ ~RET `false^jv ◎ If O does not implement an interface with a named property deleter, then return false.
   2. %演算 ~LET `有名~prop削除子$を宣言するために利用された演算 ◎ Let operation be the operation used to declare the named property deleter.

   3. ~IF［ %演算 は`識別子$を伴わずに定義された ］： ◎ If operation was defined without an identifier, then:

      1. %演算 を宣言した`~ifc$用の`既存の有名~propを削除する手続き$( %P ) ◎ Perform the steps listed in the interface description to delete an existing named property with P as the name.
      2. ~IF［ 手続きから削除の失敗-が指示された ］ ⇒ ~RET `false^jv ◎ If the steps indicated that the deletion failed, then return false.

   4. ~ELSE： ◎ Otherwise, operation was defined with an identifier:

      1. %演算 用の`~method手続き$を［ `this$V として %O, 引数~list « %P » ］を与える下で遂行する ◎ Perform method steps of operation with O as this and « P » as the argument values.
      2. ~IF［ %演算 は `返り値~型$ `boolean$T を伴って宣言された ］~AND［ 前~段の結果 ~EQ `false^V ］ ⇒ ~RET `false^jv ◎ If operation was declared with a return type of boolean and the steps returned false, then return false.

3. ~IF［ %O は 名前 %P の自前の~propを有する ］： ◎ If O has an own property with name P, then:

   1. ~IF［ その~propは~configure可能でない ］ ⇒ ~RET `false^jv ◎ If the property is not configurable, then return false.
   2. ~ELSE ⇒ その~propを %O から除去する ◎ Otherwise, remove the property from O.

`旧来の~platform~obj$の `PreventExtensions^sl 内部~methodが~callされたときは、 次を走らす： ◎ When the [[PreventExtensions]] internal method of a legacy platform object is called, the following steps are taken:

`旧来の~platform~obj$ %O の `OwnPropertyKeys^sl 内部~methodの~call時には、 次を走らす： ◎ When the [[OwnPropertyKeys]] internal method of a legacy platform object O is called, the following steps are taken:

1. %~key群 ~LET 新たな空`~list$ — これは、 いくつかの~JS［ `String^jt ／ `Symbol^jt ］値からなる。 ◎ Let keys be a new empty list of JavaScript String and Symbol values.
2. ~IF［ %O は`有index~propを~support$する ］ ⇒ ~EACH( %O が`~supportする~prop~index$ %~index ) に対し，昇順に ⇒ %~key群 に次の結果を`付加する$ ⇒ ~NOABRUPT `ToString$A( %~index ) ◎ If O supports indexed properties, then for each index of O’s supported property indices, in ascending numerical order, append ! ToString(index) to keys.
3. ~IF［ %O は`有名~propを~support$する ］ ⇒ ~EACH( %O が`~supportする~prop名$ %P ) に対し 【~prop名たちが成す集合を定義する仕様により定義される順序で】 ⇒ ~IF［ `有名~propは可視か？$( %P, %O ) ~EQ ~T ］ ⇒ %~key群 に %P を`付加する$ ◎ If O supports named properties, then for each P of O’s supported property names that is visible according to the named property visibility algorithm, append P to keys.
4. %O の ~EACH( 自前の~prop~key %P ) に対し，~propを作成した順に ⇒ ~IF［ %P は `String^jt である ］ ⇒ %~key群 に %P を`付加する$ ◎ For each P of O’s own property keys that is a String, in ascending chronological order of property creation, append P to keys.
5. %O の ~EACH( 自前の~prop~key %P ) に対し，~propを作成した順に ⇒ ~IF［ %P は `Symbol^jt である ］ ⇒ %~key群 に %P を`付加する$ ◎ For each P of O’s own property keys that is a Symbol, in ascending chronological order of property creation, append P to keys.
6. ~Assert: %~key群 内には重複する~itemは無い ◎ Assert: keys has no duplicate items.
7. ~RET %~key群 ◎ Return keys.

所与の~prop名 %P が `配列~indexで@ あるかどうか決定するときは、 次の~algoを適用する： ◎ To determine if a property name P is an array index, the following algorithm is applied:

1. ~IF［ %P は `String$jt でない ］ ⇒ ~RET ~F ◎ If P is not a String, then return false.
2. %~index ~LET `CanonicalNumericIndexString$A( %P ) ◎ Let index be CanonicalNumericIndexString(P).
3. ~IF［ %~index ~EQ `undefined^jv ］ ⇒ ~RET ~F ◎ If index is undefined, then return false.
4. ~IF［ `IsInteger$A( %~index ) ~EQ `false^jv ］ ⇒ ~RET ~F ◎ If IsInteger(index) is false, then return false.

5. ~IF［ %~index ~EQ −0 ］~OR［ %~index ~LT 0 ］~OR［ %~index ~GTE 2`32^sup ~MINUS 1 ］ ⇒ ~RET ~F ◎ If index is −0, then return false. ◎ If index < 0, then return false. ◎ If index ≥ 232 − 1, then return false.

   注記： 2`32^sup ~MINUS 1 は、 ~JSに許容される最大な配列~長さである。 ◎ Note: 232 − 1 is the maximum array length allowed by JavaScript.

6. ~RET ~T ◎ Return true.

所与の有名~propを~obj上に公開するかどうかは、 `有名~propの可視性判定~algo@ を利用して決定される。 一部の有名~propは、［ `LegacyOverrideBuiltIns$x `拡張d属性$が利用されたかどうか ］に依存して，~obj上に公開されなくなる。 この~algoは、 所与の ( ~prop名 %P, ~obj %O ) に対し，次に従って演算する： ◎ The named property visibility algorithm is used to determine if a given named property is exposed on an object. Some named properties are not exposed on an object depending on whether the [LegacyOverrideBuiltIns] extended attribute was used. The algorithm operates as follows, with property name P and object O:

1. ~IF［ %P は %O が`~supportする~prop名$でない ］ ⇒ ~RET ~F ◎ If P is not a supported property name of O, then return false.

2. ~IF［ %O は名前 %P の自前の~propを有する ］ ⇒ ~RET ~F ◎ If O has an own property named P, then return false.

   注記： これには %O が偽造-不能な~propを有する事例も含まれる — 実施においては、 それらは常に %O が~supportする~prop名を有する前に設定しておかれ， 対応する有名~propを不可視にするので。 ◎ Note: This will include cases in which O has unforgeable properties, because in practice those are always set up before objects have any supported property names, and once set up will make the corresponding named properties invisible.

3. ~IF［ %O が`実装-$する ある~ifcは， `LegacyOverrideBuiltIns$x `拡張d属性$を有する ］ ⇒ ~RET ~T ◎ If O implements an interface that has the [LegacyOverrideBuiltIns] extended attribute, then return true.
4. %prototype ~LET %O . `GetPrototypeOf^sl() ◎ Let prototype be O.[[GetPrototypeOf]]().

5. ~WHILE［ %prototype ~NEQ `null^jv ］： ◎ While prototype is not null:

   1. ~IF［ %prototype は `有名~prop群~obj$でない ］~AND［ %prototype は 名前 %P の自前の~propを有する ］ ⇒ ~RET ~F ◎ If prototype is not a named properties object, and prototype has an own property named P, then return false.
   2. %prototype ~SET %prototype . `GetPrototypeOf^sl() ◎ Set prototype to prototype.[[GetPrototypeOf]]().
6. ~RET ~T ◎ Return true.

`有index~prop設定子$を伴う`~ifc$ %A を`実装-$する`~platform~obj$ %O 上で `有index~prop設定子を呼出す@ ~algoは、 所与の ( ~prop名 %P, ~JS値 %V ) に対し： ◎ To invoke an indexed property setter on a platform object O with property name P and JavaScript value V, the following steps must be performed:

1. %~index ~LET ~ABRUPT `ToUint32$A( %P ) ◎ Let index be the result of calling ? ToUint32(P). ◎ ↓ Let creating be true if index is not a supported property index, and false otherwise.
2. %演算 ~LET `有index~prop設定子$を宣言するために利用された演算 ◎ Let operation be the operation used to declare the indexed property setter.
3. %T ~LET %演算 の 2 個目の引数の型 ◎ Let T be the type of the second argument of operation.
4. %値 ~LET `~IDL値に変換する$( %V, %T ) ◎ Let value be the result of converting V to an IDL value of type T.
5. 1. ~IF［ %~index は %O が`~supportする~prop~index$でない ］ ⇒ %A 用の`新たな有index~propを設定する手続き$( %~index, %値 ) ◎ If creating is true, then perform the steps listed in the interface description to set the value of a new indexed property with index as the index and value as the value.
   2. ~ELSE ⇒ %A 用の`既存の有index~propを設定する手続き$( %~index, %値 ) ◎ Otherwise, creating is false. Perform the steps listed in the interface description to set the value of an existing indexed property with index as the index and value as the value.
6. ~ELSE ⇒ %演算 用の`~method手続き$を［ `this$V として %O, 引数~list « %~index, %値 » ］を与える下で遂行する ◎ Otherwise, operation was defined with an identifier. Perform the method steps of operation with O as this and « index, value » as the argument values.

`有名~prop設定子$を伴う`~ifc$ %A を`実装-$する`~platform~obj$ %O 上で `有名~prop設定子を呼出す@ ~algoは、 所与の ( ~prop名 %P, ~JS値 %V ) に対し： ◎ To invoke a named property setter on a platform object O with property name P and JavaScript value V, the following steps must be performed:

1. %演算 ~LET `有名~prop設定子$を宣言するために利用された演算 ◎ ↓ Let creating be true if P is not a supported property name, and false otherwise. ◎ Let operation be the operation used to declare the named property setter.
2. 1. ~IF［ %P は %O が`~supportする~prop名$である ］ ⇒ %A 用の`新たな有名~propを設定する手続き$( %P, %値 ) ◎ If creating is true, then perform the steps listed in the interface description to set the value of a new named property with P as the name and value as the value.
   2. ~ELSE ⇒ %A 用の`既存の有名~propを設定する手続き$( %P, %値 ) ◎ Otherwise, creating is false. Perform the steps listed in the interface description to set the value of an existing named property with P as the name and value as the value.
3. ~ELSE ⇒ %演算 用の`~method手続き$を［ `this$V として %O, 引数~list « %P, %値 » ］を与える下で遂行する ◎ Otherwise, operation was defined with an identifier. Perform the method steps of operation with O as this and « P, value » as the argument values.

`LegacyPlatformObjectGetOwnProperty@A 抽象-演算は、 所与の ( ~obj %O, ~prop名 %P, 真偽-値 %有名~propは無視するか ) で~callされたとき，次の手続きを遂行する： ◎ The LegacyPlatformObjectGetOwnProperty abstract operation performs the following steps when called with an object O, a property name P, and a boolean ignoreNamedProps value:

1. 1. ~IF［ %~index は %O が`~supportする~prop~index$である ］： ◎ If index is a supported property index, then:

      1. %演算 ~LET `有index~prop取得子$を宣言するために利用された演算 ◎ Let operation be the operation used to declare the indexed property getter.
      2. ~IF［ %演算 は`識別子$を伴わずに定義された ］ ⇒ %値 ~SET %演算 を宣言した`~ifc$用の`有index~propの値を決定する手続き$( %~index ) ◎ If operation was defined without an identifier, then set value to the result of performing the steps listed in the interface description to determine the value of an indexed property with index as the index.
      3. ~ELSE ⇒ %値 ~SET %演算 用の`~method手続き$を［ `this$V として %O, 引数~list « %~index » ］を与える下で遂行した結果 ◎ Otherwise, operation was defined with an identifier. Set value to the result of performing the method steps of operation with O as this and « index » as the argument values.

      4. ~RET 次を伴う新たな`~pdesc$ ⇒ `BTT-V^desc — ここで：

         • %B ~LET ［ %O が`実装-$する ある~ifcは`有index~prop設定子$を伴うならば `true^jv ／ ~ELSE_ `false^jv ］
         ◎ Let desc be a newly created Property Descriptor with no fields. ◎ Set desc.[[Value]] to the result of converting value to a JavaScript value. ◎ If O implements an interface with an indexed property setter, then set desc.[[Writable]] to true, otherwise set it to false. ◎ Set desc.[[Enumerable]] and desc.[[Configurable]] to true. ◎ Return desc.
   2. %有名~propは無視するか ~SET ~T ◎ Set ignoreNamedProps to true.

2. ~IF［ %O は`有名~propを~support$する ］~AND［ %有名~propは無視するか ~EQ ~F ］： ◎ If O supports named properties and ignoreNamedProps is false, then:

   1. ~IF［ `有名~propは可視か？$( %P, %O ) ~EQ ~T ］： ◎ If the result of running the named property visibility algorithm with property name P and object O is true, then:

      1. %演算 ~LET `有名~prop取得子$を宣言するために利用された演算 ◎ Let operation be the operation used to declare the named property getter.
      2. ~ELSE ⇒ %値 ~SET %演算 用の`~method手続き$を［ `this$V として %O, 引数~list « %P » ］を与える下で遂行した結果 ◎ Otherwise, operation was defined with an identifier. Set value to the result of performing the method steps of operation with O as this and « P » as the argument values.

      3. ~RET 次を伴う新たな`~pdesc$ ⇒ `BET-V^desc — ここで：

         • %B ~LET ［ %O が`実装-$する ある~ifcは`有名~prop設定子$を伴うならば `true^jv ／ ~ELSE_ `false^jv ］
         • %E ~LET ［ %O が`実装-$する ある~ifcは `LegacyUnenumerableNamedProperties$x `拡張d属性$を伴うならば `false^jv ／ ~ELSE_ `true^jv ］
         ◎ Let desc be a newly created Property Descriptor with no fields. ◎ Set desc.[[Value]] to the result of converting value to a JavaScript value. ◎ If O implements an interface with a named property setter, then set desc.[[Writable]] to true, otherwise set it to false. ◎ If O implements an interface with the [LegacyUnenumerableNamedProperties] extended attribute, then set desc.[[Enumerable]] to false, otherwise set it to true. ◎ Set desc.[[Configurable]] to true. ◎ Return desc.

`観測-可能な配列~exotic~obj$用の `defineProperty^jp ~proxy~trap用の手続きは、 所与の ( %O, %P, %記述子~obj ) に対し，次に従う： ◎ The steps for the defineProperty proxy trap for observable array exotic objects, given O, P, and descriptorObj are as follows:

1. %~handler ~LET `this^jv 値 ◎ Let handler be the this value.
2. %記述子 ~LET ~NOABRUPT `ToPropertyDescriptor$A( %記述子~obj ) ◎ Let descriptor be ! ToPropertyDescriptor(descriptorObj).

3. ~IF［ %P ~EQ `length^l ］： ◎ If P is "length", then:

   1. ~IF［ `IsAccessorDescriptor$A( %記述子 ) ~EQ `true^jv ］ ⇒ ~RET `false^jv ◎ If IsAccessorDescriptor(descriptor) is true, then return false.

   2. ~IF［ ~OR↓ ］…

      • %記述子.`Configurable^sl は在って, その値 ~EQ `true^jv
      • %記述子.`Enumerable^sl は在って, その値 ~EQ `true^jv
      • %記述子.`Writable^sl は在って, その値 ~EQ `false^jv

      …ならば ⇒ ~RET `false^jv

      ◎ If descriptor.[[Configurable]] is present and has the value true, then return false. ◎ If descriptor.[[Enumerable]] is present and has the value true, then return false. ◎ If descriptor.[[Writable]] is present and has the value false, then return false.
   3. ~IF［ %記述子.`Value^sl は在る ］ ⇒ ~RET `観測-可能な配列~exotic~objの長さを設定する$( %~handler, %記述子.`Value^sl ) ◎ If descriptor.[[Value]] is present, then return the result of setting the length given handler and descriptor.[[Value]].

4. ~IF［ %P は`配列~indexで$ある ］： ◎ If P is an array index, then:

   1. ~IF［ `IsAccessorDescriptor$A( %記述子 ) ~EQ `true^jv ］ ⇒ ~RET `false^jv ◎ If IsAccessorDescriptor(descriptor) is true, then return false.

   2. ~IF［ ~OR↓ ］…

      • %記述子.`Configurable^sl は在って, その値 ~EQ `false^jv
      • %記述子.`Enumerable^sl は在って, その値 ~EQ `false^jv
      • %記述子.`Writable^sl は在って, その値 ~EQ `false^jv

      …ならば ⇒ ~RET `false^jv

      ◎ If descriptor.[[Configurable]] is present and has the value false, then return false. ◎ If descriptor.[[Enumerable]] is present and has the value false, then return false. ◎ If descriptor.[[Writable]] is present and has the value false, then return false.
   3. ~IF［ %記述子.`Value^sl は在る ］ ⇒ ~RET `観測-可能な配列~exotic~objの有index値を設定する$( %~handler, %P, %記述子.`Value^sl ) ◎ If descriptor.[[Value]] is present, then return the result of setting the indexed value given handler, P, and descriptor.[[Value]].
5. ~RET ~ABRUPT %O.`DefineOwnProperty^sl( %P, %記述子 ) ◎ Return ? O.[[DefineOwnProperty]](P, descriptor).

`観測-可能な配列~exotic~obj$用の `deleteProperty^jp ~proxy~trap用の手続きは、 所与の ( %O, %P ) に対し，次に従う： ◎ The steps for the deleteProperty proxy trap for observable array exotic objects, given O and P, are as follows:

1. ~IF［ %P ~EQ `length^l ］ ⇒ ~RET `false^jv ◎ If P is "length", then return false.
2. 1. %旧-長さ ~LET %~handler.`BackingList^sl の`~size$ ◎ Let oldLen be handler.[[BackingList]]'s size.
   2. %~index ~LET ~NOABRUPT `ToUint32$A( %P ) ◎ Let index be ! ToUint32(P).
   3. ~IF［ %~index ~NEQ %旧-長さ ~MINUS 1 ］ ⇒ ~RET `false^jv ◎ If index ≠ oldLen − 1, then return false.
   4. %~handler.`DeleteAlgorithm^sl( %~handler.`BackingList^sl[ %~index ], %~index ) ◎ Perform the algorithm steps given by handler.[[DeleteAlgorithm]], given handler.[[BackingList]][index] and index.
   5. %~handler.`BackingList^sl から最後の~itemを`除去する$ ◎ Remove the last item from handler.[[BackingList]].
3. ~RET ~ABRUPT %O.`Delete^sl( %P ) ◎ Return ? O.[[Delete]](P).

`観測-可能な配列~exotic~obj$用の `get^jp ~proxy~trap用の手続きは、 所与の ( %O, %P, %Receiver ) に対し，次に従う： ◎ The steps for the get proxy trap for observable array exotic objects, given O, P, and Receiver, are as follows:

1. %長さ ~LET %~handler.`BackingList^sl の`~size$ ◎ Let length be handler.[[BackingList]]'s size.
2. ~IF［ %P ~EQ `length^l ］ ⇒ ~RET %長さ ◎ If P is "length", then return length.
3. 1. ~IF［ %~index ~GTE %長さ ］ ⇒ ~RET `undefined^jv ◎ If index ≥ length, then return undefined.
   2. %~js値 ~LET `~JS値に変換する$( %~handler.`BackingList^sl[ %~index ] ) ◎ Let jsValue be the result of converting handler.[[BackingList]][index] to a JavaScript value.
   3. ~Assert： 前~段が例外を投出することは決してない ◎ Assert: the above step never throws an exception.
   4. ~RET %~js値 ◎ Return jsValue.
4. ~RET ~ABRUPT %O.`Get^sl( %P, %Receiver ) ◎ Return ? O.[[Get]](P, Receiver).

`観測-可能な配列~exotic~obj$用の `getOwnPropertyDescriptor^jp ~proxy~trap用の手続きは、 所与の ( %O, %P ) に対し，次に従う： ◎ The steps for the getOwnPropertyDescriptor proxy trap for observable array exotic objects, given O and P, are as follows:

1. ~IF［ %P ~EQ `length^l ］ ⇒ ~RET ~NOABRUPT【！余計？】 `FromPropertyDescriptor$A( `TFF-長さ^desc ) ◎ If P is "length", then return ! FromPropertyDescriptor(PropertyDescriptor{[[Configurable]]: false, [[Enumerable]]: false, [[Writable]]: true, [[Value]]: length }).
2. 1. ~IF［ %~index ~GTE %長さ ］ ⇒ ~RET `undefined^jv ◎ If index ≥ length, then return undefined.
   2. %~js値 ~LET `~JS値に変換する$( %~handler.`BackingList^sl[ %~index ] ) ◎ Let jsValue be the result of converting handler.[[BackingList]][index] to a JavaScript value.
   3. ~Assert： 前~段が例外を投出することは決してない ◎ Assert: the above step never throws an exception.
   4. ~RET `FromPropertyDescriptor$A( `TTT-~js値^desc ) ◎ Return FromPropertyDescriptor(PropertyDescriptor{[[Configurable]]: true, [[Enumerable]]: true, [[Writable]]: true, [[Value]]: jsValue }).
3. ~RET `FromPropertyDescriptor$A( ~ABRUPT %O.`GetOwnProperty^sl( %P ) ) ◎ Return FromPropertyDescriptor(? O.[[GetOwnProperty]](P)).

`観測-可能な配列~exotic~obj$用の `has^jp ~proxy~trap用の手続きは、 所与の ( %O, %P ) に対し，次に従う： ◎ The steps for the has proxy trap for observable array exotic objects, given O and P, are as follows:

1. ~IF［ %P ~EQ `length^l ］ ⇒ ~RET `true^jv ◎ If P is "length", then return true.
2. 1. ~IF［ %~index ~LT %~handler.`BackingList^sl の`~size$ ］ ⇒ ~RET `true^jv ◎ If index < handler.[[BackingList]]'s size, then return true.
3. ~RET ~ABRUPT %O.`HasProperty^sl( %P ) ◎ Return ? O.[[HasProperty]](P).

`観測-可能な配列~exotic~obj$用の `ownKeys^jp ~proxy~trap用の手続きは、 所与の ( %O ) に対し，次に従う： ◎ The steps for the ownKeys proxy trap for observable array exotic objects, given O, are as follows:

1. %~key群 ~LET 空`~list$ ◎ Let keys be an empty list.
2. ~EACH( %i ~IN { 0 〜 %長さ ~MINUS 1 } ) に対し，昇順に ⇒ %~key群 に次の結果を`付加する$ ⇒ ~NOABRUPT `ToString$A( %i ) ◎ Let i be 0. ◎ While i < length: • Append ! ToString(i) to keys. • Set i to i + 1.
3. %~key群 を次の結果で`拡張する$ ⇒ ~NOABRUPT %O.`OwnPropertyKeys^sl() ◎ Extend keys with ! O.[[OwnPropertyKeys]]().
4. ~RET `CreateArrayFromList$A( %~key群 ) ◎ Return CreateArrayFromList(keys).

`観測-可能な配列~exotic~obj$用の `preventExtensions^jp ~proxy~trap用の手続きは、 次に従う： ◎ The steps for the preventExtensions proxy trap for observable array exotic objects are as follows:

`観測-可能な配列~exotic~obj$用の `set^jp ~proxy~trap用の手続きは、 所与の ( %O, %P, %V, %Receiver ) に対し，次に従う： ◎ The steps for the set proxy trap for observable array exotic objects, given O, P, V, and Receiver, are as follows:

1. ~IF［ %P ~EQ `length^l ］ ⇒ ~RET `観測-可能な配列~exotic~objの長さを設定する$( %~handler, %V ) ◎ If P is "length", then return the result of setting the length given handler and V.
2. ~IF［ %P は`配列~indexで$ある ］ ⇒ ~RET `観測-可能な配列~exotic~objの有index値を設定する$( %~handler, %P, %V ) ◎ If P is an array index, then return the result of setting the indexed value given handler, P, and V.
3. ~RET ~ABRUPT %O.`Set^sl( %P, %V, %Receiver ) ◎ Return ? O.[[Set]](P, V, Receiver).

`観測-可能な配列~exotic~objの長さを設定する@ ~algoは、 所与の ( %~handler, %新-長さ ) に対し： ◎ To set the length of an observable array exotic object given handler and newLen:

1. %uint32長さ ~LET ~ABRUPT `ToUint32$A( %新-長さ ) ◎ Let uint32Len be ? ToUint32(newLen).
2. %number長さ ~LET ~ABRUPT `ToNumber$A( %新-長さ ) ◎ Let numberLen be ? ToNumber(newLen).
3. ~IF［ %uint32長さ ~NEQ %number長さ ］ ⇒ ~THROW `RangeError$jE ◎ If uint32Len ≠ numberLen, then throw a RangeError exception.
4. ~IF［ %uint32長さ ~GT %旧-長さ ］ ⇒ ~RET `false^jv ◎ If uint32Len > oldLen, then return false.
5. %削除する~index ~LET %旧-長さ ~MINUS 1 ◎ Let indexToDelete be oldLen − 1.

6. ~WHILE［ %削除する~index ~GTE %uint32長さ ］： ◎ While indexToDelete ≥ uint32Len:

   1. %~handler.`DeleteAlgorithm^sl( %~handler.`BackingList^sl[ %削除する~index ], %削除する~index ) ◎ Perform the algorithm steps given by handler.[[DeleteAlgorithm]], given handler.[[BackingList]][indexToDelete] and indexToDelete.
   2. %~handler.`BackingList^sl から最後の~itemを`除去する$ ◎ Remove the last item from handler.[[BackingList]].
   3. %削除する~index ~DECBY 1 ◎ Set indexToDelete to indexToDelete − 1.
7. ~RET `true^jv ◎ Return true.

`観測-可能な配列~exotic~objの有index値を設定する@ ~algoは、 所与の ( %~handler, %P, %V ) に対し： ◎ To set the indexed value of an observable array exotic object given handler, P, and V:

1. ~IF［ %~index ~GT %旧-長さ ］ ⇒ ~RET `false^jv ◎ If index > oldLen, return false.
2. %~idl値 ~LET `~IDL値に変換する$( %V, %~handler.`Type^sl ) ◎ Let idlValue be the result of converting V to the type given by handler.[[Type]].

3. ~IF［ %~index ~LT %旧-長さ ］： ◎ If index < oldLen, then:

   1. %~handler.`DeleteAlgorithm^sl( %~handler.`BackingList^sl[ %~index ], %~index ) ◎ Perform the algorithm steps given by handler.[[DeleteAlgorithm]], given handler.[[BackingList]][index] and index.
4. %~handler.`SetAlgorithm^sl( %~idl値, %~index ) ◎ Perform the algorithm steps given by handler.[[SetAlgorithm]], given idlValue and index.
5. ~IF［ %~index ~EQ %旧-長さ ］ ⇒ %~handler.`BackingList^sl に %~idl値 を`付加する$ ◎ If index = oldLen, then append idlValue to handler.[[BackingList]].
6. ~ELSE ⇒ %~handler.`BackingList^sl[ %~index ] ~SET %~idl値 ◎ Otherwise, set handler.[[BackingList]][index] to idlValue.

`~callback~ifc$用の`旧来の~callback~ifc~obj$は、 以下に従って作成される — `旧来の~callback~ifc~objを作成する@ ~algoは、 所与の ( `~callback~ifc$ %I, `識別子$ %識別子, `~realm$ %~realm ) に対し： ◎ The legacy callback interface object for a given callback interface interface with identifier id and in realm realm is created as follows:

1. %手続き ~LET 次に与える手続き： ◎ Let steps be the following steps:
2. %F ~LET `CreateBuiltinFunction$A( %手続き, 0, %識別子, « », %~realm ) ◎ Let F be CreateBuiltinFunction(steps, 0, id, « », realm).
3. `定数を定義する$( %I, %F, %~realm ) ◎ Define the constants of interface on F given realm.

`~ns~objを作成する@ ~algoは、 所与の ( `~ns$ %~ns, `~realm$ %~realm ) に対し： ◎ The namespace object for a given namespace namespace and realm realm is created as follows:

1. %~ns~obj ~LET `OrdinaryObjectCreate$A( %~realm.`Object.prototype$jIsl ) ◎ Let namespaceObject be OrdinaryObjectCreate(realm.[[Intrinsics]].[[%Object.prototype%]]).
2. `正則~属性を定義する$( %~ns, %~ns~obj, %~realm ) ◎ Define the regular attributes of namespace on namespaceObject given realm.
3. `正則~演算を定義する$( %~ns, %~ns~obj, %~realm ) ◎ Define the regular operations of namespace on namespaceObject given realm.
4. `定数を定義する$( %~ns, %~ns~obj, %~realm ) ◎ Define the constants of namespace on namespaceObject given realm.
5. %~ifc群 ~LET 次を満たす`~ifc$たちが成す集合 ⇒ ［ `公開されて$いる ］~AND［ %~ns の識別子を引数にとる `LegacyNamespace$x 拡張d属性を伴う ］ ◎ For each exposed interface interface which has the [LegacyNamespace] extended attribute with the identifier of namespace as its argument,

6. %~ifc群 を成す ~EACH( %~ifc ) に対し： ◎ ↑

   1. `DefineMethodProperty$A( %~ns~obj, %~ID, %~ifc~obj, `false^jv ) ◎ Perform DefineMethodProperty(namespaceObject, id, interfaceObject, false).
7. ~RET %~ns~obj ◎ Return namespaceObject.

%T 型の`単純~例外$用に`例外を作成する$ときは： ◎ To create a simple exception of type T:

1. %~message ~LET 当の`例外~用の適切な~message$ ◎ Let message be an implementation-defined message appropriate for the exceptional situation. The calling specification may contain information to to help implementations construct this message. ◎ Implementations need to be cautious not to leak sensitive or secured information when constructing this message, e.g., by including the URL of a cross-origin frame, or information which could identify the user.

2. %引数~群 ~LET « %~message » ◎ Let args be « message ».
3. %構築子 ~LET `現在の~realm$ .`Intrinsics^sl.`T^jI ◎ Let constructor be current realm.[[Intrinsics]].[[%T%]].
4. ~RET ~NOABRUPT `Construct$A( %構築子, %引数~群 ) ◎ Return ! Construct(constructor, args).

`DOMException$T 用に`例外を作成する$ときは、 所与の ( 文字列 %名前 ) に対し： ◎ To create a DOMException given a string name:

1. ~Assert： %名前 は`~DOMException用の名前~表t$に現れる。 ◎ Assert: name appears in the DOMException names table.
2. %例外 ~LET `~ifcを実装する新たな~objを作成する$( `DOMException$T, `現在の~realm$ ) ◎ Let ex be a new DOMException created in the current realm.
3. %例外 の`名前$eX ~SET %名前 ◎ Set ex’s name to name.
4. %例外 の`~message$eX ~SET 当の`例外~用の適切な~message$ ◎ Set ex’s message to an implementation-defined message appropriate for the exceptional situation. The calling specification may contain information to to help implementations construct this message. ◎ Implementations need to be cautious not to leak sensitive or secured information when constructing this message, e.g., by including the URL of a cross-origin frame, or information which could identify the user.
5. ~RET %例外 ◎ Return ex.

`DOMException$T 派生~ifc用に`例外を作成する$ときは、 所与の ( ある`~ifc$の`識別子$ %型, 追加的な初期化~用の指示書き ) に対し： ◎ To create a DOMException derived interface given the interface identifier type and additional initialization instructions:

1. %例外 ~LET `~ifcを実装する新たな~objを作成する$( %型 により識別される`~ifc$, `現在の~realm$ ) ◎ Let ex be a new instance of the interface identified by type, created in the current realm.
2. %例外 の`名前$eX ~SET %型 ◎ Set ex’s name to type.
3. %例外 の`~message$eX ~SET 当の`例外~用の適切な~message$ ◎ Set ex’s message to an implementation-defined message appropriate for the exceptional situation. The calling specification may contain information to to help implementations construct this message. ◎ Implementations need to be cautious not to leak sensitive or secured information when constructing this message, e.g., by including the URL of a cross-origin frame, or information which could identify the user.
4. %例外 に対する追加的な初期化を~call元にて述べられたとおりに遂行する ◎ Perform any additional initialization on ex as described by the caller.
5. ~RET %例外 ◎ Return ex.

`例外~用の適切な~message@ は、 当の例外的な状況~用に適切な`実装定義$な文字列を返す — 各~仕様は、 `例外を作成する$ときに，実装がこの~messageを構築する助けになる情報を包含してもヨイ。

実装は、 この~messageを構築するときには，［ 敏感な情報／~secure化された情報 ］を漏洩しないよう用心深くなる必要がある — 例えば，次を含まないよう ⇒＃ 非同一-生成元に属する~frameの~URL／ 利用者を識別し得るような情報

◎ ↑↑

`例外を投出する$ときは、 所与の ( `例外を作成する$ときに与えるものと同じ引数~群 ) に対し，次を走らす： ◎ To throw an exception:

1. %例外 ~LET `例外を作成する$( 引数~群 ) ◎ Let O be the result of creating an exception with the same arguments.
2. `~THROW$ %例外 ◎ Throw O.

[Exposed=Window]
interface MathUtils {
  /* 
%x は負ならば `NotSupportedError$E `DOMException$T を投出する。
◎
If x is negative, throws a "NotSupportedError" DOMException.
 */
  double computeSquareRoot(double %x);
};

const %myMU = window.getMathUtils();          /* 
この~realmに属する `MathUtils^T
◎
A MathUtils object from this realm
 */
const %otherMU = %otherWindow.getMathUtils();  /* 
異なる~realmに属する `MathUtils^T
◎
A MathUtils object from a different realm
 */

%myMU instanceof Object;                      /*  */
%otherMU instanceof Object;                   /*  */
%otherMU instanceof %otherWindow.Object;       /*  */

try {
  %otherMU.computeSquareRoot【！doComputation】.call(%myMU, -1);
} catch (%e) {
  console.assert(!(%e instanceof DOMException));
  console.assert(%e instanceof %otherWindow.DOMException);
}