Web IDL — ECMAScript 言語束縛

~ES値 %V を `any$T 型の`~IDL値に変換する$ときは、 次に従う： ◎ An ECMAScript value V is converted to an IDL any value by running the following algorithm:

1. ~IF［ %V ~EQ `undefined^jv ］ ⇒ ~RET 一意な `undefined$T ~IDL値 ◎ If V is undefined, then return the unique undefined IDL value.
2. ~IF［ %V ~EQ `null^jv ］ ⇒ ~RET `null^V `object$T​? 参照 ◎ If V is null, then return the null object? reference.

3. ~RET `Type$A( %V ) に応じて： ◎ ↓

   `Boolean^jt

   同じ真偽-値を表現する `boolean$T 値 ◎ If Type(V) is Boolean, then return the boolean value that represents the same truth value.

   `Number^jt

   `unrestricted double＠#es-unrestricted-double§T に従って， %V を `unrestricted double$T 値に変換した結果 ◎ If Type(V) is Number, then return the result of converting V to an unrestricted double.

   `BigInt^jt

   `bigint＠#es-bigint§T に従って， %V を `bigint$T 値に変換した結果 ◎ If Type(V) is BigInt, then return the result of converting V to a bigint.

   `String^jt

   `DOMString＠#es-DOMString§T に従って， %V を `DOMString$T 値に変換した結果 ◎ If Type(V) is String, then return the result of converting V to a DOMString.

   `Symbol^jt

   `symbol＠#es-symbol§T に従って， %V を `symbol$T 値に変換した結果 ◎ If Type(V) is Symbol, then return the result of converting V to a symbol.

   `Object^jt

   %V を参照する~IDL `object$T 値 ◎ If Type(V) is Object, then return an IDL object value that references V.

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

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

~ES値 %V を `boolean$T 型の`~IDL値に変換する$ときは、 次に従う： ◎ An ECMAScript 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 ［ ~ES `Boolean^jt 値 %x ］と同じ真偽-値を表現する~IDL `boolean$T 値 ◎ Return the IDL boolean value that is the one that represents the same truth value as the ECMAScript Boolean value x.

~ES値 %V を `整数~型$ %T の`~IDL値に変換する$ときは、 次に従う： ◎ An ECMAScript 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 を`~ES値に変換する$ときは、 %T に応じて：

`long long$T

`unsigned long long$T

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

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

他の整数~型

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

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

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

~ES値 %V を `float$T 型の`~IDL値に変換する$ときは、 次に従う： ◎ An ECMAScript 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.

~ES値 %V を `unrestricted float$T 型の`~IDL値に変換する$ときは、 次に従う： ◎ An ECMAScript 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 を`~ES値に変換する$ときは、 次に従う： ◎ The result of converting an IDL unrestricted float value to an ECMAScript 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.

~ES値 %V を `double$T 型の`~IDL値に変換する$ときは、 次に従う： ◎ An ECMAScript 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.

~ES値 %V を `unrestricted double$T 型の`~IDL値に変換する$ときは、 次に従う： ◎ An ECMAScript 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 を`~ES値に変換する$ときは、 次に従う： ◎ The result of converting an IDL unrestricted double value to an ECMAScript 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.

~ES値 %V を `bigint$T 型の`~IDL値に変換する$ときは、 次に従う： ◎ An ECMAScript 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 を`~ES値に変換する$ときは ⇒ ~RET %V と同じ数量-値を表現する `BigInt$jt 値 ◎ The result of converting an IDL bigint value to an ECMAScript value is a BigInt: • Return the BigInt value that represents the same numeric value as the IDL bigint value.

~ES値 %V を~IDL［ `数量-型$ %T, `bigint$T 型 ］ `いずれかの型の~IDL値に変換する@ ときは、 次に従う： ◎ An ECMAScript 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［ `Type$A( %x ) ~EQ `BigInt^jt ］ ⇒ ~RET %x と同じ数量-値を表現する，型 `bigint$T の~IDL値 ◎ If Type(x) is BigInt, then • Return the IDL bigint value that represents the same numeric value as x.
3. ~Assert： `Type$A( %x ) ~EQ `Number^jt ◎ Assert: Type(x) is Number.
4. ~RET `~IDL値に変換する$【！`~ES値に変換する$】( %x, %T ) ◎ Return the result of converting x to T.

~ES値 %V を `DOMString$T 型の`~IDL値に変換する$ときは、 次に従う： ◎ An ECMAScript value V is converted to an IDL DOMString value by running the following algorithm:

1. ~IF［ %V ~EQ `null^jv ］~AND［ `LegacyNullToEmptyString$x `拡張属性が結付けられ$ている~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 ［ その~ES `String^jt 値 %x が表現するものと同じ，符号単位~並び ］を表現する~IDL `DOMString$T 値 ◎ Return the IDL DOMString value that represents the same sequence of code units as the one the ECMAScript String value x represents.

~ES値 %V を `ByteString$T 型の`~IDL値に変換する$ときは、 次に従う： ◎ An ECMAScript 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.

~ES値 %V を `USVString$T 型の`~IDL値に変換する$ときは、 次に従う： ◎ An ECMAScript 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 を`~ES値に変換する$ときは、 次に従う： ◎ An IDL USVString value is converted to an ECMAScript value by running the following algorithm:

1. %~scalar値~列 ~LET %V が表現する`~scalar値$並び ◎ Let scalarValues be the sequence of scalar values the USVString represents.
2. %文字列 ~LET %~scalar値~列 を~UTF-16に符号化した結果の`符号単位$並び ◎ Let string be the sequence of code units that results from encoding scalarValues in UTF-16.
3. ~RET %文字列 と同じ`符号単位$並びを表現する `String^jt 値 ◎ Return the String value that represents the same sequence of code units as string.

~ES値 %V を `object$T 型の`~IDL値に変換する$ときは、 次に従う： ◎ An ECMAScript value V is converted to an IDL object value by running the following algorithm:

1. ~IF［ `Type$A( %V ) ~NEQ `Object^jt ］ ⇒ `~THROW$ `TypeError$jt ◎ If Type(V) is not 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.

~ES値 %V を `symbol$T 型の`~IDL値に変換する$ときは、 次に従う： ◎ An ECMAScript value V is converted to an IDL symbol value by running the following algorithm:

1. ~IF［ `Type$A( %V ) ~NEQ `Symbol^jt ］ ⇒ `~THROW$ `TypeError$jt ◎ If Type(V) is not 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.

~ES値 %V を `~ifc型$ %I の`~IDL値に変換する$ときは、 次に従う： ◎ An ECMAScript 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.

~ES値 %V を `~callback~ifc型$の`~IDL値に変換する$ときは、 次に従う： ◎ An ECMAScript 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.

~ES値 %~es辞書 を`辞書~型$ %D の`~IDL値に変換する$ときは、 次に従う： ◎ An ECMAScript value esDict is converted to an IDL dictionary type value by running the following algorithm (where D is the dictionary type):

1. %型 ~LET `Type$A( %~es辞書 ) ◎ ↓
2. ~IF［ %型 ~NIN { `Undefined^jt, `Null^jt, `Object^jt } ］ ⇒ `~THROW$ `TypeError$jt ◎ If Type(esDict) is not Undefined, Null or Object, then throw a TypeError.
3. %~idl辞書 ~LET 型 %D の辞書を表現している新たな`有順序~map$ ◎ Let idlDict be an empty ordered map, representing a dictionary of type D.

4. ［ %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. %~es~mb値 ~LET %型 に応じて，次で与えられる~ES値 ⇒＃ `Undefined^jt ならば `undefined^jv ／ `Null^jt ならば `undefined^jv ／ ~ELSE_ ~ABRUPT `Get$A( %~es辞書, %~key ) ◎ Let esMemberValue be an ECMAScript value, depending on Type(esDict): ◎ Undefined Null • undefined ◎ anything else • ? Get(esDict, key)

      3. ~IF［ %~es~mb値 ~NEQ `undefined^jv ］ ⇒ %~idl辞書[ %~key ] ~SET `~IDL値に変換する$( %~es~mb値, %~mb に宣言された型 ) ◎ If esMemberValue is not undefined, then: • Let idlMemberValue be the result of converting esMemberValue to an IDL value whose type is the type member is declared to be of. • Set idlDict[key] to idlMemberValue.
      4. ~ELIF［ %~mb には`既定~値$diC %d が指定されている ］ ⇒ %~idl辞書[ %~key ] ~SET %d ◎ Otherwise, if esMemberValue is undefined but member has a default value, then: • Let idlMemberValue be member’s default value. • Set idlDict[key] to idlMemberValue.
      5. ~ELIF［ %~mb は`要求され$diCる ］ ⇒ `~THROW$ `TypeError$jt ◎ Otherwise, if esMemberValue is undefined and member is required, then throw a TypeError.
5. ~RET %~idl辞書 ◎ Return idlDict.

~IDL辞書 %D 型の値 %V を `Object^jt 型の`~ES値に変換する$ときは、 次に従う： ◎ An IDL dictionary value V is converted to an ECMAScript 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. %~es値 ~LET `~ES値に変換する$( %~idl値 ) ◎ Let value be the result of converting idlValue to an ECMAScript value.
      5. ~NOABRUPT `CreateDataProperty$A( %O, %~key, %~es値 ) ◎ Perform ! CreateDataProperty(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.

~ES値 %V を`列挙$型 %E の`~IDL値に変換する$ときは、 次に従う： ◎ An ECMAScript 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.

~ES値 %V を`~callback関数~型$の`~IDL値に変換する$ときは、 次に従う： ◎ An ECMAScript value V is converted to an IDL callback function type value by running the following algorithm:

1. ~IF［ 次のいずれかが満たされる ］…：

   • `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 ◎ ↑

~ES値 %V を型 `~varT?^T の`~IDL値に変換する$ときは、 次に従う： ◎ An ECMAScript value V is converted to an IDL nullable type T? value (where T is the inner type) as follows:

1. ~IF［ 次がいずれも満たされる ］…：

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

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

   ◎ If Type(V) is not 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.

~ES値 %V を`~sequence_T$ 型の`~IDL値に変換する$ときは、 次に従う： ◎ An ECMAScript value V is converted to an IDL sequence<T> value as follows:

1. ~IF［ `Type$A( %V ) ~NEQ `Object^jt ］ ⇒ `~THROW$ `TypeError$jt ◎ If Type(V) is not Object, throw a TypeError.
2. %~method ~LET ~ABRUPT `GetMethod$A( %V, `iterator$jS ) ◎ Let method be ? GetMethod(V, @@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 型の`~ES値に変換する$ときは、 次に従う： ◎ An IDL sequence value S of type sequence<T> is converted to an ECMAScript 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 `~ES値に変換する$( %S [ %i ] ) ◎ Let V be the value in S at index i. ◎ Let E be the result of converting V to an ECMAScript value.
   2. %P ~LET ~NOABRUPT `ToString$A( %i ) ◎ Let P be the result of calling ! ToString(i).
   3. ~NOABRUPT `CreateDataProperty$A( %A, %P, %E ) ◎ Call ! CreateDataProperty(A, P, E). ◎ ↑↑Set i to i + 1.
4. ~RET %A ◎ Return A.

~ES値 %O を `~record_KV$ 型の`~IDL値に変換する$ときは、 次に従う： ◎ An ECMAScript value O is converted to an IDL record<K, V> value as follows:

1. ~IF［ `Type$A( %O ) ~NEQ `Object^jt ］ ⇒ `~THROW$ `TypeError$jt ◎ If Type(O) is not 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 を`~ES値に変換する$ときは、 次に従う： ◎ An IDL record<…> value D is converted to an ECMAScript 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. %~es~key ~LET `~ES値に変換する$( %~key ) ◎ Let esKey be key converted to an ECMAScript value.
   2. %~es値 ~LET `~ES値に変換する$( %値 ) ◎ Let esValue be value converted to an ECMAScript value.
   3. %作成したか ~LET ~NOABRUPT `CreateDataProperty$A( %結果, %~es~key, %~es値 ) ◎ Let created be ! CreateDataProperty(result, esKey, esValue).
   4. ~Assert： %作成したか ~EQ `true^jv ◎ Assert: created is true.
3. ~RET %結果 ◎ Return result.

~ES値 %V を `~promise_T$ 型の`~IDL値に変換する$ときは、 次に従う： ◎ An ECMAScript 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.

~ES値 %V を`共用体~型$ %U の`~IDL値に変換する$ときは、 次に従う： ◎ To convert an ECMAScript 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. %型 ~LET `Type$A( %V ) ◎ ↓

7. ~IF［ %型 ~EQ `Object^jt ］~AND［ %V は `ArrayBufferData^sl `内部~slot$を持つ ］： ◎ If Type(V) is Object and V has an [[ArrayBufferData]] internal slot, then:

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

8. ~IF［ %型 ~EQ `Object^jt ］~AND［ %V は `DataView^sl `内部~slot$を持つ ］： ◎ If Type(V) is 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.

9. ~IF［ %型 ~EQ `Object^jt ］~AND［ %V は `TypedArrayName^sl `内部~slot$を持つ ］： ◎ If Type(V) is 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.

10. ~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.

11. ~IF［ %型 ~EQ `Object^jt ］： ◎ If Type(V) is Object, then:

    1. ~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.

    2. ~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.
    3. ~IF［ %型~群 に`辞書~型$が含まれている ］ ⇒ ~RET `~IDL値に変換する$( %V, その型 ) ◎ If types includes a dictionary type, then return the result of converting V to that dictionary type.
    4. ~IF［ %型~群 に`~record型$が含まれている ］ ⇒ ~RET `~IDL値に変換する$( %V, その型 ) ◎ If types includes a record type, then return the result of converting V to that record type.
    5. ~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.

12. ~IF［ %型 ~EQ `Boolean^jt ］： ◎ If Type(V) is Boolean, then:

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

13. ~IF［ %型 ~EQ `Number^jt ］： ◎ If Type(V) is Number, then:

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

14. ~IF［ %型 ~EQ `BigInt^jt ］： ◎ If Type(V) is BigInt, then:

    1. ~IF［ %型~群 に `bigint$T が含まれている ］ ⇒ ~RET `~IDL値に変換する$( %V, `bigint$T ) ◎ If types includes bigint, then return the result of converting V to bigint.
15. ~IF［ %型~群 に`文字列~型$が含まれている ］ ⇒ ~RET `~IDL値に変換する$( %V, その型 ) ◎ If types includes a string type, then return the result of converting V to that type.
16. ~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.

~ES値 %V を`ArrayBuffer$T 型の`~IDL値に変換する$ときは、 次に従う： ◎ An ECMAScript value V is converted to an IDL ArrayBuffer value by running the following algorithm:

1. ~IF［ `Type$A( %V ) ~NEQ `Object^jt ］~OR［ %V は `ArrayBufferData^sl `内部~slot$を持たない ］ ⇒ `~THROW$ `TypeError$jt ◎ If Type(V) is not Object, or V does not have an [[ArrayBufferData]] internal slot, then throw a TypeError.
2. ~IF［ `AllowShared$x `拡張属性が結付けられ$ている~IDL型への変換でない ］~AND［ `IsSharedArrayBuffer$A( %V ) ~EQ `true^jv ］ ⇒ `~THROW$ `TypeError$jt ◎ If the conversion is not to an IDL type associated with the [AllowShared] extended attribute, and IsSharedArrayBuffer(V) is true, then throw a TypeError.
3. ~IF［ `AllowResizable$x `拡張属性が結付けられ$ている~IDL型への変換でない ］~AND［ `IsResizableArrayBuffer$A( %V ) ~EQ `true^jv ］ ⇒ `~THROW$ `TypeError$jt ◎ If the conversion is not to an IDL type associated with the [AllowResizable] extended attribute, and IsResizableArrayBuffer(V) is true, then throw a TypeError.
4. ~RET %V と同じ~objへの参照である~IDL `ArrayBuffer$T 値 ◎ Return the IDL ArrayBuffer value that is a reference to the same object as V.

~ES値 %V を `DataView$T 型の`~IDL値に変換する$ときは、 次に従う： ◎ An ECMAScript value V is converted to an IDL DataView value by running the following algorithm:

1. ~IF［ `Type$A( %V ) ~NEQ `Object^jt ］~OR［ %V は `DataView^sl `内部~slot$を持たない ］ ⇒ `~THROW$ `TypeError$jt ◎ If Type(V) is not Object, or V does not have a [[DataView]] internal slot, then throw a TypeError.
2. ~IF［ `AllowShared$x `拡張属性が結付けられ$ている~IDL型への変換でない ］~AND［ `IsSharedArrayBuffer$A( %V.`ViewedArrayBuffer^sl ) ~EQ `true^jv ］ ⇒ `~THROW$ `TypeError$jt ◎ 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.
3. ~IF［ `AllowResizable$x `拡張属性が結付けられ$ている~IDL型への変換でない ］~AND［ `IsResizableArrayBuffer$A( %V.`ViewedArrayBuffer^sl ) ~EQ `true^jv ］ ⇒ `~THROW$ `TypeError$jt ◎ If the conversion is not to an IDL type associated with the [AllowResizable] extended attribute, and IsResizableArrayBuffer(V.[[ViewedArrayBuffer]]) is true, then throw a TypeError.
4. ~RET %V と同じ~objへの参照である~IDL `DataView$T 値 ◎ Return the IDL DataView value that is a reference to the same object as V.

~ES値 %V を いずれかの`有型~配列~型$ %T の`~IDL値に変換する$ときは、 次に従う： ◎ An ECMAScript value V is converted to an IDL Int8Array, Int16Array, Int32Array, Uint8Array, Uint16Array, Uint32Array, Uint8ClampedArray, BigInt64Array, BigUint64Array, Float32Array or Float64Array value by running the following algorithm: • Let T be the IDL type V is being converted to.

1. ~IF［ `Type$A( %V ) ~NEQ `Object^jt ］~OR［ %V は `TypedArrayName^sl `内部~slot$を持たない ］~OR［ %V の `TypedArrayName^sl `内部~slot$の値 ~NEQ %T の名前 ］ ⇒ `~THROW$ `TypeError$jt ◎ If Type(V) is not Object, or V does not have a [[TypedArrayName]] internal slot with a value equal to T’s name, 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を~byte列から作成する@ ときは、 所与の ( `~buffer~source型$ %T, `~byte列$ %~byte列, `~realm$ %~realm ) に対し： ◎ To create an ArrayBuffer from a byte sequence bytes in a realm realm: ◎ ↓↓

1. %~es配列~buffer ~LET ~ABRUPT `AllocateArrayBuffer$A( %~realm.`Intrinsics^sl.`ArrayBuffer$jIsl, %~byte列 の`長さ$byte ) ◎ Let esArrayBuffer be ? AllocateArrayBuffer(realm.[[Intrinsics]].[[%ArrayBuffer%]], bytes’s length).
2. %配列~buffer ~LET `~IDL値に変換する$( %~es配列~buffer, `ArrayBuffer$T ) ◎ Let arrayBuffer be the result of converting esArrayBuffer to an IDL value of type ArrayBuffer.
3. `配列~bufferの中へ~byte列を書込む$( %配列~buffer, %~byte列 ) ◎ Write bytes into arrayBuffer.
4. ~IF［ %T ~EQ `ArrayBuffer$T ］ ⇒ ~RET %配列~buffer ◎ Return arrayBuffer.

5. ~ELSE： ◎ ↑↑To create one of the ArrayBufferView types from a byte sequence bytes in a realm realm:

   1. ~Assert： ［ %T ~EQ `DataView$T ］~OR［ ( %~byte列 の`長さ$byte ) `modulo$op ( %T の`要素~size$eS ) ~EQ 0 ］ ◎ Assert: if the type is not DataView, then bytes’s length modulo the element size of that type is 0.
   2. %構築子 ~LET %~realm.`Intrinsics^sl からの［ %T 用の適切な構築子 ］ ◎ ↑↑Let arrayBuffer be the result of creating an ArrayBuffer from bytes in realm. ◎ ↑↑Let esArrayBuffer be the result of converting arrayBuffer to an ECMAScript value. ◎ Let constructor be the appropriate constructor from realm.[[Intrinsics]] for the type of ArrayBufferView being created.
   3. %~es~view ~LET ~NOABRUPT `Construct$A( %構築子, « %~es配列~buffer » ) ◎ Let esView be ! Construct(constructor, « esArrayBuffer »).
   4. ~RET `~IDL値に変換する$( %~es~view, %T ) ◎ Return the result of converting esView into the given type.

【 この~algoは、 原文では %T ~EQ ［ `ArrayBuffer$T の場合 ／ `ArrayBufferView$T の場合 ］の 2 つに分けて定義されているが， この訳では 1 つに統合することにする。 】

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

1. %~es~buffer~source ~LET `~ES値に変換する$( %~buffer~source ) ◎ Let esBufferSource be the result of converting bufferSource to an ECMAScript value.
2. %~es配列~buffer ~LET %~es~buffer~source ◎ Let esArrayBuffer be esBufferSource.
3. %~offset ~LET 0 ◎ Let offset be 0.
4. %長さ ~LET 0 ◎ Let length be 0.

5. ~IF［ %~es~buffer~source は `ViewedArrayBuffer^sl `内部~slot$を持つ ］： ◎ If esBufferSource has a [[ViewedArrayBuffer]] internal slot, then:

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

6. ~ELSE： ◎ Otherwise:

   1. ~Assert： %~es~buffer~source は［ `ArrayBuffer$T ／ `SharedArrayBuffer$jt ］~objである ◎ Assert: esBufferSource is an ArrayBuffer or SharedArrayBuffer object.
   2. %長さ ~SET %~es~buffer~source.`ArrayBufferByteLength^sl ◎ Set length to esBufferSource.[[ArrayBufferByteLength]].
7. %~byte列 ~LET 空な`~byte列$ ◎ ↓
8. ~IF［ `IsDetachedBuffer$A( %~es配列~buffer ) ~EQ `true^jv ］ ⇒ ~RET %~byte列 ◎ If IsDetachedBuffer(esArrayBuffer) 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( %~es配列~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(esArrayBuffer, i, Uint8, true, Unordered).
10. ~Assert： %~byte列 の`長さ$byte ~EQ %長さ ◎ ↑
11. ~RET %~byte列 ◎ Return bytes.

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

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

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

1. ~IF［ %~buffer~source は `ArrayBuffer$T 型である ］ ⇒ ~RET %~buffer~source ◎ If bufferSource is an ArrayBuffer, return bufferSource.
2. %~es~buffer~source ~LET `~ES値に変換する$( %~buffer~source ) ◎ Let esBufferSource be the result of converting bufferSource to an ECMAScript value.
3. ~RET `~IDL値に変換する$( %~es~buffer~source.`ViewedArrayBuffer^sl, `ArrayBuffer$T ) ◎ Return the result of converting esBufferSource.[[ViewedArrayBuffer]] to an IDL value of type ArrayBuffer.

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

1. %~es配列~buffer ~LET `~ES値に変換する$( %配列~buffer ) ◎ Let esArrayBuffer be the result of converting arrayBuffer to an ECMAScript value.
2. ~Assert： %開始-時の~offset ~PLUS %~byte列 の`長さ$byte ~LTE %~es配列~buffer.`ArrayBufferByteLength^sl ◎ Assert: bytes’s length ≤ esArrayBuffer.[[ArrayBufferByteLength]] − startingOffset.
3. ~EACH( %i ~IN { 0 〜 %~byte列 の`長さ$byte ~MINUS 1 } ) に対し，昇順に ⇒ `SetValueInBuffer$A( %~es配列~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(esArrayBuffer, i, Uint8, bytes[i - startingOffset], true, Unordered).

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

1. %~es~view ~LET `~ES値に変換する$( %~view ) ◎ Let esView be the result of converting view to an ECMAScript value.
2. %長さ ~LET %~byte列 の`長さ$byte ◎ ↓
3. ~Assert： %開始-時の~offset ~PLUS %長さ ~LTE %~es~view.`ByteLength^sl ◎ Assert: bytes’s length ≤ esView.[[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値に変換する$( %~es~view.`ViewedArrayBuffer^sl, `ArrayBuffer$T ) ◎ Let arrayBuffer be the result of converting esView.[[ViewedArrayBuffer]] to an IDL value of type ArrayBuffer.
6. `配列~bufferの中へ~byte列を書込む$( %配列~buffer, %~byte列, %~es~view.`ByteOffset^sl ~PLUS %開始-時の~offset ) ◎ Write bytes into arrayBuffer with startingOffset set to esView.[[ByteOffset]] + startingOffset.

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

1. %~es配列~buffer ~LET `~ES値に変換する$( %配列~buffer ) ◎ Let esArrayBuffer be the result of converting arrayBuffer to an ECMAScript value.
2. ~Assert： `IsSharedArrayBuffer$A( %~es配列~buffer ) ~EQ `false^jv ◎ Assert: IsSharedArrayBuffer(esArrayBuffer) is false.
3. ~ABRUPT `DetachArrayBuffer$A( %~es配列~buffer ) ◎ Perform ? DetachArrayBuffer(esArrayBuffer).

注記： これは、［ %~es配列~buffer は `ArrayBufferDetachKey^sl を持っていて `undefined^jv 以外の値をとる場合 ］に例外を投出することになる — `WebAssembly.Memory$c の `buffer$M 属性の値を伴う事例など `WASM-JS-API-1$r 。 ◎ This will throw an exception if esArrayBuffer 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.

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

1. %~es配列~buffer ~LET `~ES値に変換する$( %~buffer~source ) ◎ Let esArrayBuffer be the result of converting bufferSource to an ECMAScript value.
2. ~IF［ %~es配列~buffer は `ViewedArrayBuffer^sl 内部~slotを持つ ］ ⇒ %~es配列~buffer ~SET %~es配列~buffer.`ViewedArrayBuffer^sl ◎ If esArrayBuffer has a [[ViewedArrayBuffer]] internal slot, then set esArrayBuffer to esArrayBuffer.[[ViewedArrayBuffer]].
3. ~RET `IsDetachedBuffer$A( %~es配列~buffer ) ◎ Return IsDetachedBuffer(esArrayBuffer).

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

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

注記： これは、 `配列~bufferを切離す$ときと同じ状況下で，例外を投出することになる。 ◎ This will throw an exception under the same circumstances as detaching.

~ES値 %V を `~FrozenArray_T$ 型の`~IDL値に変換する$ときは、 次に従う： ◎ An ECMAScript 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配列を作成する@ ときは、 所与の ( 型 %T の値の連列 %S ) に対し，次の手続きに従う： ◎ To create a frozen array from a sequence of values of type T, follow these steps:

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

~ES言語束縛における，観測-可能な配列~属性を`~backしている~list$は、 所与の ( `~platform~obj$ %~obj, 属性 %属性 ) に対し，次の~algoが返す`~list$になる： ◎ The backing list for an observable array attribute in the ECMAScript 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 `拡張属性$は指定されている ］ ⇒ ~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 `拡張属性$は指定されている ］ ⇒ ~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 `拡張属性$は指定されている ］ ⇒ ~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 `拡張属性$は指定されている ◎ 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 を返すならば，所与の`拡張属性$ %公開~条件 上で `条件付きで公開されて@ いるとされる： ◎ 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［ %構成子 上に %公開~条件 `拡張属性$は指定されている ］ ⇒ ~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［ %構成子 上に %公開~条件 `拡張属性$は指定されている ］ ⇒ ~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［ %構成子 上に %公開~条件 `拡張属性$は指定されている ］ ⇒ ~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［ %構成子 上に %公開~条件 `拡張属性$は指定されている ］ ⇒ ~RET ~T ◎ If the exposure condition extended attribute is specified on construct, then return true.
8. ~RET ~F ◎ Otherwise, return false.

`~ifc$用の`~ifc~obj$は、 以下に従って作成される — `~ifc~objを作成する@ ときは、 所与の ( `~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 `~ES値に変換する$( %object ) ◎ Let O be object, converted to an ECMAScript 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. %F ~LET `CreateBuiltinFunction$A( %手続き, « `Unforgeables^sl », %~realm, %構築子~原型 ) ◎ Let F be CreateBuiltinFunction(steps, « [[Unforgeables]] », realm, constructorProto).
5. %偽造-不能~obj ~LET `OrdinaryObjectCreate$A( `null^jv ) ◎ Let unforgeables be OrdinaryObjectCreate(null).
6. `偽造-不能な正則~演算を定義する$( %I, %偽造-不能~obj, %~realm ) ◎ Define the unforgeable regular operations of I on unforgeables, given realm.
7. `偽造-不能な正則~属性を定義する$( %I, %偽造-不能~obj, %~realm ) ◎ Define the unforgeable regular attributes of I on unforgeables, given realm.

8. %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.

9. `SetFunctionName$A( %F, %識別子 ) ◎ Perform SetFunctionName(F, id).
10. %長さ ~LET 0 ◎ Let length be 0.

11. ~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.
12. `SetFunctionLength$A( %F, %長さ ) ◎ Perform SetFunctionLength(F, length).
13. %proto ~LET `~ifc原型~objを作成する$( %I, %~realm ) ◎ Let proto be the result of creating an interface prototype object of interface I in realm.
14. ~NOABRUPT `DefinePropertyOrThrow$A( %F, `prototype^l, `FFF-proto^desc ) ◎ Perform ! DefinePropertyOrThrow(F, "prototype", PropertyDescriptor{[[Value]]: proto, [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false}).
15. `定数を定義する$( %I, %F, %~realm ) ◎ Define the constants of interface I on F given realm.
16. `静的~属性を定義する$( %I, %F, %~realm ) ◎ Define the static attributes of interface I on F given realm.
17. `静的~演算を定義する$( %I, %F, %~realm ) ◎ Define the static operations of interface I on F given realm.
18. ~RET %F ◎ Return F.

`~ifc$用の`旧来の~factory関数$は、 以下に従って作成される — `旧来の~factory関数を作成する@ ときは、 所与の ( `~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. %F ~LET `CreateBuiltinFunction$A( %手続き, « », %~realm ) ◎ Let F be CreateBuiltinFunction(steps, « », realm).
4. %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.
5. %長さ ~LET %S 内の各~entryの引数~listの長さのうち，最小 ◎ Let length be the length of the shortest argument list of the entries in S.
6. %proto ~LET %~realm 内で %I を成す`~ifc原型~obj$ ◎ Let proto be the interface prototype object of interface I in realm.

`~ifc原型~objを作成する@ ときは、 所与の ( `~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 `拡張属性$を伴って宣言された ］~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： `Type$A( %原型 ) ~EQ `Object^jt ◎ Assert: Type(proto) is Object.
7. %~ifc原型~obj ~LET ~NULL ◎ Let interfaceProtoObj be null.

8. ~IF［ %~ifc の`自身も含む継承した~ifc群$を成すある~ifcは、 `Global$x `拡張属性$を伴って宣言された 【！declared with..., or %I が`継承した~ifc群$】 ］： ◎ 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.
9. ~ELSE ⇒ %~ifc原型~obj ~SET `OrdinaryObjectCreate$A( %原型 ) ◎ Otherwise, set interfaceProtoObj to OrdinaryObjectCreate(proto).

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

    %~ifc は `Global$x `拡張属性$を伴って宣言された場合、 `toStringTag$jS ~propも定義されるべきか？ これは `課題 #544＠~WEBIDLissue/544$ にて論じられている。 ◎ Should an @@unscopables property also be defined if interface is declared with the [Global] extended attribute? This is discussed in issue #544.

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

    2. %~ifc に`公開されて$いる, かつ `Unscopable$x `拡張属性$を伴って宣言された ~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 `CreateDataProperty$A( %~scope不能~obj, %識別子, `true^jv ) ◎ Perform ! CreateDataProperty(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, `toStringTag$jS, %記述子 ) ◎ Perform ! DefinePropertyOrThrow(interfaceProtoObj, @@unscopables, desc).

11. ~IF［ %~ifc は `Global$x `拡張属性$を伴って宣言されてない ］： ◎ 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.
12. `定数を定義する$( %~ifc, %~ifc原型~obj, %~realm ) ◎ Define the constants of interface on interfaceProtoObj given realm.

13. ~IF［ %~ifc には `LegacyNoInterfaceObject$x `拡張属性$は指定されていない ］： ◎ 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).
14. ~RET %~ifc原型~obj ◎ Return interfaceProtoObj.

`有名~prop~objを作成する@ ときは、 所与の ( `~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.

`定数を定義する@ ときは、 所与の ( ［ `~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 `~ES値に変換する$( %定数 の~IDL値 ) ◎ Let value be the result of converting const’s IDL value to an ECMAScript 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).

`正則~属性を定義する@ ときは、 所与の ( `~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.

`静的~属性を定義する@ ときは、 所与の ( `~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.

`偽造-不能な正則~属性を定義する@ ときは、 所与の ( `~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.

`属性を定義する@ ときは、 所与の ( %属性~群, `~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 { [[Get]]: %取得子, [[Set]]: %設定子, [[Enumerable]]: `true^jv, [[Configurable]]: %~configure可能 } ◎ Let desc be the PropertyDescriptor{[[Get]]: getter, [[Set]]: 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.

`属性~取得子を作成する@ ときは、 所与の ( `属性$ %属性, ［`~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. %~es値 ~LET ［ `this^jv 値 ~NIN { `null^jv, `undefined^jv } ならば `this^jv 値 ／ ~ELSE_ %~realm の`大域~obj$ ］

         （この大域~objが %target を実装しない, かつ `LegacyLenientThis$x は指定されていない場合、 数~段~先で `TypeError$jE が生じることになる。）

         ◎ Let esValue be the this value, if it is not null or undefined, or realm’s global object otherwise. (This will subsequently cause a TypeError in a few steps, if the global object does not implement target and [LegacyLenientThis] is not specified.)
      2. ~IF［ %~es値 は `~platform~objである$ ］ ⇒ `~security検査を遂行する$( %~es値, %属性 の`識別子$, `取得子^C ) ◎ If esValue is a platform object, then perform a security check, passing esValue, attribute’s identifier, and "getter".

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

         1. ~IF［ %属性 には `LegacyLenientThis$x `拡張属性$が指定されている ］ ⇒ ~RET `undefined^jv ◎ If attribute was specified with the [LegacyLenientThis] extended attribute, then return undefined.
         2. ~ELSE ⇒ `~THROW$ `TypeError$jt ◎ Otherwise, throw a TypeError.
      4. ~IF［ %属性 の型は`観測-可能な配列~型$である ］ ⇒ ~RET %~es値 の %属性 を`~backしている観測-可能な配列~exotic~obj$ ◎ If attribute’s type is an observable array type, then return esValue’s backing observable array exotic object for attribute.
      5. %~idl~obj ~SET %~es値 への参照を表現する，~IDL`~ifc型$の値 ◎ Set idlObject to the IDL interface type value that represents a reference to esValue.
   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 （ %属性 に宣言された型から）`~ES値に変換する$( %R ) ◎ Return the result of converting R to an ECMAScript 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. ~ELSE ⇒ `~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. `SetFunctionName$A( %F, %名前 ) ◎ Perform SetFunctionName(F, name).
4. `SetFunctionLength$A( %F, 0 ) ◎ Perform SetFunctionLength(F, 0).

`属性~設定子を作成する@ ときは、 所与の ( `属性$ %属性, `~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 ］いずれの`拡張属性$も伴わない ］ ⇒ ~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. ~IF［ 渡された引数の個数 ~EQ 0 ］ ⇒ `~THROW$ `TypeError$jt ◎ If no arguments were passed, then throw a TypeError.
   2. %V ~LET 渡された最初の引数の値 ◎ Let V be the value of the first argument passed.
   3. %識別子 ~LET %属性 の`識別子$ ◎ Let id be attribute’s identifier.

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

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

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

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

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

         1. %Q ~LET ~ABRUPT `Get$A( %~es値, %識別子 ) ◎ Let Q be ? Get(esValue, id).
         2. ~IF［ `Type$A( %Q ）~NEQ `Object^jt ］ ⇒ `~THROW$ `TypeError$jt ◎ If Type(Q) is not Object, then throw a TypeError.
         3. %回送-~ID ~LET `PutForwards$x 拡張属性の識別子~引数 ◎ 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.

      8. ~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. `SetFunctionLength$A( %F, 1 ) ◎ Perform SetFunctionLength(F, 1).

`正則~演算を定義する@ ときは、 所与の ( `~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.

`静的~演算を定義する@ ときは、 所与の ( `~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.

`偽造-不能な正則~演算を定義する@ ときは、 所与の ( `~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.

`演算を定義する@ ときは、 所与の ( %演算~群, `~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).

`演算~関数を作成する@ ときは、 所与の ( `演算$ %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. ~IF［ %~es値 は `~platform~objである$ ］ ⇒ `~security検査を遂行する$( %~es値, %識別子, `~method^C ) ◎ If esValue is a platform object, then perform a security check, passing esValue, id, and "method".
      2. ~IF［ %~es値 は ~ifc %target を`実装-$しない ］ ⇒ `~THROW$ `TypeError$jt ◎ If esValue 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 拡張属性を伴って宣言された ］： ◎ 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 `~ES値に変換する$( %R ) ◎ Return R, converted to an ECMAScript value.

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

   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.

~prop値 %F が呼出されたときは，次に従って挙動するモノトスル： ◎ which behaves as follows:

1. %O ~LET ~ABRUPT `ToObject$A( `this^jv 値 ) ◎ Let thisValue be the this value. ◎ Let O be ? ToObject(thisValue).
2. ~IF［ %O は `~platform~objである$ ］ ⇒ `~security検査を遂行する$( %O, %文字列化子 の`識別子$, `~method^C ) ◎ If O is a platform object, then perform a security check, passing: • the platform object O, • the identifier of the stringifier, and • the type "method".
3. ~IF［ %O は %文字列化子 を宣言する~ifcを`実装-$しない ］ ⇒ `~THROW$ `TypeError$jt ◎ If O does not implement the interface on which the stringifier was declared, then throw a TypeError.
4. %V ~LET ε ◎ Let V be an uninitialized variable.
5. ~IF［ `stringifier^sym は宣言として指定された ］ ⇒ %V ~SET 当の~ifcの`文字列~化の挙動$を遂行した結果 ◎ Depending on how stringifier was specified: ◎ as a declaration • Set V to the result of performing the stringification behavior of the interface.

6. ~ELSE（ `stringifier^sym はある`属性$ %属性 に指定された）：

   1. ~IF［ %属性 は`取得子を継承する$ものと宣言された ］ ⇒ %属性 ~SET %属性 が継承した属性
   2. %V ~SET %O の %属性 の`取得子~手続き$を［ `this$V として %O ］を与える下で走らせた結果
   ◎ on an attribute • Set V to the result of running the getter steps of the attribute (or those listed in the getter steps of the inherited attribute, if this attribute is declared to inherit its getter), with O as this.
7. ~RET （ `String^jt 型の）`~ES値に変換する$( %V ) ◎ Return the result of converting V to a String value.

`反復子~methodを定義する@ ときは、 所与の ( `~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. `CreateMethodProperty$A( %~target, `iterator$jS, `Array.prototype.values$jI ) ◎ Perform CreateMethodProperty(target, @@iterator, %Array.prototype.values%).

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

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

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

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

      1. 1. %~es値 ~LET ~ABRUPT `ToObject$A( `this^jv 値 ) ◎ Let esValue be ? ToObject(this value).
         2. ~IF［ %~es値 は`~platform~objである$ ］ ⇒ `~security検査を遂行する$( %~es値, "`iterator^jS", `~method^C ) ◎ If esValue is a platform object, then perform a security check, passing esValue, "@@iterator", and "method".
         3. ~IF［ %~es値 は %定義 を`実装-$しない ］ ⇒ `~THROW$ `TypeError$jt ◎ If esValue does not implement definition, then throw a TypeError.
         4. ~RET 次のように設定された， %定義 用の`既定の反復子~obj$ ⇒＃ `~target$dI ~SET %~es値, `種類$dI ~SET `key+value^l, `~index$dI ~SET 0 ◎ Return a newly created default iterator object for definition, with esValue as its target, "key+value" as its kind, and index set to 0.
      2. `SetFunctionName$A( %F, `entries^l) ◎ Perform SetFunctionName(F, "entries").
      3. `CreateMethodProperty$A( %~target, `iterator$jS, %F ) ◎ Perform CreateMethodProperty(target, @@iterator, F).
      4. ~NOABRUPT `CreateDataProperty$A( %~target, `entries^l, %F ) ◎ Perform ! CreateDataProperty(target, "entries", F).

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

      1. 1. ~IF［ %~es値 は`~platform~objである$ ］ ⇒ `~security検査を遂行する$( %~es値, `keys^l, `~method^C ) ◎ If esValue is a platform object, then perform a security check, passing esValue, "keys", and "method".
         2. ~RET 次のように設定された， %定義 用の新たな`既定の反復子~obj$ ⇒＃ `~target$dI ~SET %~es値, `種類$dI ~SET `key^l, `~index$dI ~SET 0 ◎ Return a newly created default iterator object for definition, with esValue as its target, "key" as its kind, and index set to 0.
      2. `SetFunctionName$A( %F, `keys^l) ◎ Perform SetFunctionName(F, "keys").
      3. ~NOABRUPT `CreateDataProperty$A( %~target, `keys^l, %F ) ◎ Perform ! CreateDataProperty(target, "keys", F).

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

      1. 1. ~IF［ %~es値 は`~platform~objである$ ］ ⇒ `~security検査を遂行する$( %~es値, `values^l, `~method^C ) ◎ If esValue is a platform object, then perform a security check, passing esValue, "values", and "method".
         2. ~RET 次のように設定された， %定義 用の新たな`既定の反復子~obj$ ⇒＃ `~target$dI ~SET %~es値, `種類$dI ~SET `value^l, `~index$dI ~SET 0 ◎ Return a newly created default iterator object for definition, with esValue as its target, "value" as its kind, and index set to 0.
      2. `SetFunctionName$A( %F, `values^l) ◎ Perform SetFunctionName(F, "values").
      3. ~NOABRUPT `CreateDataProperty$A( %~target, `values^l, %F ) ◎ Perform ! CreateDataProperty(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［ %~es値 は`~platform~objである$ ］ ⇒ `~security検査を遂行する$( %~es値, `forEach^l, `~method^C ) ◎ If esValue is a platform object, then perform a security check, passing esValue, "forEach", and "method".
         2. %~idl~callback ~LET `~IDL値に変換する$( %~callback, `Function$T ) ◎ Let idlCallback be callback, converted to a Function.
         3. %~idl~obj ~LET %~es値 への参照を表現する~IDL`~ifc型$の値 ◎ Let idlObject be the IDL interface type value that represents a reference to esValue.
         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. `SetFunctionName$A( %F, `forEach^l) ◎ Perform SetFunctionName(F, "forEach").
      3. ~NOABRUPT `CreateDataProperty$A( %~target, `forEach^l, %F ) ◎ Perform ! CreateDataProperty(target, "forEach", F).

`非同期~反復子~methodを定義する@ ときは、 所与の ( `~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＼

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

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

      1. ~IF［ %~es値 は`~platform~objである$ ］ ⇒ `~security検査を遂行する$( %~es値, "`asyncIterator^jS", `~method^C ) ◎ If esValue is a platform object, then perform a security check, passing esValue, "@@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. `CreateMethodProperty$A( %~target, `asyncIterator$jS, %F ) ◎ Perform CreateMethodProperty(target, @@asyncIterator, F).

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

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

   1. 1. ~IF［ %~es値 は`~platform~objである$ ］ ⇒ `~security検査を遂行する$( %~es値, `keys^l, `~method^C ) ◎ If esValue is a platform object, then perform a security check, passing esValue, "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. `SetFunctionName$A( %F, `keys^l) ◎ Perform SetFunctionName(F, "keys").
   3. ~NOABRUPT `CreateDataProperty$A( %~target, `keys^l, %F ) ◎ Perform ! CreateDataProperty(target, "keys", F).

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

   1. 1. ~IF［ %~es値 は`~platform~objである$ ］ ⇒ `~security検査を遂行する$( %~es値, `values^l, `~method^C ) ◎ If esValue is a platform object, then perform a security check, passing esValue, "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. ~IF［ %定義 は`値を非同期に可反復な宣言$を持つ ］ ⇒ ~NOABRUPT `CreateMethodProperty$A( %~target, `asyncIterator$jS, %F ) ◎ If definition has a value asynchronously iterable declaration, then perform ! CreateMethodProperty(target, @@asyncIterator, F).

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

1. ~Assert ⇒＃ %定義 は`非同期に可反復な宣言$を持つ`~ifc$である／ %~es引数~群 は~ES値の`~list$である ◎ given an interface definition that has an asynchronously iterable declaration and a list of ECMAScript 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 %~es引数~群 の`~size$ ］~AND［ %~es引数~群[ %i ] ~NEQ `undefined^jv ］ ⇒ %~idl値 ~SET `~IDL値に変換する$( %~es引数~群[ %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 `拡張属性$を伴う`~ifc$を実装する`~platform~obj$ %O の `SetPrototypeOf^sl 内部~methodが，~ES言語~値 %V で~callされたときは、 次を走らす： ◎ When the [[SetPrototypeOf]] internal method of a platform object O that implements an interface with the [Global] extended attribute is called with ECMAScript 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, ~ES言語~値 %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 ECMAScript 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［ `Type$A( %P ) ~EQ `String^jt ］： ◎ If O implements an interface with a named property setter and Type(P) is 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［ %O は `有名~propを~support$する ］~AND［ %O は `Global$x `拡張属性$を伴う`~ifc$を`実装-$しない ］~AND［ `Type$A( %P ) ~EQ `String^jt ］~AND［ %P は %O の `LegacyUnforgeable$x ~prop名でない ］： ◎ If O supports named properties, O does not implement an interface with the [Global] extended attribute, Type(P) is String, and P is not an unforgeable property name of O, then:

   1. %作成するか ~LET ［ %P は %O が`~supportする~prop名$であるならば ~T ／ ~ELSE_ ~F ］ ◎ Let creating be true if P is not a supported property name, and false otherwise.

   2. ~IF［ %O が`実装-$する ある~ifcは `LegacyOverrideBuiltIns$x `拡張属性$を伴う ］~OR［ %O は 名前 %P の自前の~propを持たない ］： ◎ If O implements an interface with the [LegacyOverrideBuiltIns] extended attribute or O does not have an own property named P, then:

      1. ~IF［ %作成するか ~EQ ~F ］~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. ~IF［ %O は `Global$x `拡張属性$を伴う`~ifc$を`実装-$しない ］ ⇒ %記述子.`Configurable^sl ~SET `true^jv ◎ If O does not implement an interface with the [Global] extended attribute, then set Desc.[[Configurable]] to true.
4. ~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 `拡張属性$を伴う`~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 ) を与える下で遂行することにより、 既存の有名~propを削除する ◎ 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$ — これは、 いくつかの~ES［ `String^jt ／ `Symbol^jt ］値からなる。 ◎ Let keys be a new empty list of ECMAScript 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［ `Type$A( %P ) ~NEQ `String^jt ］ ⇒ ~RET ~F ◎ If Type(P) is not 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 は、 ~ESに許容される最大な配列~長さである。 ◎ Note: 232 − 1 is the maximum array length allowed by ECMAScript.

6. ~RET ~T ◎ Return true.

所与の有名~propを~obj上に公開するかどうかは、 `有名~propの可視性判定~algo@ を利用して決定される。 一部の有名~propは、［ `LegacyOverrideBuiltIns$x `拡張属性$が利用されたかどうか ］に依存して，~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 `拡張属性$を持つ ］ ⇒ ~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.

`~platform~obj$ %O 上で `有index~prop設定子を呼出す@ ときは、 所与の ( ~prop名 %P, ~ES値 %V ) に対し，次の手続きを遂行するモノトスル： ◎ To invoke an indexed property setter on a platform object O with property name P and ECMAScript value V, the following steps must be performed:

1. %~index ~LET ~ABRUPT `ToUint32$A( %P ) ◎ Let index be the result of calling ? ToUint32(P).
2. %作成するか ~LET ［ %~index は %O が`~supportする~prop~index$でないならば ~T ／ ~ELSE_ ~F ］ ◎ Let creating be true if index is not a supported property index, and false otherwise.
3. %演算 ~LET `有index~prop設定子$を宣言するために利用された演算 ◎ Let operation be the operation used to declare the indexed property setter.
4. %T ~LET %演算 の 2 個目の引数の型 ◎ Let T be the type of the second argument of operation.
5. %値 ~LET `~IDL値に変換する$( %V, %T ) ◎ Let value be the result of converting V to an IDL value of type T.
6. 1. ~IF［ %作成するか ~EQ ~T ］ ⇒ ［ ~ifcの記述に挙げられている，`新たな有index~propを設定する$手続き ］を ( ~index %~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 ⇒ ［ ~ifcの記述に挙げられている，`既存の有index~propを設定する$手続き ］を ( ~index %~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.
7. ~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.

`~platform~obj$ %O 上で `有名~prop設定子を呼出す@ ときは、 所与の ( ~prop名 %P, ~ES値 %V ) に対し，次の手続きを遂行するモノトスル： ◎ To invoke a named property setter on a platform object O with property name P and ECMAScript value V, the following steps must be performed:

1. %作成するか ~LET ［ %P は %O が`~supportする~prop名$であるならば ~T ／ ~ELSE_ ~F ］ ◎ Let creating be true if P is not a supported property name, and false otherwise.
2. %演算 ~LET `有名~prop設定子$を宣言するために利用された演算 ◎ Let operation be the operation used to declare the named property setter.
3. 1. ~IF［ %作成するか ~EQ ~T ］ ⇒ ［ ~ifcの記述に挙げられている，`新たな有名~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 ⇒ ［ ~ifcの記述に挙げられている，`既存の有名~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.
4. ~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 %~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 an ECMAScript 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 `拡張属性$を伴うならば `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 an ECMAScript 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［ 次のいずれかが満たされる ］…：

      • %記述子.`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［ 次のいずれかが満たされる ］…：

      • %記述子.`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. %~es値 ~LET `~ES値に変換する$( %~handler.`BackingList^sl[ %~index ] ) ◎ Let esValue be the result of converting handler.[[BackingList]][index] to an ECMAScript value.
   3. ~Assert： 前~段が例外を投出することは決してない ◎ Assert: the above step never throws an exception.
   4. ~RET %~es値 ◎ Return esValue.
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. %~es値 ~LET `~ES値に変換する$( %~handler.`BackingList^sl[ %~index ] ) ◎ Let esValue be the result of converting handler.[[BackingList]][index] to an ECMAScript value.
   3. ~Assert： 前~段が例外を投出することは決してない ◎ Assert: the above step never throws an exception.
   4. ~RET `FromPropertyDescriptor$A( `TTT-~es値^desc ) ◎ Return FromPropertyDescriptor(PropertyDescriptor{[[Configurable]]: true, [[Enumerable]]: true, [[Writable]]: true, [[Value]]: esValue }).
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の長さを設定する@ ときは、 所与の ( %~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値を設定する@ ときは、 所与の ( %~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を作成する@ ときは、 所与の ( `~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. `定数を定義する$( %I, %F, %~realm ) ◎ Define the constants of interface on F given realm.

`~ns~objを作成する@ ときは、 所与の ( `~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 拡張属性を伴う ］ ◎ For each exposed interface interface which has the [LegacyNamespace] extended attribute with the identifier of namespace as its argument,

6. %~ifcたち 内の ~EACH( %~ifc ) に対し： ◎ ↑

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

`例外を作成する$ときは、 所与の：

• 例外~型 %E — `単純~例外$, `DOMException$T のいずれか
• 文字列 %N — `~error名$を与える／ %E は `DOMException$T の場合に限り与えられる
• 文字列 %M — ~UAにより定義される~messageを与える／ 省略時は `undefined^jv

に対し， %E に応じて 次を走らす：

• `DOMException$T：

  1. %X ~LET `現在の~realm$に属する `DOMException$T `~ifc~obj$
  2. ~RET ~NOABRUPT `Construct$A( %X, « %M, %N » )

• `単純~例外$：

  1. %X ~LET `現在の~realm$に属する［［ %E に対応している~ES~error ］用の`構築子$ ］
  2. ~RET ~NOABRUPT `Construct$A( %X, « %M » )

`例外を投出する$ときは、 所与の［ `例外を作成する$ときに与えるものと同じ引数~群 ］に対し，次を走らす： ◎ To throw a simple exception or DOMException, with a string giving the error name for the DOMException case and optionally a string giving a user agent-defined message:

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