Web IDL

2.4.1. 定数

`定数@ は、定数~値を名前に束縛するために利用される，宣言（ `Const$g に合致）である。 定数は`~ifc$に現れ得る。 ◎ A constant is a declaration (matching Const) used to bind a constant value to a name. Constants can appear on interfaces.

過去においては，定数は、主に，有名~整数~codeを列挙する~styleで定義されていた。 ~Web~platformは、文字列~利用の支持を受けて，この設計~patternから離れつつある。 この特色機能を利用したいと望む編集者には、先に進む前に `Intent to use Constants$fI した上で論交することを，強く勧める。 ◎ Constants have in the past primarily been used to define named integer codes in the style of an enumeration. The Web platform is moving away from this design pattern in favor of the use of strings. Editors who wish to use this feature are strongly advised to discuss this by filing an issue before proceeding.

const `type^i `constant_identifier^i = 42;

`定数$の`識別子$は［ 同じ~ifc上で定義される別の`~ifc~mb$ ］の識別子と同じになっては~MUST_NOT。 また、識別子が［ `length^l ／ `name^l ／ `prototype^l ］になっては~MUST_NOT。 ◎ The identifier of a constant must not be the same as the identifier of another interface member defined on the same interface. The identifier also must not be "length", "name" or "prototype".

これらの名前は、`関数~obj$に存在する~propの名前である。 ◎ Note: These three names are the names of properties that may exist on function objects at the time the function object is created in the ECMAScript language binding.

定数の型（ `ConstType$g に合致）は、［ `~primitive型$または`~nullable$~primitive型 ］で~MUST。 `識別子$が利用される場合、その識別子は［ ~primitive型または~nullable~primitive型 ］の`~typedef$を参照し~MUST。 ◎ The type of a constant (matching ConstType) must not be any type other than a primitive type or a nullable primitive type. If an identifier is used, it must reference a typedef whose type is a primitive type or a nullable primitive type.

注記： 文字列や空~連列に加え，これらの値も［ 辞書~mbの`既定~値$diCや, `随意~引数$の`既定~値$ ］を指定するために利用できる。 文字列や空~連列 `[]^c は、`定数$の値には利用できないことに注意。 ◎ Note: These values – in addition to strings and the empty sequence – can also be used to specify the default value of a dictionary member or of an optional argument. Note that strings and the empty sequence [] cannot be used as the value of a constant.

真偽~literal~tokenの値は、それぞれ， ~IDL `boolean$T 値［ `true^V, `false^V ］になる。 ◎ The value of the boolean literal tokens true and false are the IDL boolean values true and false.

`integer$g ~tokenの型は、それを値に利用している［ 定数／辞書~mb／随意~引数 ］の型と同じである。 `integer$g ~tokenの値は、 `idl-types$sec で与えられる，その型の値として妥当な範囲に入ら~MUST。 ◎ The type of an integer token is the same as the type of the constant, dictionary member or optional argument it is being used as the value of. The value of the integer token must not lie outside the valid range of values for its type, as given in §2.12 Types.

`Infinity^c, `-Infinity^c, `NaN^c のいずれかとして指定された定数~値は、それを値に利用している［ 定数／辞書~mb／随意~引数 ］の型に依存して，単精度, 倍精度 いずれかの IEEE 754 浮動小数点数になり、次に従って決定される： ◎ The value of a constant value specified as Infinity, -Infinity or NaN is either an IEEE 754 single-precision floating point number or an IEEE 754 double-precision floating point number, depending on the type of the constant, dictionary member or optional argument is is being used as the value for:

`unrestricted float$T 型の定数~値 `Infinity^c ◎ Type unrestricted float, constant value Infinity

値は IEEE 754 単精度，正の無限~値 ◎ The value is the IEEE 754 single-precision positive infinity value.

`unrestricted double$T 型の定数~値 `Infinity^c ◎ Type unrestricted double, constant value Infinity

値は IEEE 754 倍精度，正の無限~値 ◎ The value is the IEEE 754 double-precision positive infinity value.

`unrestricted float$T 型の定数~値 `-Infinity^c ◎ Type unrestricted float, constant value -Infinity

値は IEEE 754 単精度，負の無限~値 ◎ The value is the IEEE 754 single-precision negative infinity value.

`unrestricted double$T 型の定数~値 `-Infinity^c ◎ Type unrestricted double, constant value -Infinity

値は IEEE 754 倍精度，負の無限~値 ◎ The value is the IEEE 754 double-precision negative infinity value.

`unrestricted float$T 型の定数~値 `NaN^c ◎ Type unrestricted float, constant value NaN

値は~bit~pattern `7fc00000^X の， IEEE 754 単精度 NaN ◎ The value is the IEEE 754 single-precision NaN value with the bit pattern 0x7fc00000.

`unrestricted double$T 型の定数~値 `NaN^c ◎ Type unrestricted double, constant value NaN

値は~bit~pattern `7ff8000000000000^X の， IEEE 754 倍精度 NaN ◎ The value is the IEEE 754 double-precision NaN value with the bit pattern 0x7ff8000000000000.

`float$g ~tokenの型は、それを値に利用している［ 定数／辞書~mb／随意~引数 ］の型と同じになる。 `float$g ~tokenの値は、 `idl-types$sec で与えられる，その型の値として妥当な範囲に入ら~MUST。 また、［ `Infinity^c, `-Infinity^c, `NaN^c ］が［ `float$T や `double$T ］の値として利用されては~MUST_NOT。 ◎ The type of a float token is the same as the type of the constant, dictionary member or optional argument it is being used as the value of. The value of the float token must not lie outside the valid range of values for its type, as given in §2.12 Types. Also, Infinity, -Infinity and NaN must not be used as the value of a float or double.

`null^c ~tokenの値は、`~nullable型$に属する特別な `null^V 値である。 `null^c ~tokenの型は、それを値に利用している［ 定数／辞書~mb／随意~引数 ］の型と同じになる。 ◎ The value of the null token is the special null value that is a member of the nullable types. The type of the null token is the same as the type of the constant, dictionary member or optional argument it is being used as the value of.

%VT を定数にあてがわれる値の型, %DT を［ 定数／辞書~mb／随意~引数 ］自身の型とするとき、これらの型は互換，すなわち %DT と %VT が一致するか, または %DT はその`内縁~型$が %VT であるような`~nullable型$でなければ~MUST。 ◎ If VT is the type of the value assigned to a constant, and DT is the type of the constant, dictionary member or optional argument itself, then these types must be compatible, which is the case if DT and VT are identical, or DT is a nullable type whose inner type is VT.

`定数$は、それが現れる`~ifc$の特定0の~instanceには結付けられない。 `定数$が~instanceにも公開されるかどうかは、言語束縛に特有になる。 ◎ Constants are not associated with particular instances of the interface on which they appear. It is language binding specific whether constants are exposed on instances.

[Exposed=Window]
interface A {
  const short rambaldi = 47;
};

定数に適用-可能な拡張属性は ⇒ `Exposed$x, `SecureContext$x ◎ The following extended attributes are applicable to constants: [Exposed], [SecureContext].

[Exposed=Window]
interface Util {
  const boolean DEBUG = false;
  const octet LF = 10;
  const unsigned long BIT_MASK = 0x0000fc00;
  const double AVOGADRO = 6.022e23;
};

2.4.2. 属性

`属性@ （ `inherit^sym `ReadOnly$g `AttributeRest$g ／ `static^sym `ReadOnly$g `AttributeRest$g ／ `stringifier^sym `ReadOnly$g `AttributeRest$g ／ `ReadOnly$g `AttributeRest$g いずれかに合致）は、`~ifc~mb$であり，次を宣言するために利用される ⇒ 当の`~ifc$を実装している~objは、所与の［ 型, `識別子$ ］により，値の取得0や（一部の場合は）変更を行える~data~fieldを持つ ◎ An attribute is an interface member (matching inherit ReadOnly AttributeRest, static ReadOnly AttributeRest, stringifier ReadOnly AttributeRest, or ReadOnly AttributeRest) that is used to declare data fields with a given type and identifier whose value can be retrieved and (in some cases) changed.＼

`属性$は、次の 2 種類に分けられる： ◎ There are two kinds of attributes:

• `正則~属性$は、次を宣言するために利用される ⇒ 当の`~ifc$を実装している~objは、所与の`識別子$を伴う~data~field~mbを持つ ◎ regular attributes, which are those used to declare that objects implementing the interface will have a data field member with the given identifier

  interface `interface_identifier^i {
    attribute `type^i `identifier^i;
  };
  

• `静的~属性$は、次を宣言するために利用される ⇒ 当の~ifcを実装している特定0の~objには結付けられない属性 ◎ static attributes, which are used to declare attributes that are not associated with a particular object implementing the interface

  interface `interface_identifier^i {
    static attribute `type^i `identifier^i;
  };
  

`static^c ~keywordを伴わない属性は `正則~属性@ を宣言する。 そうでなければ，`静的~属性$を宣言する。 `読専$な`正則~属性$には、`~ifc~mb$以外にも，`~ns~mb$であるものもあることに注意。 ◎ If an attribute has no static keyword, then it declares a regular attribute. Otherwise, it declares a static attribute. Note that in addition to being interface members, read only regular attributes can be namespace members as well.

`属性$の`識別子$は［ 同じ`~ifc$上に定義される別の`~ifc~mb$の識別子 ］と同じになっては~MUST_NOT。 静的~属性の識別子が `prototype^l になっては~MUST_NOT。 ◎ The identifier of an attribute must not be the same as the identifier of another interface member defined on the same interface. The identifier of a static attribute must not be "prototype".

属性の型は、 `attribute^c ~keywordの後に現れる型（ `Type$g に合致）で与えられる。 `Type$g が［ `識別子$, または `?^c が後続する識別子 ］である場合、その識別子は［ `~ifc$／`列挙$／`呼戻~関数$／`~typedef$ ］を識別し~MUST。 ◎ The type of the attribute is given by the type (matching Type) that appears after the attribute keyword. If the Type is an identifier or an identifier followed by ?, then the identifier must identify an interface, enumeration, callback function or typedef.

属性の型は、~typedefの解決-後に，次に挙げる型, あるいはその`~nullable型$になっては~MUST_NOT。 ◎ The type of the attribute, after resolving typedefs, must not be a nullable or non-nullable version of any of the following types:

• `連列~型$ ◎ a sequence type
• `辞書~型$ ◎ a dictionary type
• `~record型$ ◎ a record type
• その`平坦化~mb型$に［ ［ ~nullable／非~nullable ］の連列~型 ／ 辞書 ／ ~record ］を含んでいるような，`共用体~型$ 【平坦化~mb型は~nullableを含み得ないので，この “~nullable” の記述は不要では？】 ◎ a union type that has a nullable or non-nullable sequence type, dictionary, or record as one of its flattened member types

`attribute^c ~keywordの前に `readonly^c ~keywordが利用されている場合、属性は `読専@（ `read only^en, 読み取り専用） になる。 ［ 読専の属性が定義されている~ifc ］を実装する~objにおいては、その属性に対する代入は許容されないことになる。 代入が、単に言語において許容されないのか, 無視されるのか, あるいは例外が投出されるのか，については、言語束縛に特有になる。 ◎ The attribute is read only if the readonly keyword is used before the attribute keyword. An object that implements the interface on which a read only attribute is defined will not allow assignment to that attribute. It is language binding specific whether assignment is simply disallowed by the language, ignored or an exception is thrown.

interface `interface_identifier^i {
  readonly attribute `type^i `identifier^i;
};

`~promise型$である属性は、`読専$で~MUST。 加えて、次の`拡張属性$は持てない ⇒ `LenientSetter$x, `PutForwards$x, `Replaceable$x, `SameObject$x ◎ Attributes whose type is a promise type must be read only. Additionally, they cannot have any of the extended attributes [LenientSetter], [PutForwards], [Replaceable], or [SameObject].

`読専$でない`正則~属性$は、先祖の~ifcからその `取得子を継承-@ するように宣言できる。 これにより、先祖~ifcの読専の属性を，派生~ifc上で~writableにできる。 属性は、その宣言が `inherit^c を伴うとき，`取得子を継承-$するものとされる。 その属性が取得子を継承する読専の属性は、［ 同じ識別子の属性が定義されている，先祖の~ifc ］のうち，最も末端の~ifcに属する属性である。 取得子を［ 継承する側, される側 ］の属性の型は同じで~MUST。 また、 `inherit^c が［ `読専$な属性／`静的~属性$ ］に現れては~MUST_NOT。 ◎ A regular attribute that is not read only can be declared to inherit its getter from an ancestor interface. This can be used to make a read only attribute in an ancestor interface be writable on a derived interface. An attribute inherits its getter if its declaration includes inherit in the declaration. The read only attribute from which the attribute inherits its getter is the attribute with the same identifier on the closest ancestor interface of the one on which the inheriting attribute is defined. The attribute whose getter is being inherited must be of the same type as the inheriting attribute, and inherit must not appear on a read only attribute or a static attribute.

[Exposed=Window]
interface `Ancestor^i {
  readonly attribute `TheType^i `theIdentifier^i;
};

[Exposed=Window]
interface `Derived^i : `Ancestor^i {
  inherit attribute `TheType^i `theIdentifier^i;
};

`正則~属性$の宣言に `stringifier^c ~keywordが利用されている場合、その~ifcを実装している~objが文字列化されるときに，その属性の値になることを指示する。 詳細は `idl-stringifiers$sec を見よ。 ◎ When the stringifier keyword is used in a regular attribute declaration, it indicates that objects implementing the interface will be stringified to the value of the attribute. See §2.4.4.1 Stringifiers for details.

interface `interface_identifier^i {
  stringifier attribute DOMString `identifier^i;
};

実装が`利用元~obj$上の`属性$の値を取得-または設定しようと試みたときに（例えば 呼戻~objが実装に給されているとき），その試みによる~~結果，例外が投出される場合、他が指定されない限り，その例外は［ 実装からその属性への~accessを生じさせた，利用元~code ］まで伝播することになる。 同様に、属性の取得-により返される値を~IDL型の値に変換できない場合、それにより生じた例外も［ 実装からその属性の値の取得を試みさせた，利用元~code ］まで伝播することになる。 ◎ If an implementation attempts to get or set the value of an attribute on a user object (for example, when a callback object has been supplied to the implementation), and that attempt results in an exception being thrown, then, unless otherwise specified, that exception will be propagated to the user code that caused the implementation to access the attribute. Similarly, if a value returned from getting the attribute cannot be converted to an IDL type, then any exception resulting from this will also be propagated to the user code that resulted in the implementation attempting to get the value of the attribute.

［ 正則／静的 ］属性に適用-可能な拡張属性は ⇒ `Exposed$x, `SameObject$x, `SecureContext$x ◎ The following extended attributes are applicable to regular and static attributes: [Exposed], [SameObject], [SecureContext].

次の`拡張属性$は、正則~属性にしか適用-可能でない ⇒ `LenientSetter$x, `LenientThis$x, `PutForwards$x, `Replaceable$x, `Unforgeable$x ◎ The following extended attributes are applicable only to regular attributes: [LenientSetter], [LenientThis], [PutForwards], [Replaceable], [Unforgeable].

[Exposed=Window]
interface Animal {

  /* 
単純な，任意の文字列に設定され得る属性。
◎
A simple attribute that can be set to any string value.
 */
  readonly attribute DOMString name;

  /* 
値を代入できる属性。
◎
An attribute whose value can be assigned to.
 */
  attribute unsigned short age;
};

[Exposed=Window]
interface Person : Animal {

  /* 
取得子の挙動を `Animal^T から継承する属性。
`Person^T の記述にて指定する必要はない。
◎
An attribute whose getter behavior is inherited from Animal, and need not be specified in the description of Person.
 */
  inherit attribute DOMString name;
};

2.4.3. 演算

`演算@ （ `static^sym `RegularOperation$g ／ `stringifier^sym `RegularOperation$g ／ `RegularOperation$g ／ `SpecialOperation$g いずれかに合致）は、`~ifc~mb$であり，その~ifcを実装している~obj上で呼出せる挙動を定義する。 ◎ An operation is an interface member (matching static RegularOperation, stringifier RegularOperation, RegularOperation or SpecialOperation) that defines a behavior that can be invoked on objects implementing the interface.＼

演算には次の 3 種類がある： ◎ There are three kinds of operation:

• `正則~演算$は、次を宣言するために利用される ⇒ 当の`~ifc$を実装している~objは、所与の`識別子$を伴う~methを持つ ◎ regular operations, which are those used to declare that objects implementing the interface will have a method with the given identifier

  interface `interface_identifier^i {
    `return_type^i `identifier^i(/* arguments... */);
  };
  

• `特殊~演算$は、次を宣言するために利用される ⇒ ~objの~index法や文字列化などの，当の~ifcを実装している~obj上の特殊な挙動 ◎ special operations, which are used to declare special behavior on objects implementing the interface, such as object indexing and stringification

  interface `interface_identifier^i {
    /* special_keywords... */ `return_type^i `identifier^i(/* arguments... */);
    /* special_keywords... */ `return_type^i (/* arguments... */);
  };
  

• `静的~演算$は、次を宣言するために利用される ⇒ 当の~ifcを実装している特定0の~objには結付けられない演算 ◎ static operations, which are used to declare operations that are not associated with a particular object implementing the interface

  interface `interface_identifier^i {
    static `return_type^i `identifier^i(/* arguments... */);
  };
  

演算のうち，［ 識別子を持つ ］~AND［ `static^sym ~keywordは伴わない ］ものは、 `正則~演算@ を宣言する。 `特殊~keyword$（すなわち，［ `Special$g に合致する~keyword, または `stringifier^c ~keyword ］）が宣言に利用されている演算は，`特殊~演算$を宣言する。 演算を，正則~演算と特殊~演算を兼ねるように宣言することもできる。 特殊~演算についての詳細は、 `idl-special-operations$sec を見よ。 `正則~演算$には、`~ifc~mb$以外にも，`~ns~mb$であるものもあることに注意。 ◎ If an operation has an identifier but no static keyword, then it declares a regular operation. If the operation has a special keyword used in its declaration (that is, any keyword matching Special, or the stringifier keyword), then it declares a special operation. A single operation can declare both a regular operation and a special operation; see §2.4.4 Special operations for details on special operations. Note that in addition to being interface members, regular operations can also be namespace members.

識別子を持たない演算は、いずれかの特殊~keywordを利用して，`特殊~演算$として宣言され~MUST。 ◎ If an operation has no identifier, then it must be declared to be a special operation using one of the special keywords.

`正則~演算$／`静的~演算$の識別子は、同じ`~ifc$上に定義される`定数$や`属性$の識別子と同じになっては~MUST_NOT。 静的~演算の識別子は `prototype^l になっては~MUST_NOT。 ◎ The identifier of a regular operation or static operation must not be the same as the identifier of a constant or attribute defined on the same interface. The identifier of a static operation must not be "prototype".

注記： しかしながら、識別子をその~ifc上の別の演算と同じにすることはできる。 演算の多重定義は、これにより指定される。 ◎ Note: The identifier can be the same as that of another operation on the interface, however. This is how operation overloading is specified.

`静的~演算$の`識別子$は、同じ`~ifc$上に定義される`正則~演算$の識別子と同じになっては~MUST_NOT。 ◎ The identifier of a static operation also must not be the same as the identifier of a regular operation defined on the same interface.

演算の `返値型@ （ `ReturnType$g に合致）は、［ 随意の［ 演算の`識別子$ ］］の前に現れる型で与えられる。 返値型 `void@T は，演算は値を返さないことを指示する。 返値型が `?^c 付きの`識別子$である場合、その識別子は［ `~ifc$／`辞書$／`列挙$／`呼戻~関数$／`~typedef$ ］を識別し~MUST。 ◎ The return type of the operation is given by the type (matching ReturnType) that appears before the operation’s optional identifier. A return type of void indicates that the operation returns no value. If the return type is an identifier followed by ?, then the identifier must identify an interface, dictionary, enumeration, callback function or typedef.

演算の引数（ `ArgumentList$g に合致）は、宣言の中の丸括弧の合間にて与えられる。 それぞれの引数は、型（ `Type$g に合致）の後に `識別子$（ `ArgumentName$g に合致）を続けて指定される。 ◎ An operation’s arguments (matching ArgumentList) are given between the parentheses in the declaration. Each individual argument is specified as a type (matching Type) followed by an identifier (matching ArgumentName).

注記： 表現力のため、演算~引数の識別子には， `ArgumentNameKeyword$g 記号に合致する~keywordも，~escapeを要することなく 指定できる。 ◎ Note: For expressiveness, the identifier of an operation argument can also be specified as one of the keywords matching the ArgumentNameKeyword symbol without needing to escape it.

演算~引数の型が`~typedef$の解決-後に`~nullable型$になる場合、その`内縁~型$は`辞書~型$になっては~MUST_NOT。 ◎ If the operation argument type, after resolving typedefs, is a nullable type, its inner type must not be a dictionary type.

interface `interface_identifier^i {
  `return_type^i `identifier^i(`type^i `identifier^i, `type^i `identifier^i /* , ... */);
};

各~引数の識別子は、同じ演算~宣言~内の他の引数の識別子と同じになっては~MUST_NOT。 ◎ The identifier of each argument must not be the same as the identifier of another argument in the same operation declaration.

各~引数の前には、`拡張属性$の~list（ `ExtendedAttributeList$g に合致）を置くことができる — それらは、その引数として渡された値が，言語束縛において どう取扱われるかを制御する。 ◎ Each argument can be preceded by a list of extended attributes (matching ExtendedAttributeList), which can control how a value passed as the argument will be handled in language bindings.

interface `interface_identifier^i {
  `return_type^i `identifier^i([`extended_attributes^mk] `type^i `identifier^i, [`extended_attributes^mk] `type^i `identifier^i /* , ... */);
};

[Exposed=Window]
interface Dimensions {
  attribute unsigned long width;
  attribute unsigned long height;
};

[Exposed=Window]
interface Button {

  /* 
引数をとらず, `boolean^T を返す演算
◎
An operation that takes no arguments and returns a boolean.
 */
  boolean isMouseOver();

  /* 
多重定義された演算。
◎
Overloaded operations.
 */
  void setDimensions(Dimensions %size);
  void setDimensions(unsigned long %width, unsigned long %height);
};

演算の 最後の引数 の引数~型の直後に `...^c ~tokenが利用されている場合、その演算は `可変個的な@ もの（ `variadic^en ）と見なされ、その最後の引数を指して `可変個~引数@ という 【この用語は、参照し易くするため，この訳に導入している】 。 そのように宣言された演算は： ◎ An operation is considered to be variadic if the final argument uses the ... token just after the argument type.＼

• `可変個~引数$の後に，任意~個数の引数を伴って呼出せることを指示し、それらの余分な暗黙の形式的~引数の型は，`可変個~引数$と同じ型と見なされる。 ◎ Declaring an operation to be variadic indicates that the operation can be invoked with any number of arguments after that final argument. Those extra implied formal arguments are of the same type as the final explicit argument in the operation declaration.＼
• 呼出すときには、`可変個~引数$も省略できる。 ◎ The final argument can also be omitted when invoking the operation.＼
• `可変個~引数$以外の引数は `...^c ~tokenを伴って宣言されては~MUST_NOT。 ◎ An argument must not be declared with the ... token unless it is the final argument in the operation’s argument list.

interface `interface_identifier^i {
  `return_type^i `identifier^i(`type^i... `identifier^i);
  `return_type^i `identifier^i(`type^i `identifier^i, `type^i... `identifier^i);
};

`引数~listを引数にとる$`拡張属性$（この仕様で定義される `Constructor$x と `NamedConstructor$x ）, および `呼戻~関数$についても、その引数~listに `...^c ~tokenが利用されているならば，`可変個的な$ものと見なされる。 【以下の記述における可変個的な演算の “演算” には，これらの（構築子を与える）拡張属性や呼戻子も含まれる。】 ◎ Extended attributes that take an argument list ([Constructor] and [NamedConstructor], of those defined in this specification) and callback functions are also considered to be variadic when the ... token is used in their argument lists.

[Exposed=Window]
interface IntegerSet {
  readonly attribute unsigned long cardinality;

  void union(long... %ints);
  void intersection(long... %ints);
};

var %s = getIntegerSet();  /* 
`IntegerSet^T の~instanceを得る。
◎
Obtain an instance of IntegerSet.
 */

%s.union();                /* 
`ints^l に対応する引数を~~省略。
◎
Passing no arguments corresponding to 'ints'.
 */
%s.union(1, 4, 7);         /* 
`ints^l に対応する 3 個の引数を渡す。
◎
Passing three arguments corresponding to 'ints'.
 */

`optional^c ~keywordを伴って宣言された引数は、 `随意~引数@ であるものと見なされる。 `可変個的な$演算の`可変個~引数$も随意~引数と見なされる。 随意として宣言された引数は、演算を呼出すときに，その値を省略できることを指示する。 `可変個~引数$は、明示的に随意として宣言されては~MUST_NOT。 ◎ An argument is considered to be an optional argument if it is declared with the optional keyword. The final argument of a variadic operation is also considered to be an optional argument. Declaring an argument to be optional indicates that the argument value can be omitted when the operation is invoked. The final argument in an operation must not explicitly be declared to be optional if the operation is variadic.

interface `interface_identifier^i {
  `return_type^i `identifier^i(`type^i `identifier^i, optional `type^i `identifier^i);
};

随意~引数には `既定~値@ を指定できる。 引数の識別子に `003D^U1 と値（ `DefaultValue$g に合致）が後続している場合、その値がその随意~引数の `既定~値$ を与える。 ただし、`可変個的な$演算の`可変個~引数$には、既定~値が指定されては~MUST_NOT。 既定~値は、対応する引数が省略されて演算が~callされたときに，その引数がとる値と見做される。 ◎ Optional arguments can also have a default value specified. If the argument’s identifier is followed by a U+003D EQUALS SIGN ("=") and a value (matching DefaultValue), then that gives the optional argument its default value. The implicitly optional final argument of a variadic operation must not have a default value specified. The default value is the value to be assumed when the operation is called with the corresponding argument omitted.

interface `interface_identifier^i {
  `return_type^i `identifier^i(`type^i `identifier^i, optional `type^i `identifier^i = "`value^i");
};

`boolean$T 型の引数には、`既定~値$として `true^V を利用しないことを強く勧める。 さもなければ、 `undefined^jv に既定の変換（すなわち， `false^V ）が利用されると期待する作者たちを惑わすことになるので。 ◎ It is strongly suggested not to use a default value of true for boolean-typed arguments, as this can be confusing for authors who might otherwise expect the default conversion of undefined to be used (i.e., false).

次をすべて満たす引数は、随意として指定され~MUST。 ◎ If＼

• 引数の型は、［ `辞書~型$である ］~OR［ `共用体~型$であって，その`平坦化~mb型$に ある`辞書~型$を含んでいる ］ ◎ the type of an argument is a dictionary type or a union type that has a dictionary as one of its flattened member types, and＼
• 前項の辞書~型と その先祖には、必須の~mbは無い ◎ that dictionary type and its ancestors have no required members, and＼
• ［ 引数は最後の引数である ］~OR［ 引数に後続するどの引数も`随意~引数$である ］ ◎ the argument is either the final argument or is followed only by optional arguments,＼

そのような引数は、他が指定されない限り，常に［ 既定~値として，空の辞書をとる ］ものと見なされる。 【この辞書の各~mbは、`既定~値$diCがあれば それをとるものと扱われることになる。】 ◎ then the argument must be specified as optional. Such arguments are always considered to have a default value of an empty dictionary, unless otherwise specified.

注記： これは、作者が辞書の既定~値のみの利用を望むときでも，空の辞書~値を渡さずに済むような~APIの設計を促すためにある。 ◎ This is to encourage API designs that do not require authors to pass an empty dictionary value when they wish only to use the dictionary’s default values.

注記： 辞書~型には，既定~値を明示的には指定できないので、上の “他が指定されない限り” にて 他を指定できるものは，`平坦化~mb型$に辞書~型を含んでいる`共用体~型$に限られる。 ◎ Dictionary types cannot have a default value specified explicitly, so the “unless otherwise specified” clause above can only be invoked for a union type that has a dictionary type as one of its flattened member types.

`既定~値$に`定数~token$が利用された場合、`定数$に対するときと同じ仕方で解釈される。 ◎ When a boolean literal token (true or false), the null token, an integer token, a float token or one of the three special floating point literal values (Infinity, -Infinity or NaN) is used as the default value, it is interpreted in the same way as for a constant.

`随意~引数$の型が`列挙$である場合、その`既定~値$に指定される値は，その列挙を成すいずれかの`列挙~値$で~MUST。 ◎ If the type of the optional argument is an enumeration, then its default value if specified must be one of the enumeration’s values.

`連列~型$（`~nullable$も含む）の随意~引数の既定~値には、［ 2 個の~tokenが成す値 `[]^c ］を利用して，［ その型と同じ型の空~連列~値 ］を表現する値も指定できる。 この既定~値の型は、次のいずれかで~MUST ⇒＃ `連列~型$ ／ `~nullable$であって その`内縁~型$は`連列~型$であるもの ／ `共用体~型$または`~nullable$なそれであって その`平坦化~mb型$は`連列~型$を含むもの ◎ Optional argument default values can also be specified using the two token value [], which represents an empty sequence value. The type of this value is the same as the type of the optional argument it is being used as the default value of. That type must be a sequence type, a nullable type whose inner type is a sequence type or a union type or nullable union type that has a sequence type in its flattened member types.

[Exposed=Window]
interface ColorCreator {
  object createColor(double %v1, double %v2, double %v3, optional double %alpha);
};

[Exposed=Window]
interface ColorCreator {
  object createColor(double %v1, double %v2, double %v3);
  object createColor(double %v1, double %v2, double %v3, double %alpha);
};

実装が`利用元~obj$上の`演算$の呼出しを試みた結果 （例えば，呼戻~objが実装に給されていて），例外が投出される場合、他が指定されない限り，その例外は［ 実装からその演算の呼出しを生じさせた，利用元~code ］まで伝播することになる。 同様に，演算の呼出しにより返される値を~IDL型に変換できない場合、それにより生じた例外も［ 実装からその演算の呼出しを試みさせた，利用元~code ］まで伝播することになる。 ◎ If an implementation attempts to invoke an operation on a user object (for example, when a callback object has been supplied to the implementation), and that attempt results in an exception being thrown, then, unless otherwise specified, that exception will be propagated to the user code that caused the implementation to invoke the operation. Similarly, if a value returned from invoking the operation cannot be converted to an IDL type, then any exception resulting from this will also be propagated to the user code that resulted in the implementation attempting to invoke the operation.

演算に適用-可能な拡張属性は ⇒ `Default$x, `Exposed$x, `NewObject$x, `SecureContext$x, `Unforgeable$x ◎ The following extended attributes are applicable to operations: [Default], [Exposed], [NewObject], [SecureContext], [Unforgeable].

[Exposed=Window]
interface Transaction {
  readonly attribute DOMString from;
  readonly attribute DOMString to;
  readonly attribute double amount;
  readonly attribute DOMString description;
  readonly attribute unsigned long number;
  TransactionJSON toJSON();
};

dictionary TransactionJSON {
  Account from;
  Account to;
  double amount;
  DOMString description;
};

/* 
`Transaction^T の~instanceを取得する
◎
Get an instance of Transaction.
 */
var %txn = getTransaction();

/* 
次の様な~objに評価される：
◎
Evaluates to an object like this:
 */
   {
     from: "Bob",
     to: "Alice",
     amount: 50,
     description: "books"
   }
*/
%txn.toJSON();

/* 
次の様な文字列に評価される：
◎
Evaluates to a string like this:
 */
   '{"from":"Bob","to":"Alice","amount":50,"description":"books"}'
*/
JSON.stringify(%txn);

2.4.4. 特殊~演算

`特殊~演算@ は、［ その特殊~演算~宣言が現れる~ifc ］を実装する~obj上における［ 一定の種類の特殊な挙動 ］の宣言である。 `特殊~演算$は，演算~宣言において `特殊~keyword@ を利用して宣言される。 ◎ A special operation is a declaration of a certain kind of special behavior on objects implementing the interface on which the special operation declarations appear. Special operations are declared by using a special keyword in an operation declaration.

`特殊~演算$には、次の一覧に挙げる 4 種類がある。 一覧には、それぞれの種類の特殊~演算に対し，その宣言-時に利用される特殊~keyword, および演算の目的も示す： ◎ There are four kinds of special operations. The table below indicates for a given kind of special operation what special keyword is used to declare it and what the purpose of the special operation is:

すべての言語束縛が、［ これら 4 種類の，~objの特殊な挙動 ］すべてを~supportするわけではない。 `特殊~演算$が，識別子を伴わない演算を利用して宣言された場合、その特定0の種類の特殊~演算を~supportしない言語束縛においては，単にその機能性が存在しないことになる。 ◎ Not all language bindings support all of the five kinds of special object behavior. When special operations are declared using operations with no identifier, then in language bindings that do not support the particular kind of special operations there simply will not be such functionality.

[Exposed=Window]
interface Dictionary {
  readonly attribute unsigned long propertyCount;

  getter double (DOMString %propertyName);
  setter void (DOMString %propertyName, double %propertyValue);
};

`特殊~演算$を`識別子$を伴わせて定義することは、その宣言から識別子のない特殊~演算を分離することと，等価である。 この書き方は、~ifcの演算についての注釈文の記述を単純化するために許容されている。 ◎ Defining a special operation with an identifier is equivalent to separating the special operation out into its own declaration without an identifier. This approach is allowed to simplify prose descriptions of an interface’s operations.

[Exposed=Window]
interface Dictionary {
  readonly attribute unsigned long propertyCount;

  getter double getProperty(DOMString %propertyName);
  setter void setProperty(DOMString %propertyName, double %propertyValue);
};

[Exposed=Window]
interface Dictionary {
  readonly attribute unsigned long propertyCount;

  double getProperty(DOMString %propertyName);
  void setProperty(DOMString %propertyName, double %propertyValue);

  getter double (DOMString %propertyName);
  setter void (DOMString %propertyName, double %propertyValue);
};

1 つの演算に同じ`特殊~keyword$が複数~回 現れては~MUST_NOT。 ◎ A given special keyword must not appear twice on an operation.

取得子, 設定子, 削除子は 2 種の系列に分類される： ◎ Getters and setters come in two varieties:＼

• `有名~prop取得子@, `有名~prop設定子@, `有名~prop削除子@ と呼ばれる，~prop名として `DOMString$T をとるもの。 ◎ ones that take a DOMString as a property name, known as named property getters and named property setters, and＼
• `有index~prop取得子@, `有index~prop設定子@ と呼ばれる，~prop~indexとして `unsigned long$T をとるもの — 有index~propには，削除子は無い。 ◎ ones that take an unsigned long as a property index, known as indexed property getters and indexed property setters. There is only one variety of deleter: named property deleters.＼

詳細は、 `idl-indexed-properties$sec, `idl-named-properties$sec を見よ。 ◎ See §2.4.4.2 Indexed properties and §2.4.4.3 Named properties for details.

所与の`~ifc$上に存在する，［ `文字列化子$, `削除子$ および, 各~系列の［ `取得子$, `設定子$ ］］は、それぞれ，高々 1 個までで~MUST。 ◎ On a given interface, there must exist at most one stringifier, at most one named property deleter, and at most one of each variety of getter and setter.

~ifcが［ いずれかの系列の`設定子$, あるいは`有名~prop削除子$ ］を持つ場合、同じ系列の`取得子$も持た~MUST。 ◎ If an interface has a setter of a given variety, then it must also have a getter of that variety. If it has a named property deleter, then it must also have a named property getter.

演算を利用して宣言される`特殊~演算$は，［ `可変個的な$ ／ `随意~引数$をとる ］ようにされては~MUST_NOT。 ◎ Special operations declared using operations must not be variadic nor have any optional arguments.

`特殊~演算$は，`呼戻~ifc$上で宣言されては~MUST_NOT。 ◎ Special operations must not be declared on callback interfaces.

~objが，所与の`特殊~演算$を定義する複数の`~ifc$を実装する場合、その演算に対し，どの特殊~演算が呼出されるかは 未定義である。 ◎ If an object implements more than one interface that defines a given special operation, then it is undefined which (if any) special operation is invoked for that operation.

interface `interface_identifier^i {
  stringifier DOMString `identifier^i();
  stringifier DOMString ();
};

interface `interface_identifier^i {
  stringifier;
};

[Exposed=Window]
interface A {
  stringifier DOMString ();
};

[Exposed=Window]
interface A {
  stringifier;
};

interface `interface_identifier^i {
  stringifier attribute DOMString `identifier^i;
};

[Exposed=Window, Constructor]
interface Student {
  attribute unsigned long id;
  stringifier attribute DOMString name;
};

var %s = new Student();
%s.id = 12345678;
%s.name = '周杰倫';

var %挨拶 = 'こんにちは、 ' + %s + ' さん。';
    /* 
`こんにちは、 周杰倫 さん。^l になる。
◎
Now greeting == 'Hello, 周杰倫!'.
 */

[Exposed=Window, Constructor]
interface Student {
  attribute unsigned long id;
  attribute DOMString? familyName;
  attribute DOMString givenName;

  stringifier DOMString ();
};

var %s = new Student();
%s.id = 12345679;
%s.familyName = 'Smithee';
%s.givenName = 'Alan';

var %挨拶 = 'こんにちは、 ' + %s + ' さん。';
    /* 
`こんにちは、 Alan Smithee さん^l になる。
◎
Now greeting == 'Hi Alan Smithee'.
 */

interface `interface_identifier^i {
  getter `type^i `identifier^i(unsigned long `identifier^i);
  setter `type^i `identifier^i(unsigned long `identifier^i, `type^i `identifier^i);

  getter `type^i (unsigned long `identifier^i);
  setter `type^i (unsigned long `identifier^i, `type^i `identifier^i);
};

[Exposed=Window]
interface A {
  getter DOMString toWord(unsigned long %index);
};

var %a = getA();

%a.toWord(0);  /* 
`zero^l  に評価される。
◎
Evaluates to "zero".
 */
%a[0];         /* 
これも `zero^l に評価される。
◎
Also evaluates to "zero".
 */

%a.toWord(5);  /* 
`five^l に評価される。
◎
Evaluates to "five".
 */
%a[5];         /* 
~prop `5^l は存在しないので `undefined^jv に評価される。
◎
Evaluates to undefined, since there is no property "5".
 */

[Exposed=Window]
interface OrderedMap {
  readonly attribute unsigned long size;

  getter any getByIndex(unsigned long %index);
  setter void setByIndex(unsigned long %index, any %value);

  getter any get(DOMString %name);
  setter void set(DOMString %name, any %value);
};

/* 
%map は `OrderedMap^T ~ifcを実装する旧来の~platform~objであるとする。
◎
Assume map is a legacy platform object implementing the OrderedMap interface.
 */
var %map = getOrderedMap();
var %x, %y;

%x = %map[0];       /* 
`map.length^c ~GT 0 ならば、これは
`x = map.getByIndex(0)^c
と等価になる（名前 `0^l の~propが %map 上に置かれるので）。
他の場合、名前 `0^l の~propは %map 上にないので，
%x は `undefined^jv に設定されることになる。
◎
If map.length > 0, then this is equivalent to:

  x = map.getByIndex(0)

since a property named "0" will have been placed on map.
Otherwise, x will be set to undefined, since there will be
no property named "0" on map.
 */

%map[1] = false;   /* 
これは、
`map.setByIndex(1, false)^c
と等価な動作になる。
◎
This will do the equivalent of:

  map.setByIndex(1, false)
 */

%y = %map.apple;    /* 
名前 `apple^l の有名~propが存在する場合、
%map 上には名前 `apple^l の~propがあり，
`y = map.get('apple')^c
と等価な動作になる。
他の場合、 %map 上に名前 `apple^l の~propはないので，
%y は `undefined^jv に設定されることになる。
◎
If there exists a named property named "apple", then this
will be equivalent to:

  y = map.get('apple')

since a property named "apple" will have been placed on
map.  Otherwise, y will be set to undefined, since there
will be no property named "apple" on map.
 */

%map.berry = 123;  /* 
これは、
`map.set('berry', 123)^c
と等価な動作になる。
◎
This will do the equivalent of:

  map.set('berry', 123)
 */

delete %map.cake;  /* 
有名~prop `cake^l が存在するならば、 `cake^jp ~propは削除され，
`map.remove("cake")^c
と等価な動作になる。
◎
If a named property named "cake" exists, then the "cake"
property will be deleted, and then the equivalent to the
following will be performed:

	  map.remove("cake")
 */

interface `interface_identifier^i {
  getter `type^i `identifier^i(DOMString `identifier^i);
  setter `type^i `identifier^i(DOMString `identifier^i, `type^i `identifier^i);
  deleter `type^i `identifier^i(DOMString `identifier^i);

  getter `type^i (DOMString `identifier^i);
  setter `type^i (DOMString `identifier^i, `type^i `identifier^i);
  deleter `type^i (DOMString `identifier^i);
};

2.4.5. 静的~属性と静的~演算

`静的~属性@, `静的~演算@ は、それが宣言される`~ifc$の特定0の~instance上には結付けられないものであり、代わりに，その ~ifc自身に結付けられる。 静的~属性と静的~演算は，それらの宣言の中で `static^c ~keywordを利用して宣言される。 ◎ Static attributes and static operations are ones that are not associated with a particular instance of the interface on which it is declared, and is instead associated with the interface itself. Static attributes and operations are declared by using the static keyword in their declarations.

［ 静的~演算を呼出す／ 静的~属性を取得する／ 静的~属性を設定する ］ことが，~ifcの~instanceへの参照を通してアリかどうかは、言語束縛に特有になる。 ◎ It is language binding specific whether it is possible to invoke a static operation or get or set a static attribute through a reference to an instance of the interface.

静的~演算／静的~属性は，`呼戻~ifc$上で宣言されては~MUST_NOT。 ◎ Static attributes and operations must not be declared on callback interfaces.

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

[Exposed=Window]
interface Circle {
  attribute double cx;
  attribute double cy;
  attribute double radius;

  static readonly attribute long triangulationCount;
  static Point triangulate(Circle %c1, Circle %c2, Circle %c3);
};

var %circles = getCircles();        /* 
`Circle^T ~objの `Array^jt
◎
an Array of Circle objects
 */

typeof Circle.triangulate;         /* 
`function^l に評価される。
◎
Evaluates to "function"
 */
typeof Circle.triangulationCount;  /* 
`number^l に評価される。
◎
Evaluates to "number"
 */
Circle.prototype.triangulate;      /* 
`undefined^jv に評価される。
◎
Evaluates to undefined
 */
Circle.prototype.triangulationCount;  /* 
これも `undefined^jv に評価される。
◎
Also evaluates to undefined
 */
%circles[0].triangulate;            /* 
これも。
◎
As does this
 */
%circles[0].triangulationCount;     /* 
これも。
◎
And this
 */

/* 
静的~演算の~call
◎
Call the static operation
 */
var %triangulationPoint = Circle.triangulate(%circles[0], %circles[1], %circles[2]);
/* 
`triangulate^M を呼んだ回数を調べる
◎
Find out how many triangulations we have done
 */
window.alert(Circle.triangulationCount);

2.4.6. 多重定義

`~ifc$上に定義される［ `正則~演算$／`静的~演算$ ］が，その~ifc上の同じ種類の別の（正則／静的）演算と 同じ`識別子$を持つ場合、その演算は `多重定義@ されているという。 その~ifcを実装する~obj上で［ それらの演算のどれかを呼出すために［ 多重定義された演算の識別子 ］が利用された ］ときに，どの演算が実際に呼出されるかは、演算に渡された引数の個数と型により決定される。 ~ES言語束縛においては `Constructor$x も多重定義され得る。 多重定義された［ 演算／構築子 ］がとり得る引数の指定には一定の制約があり、これらの制約を記述するため，`有効~多重定義~集合$の~~概念が利用される。 ◎ If a regular operation or static operation defined on an interface has an identifier that is the same as the identifier of another operation on that interface of the same kind (regular or static), then the operation is said to be overloaded. When the identifier of an overloaded operation is used to invoke one of the operations on an object that implements the interface, the number and types of the arguments passed to the operation determine which of the overloaded operations is actually invoked. In the ECMAScript language binding, constructors can be overloaded too. There are some restrictions on the arguments that overloaded operations and constructors can be specified to take, and in order to describe these restrictions, the notion of an effective overload set is used.

`演算$は、複数の［ `~ifc$, `部分的~ifc$, `~ifc~mixin$, `部分的~ifc~mixin$ ］にまたがって多重定義されては~MUST_NOT。 ◎ Operations must not be overloaded across interface, partial interface, interface mixin, and partial interface mixin definitions.

[Exposed=Window]
interface A {
  void f();
};

partial interface A {
  void f(double %x);
  void g();
};

partial interface A {
  void g(DOMString %x);
};

正則~演算 ◎ For regular operations

静的~演算 ◎ For static operations

`演算$が見出される`~ifc$, および 演算の`識別子$ ◎ the interface on which the operations are to be found ◎ the identifier of the operations ◎ the number of arguments to be passed

構築子 ◎ For constructors

`Constructor$x `拡張属性$が見出される`~ifc$ ◎ the interface on which the [Constructor] extended attributes are to be found ◎ the number of arguments to be passed

有名~構築子 ◎ For named constructors

`NamedConstructor$x `拡張属性$が見出される`~ifc$, および 有名~構築子の`識別子$ ◎ the interface on which the [NamedConstructor] extended attributes are to be found ◎ the identifier of the named constructors ◎ the number of arguments to be passed

呼戻~関数 ◎ For callback functions

`呼戻~関数$ ◎ the callback function ◎ the number of arguments to be passed

有効~多重定義~集合は、~ifc上に多重定義された`関数類$たちに多義性があるかどうかを — 他と伴に — 決定するために利用される。 ◎ An effective overload set is used, among other things, to determine whether there are ambiguities in the overloaded operations and constructors specified on an interface.

`有効~多重定義~集合$は、`有順序~集合$であり，それを成す各`~item$は［ 次に挙げる`~item$sctからなる`~tuple$ ］である — これらの~tupleは、 ( `~callable$oL, `型~list$oL, `省略可否~list$oL ) の形で記される： ◎ The items of an effective overload set are tuples of the form (callable, type list, optionality list) whose items are described below:

`~callable@oL

`関数類$の種別に応じて，次で与えられる：

`正則~演算$

`静的~演算$

【同じ識別子を共有する】いずれかの`演算$

構築子

`有名~構築子$

【同じ識別子を共有する】いずれかの`拡張属性$

`呼戻~関数$

呼戻~関数~自身

◎ A callable is an operation if the effective overload set is for regular operations or static operations; it is an extended attribute if the effective overload set is for constructors or named constructors; and it is the callback function itself if the effective overload set is for callback functions.

`型~list@oL

0 個~以上の~IDL型からなる`~list$。 — `~callable$oL の引数たちにあてがわれているそれらになる。 ◎ A type list is a list of IDL types.

`省略可否~list@oL

0 個~以上の `省略可否 値@ からなる`~list$。 各 `省略可否 値$にアリな値は、次のいずれかであり，所与の~indexに位置する引数について指示する：

• `必須^C — 引数は省略できない
• `省略可^C — `随意~引数$である
• `可変個^C — `可変個~引数$である

◎ An optionality list is a list of three possible optionality values – "required", "optional" or "variadic" – indicating whether the argument at a given index was declared as being optional or corresponds to a variadic argument.

各`~tuple$は、［ 引数~値~listに伴われる一連の型であって，当の`関数類$の呼出に許容され得るもの ］を表現する。 ［ `随意~引数$／［ `可変個的な$`関数類$ （すなわち，演算または構築子） ］］の利用に因り、有効~多重定義~集合~内には，同じ種類の`関数類$を識別する複数の~itemが存在し得る。 ◎ Each tuple represents an allowable invocation of the operation, constructor, or callback function with an argument value list of the given types. Due to the use of optional arguments and variadic operations and constructors, there may be multiple items in an effective overload set identifying the same operation or constructor.

[Exposed=Window]
interface A {
  /* f1 */ void f(DOMString %a);
  /* f2 */ void f(Node %a, DOMString %b, double... %c);
  /* f3 */ void f();
  /* f4 */ void f(Event %a, DOMString %b, optional DOMString %c, double... %d);
};

«
  (f1, « DOMString »,                           « `必須^C »),
  (f2, « Node, DOMString »,                     « `必須^C, `必須^C »),
  (f2, « Node, DOMString, double »,             « `必須^C, `必須^C, `可変個^C »),
  (f2, « Node, DOMString, double, double »,     « `必須^C, `必須^C, `可変個^C, `可変個^C »),
  (f3, « »,                                     « »),
  (f4, « Event, DOMString »,                    « `必須^C, `必須^C »),
  (f4, « Event, DOMString, DOMString »,         « `必須^C, `必須^C, `省略可^C »),
  (f4, « Event, DOMString, DOMString, double », « `必須^C, `必須^C, `省略可^C, `可変個^C »)
»

[Exposed=Window]
interface B {
  void f(DOMString %x);
  void f(USVString %x);
};

加えて，［ 0 ~LTE %j ~LT ［ 所与の `型~list$oL ~sizeに対する`判別~引数~index$ ］］を満たすどの~index %j に対しても，次が満たされ~MUST ⇒ 【~sizeから算出される】 `有効~多重定義~集合$のすべての~itemにわたり ⇒ ［ それらの`型~list$oL[ %j ] は互いに同じ ］~AND［ それらの`省略可否~list$oL[ %j ] は互いに同じ ］ ◎ In addition, for each index j, where j is less than the distinguishing argument index for a given type list size, the types at index j in all of the items’ type lists must be the same, and the optionality values at index j in all of the items’ optionality lists must be the same.

[Exposed=Window]
interface B {
  /* f1 */ void f(DOMString %w);
  /* f2 */ void f(long %w, double %x, Node %y, Node %z);
  /* f3 */ void f(double %w, double %x, DOMString %y, Node %z);
};

«
  (f1, « DOMString »,                       « `必須^C »),
  (f2, « long, double, Node, Node »,        « `必須^C, `必須^C, `必須^C, `必須^C »),
  (f3, « double, double, DOMString, Node », « `必須^C, `必須^C, `必須^C, `必須^C »)
»

[Exposed=Window]
interface A {
             /*---f4----*/ /*-f2-*/     /*---f1----*/    /*-f3-*/
  void f(
    optional ( Event     or Node     or   DOMString ) %a, /*----*/
    optional   DOMString             %b, /*---------------------*/
    optional ( DOMString or double ) %c, /*---------------------*/
               double...             %d  /*---------------------*/
  );
};

interface CanvasDrawPathExcerpt {
  void stroke();
  void stroke(Path2D %path);
};

interface CanvasDrawPathExcerptOptional {
  void stroke(optional Path2D %path);
};

2.4.7. 可反復~宣言

~ifcは `可反復@ になるように宣言できる。 そのためには、`~ifc$の本体にて `可反復~宣言@ （`Iterable$g に合致）を利用する。 ◎ An interface can be declared to be iterable by using an iterable declaration (matching Iterable) in the body of the interface.

interface `interface_identifier^i {
  iterable<`value_type^i>;
  iterable<`key_type^i, `value_type^i>;
};

可反復として宣言された~ifcを実装している~objは、値の連列を得るために反復できるようになる。 ◎ Objects implementing an interface that is declared to be iterable support being iterated over to obtain a sequence of values.

注記： ~ES言語束縛においては、可反復な~ifcは、その`~ifc原型~obj$上に，［ `entries^jp, `forEach^jp, `keys^jp, `values^jp, `iterator$jS ］~propを持つことになる。 ◎ Note: In the ECMAScript language binding, an interface that is iterable will have entries, forEach, keys, values, and @@iterator properties on its interface prototype object.

~parameterとして所与の型の個数が： ◎ ↓

• 1 個の場合、~ifcは，その型の値たちを供する `値~反復子@ を持つことになる。 ◎ If a single type parameter is given, then the interface has a value iterator and provides values of the specified type.＼
• 2 個の場合、~ifcは，［ ~key, 値 ］からなる~pairたちを供する `~pair反復子@ を持つことになる。 ここで、~pairの~keyは， 1 個目の型の値をとり、~pairの値は， 2 個目の型の値をとる。 ◎ If two type parameters are given, then the interface has a pair iterator and provides value pairs, where the first value is a key and the second is the value associated with the key.

`値~反復子$は、`有index~propを~support$する~ifc上を除き，宣言されては~MUST_NOT。 `値~反復子$の値~型は、`有index~prop取得子$が返す型と同じで~MUST。 `値~反復子$は暗黙的に，当の~objの有index~prop上を反復するように定義される。 ◎ A value iterator must only be declared on an interface that supports indexed properties. The value-type of the value iterator must be the same as the type returned by the indexed property getter. A value iterator is implicitly defined to iterate over the object’s indexed properties.

`~pair反復子$は、`有index~propを~support$する~ifc上に宣言されては~MUST_NOT。 `~pair反復子$を伴う`~ifc$においては、付帯する注釈文にて［ 何が `反復される値~pair@ の~listを成すのか ］が定義され~MUST。 ◎ A pair iterator must not be declared on an interface that supports indexed properties. Prose accompanying an interface with a pair iterator must define what the list of value pairs to iterate over is.

注記： `配列~反復子~obj$は，このように働く。 `有index~propを~support$する ~ifcに対しては、［ `entries^jp ／ `keys^jp ／ `values^jp ／ `iterator$jS ］から返される反復子~objは，実際の`配列~反復子~obj$である。 ◎ Note: This is how array iterator objects work. For interfaces that support indexed properties, the iterator objects returned by entries, keys, values, and @@iterator are actual array iterator objects.

［ 可反復~宣言を伴う~ifc, および その`継承d~ifc$ ］の`~ifc~mb$の名前は［ `entries^l ／ `forEach^l ／ `keys^l ／ `values^l ］にされては~MUST_NOT。 ◎ Interfaces with iterable declarations must not have any interface members named "entries", "forEach", "keys", or "values", or have any inherited interfaces that have members with these names.

[Exposed=Window]
interface SessionManager {
  Session getSessionForUser(DOMString %username);

  iterable<DOMString, Session>;
};

[Exposed=Window]
interface Session {
  readonly attribute DOMString username;
  /*  */
};

/* 
`SessionManager^T の~instanceを取得する。
2 人の利用者 `anna^l, `brian^l 用の session があるとする。
◎
Get an instance of SessionManager.
Assume that it has sessions for two users, "anna" and "brian".
 */
var %sm = getSessionManager();

typeof SessionManager.prototype.values;  /*  */
var %it = %sm.values();    /* 
`values()^c は反復子~objを返す
◎
values() returns an iterator object
 */
typeof %it.next;          /*  */

/* 
この~loopは、順に `anna^l, `brian^l を log することになる。
◎
This loop will log "anna" and then "brian".
 */
for (;;) {
  let %result = %it.next();
  if (%result.done) {
    break;
  }
  let %session = %result.value;
  console.log(%session.username);
}

/* 
この~loopも、順に `anna^l, `brian^l を log することになる。
◎
This loop will also log "anna" and then "brian".
 */
for (let %username of %sm.keys()) {
  console.log(%username);
}

/* 
同じことを達成する別の仕方。
◎
Yet another way of accomplishing the same.
 */
for (let [%username, %session] of %sm) {
  console.log(%username);
}

`可反復~宣言$を伴う~ifc %I に対しては、［ %I, および %I の`継承d~ifc$ ］に［ 別の`可反復~宣言$, `~maplike 宣言$, `~setlike 宣言$ ］が宣言されていては~MUST_NOT。 ◎ An interface must not have more than one iterable declaration. The inherited interfaces of an interface with an iterable declaration must not also have an iterable declaration. An interface with an iterable declaration and its inherited interfaces must not have a maplike declaration or setlike declaration.

`可反復~宣言$に適用-可能な拡張属性は ⇒ `Exposed$x, `SecureContext$x ◎ The following extended attributes are applicable to iterable declarations: [Exposed], [SecureContext].

2.7.1. ~error名

下の `~error名~一覧@ は、 `DOMException$T に許容されるすべての~error名, ~~説明, および 旧来の code 名とその値の一覧である。 ◎ The error names table below lists all the allowed error names for DOMException, a description, and legacy code values.

“非推奨” と記されている `DOMException$T 名は、旧来の目的~用に保たれてはいるが，利用しないことが奨励される。 ◎ The DOMException names marked as deprecated are kept for legacy purposes but their usage is discouraged.

注記： ここに挙げられていない~error名があれば、この仕様の冒頭に指示したように, ~bugを提出されるよう願う。 間もなく解消に向けて取組まれることになる。 Thanks! ◎ Note: If an error name is not listed here, please file a bug as indicated at the top of this specification and it will be addressed shortly. Thanks!

注記： ここに定義される `SyntaxError$E `DOMException$T 例外と ~ESの `SyntaxError$jE とを混同しないように。 前者は — 例えば選択子を構文解析するときなど — ~Web~APIにおける構文解析-時の~errorを報告するために利用される一方で、後者は~ES構文解析器~用に予約されている。 これをより一義化し易くするため、単に `SyntaxError$E を用いずに，常に［ "`SyntaxError$E" `DOMException$T ］と表記して `DOMException$T を指す方が好ましい。 【が，上述したように、他の~Web仕様の和訳では， `DOMException^T は省略している — ~ES `SyntaxError^jE は，それらの仕様には現れないので。】 `DOM$r ◎ Note: Don’t confuse the "SyntaxError" DOMException defined here with ECMAScript’s SyntaxError. "SyntaxError" DOMException is used to report parsing errors in web APIs, for example when parsing selectors, while the ECMAScript SyntaxError is reserved for the ECMAScript parser. To help disambiguate this further, always favor the "SyntaxError" DOMException notation over just using SyntaxError to refer to the DOMException. [DOM]

2.12.1. `any^T

`any$T 型は、 `共用体~型$ 以外の，アリなすべての型の和集合である。 その`型~名$は、 `Any^l である。 ◎ The any type is the union of all other possible non-union types. Its type name is "Any".

`any$T 型は、そのそれぞれの値ごとに特有の非 `any$T 型が結付けられる意味で，~~特別な共用体~型のようなものである。 例えば， `any$T 型のある値は `unsigned long$T 150 をとり得る一方、別の値は `long$T 150 をとり得る。 これらは別個の型の値になる。 ◎ The any type is like a discriminated union type, in that each of its values has a specific non-any type associated with it. For example, one value of the any type is the unsigned long 150, while another is the long 150. These are distinct values.

`any$T 型のある値を成す特定0の型は、その値の `特有~型@ と呼ばれる。 （ `共用体~型$の値も`特有~型$を持つ。） ◎ The particular type of an any value is known as its specific type. (Values of union types also have specific types.)

【 `any^T 型は、 `es-any$sec にも見られるように `null^V 値もとり得るようだが， “`~nullable$型である” ものと定義されてはいない。 】

2.12.2. `boolean^T

`boolean$T 型は 2 つの値： `true^V と `false^V をとり得る。 ◎ The boolean type has two values: true and false.

~IDLにおいては、 `boolean$T 定数~値は［ `true^c ／ `false^c ］~tokenで表現される。 ◎ boolean constant values in IDL are represented with the true and false tokens.

`boolean$T 型の`型~名$は、 `Boolean^l である。 ◎ The type name of the boolean type is "Boolean".

2.12.3〜10. 整数~型

【 この訳では、原文の 2.12.3 〜 2.12.10 節の内容 — 各種~IDL整数~型の定義を集約して，一括して与える。 】

各種 有符号／無符号 `整数~型$の，とり得る値の範囲, および `型~名$は、次の表で与えられる： ◎ The xxx ~LET (byte|short|long|long long／octet|unsigned short|unsigned long|unsigned long long) type is a (signed／unsigned) integer type that has values in the range ([−P÷2, P÷2 − 1]／[0, P − 1]); P ~LET 2^(8|16|32|64). ◎ xxx constant values in IDL are represented with integer tokens. ◎ The type name of the xxx type is "Xxx".

~IDLにおいては、どの`整数~型$の定数~値も， `integer$g ~tokenで表現される。

2.12.11〜14. 浮動小数点数~型

【 この訳では、原文の 2.12.11 〜 2.12.14 節の内容 — 各種~IDL浮動小数点数~型の定義を集約して，一括して与える。 】

各種 “浮動小数点数 型” — `整数~型$でない`実数~型$ — に対応する値の範囲, および それぞれの`型~名$は、次の表で与えられる：

~IDLにおいては、どの浮動小数点数 型の定数~値も， `float$g ~tokenで表現される。 ◎ The type name of the( xxx)? yyy type is “(Xxx)Yyy”.

特に 32 ~bit浮動小数点~型を利用する理由が無い限り，仕様は `float$T でなく，`double$T を利用するべきである。 `double$T が表現できる値~集合は，より近く~ES `Number^jt に合致するので。 ◎ Unless there are specific reasons to use a 32 bit floating point type, specifications should use double rather than float, since the set of values that a double can represent more closely matches an ECMAScript Number.

2.12.15. `DOMString^T

`DOMString$T 型は、アリなすべての［ `符号単位$の並び ］の集合に対応する。 そのような並びは、共通的に，~UTF-16に符号化された文字列 `RFC2781$r として解釈されるが、要求されてはいない。 `DOMString$T は DOM Level 3 Core §The DOMString Type において［ OMG IDL boxed `sequence<unsigned short>^T valuetype ］として定義されているが、この文書は，文字列が要求される様々な状況における，その連列~型に対する特別な場合分けを避けるため、 `DOMString$T を内在的な型として定義する。 ◎ The DOMString type corresponds to the set of all possible sequences of code units. Such sequences are commonly interpreted as UTF-16 encoded strings [RFC2781] although this is not required. While DOMString is defined to be an OMG IDL boxed sequence<unsigned short> valuetype in DOM Level 3 Core §The DOMString Type, this document defines DOMString to be an intrinsic type so as to avoid special casing that sequence type in various situations where a string is required.

注記： `null^V は `DOMString$T の値ではないことにも注意。 ~IDLにおいて `null^V を許容するためには， DOMString? と記される `~nullable$ `DOMString$T を利用する必要がある。 ◎ Note: Note also that null is not a value of type DOMString. To allow null, a nullable DOMString, written as DOMString? in IDL, needs to be used.

この仕様においては、 `DOMString$T 値が妥当な~UTF-16文字列であることは要求されない — 例えば、対を成さない~surrogate（代用対（ `surrogate pair^en ）を成し得る符号単位）も含み得る。 しかしながら，~Web~IDLを利用する仕様の策定者は、所与の［ 特定0の`符号単位$列 ］から `~Unicode~scalar値$列を得たいと求めることもあろう。 ◎ Nothing in this specification requires a DOMString value to be a valid UTF-16 string. For example, a DOMString value might include unmatched surrogate pair characters. However, authors of specifications using Web IDL might want to obtain a sequence of Unicode scalar values given a particular sequence of code units.

~IDLにおいて，定数 `DOMString$T 値を表現する仕方は、ない。 `string$g ~literalを利用して， `DOMString$T 型の［ `辞書~mb$ ／ 演算の`随意~引数$ ］に既定~値を指定することはできる。 ◎ There is no way to represent a constant DOMString value in IDL, although DOMString dictionary member and operation optional argument default values can be specified using a string literal.

`DOMString$T 型の`型~名$は、 `String^l である。 ◎ The type name of the DOMString type is "String".

2.12.16. `ByteString^T

`ByteString$T 型は、アリなすべての［ byte の並び ］の集合に対応する。 その種の並びは、要求されてはいないが，［ ~UTF-8に符号化された文字列 `RFC3629$r, あるいは［ 他の何らかの［ 1 符号単位あたり 8 ~bit ］になる符号化法 ］により符号化された文字列 ］に解釈し得る。 ◎ The ByteString type corresponds to the set of all possible sequences of bytes. Such sequences might be interpreted as UTF-8 encoded strings [RFC3629] or strings in some other 8-bit-per-code-unit encoding, although this is not required.

~IDLにおいて，定数 `ByteString$T 値を表現する仕方は、ない。 `string$g ~literalを利用して， `ByteString$T 型の［ `辞書~mb$ ／ 演算の`随意~引数$ ］に既定~値を指定することはできる。 ◎ There is no way to represent a constant ByteString value in IDL, although ByteString dictionary member and operation optional argument default values can be specified using a string literal.

`ByteString$T 型の`型~名$は、 `ByteString^l である。 ◎ The type name of the ByteString type is "ByteString".

仕様は、［ HTTP などの，~byteや文字列を交換-可能に利用する~protocol ］を~ifc化するときに限り， `ByteString$T を利用するべきである。 一般に、文字列は，その値が［ 常に ASCII または 何らかの 8 ~bit文字~符号化法 ］になることが期待されているとしても， `DOMString$T 値により表現されるべきである。 8 ~bit~dataを保持するためには、 `ByteString$T ではなく，［ `octet$T または `byte$T ］を要素とする［ `連列~型$ ／ `凍結~配列~型$ ／ `Uint8Array$T ／ `Int8Array$T ］が利用されるべきである。 ◎ Specifications should only use ByteString for interfacing with protocols that use bytes and strings interchangeably, such as HTTP. In general, strings should be represented with DOMString values, even if it is expected that values of the string will always be in ASCII or some 8 bit character encoding. Sequences or frozen arrays with octet or byte elements, Uint8Array, or Int8Array should be used for holding 8 bit data rather than ByteString.

2.12.17. `USVString^T

`USVString$T 型は、アリなすべての［［ `~Unicode~scalar値$ — ~surrogate符号位置でない~Unicode符号位置 ］の並び ］の集合に対応する。 ◎ The USVString type corresponds to the set of all possible sequences of Unicode scalar values, which are all of the Unicode code points apart from the surrogate code points.

~IDLにおいて，定数 `USVString$T 値を表現する仕方は、ない。 `string$g ~literalを利用して， `USVString$T 型の［ `辞書~mb$ ／ 演算の`随意~引数$ ］に既定~値を指定することはできる。 ◎ There is no way to represent a constant USVString value in IDL, although USVString dictionary member and operation optional argument default values can be specified using a string literal.

`USVString$T 型の`型~名$は、 `USVString^l である。 ◎ The type name of the USVString type is "USVString".

仕様は、［ ~text処理を遂行する際に `~Unicode~scalar値$による文字列~演算が必要になる ］ときに限り， `USVString$T を~APIに利用するべきである。 文字列を利用する ほとんどの~APIは、文字列~内の`符号単位$に いかなる解釈も行わない `DOMString$T を利用するべきである。 疑わしい場合は `DOMString$T を利用すること。 ◎ Specifications should only use USVString for APIs that perform text processing and need a string of Unicode scalar values to operate on. Most APIs that use strings should instead be using DOMString, which does not make any interpretations of the code units in the string. When in doubt, use DOMString.

2.12.18. `object^T

`object$T 型は、アリなすべての［ 非 `null^V ~obj参照 ］の集合に対応する。 ◎ The object type corresponds to the set of all possible non-null object references.

~IDLにおいて，定数 `object$T 値を表現する仕方は、ない。 ◎ There is no way to represent a constant object value in IDL.

アリなすべての~obj参照に加えて， `null^V 値も内包する型を表すためには、 `~nullable型$ `object?^T を利用する。 ◎ To denote a type that includes all possible object references plus the null value, use the nullable type object?.

`object$T 型の`型~名$は、 `Object^l である。 ◎ The type name of the object type is "Object".

2.12.20. ~ifc型

`~ifc$を識別する`識別子$は、その~ifcを実装する，アリなすべての［ 非 `null^V ~obj参照の集合 ］に対応する型を指すために利用される。 ◎ An identifier that identifies an interface is used to refer to a type that corresponds to the set of all possible non-null references to objects that implement that interface.

非~呼戻~ifcに対しては、~ifc型の~IDL値は，単に~obj参照により表現される。 `呼戻~ifc$ に対しては、~ifc型の~IDL値は［ ~obj参照, `呼戻~文脈$ ］の組により表現される。 `呼戻~文脈@ とは、言語束縛に特有の値であり、［ 言語束縛に特有の~obj参照が~IDL値に変換される時点における，実行~文脈についての情報 ］を格納するために利用されるものである。 ◎ For non-callback interfaces, an IDL value of the interface type is represented just by an object reference. For callback interfaces, an IDL value of the interface type is represented by a tuple of an object reference and a callback context. The callback context is a language binding specific value, and is used to store information about the execution context at the time the language binding specific object reference is converted to an IDL value.

注記： ~ES~objに対しては、`呼戻~文脈$は， `Object^jt 値が~IDL呼戻~ifc型の値に変換される時点の `現任の設定群~obj$への参照を保持するために利用される。 `es-interface$sec を見よ。 ◎ Note: For ECMAScript objects, the callback context is used to hold a reference to the incumbent settings object at the time the Object value is converted to an IDL callback interface type value. See §3.2.14 Interface types.

~IDLにおいて，特定0の~ifc型の定数~obj参照~値を表現する仕方は、ない。 ◎ There is no way to represent a constant object reference value for a particular interface type in IDL.

［ 所与の~ifcを実装する アリなすべての~obj参照に加え， `null^V 値も内包する ］ような型を表すためには、`~nullable型$を利用する。 ◎ To denote a type that includes all possible references to objects implementing the given interface plus the null value, use a nullable type.

~ifc型の`型~名$は、その~ifcの`識別子$である。 ◎ The type name of an interface type is the identifier of the interface.

2.12.21. 辞書~型

`辞書$を識別する`識別子$は、［ 辞書~定義に~~寄与する，すべての辞書の集合 ］に対応する型を指すために利用される。 ◎ An identifier that identifies a dictionary is used to refer to a type that corresponds to the set of all dictionaries that adhere to the dictionary definition.

`有順序~map$用の~literal構文も，辞書を表現するために利用できる — その文脈から、暗黙的に［ 当の~mapが，特定の辞書~型の~instanceとして扱われる ］ものと解されるならば。 しかしながら、~IDL片の内側では，定数~辞書~値を表現する仕方は、ない。 ◎ The literal syntax for ordered maps may also be used to represent dictionaries, when it is implicitly understood from context that the map is being treated as an instance of a specific dictionary type. However, there is no way to represent a constant dictionary value inside IDL fragments.

辞書~型の`型~名$は、その辞書の`識別子$である。 ◎ The type name of a dictionary type is the identifier of the dictionary.

2.12.22. 列挙~型

`列挙$を識別する`識別子$は、［ その`列挙~値$に属する文字列（ `DOMString$T と同様の，`符号単位$の並び）の集合 ］を値にとる型を指すために利用される。 ◎ An identifier that identifies an enumeration is used to refer to a type whose values are the set of strings (sequences of code units, as with DOMString) that are the enumeration’s values.

`DOMString$T と同様に、 ~IDLにおいて，定数`列挙$値を表現する仕方は、ない。 `string$g ~literalを利用して、列挙~型にされた`辞書~mb$に `既定~値$diCを指定することはできる。 ◎ Like DOMString, there is no way to represent a constant enumeration value in IDL, although enumeration-typed dictionary member default values can be specified using a string literal.

列挙~型の`型~名$は、その列挙の`識別子$である。 ◎ The type name of an enumeration type is the identifier of the enumeration.

2.12.23. 呼戻~関数~型

`呼戻~関数$を識別する`識別子$は、［ 所与の~signatureを伴う関数~objへの参照 ］を値にとる型を指すために利用される。 ◎ An identifier that identifies a callback function is used to refer to a type whose values are references to objects that are functions with the given signature.

呼戻~関数~型の~IDL値は，［ ~obj参照, `呼戻~文脈$ ］の組により表現される。 ◎ An IDL value of the callback function type is represented by a tuple of an object reference and a callback context.

注記： `~ifc型$と同様に、`呼戻~文脈$は， ~ES `Object^jt 値が~IDL呼戻~ifc型の値に変換される時点の `現任の設定群~obj$への参照を保持するために利用される。 `es-callback-function$sec を見よ。 ◎ Note: As with callback interface types, the callback context is used to hold a reference to the incumbent settings object at the time an ECMAScript Object value is converted to an IDL callback function type value. See §3.2.17 Callback function types.

~IDLにおいて，定数 `呼戻~関数$値を表現する仕方は、ない。 ◎ There is no way to represent a constant callback function value in IDL.

呼戻~関数~型の`型~名$は、その呼戻~関数の`識別子$である。 ◎ The type name of a callback function type is the identifier of the callback function.

2.12.24. ~nullable型 — `~varT?^T

`~nullable型@ は、（その `内縁~型@ と呼ばれる）既存の型から構築される~IDL型であり、とり得る値の集合は，内縁~型がとり得る値に値 `null^V のみを~~追加したものになる。 ~IDLにおいては、`~nullable型$は，既存の型の後に文字 `003F^U1 を置いて表現される。 `内縁~型$は次のいずれであっても~MUST_NOT： ◎ A nullable type is an IDL type constructed from an existing type (called the inner type), which just allows the additional value null to be a member of its set of values. Nullable types are represented in IDL by placing a U+003F QUESTION MARK ("?") character after an existing type. The inner type must not be:

注記： 辞書~型は，一般には~nullableになれるが、その場合，演算~引数や辞書~mbの型には利用できない。 ◎ Note: Although dictionary types can in general be nullable, they cannot when used as the type of an operation argument or a dictionary member.

~IDLにおいては、~nullable型の定数~値は，その`内縁~型$の定数~値と同じ仕方で表現されるか, または `null^c ~tokenで表現される。 ◎ Nullable type constant values in IDL are represented in the same way that constant values of their inner type would be represented, or with the null token.

~nullable型の`型~名$は、次の連結とする ⇒＃ その`内縁~型$ %T の型~名, 文字列 `OrNull^l ◎ The type name of a nullable type is the concatenation of the type name of the inner type T and the string "OrNull".

[Exposed=Window]
interface NetworkFetcher {
  void get(optional boolean? areWeThereYet = false);
};

[Exposed=Window]
interface Node {
  readonly attribute DOMString? namespaceURI;
  readonly attribute Node? parentNode;
  /*  */
};

2.12.25. 連列~型 — ~sequence_T

`連列~型@ — ~sequence_T — は、［ 一連の［ 型 %T の値 ］からなる`~list$（長さ 0 にもなり得る） ］を値にとり得るような，~parameter化された型である。 ◎ The sequence<T> type is a parameterized type whose values are (possibly zero-length) lists of values of type T.

連列は常に値渡しである。 連列が何らかの種類の~objで表現される言語束縛においても、`~platform~obj$に連列が渡された際に，その連列への参照が~objに保有されることはない。 同様に，~platform~objから返されるどの連列も複製であり、それに対する改変は~platform~objからは可視にならないことになる。 ◎ Sequences are always passed by value. In language bindings where a sequence is represented by an object of some kind, passing a sequence to a platform object will not result in a reference to the sequence being kept by that object. Similarly, any sequence returned from a platform object will be a copy and modifications made to it will not be visible to the platform object.

`~list$用の~literal構文も，連列を表現するために利用できる — その文脈から、暗黙的に［ 当の~listが，ある連列の~instanceとして扱われる ］ものと解されるならば。 しかしながら、~IDL片の内側では，定数~連列~値を表現する仕方は、ない。 ◎ The literal syntax for lists may also be used to represent sequences, when it is implicitly understood from context that the list is being treated as a sequences. However, there is no way to represent a constant sequence value inside IDL fragments.

連列は［ `属性$／`定数$ ］の型に利用されては~MUST_NOT。 ◎ Sequences must not be used as the type of an attribute or constant.

注記： この制約は、［ `連列~型$は、その参照が渡し回されるものではなく，複製されるものである ］ことを，仕様の［ 策定者／利用者 ］から見て明らかにするためにある。 連列~型の~writableな`属性$には、代わりに，連列を取得-／設定する`演算$~pairの利用を勧める。 ◎ Note: This restriction exists so that it is clear to specification writers and API users that sequences are copied rather than having references to them passed around. Instead of a writable attribute of a sequence type, it is suggested that a pair of operations to get and set the sequence is used.

連列~型の`型~名$は、次の連結とする ⇒＃ %T の型~名, 文字列 `Sequence^l ◎ The type name of a sequence type is the concatenation of the type name for T and the string "Sequence".

どの`~list$であれ、そのどの`~item$の型も %T である限り，暗黙的に ~sequence_T として扱える。 ◎ Any list can be implicitly treated as a sequence<T>, as long as it contains only items that are of type T.

2.12.27. ~promise型 — ~promise_T

`~promise型@ — ~promise_T — は、［［［［ “［［ 非同期 演算において，先送りされ得る（非同期にもなり得る）計算 ］の最終的な結果† ］の置き場（ `place holder^en ）” `ECMA-262$r ］として利用される~obj ］への参照 ］を値にとる ］ような，~parameter化された型である。 【† %T が，充足-時における結果の値の型を与える。】 ~promise~objの意味論についての詳細は~ES仕様 25.4 節 を見よ。 ◎ A promise type is a parameterized type whose values are references to objects that “is used as a place holder for the eventual results of a deferred (and possibly asynchronous) computation result of an asynchronous operation”. See section 25.4 of the ECMAScript specification for details on the semantics of promise objects.

~promise型は~nullableでないが、 %T は~nullableにもなり得る。 ◎ Promise types are non-nullable, but T may be nullable.

~IDLにおいて，~promise値を表現する仕方は、ない。 ◎ There is no way to represent a promise value in IDL.

~promise型の`型~名$は、次の連結とする ⇒＃ %T の型~名, 文字列 `Promise^l ◎ The type name of a promise type is the concatenation of the type name for T and the string "Promise".

2.12.28. 共用体~型

`共用体~型@ （ `union^en ）は、とり得る値の集合が［ 複数の型の，それぞれがとり得る値の集合 ］の和集合であるような，型である。 共用体~型（ `UnionType$g に合致）は、 `or^c ~keywordで区切られた型の並びを左右~丸括弧で括って記される。 共用体~型を構成する型は、共用体の `~mb型@ と呼ばれる。 ◎ A union type is a type whose set of values is the union of those in two or more other types. Union types (matching UnionType) are written as a series of types separated by the or keyword with a set of surrounding parentheses. The types which comprise the union type are known as the union’s member types.

`any$T 型と同様、共用体~型の値は，その値に合致する特定0の`~mb型$を`特有~型$として持つ。 ◎ Like the any type, values of union types have a specific type, which is the particular member type that matches the value.

注記： 例えば，`共用体~型$ `(Node or (sequence<long> or Event) or (XMLHttpRequest or DOMString)? or sequence<(sequence<double> or NodeList)>)^T の`平坦化~mb型$は、 6 つの型［ `Node^T , `sequence<long>^T , `Event^T , `XMLHttpRequest^T , `DOMString^T , `sequence<(sequence<double> or NodeList)>^T ］からなる。 ◎ Note: For example, the flattened member types of the union type (Node or (sequence<long> or Event) or (XMLHttpRequest or DOMString)? or sequence<(sequence<double> or NodeList)>) are the six types Node, sequence<long>, Event, XMLHttpRequest, DOMString and sequence<(sequence<double> or NodeList)>.

`~mb型$に `any$T 型が利用されては~MUST_NOT。 ◎ The any type must not be used as a union member type.

`共用体~型$の`~nullable~mb型の個数$は 0 か 1 で~MUST。 1 の場合、その共用体~型は`平坦化~mb型$に`辞書~型$を含んでは~MUST_NOT。 ◎ The number of nullable member types of a union type must be 0 or 1, and if it is 1 then the union type must also not have a dictionary type in its flattened member types.

次のいずれかを満たす型は `~nullable型を内包する@ とされる。 ◎ A type includes a nullable type if:

• `~nullable型$である ◎ the type is a nullable type, or
• ［ `注釈付きの型$である ］~AND［ その`内縁~型$anOは`~nullable型$である ］ ◎ the type is an annotated type and its inner type is a nullable type, or
• ［ `共用体~型$である ］~AND［ その `~nullable~mb型の個数$は 0 でない（ 1 である） ］ ◎ the type is a union type and its number of nullable member types is 1.

【 概念的には， `null^V を値にとり得る型と考えられる。 ただし、この定義では `any$T 型は含まれないことになる。 】

`共用体~型$の`平坦化~mb型$に属する どの 2 つの型も`判別-可能$で~MUST。 ◎ Each pair of flattened member types in a union type, T and U, must be distinguishable.

~IDLにおいては、`共用体~型$の定数~値は，それらの`~mb型$の定数~値と同じ仕方で表現される。 ◎ Union type constant values in IDL are represented in the same way that constant values of their member types would be represented.

共用体~型の`型~名$は、その各~mb型の型~名を 文字列 `Or^l で区切って順に連結した結果とする。 ◎ The type name of a union type is formed by taking the type names of each member type, in order, and joining them with the string "Or".

2.12.30. `Error^T

`Error$T 型は、［ `単純例外$, `DOMException$T ］~objを含む，アリなすべての［ 非 null 例外~objへの参照 ］の集合に対応する。 ◎ The Error type corresponds to the set of all possible non-null references to exception objects, including simple exceptions and DOMException objects.

~IDLにおいて，定数 `Error$T 値を表現する仕方は、ない。 ◎ There is no way to represent a constant Error value in IDL.

`Error$T の`型~名$は、 `Error^l である。 ◎ The type name of the Error type is "Error".

2.12.31. ~buffer~source型

アリなすべての［［［ ~dataの~buffer, または［ ~dataの~buffer上の~view ］］を表現する~obj ］への 非 `null^V 参照 ］の集合に対応する，いくつかの型がある。 下の一覧に、それらの型, および それらが表現する［ ~bufferまたは その~view ］の種類を挙げる。 ◎ There are a number of types that correspond to sets of all possible non-null references to objects that represent a buffer of data or a view on to a buffer of data. The table below lists these types and the kind of buffer or view they represent.

注記： これらの型はすべて、~ESにて定義される~classに対応する。 ◎ Note: These types all correspond to classes defined in ECMAScript.

これらのどの型についても： ◎ ↓

• ~IDLにおいて，その型の定数~値を表現する仕方は、ない。 ◎ There is no way to represent a constant value of any of these types in IDL.
• その`型~名$は、その型~自身の名前である。 ◎ The type name of all of these types is the name of the type itself.

仕様の中の注釈文~levelにおいては、~IDL`~buffer~source型$は，単純に~objへの参照である。 仕様の注釈文にて，~buffer内の~byte列を 検分したり操作するときは、最初に，~buffer~sourceに保持されている~byte列の `参照／複製を取得-@ する手続きを介さ~MUST。 仕様の注釈文では、その結果の~byte列への参照／複製を利用して，個々の~byte値を取得したり設定できる。 ◎ At the specification prose level, IDL buffer source types are simply references to objects. To inspect or manipulate the bytes inside the buffer, specification prose must first either get a reference to the bytes held by the buffer source or get a copy of the bytes held by the buffer source. With a reference to the buffer source’s bytes, specification prose can get or set individual byte values using that reference.

`切離された$ `ArrayBuffer$T ~objに対し，~buffer~sourceに保持されている~byte列の`参照／複製を取得-$しようと試みたときは、言語束縛に特有の方式で失敗することになる。 ◎ Attempting to get a reference to or get a copy of the bytes held by a buffer source when the ArrayBuffer has been detached will fail in a language binding-specific manner.

注記： ~ES言語束縛において ~buffer~source型とどう相互作用するかについては、 `es-buffer-source-types$sec を見よ。 ◎ Note: See §3.2.25 Buffer source types below for how interacting with buffer source types works in the ECMAScript language binding.

これらの型や用語を利用する仕様~textの例を含ませる必要がある。 ◎ We should include an example of specification text that uses these types and terms.

3.2.1. `any^T

~IDL `any$T 型は、他のすべての~IDL型の和集合なので，どの~ES値~型にも対応し得る。 ◎ Since the IDL any type is the union of all other IDL types, it can correspond to any ECMAScript value type.

~IDL `any$T 値 %V は，次のように`~ES値に変換-$される： ◎ An IDL any value is converted to an ECMAScript value as follows.＼

• %V が［ ~ES `undefined^jv 値を表現する特別な~objへの `object$T 参照 ］ならば、~ES `undefined^jv 値に変換される。 ◎ If the value is an object reference to a special object that represents an ECMAScript undefined value, then it is converted to the ECMAScript undefined value.＼
• 他の場合、この節の残りで述べられる， %V の`特有~型$を変換するための規則に従う。 ◎ Otherwise, the rules for converting the specific type of the IDL any value as described in the remainder of this section are performed.

3.2.2. `void^T

`void$T が~IDLに現れ得る唯一の場所は、`演算$の`返値型$である。 ［ ~IDLにおいて `void$T 返値型が指定されている演算 ］を実装する［ `~platform~obj$上の関数 ］は、 `undefined^jv 値を返さ~MUST。 ◎ The only place that the void type may appear in IDL is as the return type of an operation. Functions on platform objects that implement an operation whose IDL specifies a void return type must return the undefined value.

［ ~IDLにおいて `void$T 返値型が指定されている演算 ］を実装する~ES関数は、どのような値を返しても~MAY（破棄されることになる）。 ◎ ECMAScript functions that implement an operation whose IDL specifies a void return type may return any value, which will be discarded.

3.2.3. `boolean^T

~IDL `boolean$T 値［ `true^V／`false^V ］は，~ES［ `true^jv／`false^jv ］値に 変換される。 ◎ The IDL boolean value true is converted to the ECMAScript true value and the IDL boolean value false is converted to the ECMAScript false value.

3.2.4. 整数~型

この節に利用される数学的~演算は、 `ECMA-262$r による`~algo規約$節に定義されるものも含め，数学的実数による数学的に正確な結果を算出していると解されるとする。 ◎ Mathematical operations used in this section, including those defined in ECMA-262 §5.2 Algorithm conventions, are to be understood as computing exact mathematical results on mathematical real numbers.

`Number^jt 値 %x に対し， “%x に演算する” ことは、実質的に “%x と同じ実数~値を表現する数学的実数に演算する” ことの略記である。 ◎ In effect, where x is a Number value, “operating on x” is shorthand for “operating on the mathematical real number that represents the same numeric value as x”.

3.2.4.1. `byte^T

3.2.4.2. `octet^T

3.2.4.3. `short^T

3.2.4.4. `unsigned short^T

3.2.4.5. `long^T

3.2.4.6. `unsigned long^T

3.2.4.7. `long long^T

3.2.4.8. `unsigned long long^T

【 この訳では、原文のこれら各~下位~節の内容 — ~ES値 から各種~IDL整数~型 値への変換, およびその逆の変換の定義 — を集約して，一括して与える。 】

~IDL`整数~型$ %T の値 %V を`~ES値に変換-$した結果は， %T に応じて次で与えられる： ◎ The result of converting an IDL _T_ value to an ECMAScript value is a ...

3.2.5. `float^T

~IDL `float$T 値を`~ES値に変換-$した結果は、その ~IDL値と同じ実数~値を表現する `Number^jt 値になる。 ◎ The result of converting an IDL float value to an ECMAScript value is the Number value that represents the same numeric value as the IDL float value.

3.2.6. `unrestricted float^T

注記： ~ES `NaN^jv 値は唯 1 個しかないので，特定0の単精度 IEEE 754 NaN 値に正準化されなければならない。 上で言及した NaN 値は、単純に，その~bit~patternが無符号 32 ~bit整数に解釈されたときに最低~値の quiet NaN になることから，選ばれている。 ◎ Note: Since there is only a single ECMAScript NaN value, it must be canonicalized to a particular single precision IEEE 754 NaN value. The NaN value mentioned above is chosen simply because it is the quiet NaN with the lowest value when its bit pattern is interpreted as an unsigned 32 bit integer.

3.2.7. `double^T

~IDL `double$T 値を`~ES値に変換-$した結果は、その ~IDL値と同じ実数~値を表現する `Number^jt 値になる。 ◎ The result of converting an IDL double value to an ECMAScript value is the Number value that represents the same numeric value as the IDL double value.

3.2.8. `unrestricted double^T

注記： ~ES `NaN^jv 値は唯 1 個しかないので，特定0の倍精度 IEEE 754 NaN 値に正準化されなければならない。 上で言及した NaN 値は、単純に，その~bit~patternが無符号 64 ~bit整数に解釈されたときに最低~値の quiet NaN になることから，選ばれている。 ◎ Note: Since there is only a single ECMAScript NaN value, it must be canonicalized to a particular double precision IEEE 754 NaN value. The NaN value mentioned above is chosen simply because it is the quiet NaN with the lowest value when its bit pattern is interpreted as an unsigned 64 bit integer.

3.2.9. `DOMString^T

~IDL `DOMString$T 値を`~ES値に変換-$した結果は、 その~IDL `DOMString$T が表現するものと同じ, `符号単位$の並びを表現する `String^jt 値になる。 ◎ The result of converting an IDL DOMString value to an ECMAScript value is the String value that represents the same sequence of code units that the IDL DOMString represents.

3.2.10. `ByteString^T

~IDL `ByteString$T 値 %V を`~ES値に変換-$した結果は、次を満たすようにされた `String^jt 値になる ⇒ ［ 長さ ~EQ %V の長さ ］~AND［ 各 `要素$eSに対し，その値 ~EQ %V の対応する要素の値 ］ ◎ The result of converting an IDL ByteString value to an ECMAScript value is a String value whose length is the length of the ByteString, and the value of each element of which is the value of the corresponding element of the ByteString.

3.2.11. `USVString^T

3.2.12. `object^T

~IDL `object$T 値は、~ES `Object^jt 値により表現される。 ◎ IDL object values are represented by ECMAScript Object values.

~IDL `object$T 値 %V を`~ES値に変換-$した結果は、 %V が表現するものと同じ~objへの参照を表現する `Object^jt 値になる。 ◎ The result of converting an IDL object value to an ECMAScript value is the Object value that represents a reference to the same object that the IDL object represents.

3.2.13. `symbol^T

~IDL `symbol$T 値は、~ES `Symbol^jt 値により表現される。 ◎ IDL symbol values are represented by ECMAScript Symbol values.

~IDL `symbol$T 値 %V を`~ES値に変換-$した結果は、 %V が表現するものと同じ~symbolへの参照を表現する `Symbol^jt 値になる。 ◎ The result of converting an IDL symbol value to an ECMAScript value is the Symbol value that represents a reference to the same symbol that the IDL symbol represents.

3.2.14. ~ifc型

~IDL`~ifc型$の値は、~ES `Object^jt 値（`関数~obj$も含む）により表現される。 ◎ IDL interface type values are represented by ECMAScript Object values (including function objects).

~IDL`~ifc型$の値 %V を`~ES値に変換-$した結果は、 %V が表現するものと同じ~objへの参照を表現する `Object^jt 値になる。 ◎ The result of converting an IDL interface type value to an ECMAScript value is the Object value that represents a reference to the same object that the IDL interface type value represents.

3.2.15. 辞書~型

~IDL`辞書~型$の値は、~ES `Object^jt 値により表現される。 その~obj（またはその原型鎖）上の~propが`辞書~mb$に対応する。 ◎ IDL dictionary type values are represented by ECMAScript Object values. Properties on the object (or its prototype chain) correspond to dictionary members.

注記： ~ES~obj上で`辞書~mb$を検索する順序は、~objの~prop列挙~順序と同じになる必要はない。 ◎ Note: The order that dictionary members are looked up on the ECMAScript object are not necessarily the same as the object’s property enumeration order.

3.2.16. 列挙~型

~IDL`列挙~型$の値は、~ES `String^jt 値により表現される。 ◎ IDL enumeration types are represented by ECMAScript String values.

~IDL`列挙$型の値を`~ES値に変換-$した結果は、［ その`列挙~値$と同じ`符号単位$の並び ］を表現する `String^jt 値になる。 ◎ The result of converting an IDL enumeration type value to an ECMAScript value is the String value that represents the same sequence of code units as the enumeration value.

3.2.17. 呼戻~関数~型

~IDL`呼戻~関数~型$の値は、~ES`関数~obj$により表現される。 ただし， `TreatNonObjectAsNull$x の場合は、任意の~objをとり得る。 ◎ IDL callback function types are represented by ECMAScript function objects, except in the [TreatNonObjectAsNull] case, when they can be any object.

~IDL`呼戻~関数~型$の値を`~ES値に変換-$した結果は、その`呼戻~関数~型$の値が表現するものと同じ~objへの参照になる。 ◎ The result of converting an IDL callback function type value to an ECMAScript value is a reference to the same object that the IDL callback function type value represents.

3.2.18. ~nullable型 — `~varT?^T

~IDL`~nullable型$の値は、その`内縁~型$に対応する~ES型の値か, または ~ES `null^jv 値により表現される。 ◎ IDL nullable type values are represented by values of either the ECMAScript type corresponding to the inner IDL type, or the ECMAScript null value.

この節を通して、 `~varT?^T は，`内縁~型$が %T である~IDL`~nullable型$を表す。

型 `~varT?^T の~IDL値 %V を`~ES値に変換-$した結果は、［ %V ~EQ `null^V ならば `null^jv ／ ~ELSE_ %V を型 %T の値として`~ES値に変換-$した結果 ］になる。 ◎ The result of converting an IDL nullable type value to an ECMAScript value is: • If the IDL nullable type T? value is null, then the ECMAScript value is null. • Otherwise, the ECMAScript value is the result of converting the IDL nullable type value to the inner IDL type T.

3.2.19. 連列 — ~sequence_T

~IDL `~sequence_T$ 値は、~ES `Array^jt 値により表現される。 ◎ IDL sequence<T> values are represented by ECMAScript Array values.

[Exposed=Window]
interface Canvas {

  sequence<DOMString> getSupportedImageCodecs();

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

  /*  */
};

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

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

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

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

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

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


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

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

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

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

3.2.21. ~promise型 — ~promise_T

~IDL`~promise型$値は、~ES `Promise$jt ~objにより表現される。 ◎ IDL promise type values are represented by ECMAScript Promise objects.

~IDL`~promise型$値 %V を`~ES値に変換-$した結果は、 %V が表現するものと同じ~objへの参照を表現する `Promise$jt 値になる。 ◎ The result of converting an IDL promise type value to an ECMAScript value is the Promise value that represents a reference to the same object that the IDL promise type represents.

この用語を用いて仕様を書く例を含める必要がある。 ◎ Include an example of how to write spec text using this term.

3.2.22. 共用体~型

~IDL`共用体~型$の値は、共用体の`~mb型$に対応する~ES値により表現される。 ◎ IDL union type values are represented by ECMAScript values that correspond to the union’s member types.

~IDL共用体~型の値 %U は，次に従って`~ES値に変換-$される： ◎ An IDL union type value is converted to an ECMAScript value as follows.

• %U が［ ~ES `undefined^jv 値を表現する特別な~objへの `object$T 参照 ］ならば、~ES `undefined^jv 値に変換される。 ◎ If the value is an object reference to a special object that represents an ECMAScript undefined value, then it is converted to the ECMAScript undefined value.＼
• 他の場合、この`es-type-mapping$secにて述べている， %U の`特有~型$を変換するための規則に従う。 ◎ Otherwise, the rules for converting the specific type of the IDL union type value as described in this section (§3.2 ECMAScript type mapping).

3.2.23. `Error^T

~IDL `Error$T 値は、［ ~native~ES `Error$jt ~obj ／ `DOMException$T ~platform~obj ］により表現される。 ◎ IDL Error values are represented by native ECMAScript Error objects and by DOMException platform objects.

~IDL `Error$T 値 %V を`~ES値に変換-$した結果は、 %V が表現するものと同じ~objへの参照を表現する `Error$jt 値になる。 ◎ The result of converting an IDL Error value to an ECMAScript value is the Error value that represents a reference to the same object that the IDL Error represents.

3.2.24. `DOMException^T

~IDL `DOMException$T 値は、~ES `Object^jt 値により表現される。 ◎ IDL DOMException values are represented by ECMAScript Object values.

~IDL `DOMException$T 値 %V を`~ES値に変換-$した結果は、 %V が表現するものと同じ~objへの参照を表現する `Object^jt 値になる。 ◎ The result of converting an IDL DOMException value to an ECMAScript value is the Object value that represents a reference to the same object that the IDL DOMException represents.

3.2.25. ~buffer~source型

~IDL`~buffer~source型$の値は、対応する~ES~classの~objにより表現され，~ES［ `ArrayBuffer$jt ／ `SharedArrayBuffer$jt ］~objに~backされ得るが、後者に~backできるのは，当の型に `AllowShared$x `拡張属性が結付けられ$ている場合に限られる。 ◎ Values of the IDL buffer source types are represented by objects of the corresponding ECMAScript class, with the additional restriction that unless the type is associated with the [AllowShared] extended attribute, they can only be backed by ECMAScript ArrayBuffer objects, and not SharedArrayBuffer objects.

いずれの`~buffer~source型$に対しても、その型の~IDL値 %V を`~ES値に変換-$した結果は、 %V が表現するものと同じ~objへの参照を表現する `Object^jt 値になる。 ◎ The result of converting an IDL value of any buffer source type to an ECMAScript value is the Object value that represents a reference to the same object that the IDL value represents.

3.3.2. `Clamp^x

`Clamp$x `拡張属性$が`整数~型$に現れた場合、次に従ってふるまう，新たな型を作成する ⇒ ~ES `Number^jt 値がこの~IDL型へ変換される際には、範囲~外の値に対しては，範囲~内の最も近い妥当な値に切詰める — modulo 演算を利用する演算子（ `ToInt32$A, `ToUint32$A, 等々）は利用せずに。 ◎ If the [Clamp] extended attribute appears on one of the integer types, it creates a new IDL type such that that when an ECMAScript Number is converted to the IDL type, out-of-range values will be clamped to the range of valid values, rather than using the operators that use a modulo operation (ToInt32, ToUint32, etc.).

`Clamp$x 拡張属性には、`引数をとらない$ことが要求される。 ◎ The [Clamp] extended attribute must take no arguments.

`Clamp$x の利用に課される特有の要件については、 `es-integer-types$secの［ ~ES値から種々の~IDL整数~型へ変換する規則 ］を見よ。 ◎ See the rules for converting ECMAScript values to the various IDL integer types in §3.2.4 Integer types for the specific requirements that the use of [Clamp] entails.

[Exposed=Window]
interface GraphicsContext {
  void setColor(octet %red, octet %green, octet %blue);
  void setColorClamped([Clamp] octet %red, [Clamp] octet %green, [Clamp] octet %blue);
};

/* 
`GraphicsContext^T の~instanceを取得する。
◎
Get an instance of GraphicsContext.
 */
var %context = getGraphicsContext();

/* 非 `Clamp^x 版の~callは実数~値を~octetに強制する ToUint8 を利用する。
◎
Calling the non-[Clamp] version uses ToUint8 to coerce the Numbers to octets
 */
/* 
次は `setColor(255, 255, 1)^c の~callと等価。
◎
This is equivalent to calling setColor(255, 255, 1).
 */
%context.setColor(-1, 255, 257);

/* 
範囲~外の値を渡して `setColorClamped^M を~callする。
◎
Call setColorClamped with some out of range values.
 */
/* 
次は `setColorClamped(0, 255, 255)^c の~callと等価。
◎
This is equivalent to calling setColorClamped(0, 255, 255).
 */
%context.setColorClamped(-1, 255, 257);

3.3.3. `Constructor^x

`Constructor$x `拡張属性$が `~ifc$上に現れた場合、その~ifc用の`~ifc~obj$は，［ その~ifcを実装する~objを構築できるようにする， `Construct^sl `内部~meth$ ］を持つことになる。 ◎ If the [Constructor] extended attribute appears on an interface, it indicates that the interface object for this interface will have an [[Construct]] internal method, allowing objects implementing the interface to be constructed.

同じ~ifc上に複数の `Constructor$x 拡張属性が現れてもよい。 ◎ Multiple [Constructor] extended attributes may appear on a given interface.

`Constructor$x 拡張属性には、［ `引数をとらない$ か, または `有名~引数~listを引数にとる$ ］ことが要求される。 略記形の前者 `[Constructor]^c は、引数~listが空にされた `[Constructor()]^c と同じ意味になる。 ~ifc上のそれぞれの `Constructor$x 拡張属性が、［ 指定された引数を渡して，その~ifcを実装する~objを構築する仕方 ］を~~供することになる。 ◎ The [Constructor] extended attribute must either take no arguments or take an argument list. The bare form, [Constructor], has the same meaning as using an empty argument list, [Constructor()]. For each [Constructor] extended attribute on the interface, there will be a way to construct an object that implements the interface by passing the specified arguments.

構築子の注釈文においては，［ `Constructor$x 拡張属性が現れる~ifcに対応する型の~IDL値を返すか, または 例外を投出する ］ように定義され~MUST。 ◎ The prose definition of a constructor must either return an IDL value of a type corresponding to the interface the [Constructor] extended attribute appears on, or throw an exception.

`Constructor$x 拡張属性は： ◎ ↓

• 同じ~ifc上で， `NoInterfaceObject$x 拡張属性と併用されては~MUST_NOT。 ◎ The [Constructor] and [NoInterfaceObject] extended attributes must not be specified on the same interface.
• `呼戻~ifc$上に利用されては~MUST_NOT。 ◎ The [Constructor] extended attribute must not be used on a callback interface.

ある~ifc用の構築子がどう実装されるかの詳細は、 `interface-object$sec を見よ。 ◎ See §3.6.1 Interface object for details on how a constructor for an interface is to be implemented.

[Exposed=Window]
interface NodeList {
  Node item(unsigned long %index);
  readonly attribute unsigned long length;
};

[Exposed=Window,
 Constructor,
 Constructor(double %radius)]
interface Circle {
  attribute double r;
  attribute double cx;
  attribute double cy;
  readonly attribute double circumference;
};

var %x = new Circle();
       /* 
これは，引数なしの構築子を利用して、 `Circle^T ~ifcを実装する~platform~objへの参照を作成する。
◎
The uses the zero-argument constructor to create a reference to a platform object that implements the Circle interface.
 */

var %y = new Circle(1.25);  
       /* 
今度は 1 個の引数をとる構築子を利用して `Circle^T ~objを作成する。
◎
This also creates a Circle object, this time using the one-argument constructor.
 */

var %z = new NodeList();    
       /* 
`Constructor^x が宣言されていないので `TypeError^jE が投出されることになる。
◎
This would throw a TypeError, since no [Constructor] is declared.
 */

3.3.5. `EnforceRange^x

`EnforceRange$x `拡張属性$が`整数~型$に現れた場合、次に従ってふるまう，新たな型を作成する ⇒ ~ES `Number^jt 値をこの~IDL型へ変換する際には、 0 側に丸めた結果が範囲~外になる値に対しては，例外を投出する — modulo 演算を利用する演算子（ `ToInt32$A, `ToUint32$A, 等々）は利用せずに。 ◎ If the [EnforceRange] extended attribute appears on one of the integer types, it creates a new IDL type such that that when an ECMAScript Number is converted to the IDL type, out-of-range values will cause an exception to be thrown, rather than being converted to a valid value using using the operators that use a modulo operation (ToInt32, ToUint32, etc.). The Number will be rounded toward zero before being checked against its range.

`EnforceRange$x 拡張属性には、`引数をとらない$ことが要求される。 ◎ The [EnforceRange] extended attribute must take no arguments.

`EnforceRange$x の利用に課される特有の要件については、 `es-type-mapping$secの［ ~ES値から種々の~IDL整数~型へ変換する規則 ］を見よ。 ◎ See the rules for converting ECMAScript values to the various IDL integer types in §3.2 ECMAScript type mapping for the specific requirements that the use of [EnforceRange] entails.

[Exposed=Window]
interface GraphicsContext {
  void setColor(octet %red, octet %green, octet %blue);
  void setColorEnforcedRange([EnforceRange] octet %red, [EnforceRange] octet %green, [EnforceRange] octet %blue);
};

/* 
`GraphicsContext^T の~instanceを取得する。
◎
Get an instance of GraphicsContext.
 */
var %context = getGraphicsContext();

/* 
非 `EnforceRange^x 版の~callは実数~値を~octetに強制する ToUint8 を利用する。これは `setColor(255, 255, 1)^c の~callと等価になる。
◎
Calling the non-[EnforceRange] version uses ToUint8 to coerce the Numbers to octets. This is equivalent to calling setColor(255, 255, 1).
 */
%context.setColor(-1, 255, 257);

/* 
実数~値は `setColorEnforcedRange^M が~callされる際に 0 側に丸められる。
これは `setColor(0, 255, 255)^c の~callと等価になる。
◎
When setColorEnforcedRange is called, Numbers are rounded towards zero.
This is equivalent to calling setColor(0, 255, 255).
 */
%context.setColorEnforcedRange(-0.9, 255, 255.2);

/* 
次は `TypeError^jE を投出させる。丸められた後でも， 1 個目, 3 個目の引数は範囲~外になるので。
◎
The following will cause a TypeError to be thrown, since even after
rounding the first and third argument values are out of range.
 */
%context.setColorEnforcedRange(-1, 255, 256);

3.3.6. `Exposed^x

`Exposed$x `拡張属性$が，次に挙げる構成子に現れたときは、その構成子が［ 拡張属性の引数により指定される，大域~ifc【 `Global$x が指定された~ifc】の集合 ］上に公開されることを指示する ⇒＃ `~ifc$ ／ `部分的~ifc$ ／ `~ifc~mixin$ ／ `部分的~ifc~mixin$ ／ `~ns$ ／ `部分的~ns$ ／ 個々の`~ifc~mb$ ／ 個々の`~ifc~mixin~mb$ ／ 個々の`~ns~mb$ ◎ When the [Exposed] extended attribute appears on an interface, partial interface, interface mixin, partial interface mixin, namespace, partial namespace, or an individual interface member, interface mixin member, or namespace member, it indicates that the construct is exposed on that particular set of global interfaces.

`Exposed$x `拡張属性$には、［ `識別子を引数にとる$か, または `識別子~listを引数にとる$ ］ことが要求される。 挙げられた各~識別子は、引数~内で一意, かつ`大域~名$で~MUST。 これらの識別子が成す~listは、当の構成子の `自前の公開~集合@ と呼ばれる。 ◎ The [Exposed] extended attribute must either take an identifier or take an identifier list. Each of the identifiers mentioned must be a global name and be unique. This list of identifiers is known as the construct’s own exposure set.

`Exposed$x 拡張属性は： ◎ ↓

• `多重定義$された ある`演算$に現れた場合、その多重定義を成す他のすべての演算にも現れ~MUST。 ◎ If [Exposed] appears on an overloaded operation, then it must appear identically on all overloads.

• ［ `~ifc~mb$ ／ `~ifc~mixin~mb$ ／ `~ns~mb$ ］, および それを宣言している［ `部分的~ifc$ ／ `部分的~ifc~mixin$ ／ `部分的~ns$ ］定義の両者に指定されては~MUST_NOT。 ◎ The [Exposed] extended attribute must not be specified both on an interface, mixin, or namespace member, and on the partial interface, partial interface mixin, or partial namespace definition the member is declared on.

  注記： そのわけは、［ `部分的~ifc$ ／ `部分的~ifc~mixin$ ／ `部分的~ns$ ］上に `Exposed$x `拡張属性$を追加することは，その各`~mb$を注釈することの略記だからである。 ◎ Note: This is because adding an [Exposed] extended attribute on a partial interface, partial interface mixin, or partial namespace is shorthand for annotating each of its members.

• ［ `部分的~ifc$ ／ `部分的~ns$ ］ %A に現れた場合、 %A の`自前の公開~集合$は， %A の元の［ `~ifc$ ／ `~ns$ ］の`公開~集合$の`下位集合$で~MUST。 ◎ If [Exposed] appears on a partial interface or partial namespace, then the partial’s own exposure set must be a subset of the exposure set of the partial’s original interface or namespace.
• ［ `~ifc$ ／ `~ns$ ］ %A 上の［ `~ifc~mb$ ／ `~ns~mb$ ］ %m に現れた場合、 %m の`公開~集合$は %A の`公開~集合$の`下位集合$で~MUST。 ◎ If [Exposed] appears on an interface or namespace member, then the member's exposure set must be a subset of the exposure set of the interface or namespace it is a member of.
• ［ `部分的~ifc~mixin$ %A, %A の元の`~ifc~mixin$ %B ］の両者に現れた場合、 %A の`自前の公開~集合$は %B の`自前の公開~集合$の`下位集合$で~MUST。 ◎ If [Exposed] appears both on a partial interface mixin and its original interface mixin, then the partial interface mixin's own exposure set must be a subset of the interface mixin's own exposure set.
• `~ifc~mixin$ %A, %A の`~ifc~mixin~mb$ %m の両者に現れた場合、 %m の`自前の公開~集合$は %A の`自前の公開~集合$の`下位集合$で~MUST。 ◎ If [Exposed] appears both on an interface mixin member and the interface mixin it is a member of, then the interface mixin members's own exposure set must be a subset of the interface mixin's own exposure set.

%A が別の~ifc %B を`継承-$しているならば、 %A の`公開~集合$は %B の`公開~集合$の`下位集合$で~MUST。 ◎ If an interface X inherits from another interface Y then the exposure set of X must be a subset of the exposure set of Y.

注記： `~ifc~mixin$ %M は，互いに異なる`~ifc$に`内包-$され得るので、 %M の`~ifc~mixin~mb$ %m の`公開~集合$は， %M を`内包-$している`~ifc$ — すなわち， %m の`~host~ifc$ %I — の関数になり、 %F を %I の`公開~集合$とするならば，次で与えられる ⇒ %m は `Exposed$x `拡張属性$で注釈されているならば `交差集合$( %m の`自前の公開~集合$, %F ) ／ ~ELSE_ %M は `Exposed$x `拡張属性$で注釈されているならば `交差集合$( %M の`自前の公開~集合$, %F ) ／ ~ELSE_ %F ◎ Note: As an interface mixin can be included by different interfaces, the exposure set of its members is a function of the interface that includes them. If the interface mixin member, partial interface mixin, or interface mixin is annotated with an [Exposed] extended attribute, then the interface mixin member's exposure set is the intersection of the relevant construct’s own exposure set with the the host interface's exposure set. Otherwise, it is the host interface's exposure set.

所与の［ `~ifc$ ／ `~ns$ ／ `~mb$ ］ %構成子 が`~Realm$ %~realm に `公開されて@ いるとは、次の両者が満たされることを意味する： ◎ An interface, namespace, or member construct is exposed in a given Realm realm if the following steps return true:

• ある［ ~ifc %I ~IN %構成子 の`公開~集合$ ］が在って， %~realm.`GlobalObject^sl は %I を実装している

• 次のいずれかが満たされる：

  • %構成子 は`保安的かどうかに関わらず可用$である
  • %~realm.`GlobalObject^sl に`関連する設定群~obj$は`保安的~文脈$である
  ◎ If construct is available in both secure and non-secure contexts, then return true. ◎ If the relevant settings object of realm.[[GlobalObject]] is a secure context, then return true. ◎ Otherwise, return false.

注記： ~ES大域~objに`関連する設定群~obj$が`保安的~文脈$であるかどうかは，変化し得ないので、実装が %構成子 用の~propを作成するかどうか決めるのは、`初期~obj$を作成する時点の一度限りになる。 ◎ Note: Since it is not possible for the relevant settings object for an ECMAScript global object to change whether it is a secure context or not over time, an implementation’s decision to create properties for an interface or interface member can be made once, at the time the initial objects are created.

`Exposed$x の利用に課される特有の要件については、 `es-interfaces$sec, `es-constants$sec, `es-attributes$sec, `es-operations$sec, `es-iterators$sec を見よ。 ◎ See §3.6 Interfaces, §3.6.6 Constants, §3.6.7 Attributes, §3.6.8 Operations, and §3.6.9 Common iterator behavior for the specific requirements that the use of [Exposed] entails.

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

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

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

/* 
`Dimensions^T は、［ 主thread上と~workerの中 ］でのみ可用。
◎
Dimensions is available for use in workers and on the main thread.
 */
[Exposed=(Window,Worker), Constructor(double %width, double %height)]
interface Dimensions {
  readonly attribute double %width;
  readonly attribute double %height;
};

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

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

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

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

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

3.3.7. `Global^x

`Global$x `拡張属性$が `~ifc$上に現れた場合、［ その~ifcを実装している~objは，~ES環境にて大域~objとして利用できる ］ことを指示する。 また、原型鎖の構造, および［ `~ifc~mb$に対応する~propが原型~obj上に どう反映されるか ］についても、他の~ifcと異なるものにされることを指示する。 特定的には： ◎ If the [Global] extended attribute appears on an interface, it indicates that objects implementing this interface can be used as the global object in an ECMAScript environment, and that the structure of the prototype chain and how properties corresponding to interface members will be reflected on the prototype objects will be different from other interfaces. Specifically:

1. どの`有名~prop$も，~obj自身ではなく, 原型鎖の中の~obj — `有名~prop~obj$ — 上に公開されることになる。 ◎ Any named properties will be exposed on an object in the prototype chain – the named properties object – rather than on the object itself.
2. `~ifc$からの`~ifc~mb$は、`~ifc原型~obj$上ではなく, ~obj自身の~propに対応することになる。 ◎ Interface members from the interface will correspond to properties on the object itself rather than on interface prototype objects.

var %indexedDB = window.indexedDB || window.webkitIndexedDB ||
                window.mozIndexedDB || window.msIndexedDB;

var %requestAnimationFrame = window.requestAnimationFrame ||
                            window.mozRequestAnimationFrame || ...;

`Global$x `拡張属性$を利用する`~ifc$ %I に対しては： ◎ If the [Global] extended attribute is used on an interface, then:

• `有名~prop設定子$は 定義されては~MUST_NOT。 ◎ The interface must not define a named property setter.
• ［ `有index~prop取得子$／`有index~prop設定子$ ］は 定義されては~MUST_NOT。 ◎ The interface must not define indexed property getters or setters.
• ［ %I, および %I の`継承d~ifc$ ］は `OverrideBuiltins$x 拡張属性を伴って宣言されては~MUST_NOT。 ◎ The interface must not also be declared with the [OverrideBuiltins] extended attribute. ◎ The interface must not inherit from another interface with the [OverrideBuiltins] extended attribute.
• %I は 他の~ifcは`継承-$しては~MUST_NOT。 ◎ Any other interface must not inherit from it.
• %I の`部分的~ifc定義$上に指定される場合、その部分的~ifc定義は， %I を成す~ifc定義の中で`有名~prop取得子$を定義する部分を成してい~MUST。 ◎ If [Global] is specified on a partial interface definition, then that partial interface definition must be the part of the interface definition that defines the named property getter.

• %I は、同じ~ES大域~環境~内で，複数の~objから実装され得るものであっては~MUST_NOT。 ◎ The [Global] extended attribute must not be used on an interface that can have more than one object implementing it in the same ECMAScript global environment.

  注記： そのわけは、有名~propを公開する`有名~prop~obj$が 原型鎖の中にあるものであり、複数の［ ~objの有名~prop ］を，それらの~objを継承する 1 個の~obj上で公開することに意味が無いからである。 ◎ Note: This is because the named properties object, which exposes the named properties, is in the prototype chain, and it would not make sense for more than one object’s named properties to be exposed on an object that all of those objects inherit from.

• %I には［ `識別子$が同じになる複数の`~mb$ ］が在っては~MUST_NOT。 また、 %I には［ 複数の`文字列化子$ ／ 複数の［ `可反復~宣言$, `~maplike 宣言$, `~setlike 宣言$【混在も含む】 ］］が在っては~MUST_NOT。 ◎ If an interface is declared with the [Global] extended attribute, then there must not be more than one member across the interface with the same identifier. There also must not be more than one stringifier or more than one iterable declaration, maplike declaration or setlike declaration across those interfaces.

  注記： そのわけは、~ifcを成す`~mb$すべてが、~ifcを実装する~objに平坦化されるからである。 ◎ Note: This is because all of the members of the interface get flattened down on to the object that implements the interface.

`Global$x 拡張属性は、 1 個~以上の大域~ifcに同じ名前を与えて， `Exposed$x 拡張属性から参照できるようにするときにも利用できる。 ◎ The [Global] extended attribute can also be used to give a name to one or more global interfaces, which can then be referenced by the [Exposed] extended attribute.

`Global$x 拡張属性には、［ `識別子を引数にとる$か, または `識別子~listを引数にとる$ ］ことが要求される。 ◎ The [Global] extended attribute must either take an identifier or take an identifier list.

`Global$x `拡張属性$の宣言に伴われた［ 識別子~引数／識別子~list~引数 ］は、一連の［ ~ifcの `大域~名@ ］を定義する。 ◎ The identifier argument or identifier list argument the [Global] extended attribute is declared with define the interface’s global names.

注記： 識別子~list引数は、 `Exposed$x `拡張属性$の中の単独の名前で，複数の大域~ifcを指せるようにするためにある。 ◎ Note: The identifier argument list exists so that more than one global interface can be addressed with a single name in an [Exposed] extended attribute.

`有名~prop$における `Global$x の利用に課される特有の要件については、 `named-properties-object$sec を見よ。 `~ifc~mb$に対応する~propの所在に関する要件については、 `es-constants$sec, `es-attributes$sec, `es-operations$sec を見よ。 ◎ See §3.6.5 Named properties object for the specific requirements that the use of [Global] entails for named properties, and §3.6.6 Constants, §3.6.7 Attributes and §3.6.8 Operations for the requirements relating to the location of properties corresponding to interface members.

[Exposed=Window, Global]
interface Window {
  getter any (DOMString %name);
  attribute DOMString name; 
   /*  */
};

<!DOCTYPE html>
<title>
Window 上の変数~宣言と代入
◎
Variable declarations and assignments on Window
</title>
<iframe name=abc></iframe>
<!-- 
有名~propを隠蔽する
◎
Shadowing named properties
 -->
<script>
  window.abc;    /* 
`iframe^c の `Window^T ~objに評価される。
◎
Evaluates to the iframe’s Window object.
 */
  %abc = 1;       /* 
有名~propを隠蔽する。
◎
Shadows the named property.
 */
  window.abc;    /* 
`1^jv に評価される。
◎
Evaluates to 1.
 */
</script>

<!-- 
~IDL属性~用の~propは保全される
◎
Preserving properties for IDL attributes
 -->
<script>
  Window.prototype.def = 2;         /* 
原型~上に~propを置く。
◎
Places a property on the prototype.
 */
  window.hasOwnProperty("length");  /*  */

  %length;        /*  */
  %def;           /* 
`2^jv に評価される。
◎
Evaluates to 2.
 */
</script>

<script>
  var %length;    /* 
この変数~宣言は既存の~propに触らない。
◎
Variable declaration leaves existing property.
 */
  %length;        /*  */
  var %def;       /* 
この変数~宣言は隠蔽する~propを作成する。
◎
Variable declaration creates shadowing property.
 */
  %def;           /*  */
</script>

3.3.12. `LenientThis^x

`LenientThis$x `拡張属性$が `正則~属性$上に現れた場合、その属性が現れる`~ifc$を実装する~objとは異なる `this^jv 値を伴うような，その属性の取得子や設定子の呼出は、無視されることになる。 ◎ If the [LenientThis] extended attribute appears on a regular attribute, it indicates that invocations of the attribute’s getter or setter with a this value that is not an object that implements the interface on which the attribute appears will be ignored.

`LenientThis$x がどう実装されるかについては、 `es-attributes$sec を見よ。 ◎ See the Attributes section for how [LenientThis] is to be implemented.

[Exposed=Window]
interface Example {
  [LenientThis] attribute DOMString x;
  attribute DOMString y;
};

var %example = getExample();  /* 
`Example^T の~instanceを取得する。
◎
Get an instance of Example.
 */
var %obj = { };

/* 
~~通常。
◎
Fine.
 */
%example.x;

/* 
この値は `Example^T ~objでなく, かつ
`LenientThis^x が利用されているので、無視される。
◎
Ignored, since the this value is not an Example object and [LenientThis] is used.
 */
Object.getOwnPropertyDescriptor(Example.prototype, "x").get.call(%obj);

/* 
`Example.prototype^jv は `Example^T ~objでなく, かつ
`LenientThis^x が利用されているので、これも無視される。
◎
Also ignored, since Example.prototype is not an Example object and [LenientThis] is used.
 */
Example.prototype.x;

/* 
`Example.prototype^jv は `Example^T ~objでないので `TypeError^jE が投出される。
◎
Throws a TypeError, since Example.prototype is not an Example object.
 */
Example.prototype.y;

3.3.13. `NamedConstructor^x

所与の~ifc上に，複数の `NamedConstructor$x 拡張属性が現れてもよい。 ◎ Multiple [NamedConstructor] extended attributes may appear on a given interface.

`NamedConstructor$x 拡張属性は： ◎ ↓

• `識別子を引数にとる$か, または`有名~引数~listを引数にとる$ことが要求される。 `=^sym の直後に現れる `identifier$g が `NamedConstructor$x の `識別子@nC になる。 前者の形 [NamedConstructor=`identifier$g] は、空の引数~list [NamedConstructor=`identifier$g()] を利用するのと同じ意味になる。 ~ifc上の各 `NamedConstructor$x 拡張属性が、［［ 前述の~propの値である`構築子$ ］に，指定された引数を渡して、その~ifcを実装する~objを構築する仕方 ］を~~供することになる。 ◎ The [NamedConstructor] extended attribute must either take an identifier or take a named argument list. The identifier that occurs directly after the “=” is the [NamedConstructor]'s identifier. The first form, [NamedConstructor=identifier], has the same meaning as using an empty argument list, [NamedConstructor=identifier()]. For each [NamedConstructor] extended attribute on the interface, there will be a way to construct an object that implements the interface by passing the specified arguments to the constructor that is the value of the aforementioned property.

• 次に挙げる識別子は、有名~構築子の識別子として利用されては~MUST_NOT：

  • 別の~ifc上の `NamedConstructor$x 拡張属性に利用されている`識別子$nC
  • 当のまたは別の~ifc上の `LegacyWindowAlias$x 拡張属性に利用されている`識別子$wA
  • `~ifc~obj$を持つ~ifcの`識別子$
  • `予約-済み識別子$
  ◎ The identifier used for the named constructor must not be the same as that used by a [NamedConstructor] extended attribute on another interface, must not be the same as an identifier used by a [LegacyWindowAlias] extended attribute on this interface or another interface, must not be the same as an identifier of an interface that has an interface object, and must not be one of the reserved identifiers.
• `呼戻~ifc$上に利用されては~MUST_NOT。 ◎ The [NamedConstructor] extended attribute must not be used on a callback interface.

有名~構築子がどう実装されるかの詳細は `named-constructors$sec を見よ。 ◎ See §3.6.2 Named constructors for details on how named constructors are to be implemented.

[Exposed=Window,
 NamedConstructor=Audio,
 NamedConstructor=Audio(DOMString %src)]
interface HTMLAudioElement : HTMLMediaElement {
  /*  */
};

typeof Audio;                   /*  */

var %a1 = new Audio();
   /* 
引数なしの構築子を利用して， `HTMLAudioElement^T を実装する ~objを作成する。
◎
Creates a new object that implements HTMLAudioElement, using the zero-argument constructor.
 */

var %a2 = new Audio('a.flac');
   /* 
1 個の引数をとる構築子を利用して， `HTMLAudioElement^T を作成する。
◎
Creates an HTMLAudioElement using the one-argument constructor.
 */

3.3.14. `NewObject^x

`NewObject$x `拡張属性$が［ `正則~演算$／`静的~演算$ ］上に現れた場合、その演算が~callされる際に，常に 新たに作成された~objへの参照が返され~MUSTことを指示する。 ◎ If the [NewObject] extended attribute appears on a regular or static operation, then it indicates that when calling the operation, a reference to a newly created object must always be returned.

`NewObject$x 拡張属性は： ◎ ↓

• `引数をとらない$ことが要求される。 ◎ The [NewObject] extended attribute must take no arguments.
• `返値型$が［ `~ifc型$, または `~promise型$ ］である［ `正則~演算$／`静的~演算$ ］以外の所に利用されては~MUST_NOT。 ◎ The [NewObject] extended attribute must not be used on anything other than a regular or static operation whose return type is an interface type or a promise type.

[Exposed=Window]
interface Document : Node {
  [NewObject] Element createElement(DOMString %localName);
  /*  */
};

3.3.15. `NoInterfaceObject^x

`NoInterfaceObject$x `拡張属性$が `~ifc$上に現れた場合、その~ifc用の`~ifc~obj$は，~ES言語束縛には存在しないことになる。 ◎ If the [NoInterfaceObject] extended attribute appears on an interface, it indicates that an interface object will not exist for the interface in the ECMAScript binding.

`NoInterfaceObject$x 拡張属性は： ◎ ↓

• `引数をとらない$ことが要求される。 ◎ The [NoInterfaceObject] extended attribute must take no arguments.
• 同じ~ifc上で， `Constructor$x 拡張属性と併用されては~MUST_NOT。 一方， `NamedConstructor$x 拡張属性との併用は差し支えない。 ◎ If the [NoInterfaceObject] extended attribute is specified on an interface, then the [Constructor] extended attribute must not also be specified on that interface. A [NamedConstructor] extended attribute is fine, however.
• `静的~演算$が定義されている~ifc上に指定されては~MUST_NOT。 ◎ The [NoInterfaceObject] extended attribute must not be specified on an interface that has any static operations defined on it.
• `呼戻~ifc$上に指定されては~MUST_NOT。 ◎ The [NoInterfaceObject] extended attribute must not be specified on a callback interface.
• この拡張属性が指定されていない~ifcが，この拡張属性が指定されている~ifcを継承しては~MUST_NOT ◎ An interface that does not have the [NoInterfaceObject] extended attribute specified must not inherit from an interface that has the [NoInterfaceObject] extended attribute specified.

`NoInterfaceObject$x の利用に課される特有の要件については、 `es-interfaces$sec を見よ。 ◎ See §3.6 Interfaces for the specific requirements that the use of [NoInterfaceObject] entails.

[Exposed=Window]
interface Storage {
  void addEntry(unsigned long %key, any %value);
};

[Exposed=Window,
 NoInterfaceObject]
interface Query {
  any lookupEntry(unsigned long %key);
};

typeof Storage;                        /* 
`object^l に評価される。
◎
evaluates to "object"
 */

/* 
`Storage.addEntry^c に~trace用の `alert()^c ~callを追加する
◎
Add some tracing alert() call to Storage.addEntry.
 */
var %fn = Storage.prototype.addEntry;
Storage.prototype.addEntry = function(%key, %value) {
  alert('Calling addEntry()');
  return %fn.call(this, %key, %value);
};

typeof Query;                          /* 
`undefined^l に評価される。
◎
evaluates to "undefined"
 */
var %fn = Query.prototype.lookupEntry;  /* 
例外が投出される。 `Query^T は定義されていないので。
◎
exception, Query isn’t defined
 */

3.3.16. `OverrideBuiltins^x

`OverrideBuiltins$x `拡張属性$が `~ifc$上に現れた場合，その~ifcを実装する`旧来の~platform~obj$ %O においては、［ %O や %O の原型鎖 ］上に存在する他の~propに関わらず，各［ %O が`~supportする~prop名$ ］に対し，対応する~propが %O 上に現れることになる。 このことは、（通例の挙動では、有名~propは［ %O 自身やその原型鎖 ］上のどこにも同じ名前の~propが存在しないときに限り，公開されるのに対し、）有名~propが、［ さもなければ %O 上に現れることになる，同じ名前のどの~prop ］も，常に隠蔽することになることを意味する。 ◎ If the [OverrideBuiltins] extended attribute appears on an interface, it indicates that for a legacy platform object implementing the interface, properties corresponding to all of the object’s supported property names will appear to be on the object, regardless of what other properties exist on the object or its prototype chain. This means that named properties will always shadow any properties that would otherwise appear on the object. This is in contrast to the usual behavior, which is for named properties to be exposed only if there is no property with the same name on the object itself or somewhere on its prototype chain.

`OverrideBuiltins$x の利用に課される特有の要件については、 `es-legacy-platform-objects$sec, `legacy-platform-object-defineownproperty$sec を見よ。 ◎ See §3.8 Legacy platform objects and §3.8.3 [[DefineOwnProperty]] for the specific requirements that the use of [OverrideBuiltins] entails.

[Exposed=Window]
interface StringMap {
  readonly attribute unsigned long length;
  getter DOMString lookup(DOMString %key);
};

[Exposed=Window,
 OverrideBuiltins]
interface StringMap2 {
  readonly attribute unsigned long length;
  getter DOMString lookup(DOMString %key);
};

/* 
`StringMap^T の~instanceを得る。
~supportする~prop名として， `abc^l, `length^l, `toString^l を持つとする。
◎
Obtain an instance of StringMap.  Assume that it has "abc", "length" and "toString" as supported property names.
 */
var %map1 = getStringMap();

/* 
有名~prop取得子を呼出す。
◎
This invokes the named property getter.
 */
%map1.abc;

/* `length^M 属性に対応する~obj上の `length^jp ~propを取りに行く。
◎
This fetches the "length" property on the object that corresponds to the length attribute.
 */
%map1.length;

/* ~objの原型鎖~上の `toString^jp ~propを取りに行く。
◎
This fetches the "toString" property from the object’s prototype chain.
 */
%map1.toString;


/* 
`StringMap2^T の~instanceを得る。
これも~supportする~prop名として， `abc^l, `length^l, `toString^l を持つとする。
◎
Obtain an instance of StringMap2.  Assume that it also has "abc", "length"
and "toString" as supported property names.
 */
var %map2 = getStringMap2();

/* 
これは 有名~prop取得子を呼出す。
◎
This invokes the named property getter.
 */
%map2.abc;

/* 
これも 有名~prop取得子を呼出す。
~obj上の `length^jp ~propが length 属性に対応しているにも関わらず。
◎
This also invokes the named property getter, despite the fact that the "length"
property on the object corresponds to the length attribute.
 */
%map2.length;

/* 
これもまた 有名~prop取得子を呼出す。
`toString^l が %map2 の prototype chain 内にある~propであるにも関わらず。
◎
This too invokes the named property getter, despite the fact that "toString" is
a property in map2’s prototype chain.
 */
%map2.toString;

3.3.17. `PutForwards^x

`PutForwards$x `拡張属性$が［ `~ifc型$の`読専$な`正則~属性$宣言 ］上に現れた場合、その属性への代入-時に特有に挙動することになる。 すなわち，その代入は、代入-が試みられた属性から，現在~参照されている~objの属性（その拡張属性の引数で指定される）に “回送-” される。 ◎ If the [PutForwards] extended attribute appears on a read only regular attribute declaration whose type is an interface type, it indicates that assigning to the attribute will have specific behavior. Namely, the assignment is “forwarded” to the attribute (specified by the extended attribute argument) on the object that is currently referenced by the attribute being assigned to.

`PutForwards$x 拡張属性には、`識別子を引数にとる$ことが要求される。 次が与えられるとき： ◎ The [PutForwards] extended attribute must take an identifier. Assuming that:

• %A は `PutForwards$x 拡張属性が現れる`属性$, ◎ A is the attribute on which the [PutForwards] extended attribute appears,
• %I は %A が宣言されている`~ifc$, ◎ I is the interface on which A is declared,
• %J は %A の型として宣言されている `~ifc型$, ◎ J is the interface type that A is declared to be of, and
• %N は その拡張属性の`識別子$引数, ◎ N is the identifier argument of the extended attribute,

このとき，`識別子$ %N を持つ別の`属性$ %B が %J 上に宣言されてい~MUST。 %I を実装している~obj上の属性 %A への値の代入では、代わりに， %A が参照する~objの属性 %B にその値が代入されることになる。 ◎ then there must be another attribute B declared on J whose identifier is N. Assignment of a value to the attribute A on an object implementing I will result in that value being assigned to attribute B of the object that A references, instead.

`PutForwards$x 注釈付きの`属性$は連鎖し得ることに注意。 すなわち、 `PutForwards$x `拡張属性$を伴う属性は，この拡張属性を持つ他の属性を指すことができる。 ただし、この代入の連鎖が循環しては~MUST_NOT。 代入の連鎖が辿られる際に，同じ`~ifc$上の特定0の属性に複数~回 遭遇するならば、循環が存在する。 ◎ Note that [PutForwards]-annotated attributes can be chained. That is, an attribute with the [PutForwards] extended attribute can refer to an attribute that itself has that extended attribute. There must not exist a cycle in a chain of forwarded assignments. A cycle exists if, when following the chain of forwarded assignments, a particular attribute on an interface is encountered more than once.

`PutForwards$x 拡張属性は： ◎ ↓

• 同じ属性~上で， `LenientSetter$x ／ `Replaceable$x 拡張属性と併用されては~MUST_NOT。 ◎ An attribute with the [PutForwards] extended attribute must not also be declared with the [LenientSetter] or [Replaceable] extended attributes.
• `読専$でない`属性$~上に利用されては~MUST_NOT。 ◎ The [PutForwards] extended attribute must not be used on an attribute that is not read only.
• `静的~属性$上に利用されては~MUST_NOT。 ◎ The [PutForwards] extended attribute must not be used on a static attribute.
• ［ `呼戻~ifc$／`~ns$ ］上で宣言される属性~上に利用されては~MUST_NOT。 ◎ The [PutForwards] extended attribute must not be used on an attribute declared on a callback interface or namespace.

`PutForwards$x がどう実装されるかについては、 `es-attributes$sec を見よ。 ◎ See the Attributes section for how [PutForwards] is to be implemented.

[Exposed=Window]
interface Name {
  attribute DOMString full;
  attribute DOMString family;
  attribute DOMString given;
};

[Exposed=Window]
interface Person {
  [PutForwards=full] readonly attribute Name name;
  attribute unsigned short age;
};

var %p = getPerson();           /* 
`Person^T の~instanceを得る。
◎
Obtain an instance of Person.
 */

%p.name = 'John Citizen';       /* 
この文は...
◎
This statement...
 */
%p.name.full = 'John Citizen';  /* 
...これと同じ挙動になる。
◎
...has the same behavior as this one.
 */

3.3.18. `Replaceable^x

`Replaceable$x `拡張属性$が `読専$な`正則~属性$上に現れた場合、`~platform~obj$上の対応する~propが設定される際に、その~obj上に，代入される値をとる同じ名前の自前の~propが作成されることになる。 この~propは、 `~ifc原型~obj$上に存在する，その属性に対応する~accessor~propを隠蔽する。 ◎ If the [Replaceable] extended attribute appears on a read only regular attribute, it indicates that setting the corresponding property on the platform object will result in an own property with the same name being created on the object which has the value being assigned. This property will shadow the accessor property corresponding to the attribute, which exists on the interface prototype object.

`Replaceable$x 拡張属性は： ◎ ↓

• `引数をとらない$ことが要求される。 ◎ The [Replaceable] extended attribute must take no arguments.
• 同じ属性~上で， `LenientSetter$x ／ `Replaceable$x 拡張属性と併用されては~MUST_NOT。 ◎ An attribute with the [Replaceable] extended attribute must not also be declared with the [LenientSetter] or [PutForwards] extended attributes.
• `読専$でない`属性$~上に利用されては~MUST_NOT。 ◎ The [Replaceable] extended attribute must not be used on an attribute that is not read only.
• `静的~属性$上に利用されては~MUST_NOT。 ◎ The [Replaceable] extended attribute must not be used on a static attribute.
• `呼戻~ifc$上で宣言される属性に利用されては~MUST_NOT。 ◎ The [Replaceable] extended attribute must not be used on an attribute declared on a callback interface.

`Replaceable$x の利用に課される特有の要件については、 `es-attributes$sec を見よ。 ◎ See §3.6.7 Attributes for the specific requirements that the use of [Replaceable] entails.

[Exposed=Window]
interface Counter {
  [Replaceable] readonly attribute unsigned long value;
  void increment();
};

var %counter = getCounter();         /* 
`Counter^T の~instanceを得る。
◎
Obtain an instance of Counter.
 */
%counter.value;                      /* 
`0^jv に評価される。
◎
Evaluates to 0.
 */

%counter.hasOwnProperty("value");    /*  */
Object.getPrototypeOf(%counter).hasOwnProperty("value");
                                    /*  */

%counter.increment();
%counter.increment();
%counter.value;                      /* 
`2^jv に評価される。
◎
Evaluates to 2.
 */

%counter.value = 'a';                
       /* 
`Counter::value^V に関係無いもので~propを隠蔽する。
◎
Shadows the property with one that is unrelated to Counter::value.
 */

%counter.hasOwnProperty("value");    /*  */

%counter.increment();
%counter.value;                      /* 
`a^l に評価される。
◎
Evaluates to 'a'.
 */

delete %counter.value;               /* 
元の~propを露にする。
◎
Reveals the original property.
 */
%counter.value;                      /* 
`3^jv に評価される。
◎
Evaluates to 3.
 */

3.3.19. `SameObject^x

`SameObject$x `拡張属性$が `読専$な`属性$に現れた場合、所与の~obj上でその属性の値が取得される度に，常に同じ値が返され~MUSTことを指示する。 ◎ If the [SameObject] extended attribute appears on a read only attribute, then it indicates that when getting the value of the attribute on a given object, the same value must always be returned.

`SameObject$x 拡張属性は： ◎ ↓

• `引数をとらない$ことが要求される。 ◎ The [SameObject] extended attribute must take no arguments.
• ［［ `~ifc型$／`~obj型$ ］である`読専$な`属性$ ］以外の所に利用されては~MUST_NOT。 ◎ The [SameObject] extended attribute must not be used on anything other than a read only attribute whose type is an interface type or object.

[Exposed=Window]
interface Document : Node {
  [SameObject] readonly attribute DOMImplementation implementation;
  /*  */
};

3.3.20. `SecureContext^x

`SecureContext$x `拡張属性$が［ `~ifc$ ／ `部分的~ifc$ ／ `~ifc~mixin$ ／ `部分的~ifc~mixin$ ／ `~ns$ ／ `部分的~ns$ ／ 個々の［ `~ifc~mb$ ／ `~ifc~mixin~mb$ ／ `~ns~mb$ ］］ %X 上に現れた場合、［ %X が公開されるのは `保安的~文脈$の中に限られる ］ことを指示する。 ◎ If the [SecureContext] extended attribute appears on an interface, partial interface, interface mixin, partial interface mixin, namespace, partial namespace, interface member, interface mixin member, or namespace member, it indicates that the construct is exposed only within a secure context.＼

`SecureContext$x 拡張属性は： ◎ ↓

• 上に挙げたもの以外の構成子に利用されては~MUST_NOT。 ◎ The [SecureContext] extended attribute must not be used on any other construct.
• `引数をとらない$ことが要求される。 ◎ The [SecureContext] extended attribute must take no arguments.

既定では、構成子は `保安的かどうかに関わらず可用@ とされる。 ◎ By default, constructs are available in both secure and non-secure contexts.

注記： 所与の構成子が`保安的~文脈~下に限り可用$かどうかは、所与の~ES大域~環境~内に`公開され$るかどうかに波及する。 ◎ Note: Whether a construct is available only in secure contexts influences whether it is exposed in a given ECMAScript global environment.

`SecureContext$x `拡張属性$は：

• `多重定義$された ある`演算$に現れるならば、その多重定義を成す他のすべての演算にも現れ~MUST。 ◎ If [SecureContext] appears on an overloaded operation, then it must appear on all overloads.

• 次の両者に指定されては~MUST_NOT ⇒ ［ `~ifc~mb$ ／ `~ifc~mixin~mb$ ／ `~ns~mb$ ］, および その`~mb$を宣言している［ `部分的~ifc$ ／ `部分的~ifc~mixin$ ／ `部分的~ns$ ］定義 ◎ The [SecureContext] extended attribute must not be specified both on an interface, mixin, or namespace member, and on the partial interface, partial interface mixin, or partial namespace definition the member is declared on.

  注記： そのわけは、［ `部分的~ifc$ ／ `部分的~ifc~mixin$ ／ `部分的~ns$ ］上に `SecureContext$x `拡張属性$を追加することは，その各`~mb$を注釈することの略記だからである。 ◎ Note: This is because adding a [SecureContext] extended attribute on a partial interface, partial interface mixin, or partial namespace is shorthand for annotating each of its members.

• 次の両者に指定されては~MUST_NOT ⇒ `~ifc~mb$, および その`~mb$を宣言している［ `~ifc$ ／ `部分的~ifc$ ］定義 ◎ The [SecureContext] extended attribute must not be specified on both an interface member and the interface or partial interface definition the interface member is declared on.＼
• 次の両者に指定されては~MUST_NOT ⇒ `~ns~mb$, および その`~mb$を宣言している［ `~ns$ ／ `部分的~ns$ ］定義 ◎ It must also not be specified on both a namespace member and the namespace or partial namespace definition the namespace member is declared on.

`SecureContext$x`拡張属性$を伴わない`~ifc$は、 `SecureContext$x を指定する別の~ifcを`継承-$しては~MUST_NOT。 ◎ An interface without the [SecureContext] extended attribute must not inherit from another interface that does specify [SecureContext].

[Exposed=Window]
interface PowerfulFeature {
  /* 
次の演算の~callはどの文脈~下でも成功する。
◎
This call will succeed in all contexts.
 */
  Promise <Result> calculateNotSoSecretResult();

  /* 
次の演算は、保安的でない文脈には公開されない。
`PowerfulFeature.prototype^c 上に
`calculateSecretResult^jp ~propはない。
◎
This operation will not be exposed to a non-secure context. In such a context, there will be no "calculateSecretResult" property on PowerfulFeature.prototype.
 */
  [SecureContext] Promise<Result> calculateSecretResult();

  /* 
次の属性にも同じことが言え、保安的でない文脈には公開されない
— `PowerfulFeature.prototype^c 上に 
`secretBoolean^jp ~propはない。
◎
The same applies here: the attribute will not be exposed to a non-secure context, and in a non-secure context there will be no "secretBoolean" property on PowerfulFeature.prototype.
 */

  [SecureContext] readonly attribute boolean secretBoolean;
};

/* 
`HeartbeatSensor^T は、保安的でない文脈にも その~mbにも公開されない
— `Window^T 上に `HeartbeatSensor^jp ~propはない。
◎
HeartbeatSensor will not be exposed in a non-secure context, nor will its members. In such a context, there will be no "HeartbeatSensor" property on Window.
 */

[SecureContext]
interface HeartbeatSensor {
  Promise<float> getHeartbeatsPerMinute();
};

/* 
次に定義される~ifc~mixin~mbは、それを内包する~ifcが保安的かどうかに関わらず，保安的でない文脈には決して公開されない
— `PowerfulFeature.prototype^c 上に `snap^jp ~propはない。
◎
The interface mixin members defined below will never be exposed in a non-secure context, regardless of whether the interface that includes them is. In a non-secure context, there will be no "snap" property on PowerfulFeature.prototype.
 */
[SecureContext]
interface mixin Snapshotable {
  Promise<boolean> snap();
};
PowerfulFeature includes Snapshotable;

/* 
他方，次の各 ~ifc~mixin~mbは、
`SecureContext$x 拡張属性を伴わない~host~ifcに内包された場合には，保安的でない文脈にも公開されることになる
— そのような文脈においても，
`PowerfulFeature.prototype^c 上に `log^jp ~propはある。
◎
On the other hand, the following interface mixin members will be exposed to a non-secure context when included by a host interface that doesn’t have the [SecureContext] extended attribute. In a non-secure context, there will be a "log" property on PowerfulFeatures.prototype.
 */
interface mixin Loggable {
  Promise<boolean> log();
};
PowerfulFeatures includes Loggable;

3.3.21. `TreatNonObjectAsNull^x

`TreatNonObjectAsNull$x `拡張属性$が `呼戻~関数$上に現れた場合、 `属性$に代入される［ `~nullable$`呼戻~関数$型であって, ~objではない ］どの値も， `null^V 値に変換するようにすることを指示する。 ◎ If the [TreatNonObjectAsNull] extended attribute appears on a callback function, then it indicates that any value assigned to an attribute whose type is a nullable callback function that is not an object will be converted to the null value.

`TreatNonObjectAsNull$x の利用に課される特有の要件については、 `es-nullable-type$sec を見よ。 ◎ See §3.2.18 Nullable types — T? for the specific requirements that the use of [TreatNonObjectAsNull] entails.

callback OccurrenceHandler = void (DOMString %details);

[TreatNonObjectAsNull]
callback ErrorHandler = void (DOMString %details);

[Exposed=Window]
interface Manager {
  attribute OccurrenceHandler? handler1;
  attribute ErrorHandler? handler2;
};

var %manager = getManager();  /* 
`Manager^T の~instanceを取得する。
◎
Get an instance of Manager.
 */

%manager.handler1 = function() { };
%manager.handler1;            /* 
当の function に評価される。
◎
Evaluates to the function.
 */

try {
  %manager.handler1 = 123;    /* 
`TypeError^jE が投出される。
◎
Throws a TypeError.
 */
} catch (%e) {
}

%manager.handler2 = function() { };
%manager.handler2;            /*  */

%manager.handler2 = 123;
%manager.handler2;            /* 
`null^jv に評価される。
◎
Evaluates to null.
 */

3.3.22. `TreatNullAs^x

`TreatNullAs$x `拡張属性$は、望ましくない特色機能である。 旧来の~Web~platform特色機能を指定できるようにするためのみに存在するので、旧来の~API［ の挙動を指定するため／との整合性のため ］に要求されない限り，仕様に利用されるべきではない。 この特色機能を利用したいと望む編集者には、先に進む前に `Intent to use [TreatNullAs]$fI した上で論交することを，強く勧める。 ◎ The [TreatNullAs] extended attribute is an undesirable feature. It exists only so that legacy Web platform features can be specified. It should not be used in specifications unless required to specify the behavior of legacy APIs, or for consistency with these APIs. Editors who wish to use this feature are strongly advised to discuss this by filing an issue before proceeding.

`TreatNullAs$x `拡張属性$が `DOMString$T 型に現れた場合、次に従ってふるまう，新たな型を作成する ⇒ ~ES `null^jv 値がこの~IDL型に変換される際には、既定による `null^l に文字列化される代わりに，空~文字列に変換される。 ◎ If the [TreatNullAs] extended attribute appears on the DOMString type, it creates a new IDL type such that that when an ECMAScript null is converted to the IDL type, it will be handled differently from its default handling. Instead of being stringified to "null", which is the default, it will be converted to the empty string.

`TreatNullAs$x 拡張属性には、次の`識別子を引数にとる$ことが要求される： `EmptyString^c ◎ The [TreatNullAs] extended attribute must take the identifier EmptyString.

`TreatNullAs$x `拡張属性が結付けられ$ている型は、 `DOMString$T で~MUST。 ◎ The [TreatNullAs] extended attribute must not be associated with a type that is not DOMString.

注記： すなわち、 `DOMString?^T 型であっても， `TreatNullAs$x を利用してはならない — `null^V はその型の妥当な値なので。 ◎ Note: This means that even DOMString? must not use [TreatNullAs], since null is a valid value of that type.

`TreatNullAs$x の利用に課される特有の要件については、 `es-DOMString$sec を見よ。 ◎ See §3.2.9 DOMString for the specific requirements that the use of [TreatNullAs] entails.

[Exposed=Window]
interface Dog {
  attribute DOMString name;
  attribute [TreatNullAs=EmptyString] DOMString owner;

  boolean isMemberOfBreed([TreatNullAs=EmptyString] DOMString %breedName);
};

var %d = getDog();
       /* 
%d は `Dog^T ~ifcを実装する~platform~objとする。
◎
Assume d is a platform object implementing the Dog
interface.
 */

%d.name = null;
       /* 
文字列 `null^l を `.name^jp ~propに代入する。
◎
This assigns the string "null" to the .name
property.
 */

%d.owner = null;
       /* 
文字列 "" を `.owner^jp ~propに代入する。
◎
This assigns the string "" to the .owner property.
 */

%d.isMemberOfBreed(null);
       /* 
文字列 "" を `isMemberOfBreed^M 関数に渡す。
◎
This passes the string "" to the isMemberOfBreed
function.
 */

3.3.23. `Unforgeable^x

所与の~ifc %A 上にて `Unforgeable$x `拡張属性$ 注釈付きで宣言されている［ 属性／演算 ］は、 %A 上において `偽装-不能@ であるとされる。 ◎ An attribute or operation is said to be unforgeable on a given interface A if the attribute or operation is declared on A, and is annotated with the [Unforgeable] extended attribute.

`Unforgeable$x `拡張属性$は： ◎ ↓

• `引数をとらない$ことが要求される。 ◎ The [Unforgeable] extended attribute must take no arguments.
• ［ `正則~属性$, `静的$oPでない`演算$ ］以外の所に現れては~MUST_NOT。 ◎ The [Unforgeable] extended attribute must not appear on anything other than a regular attribute or a non-static operation.＼
• ある演算~上に現れるならば、その~ifc上で同じ識別子を持つ他のすべての演算~上にも現れ~MUST。 ◎ If it does appear on an operation, then it must appear on all operations with the same identifier on that interface.
• `~ns$上で宣言される属性~上に利用されては~MUST_NOT。 ◎ The [Unforgeable] extended attribute must not be used on an attribute declared on a namespace.

~ifc %A 上の［ 属性／演算 ］ %m が`偽装-不能$である場合、 %A を自身の`継承d~ifc$に含むような別の~ifc %B は，`識別子$が %m と同じである［ `正則~属性$, `静的$oPでない`演算$ ］のいずれも持っては~MUST_NOT。 ◎ If an attribute or operation X is unforgeable on an interface A, and A is one of the inherited interfaces of another interface B, then B must not have a regular attribute or non-static operation with the same identifier as X.

[Exposed=Window]
interface A1 {
[Unforgeable] readonly attribute DOMString x;
};
[Exposed=Window]
interface B1 : A1 {
  void x();  /* 
妥当でない
— `A1^T の `x^M で隠蔽されるので。
◎
Invalid; would be shadowed by A1’s x.
 */
};

[Exposed=Window]
interface B2 : A1 { };
B2 includes M1;
interface mixin M1 {
  void x();  /* 
妥当でない
— `B2^T における `x^M の複製は `A1^T の `x^M で隠蔽されるので。
◎
Invalid; B2’s copy of x would be shadowed by A1’s x.
 */
};

`Unforgeable$x の利用に課される特有の要件については、 `es-attributes$sec, `es-operations$sec, `es-platform-objects$sec, `es-legacy-platform-objects$sec, `legacy-platform-object-defineownproperty$sec を見よ。 ◎ See §3.6.7 Attributes, §3.6.8 Operations, §3.7 Platform objects implementing interfaces, §3.8 Legacy platform objects and §3.8.3 [[DefineOwnProperty]] for the specific requirements that the use of [Unforgeable] entails.

[Exposed=Window]
interface System {
  [Unforgeable] readonly attribute DOMString username;
  readonly attribute long long loginTime;
};

var %system = getSystem();         /* 
`System^T の~instanceを取得する。
◎
Get an instance of System.
 */

%system.hasOwnProperty("username");             /*  */
%system.hasOwnProperty("loginTime");            /*  */
System.prototype.hasOwnProperty("username");   /*  */
System.prototype.hasOwnProperty("loginTime");  /*  */

try {
  /* 
この~callは失敗することになる — ~propは~configure不能なので。
◎
This call would fail, since the property is non-configurable.
 */
  Object.defineProperty(system, "username", { value: "administrator" });
} catch (%e) { }

/* 
次の `defineProperty^jp ~callは成功する
— `System.prototype.loginTime^c が~configure可能なので。
◎
This defineProperty call would succeed, because System.prototype.loginTime
is configurable.
 */
var %forgedLoginTime = 5;
Object.defineProperty(System.prototype, "loginTime", { value: %forgedLoginTime });

%system.loginTime;  /* 
よって，これは今や %forgedLoginTime に評価される。
◎
So this now evaluates to forgedLoginTime.
 */

3.6.1. ~ifc~obj

所与の`~ifc$ %I 用の`~ifc~obj$ %O は、`組込みの関数~obj$である： ◎ The interface object for a given interface is a built-in function object.＼

• %O は、 %I 上に定義される各［ `定数$／`静的~演算$ ］ごとに対応する~propを持つ — 詳細は `es-constants$sec, `es-operations$sec にて述べる。 ◎ It has properties that correspond to the constants and static operations defined on that interface, as described in sections §3.6.6 Constants and §3.6.8 Operations.
• %I は `Constructor$x `拡張属性$を伴って宣言されている場合、 %O を`構築子$として~callして， %I を実装する~objを作成できる。 %I を関数として~callした場合、例外が投出される。 ◎ If the interface is declared with a [Constructor] extended attribute, then the interface object can be called as a constructor to create an object that implements that interface. Calling that interface as a function will throw an exception.
• %I は `Constructor$x `拡張属性$を伴わずに宣言されている場合、`構築子$として~callしようが関数として~callしようが，例外が投出される。 ◎ Interface objects whose interfaces are not declared with a [Constructor] extended attribute will throw when called, both as a function and as a constructor.
• %I は非~呼戻`~ifc$である場合、 %O には`~ifc原型~obj$と呼ばれる~objが結付けられる — それは、 %I 上に定義される各［ `正則~属性$ ／ `正則~演算$ ］ごとに対応する~propを持つ — 詳細は `interface-prototype-object$sec にて述べる。 ◎ An interface object for a non-callback interface has an associated object called the interface prototype object. This object has properties that correspond to the regular attributes and regular operations defined on the interface, and is described in more detail in §3.6.3 Interface prototype object.

注記： `~ifc~obj$は `関数~obj$なので、 `typeof^c 演算子が適用されたときは， "`function^jv" を返すことになる。 ◎ Note: Since an interface object is a function object the typeof operator will return "function" when applied to an interface object.

3.6.2. 有名~構築子

`有名~構築子$は、`識別子$nCを伴う 1 個~以上の `NamedConstructor$x `拡張属性$に因り存在することになる，`組込みの関数~obj$である。 それは、その拡張属性が現れる`~ifc$（以下 %I とする）を実装する~objの構築を可能にする。 ◎ A named constructor that exists due to one or more [NamedConstructor] extended attributes with a given identifier is a built-in function object. It allows constructing objects that implement the interface on which the [NamedConstructor] extended attributes appear.

`有名~構築子$の記述に挙げられる手続きは、例外を投出しないならば， %I を実装する~objを返さ~MUST。 この~objに`関連する~Realm$は、有名~構築子のそれと同じで~MUST。 ◎ If the actions listed in the description of the constructor return normally, then those steps must return an object that implements interface I. This object’s relevant Realm must be the same as that of the named constructor.

3.6.3. ~ifc原型~obj

定義されたどの非~呼戻`~ifc$に対しても、その~ifcが `NoInterfaceObject$x `拡張属性$を伴って宣言されたかどうかに関わらず，対応する `~ifc原型~obj@ が存在し~MUST。 ◎ There must exist an interface prototype object for every non-callback interface defined, regardless of whether the interface was declared with the [NoInterfaceObject] extended attribute.

加えて，`~ifc原型~obj$は、次に挙げるものから宣言的に~propを取得する ⇒＃ `es-stringifier$sec, `es-iterators$sec, `es-iterable$sec, `es-maplike$sec, `es-setlike$sec ◎ Additionally, interface prototype objects get properties declaratively from: • §3.6.8.2 Stringifiers, • §3.6.9 Common iterator behavior, • §3.6.10 Iterable declarations, • §3.6.11 Maplike declarations, and • §3.6.12 Setlike declarations.

これらの~propを，代わりに命令的に定義する。 ◎ Define those properties imperatively instead.

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

partial interface Window {
  attribute Foo foo;
};

`~ifc原型~obj$の `~class文字列$は、次の連結とする ⇒＃ `~ifc$の`識別子$, 文字列 `Prototype^l ◎ The class string of an interface prototype object is the concatenation of the interface’s identifier and the string "Prototype".

3.6.4. 旧来の呼戻~ifc~obj

所与の`~ifc$ %I 用の`旧来の呼戻~ifc~obj$は、`組込みの関数~obj$であり、下の `es-constants$sec にて述べるように， %I 上に定義される`定数$のそれぞれに対応する~propを持つ。 ◎ The legacy callback interface object for a given callback interface is a built-in function object. It has properties that correspond to the constants defined on that interface, as described in sections §3.6.6 Constants.

注記： `旧来の呼戻~ifc~obj$は `関数~obj$なので、 `typeof^c 演算子が適用されたときは， "`function^jv" を返すことになる。 ◎ Note: Since a legacy callback interface object is a function object the typeof operator will return "function" when applied to a legacy callback interface object.

3.6.5. 有名~prop~obj

`Global$x `拡張属性$を伴って宣言されていて, かつ `有名~propを~support$する どの`~ifc$に対しても、その~ifcに対応する `有名~prop~obj@ と呼ばれる~objが，当の有名~propが公開される~ifc上に存在し~MUST。 ◎ For every interface declared with the [Global] extended attribute that supports named properties, there must exist an object known as the named properties object for that interface on which named properties are exposed.

`有名~prop~obj$の `~class文字列$は、次の連結とする ⇒＃ `~ifc$の`識別子$, 文字列 `Properties^l ◎ The class string of a named properties object is the concatenation of the interface’s identifier and the string "Properties".

3.6.6. 定数

`定数$は［ `~ifc~obj$ ／ `旧来の呼戻~ifc~obj$ ／ `~ifc原型~obj$ ］上に — 当の~ifcは `Global$x `拡張属性$を伴って宣言されているときには，~ifcを実装する単独の~obj上に — 公開される。 ◎ Constants are exposed on interface objects, legacy callback interface objects, interface prototype objects, and on the single object that implements the interface, when an interface is declared with the [Global] extended attribute.

3.6.7. 属性

`静的~属性$は、`~ifc~obj$上に公開される。 `正則~属性$は、`~ifc原型~obj$上に公開される — ただし，［ 属性は`偽装-不能$である／ 当の~ifcは `Global$x `拡張属性$を伴って宣言されている ］事例では、その~ifcを実装する どの~objにも公開される。 ◎ Static attributes are exposed on the interface object. Regular attributes are exposed on the interface prototype object, unless the attribute is unforgeable or if the interface was declared with the [Global] extended attribute, in which case they are exposed on every object that implements the interface.

注記： 1 個の~IDL属性に対応する~propは 1 個に限られるが、~accessor~prop［ 取得子／設定子 ］には，［［ その~IDL属性に対応する~prop ］が~accessされた ］~objを指す `this^jv 値が渡されるので、それらの~propは，~instanceに特有の~dataを公開できる。 ◎ Note: Although there is only a single property for an IDL attribute, since accessor property getters and setters are passed a this value for the object on which property corresponding to the IDL attribute is accessed, they are able to expose instance-specific data.

注記： `読専$な`属性$に対応する~propへの代入を試みた結果は、それを行う~scriptが~strict-modeであるかどうかに依存して異なる挙動になる。 ~strict-modeの場合、その種の代入により `TypeError^jE が投出されることになる。 ~strict-modeでない場合、代入の試みは無視されることになる。 ◎ Note: Attempting to assign to a property corresponding to a read only attribute results in different behavior depending on whether the script doing so is in strict mode. When in strict mode, such an assignment will result in a TypeError being thrown. When not in strict mode, the assignment attempt will be ignored.

3.6.8. 演算

［ `~ifc$上に定義され, `公開されて$いる`演算$ ］の各 一意な`識別子$ごとに，対応する~propが存在する。 `静的~演算$は、`~ifc~obj$上に公開される。 `正則~演算$は、`~ifc原型~obj$上に公開される — ただし，［ 演算は`偽装-不能$である ／ 当の~ifcは `Global$x `拡張属性$を伴って宣言されている ］事例では、~ifcを実装する どの~obj上にも公開される。 ◎ For each unique identifier of an exposed operation defined on the interface, there exist a corresponding property. Static operations are exposed of the interface object. Regular operations are exposed on the interface prototype object, unless the operation is unforgeable or the interface was declared with the [Global] extended attribute, in which case they are exposed on every object that implements the interface.

     C* - M4
     |
     B - M3
     |
M1 - A - M2*

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

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

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

interface mixin M1 {
  attribute DOMString m1;
};

interface mixin M2 {
  [Default] object toJSON();
  attribute DOMString m2;
};

interface mixin M3 {
  attribute DOMString m3;
};

interface mixin M4 {
  attribute DOMString m4;
};

A includes M1;
A includes M2;
B includes M3;
C includes M4;

{
    "a": "...",
    "m1": "...",
    "m2": "...",
    "c": "...",
    "m4": "..."
}

{
    "c": "...",
    "m4": "..."
}

3.6.9. 反復子に共通する挙動

3.6.10. 可反復~宣言

3.7.1. `SetPrototypeOf^sl

注記： `Window$T ~objに対しては、これが実装されているかどうかは観測し得ない — `WindowProxy$T ~objの存在pにより、 `Window^T ~obj上では， `SetPrototypeOf^sl が直に~callされることは決してないことが確保されるので。 しかしながら，他の~大域~objに対しては、このことは必要とされない。 ◎ Note: For Window objects, it is unobservable whether this is implemented, since the presence of the WindowProxy object ensures that [[SetPrototypeOf]] is never called on a Window object directly. For other global objects, however, this is necessary.

3.8.1. `GetOwnProperty^sl

3.8.2. `Set^sl

3.8.3. `DefineOwnProperty^sl

3.8.4. `Delete^sl

3.8.5. `PreventExtensions^sl

注記: これにより、`旧来の~platform~obj$は 拡張-可能に保たれる — それらに対する `PreventExtensions^sl を失敗させることにより。 ◎ Note: this keeps legacy platform objects extensible by making [[PreventExtensions]] fail for them.

3.8.6. `OwnPropertyKeys^sl

この文書は、`~ifc$を実装している`~platform~obj$（あるいは 例外を表現する~platform~obj ）に対しては，完全な~prop列挙~順序は定義しない。 が、`旧来の~platform~obj$に対しては，定義する — 次に与える `OwnPropertyKeys^sl 内部~methを定義することにより。 ◎ This document does not define a complete property enumeration order for platform objects implementing interfaces (or for platform objects representing exceptions). However, it does for legacy platform objects by defining the [[OwnPropertyKeys]] internal method as follows.

3.8.7. 各種 抽象~演算

3.12.1. ~DOMException~custom言語束縛

~ES言語束縛における `DOMException$T 用の`~ifc原型~obj$の `Prototype^sl `内部~slot$は、`~ifc原型~objを作成する$抽象~演算に定義されるように，内在的~obj `ErrorPrototype$jI に設定され~MUST。 ◎ In the ECMAScript binding, the interface prototype object for DOMException has its [[Prototype]] internal slot set to the intrinsic object %ErrorPrototype%, as defined in the create an interface prototype object abstract operation.

加えて，実装は、~native `Error$jt ~objに［ 特別な力／標準でない~prop ］を与える場合（ `stack^jp ~propなど），それらも `DOMException$T の各~instanceに公開するべきである。 ◎ Additionaly, if an implementation gives native Error objects special powers or nonstandard properties (such as a stack property), it should also expose those on DOMException instances.

3.12.2. 例外~obj

`単純例外$は、対応する型の~native ~ES~objにより表現される。 ◎ Simple exceptions are represented by native ECMAScript objects of the corresponding type.

`DOMException$T は、`DOMException$T ~ifcを実装する`~platform~obj$により表現される。 ◎ A DOMException is represented by a platform object that implements the DOMException interface.

3.12.3. 例外の作成-法と投出-法

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

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

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

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

3.12.4. 例外の取扱い

他が指定されない限り、この文書の要件に因り~ES~runtime意味論が呼出され，例外が投出されて終端したときは、その例外は~call元まで（そこで~catchされない場合は更にその~call元まで，等々）伝播し~MUST。 ◎ Unless specified otherwise, whenever ECMAScript runtime semantics are invoked due to requirements in this document and end due to an exception being thrown, that exception must propagate to the caller, and if not caught there, to its caller, and so on.

文書~規約により，この文書に指定される~algoは、［ `例外が投出された@ ときにとる正確な手続きを指定するか, または `中途完了$を明示的に取扱う ］ことにより，投出された例外を~~捕えることもある。 ◎ Per Document conventions, an algorithm specified in this document may intercept thrown exceptions, either by specifying the exact steps to take if an exception was thrown, or by explicitly handling abrupt completions.

[Exposed=Window]
interface Dahut {
  attribute DOMString type;
};

[Exposed=Window]
interface ExceptionThrower {
  /* 
この属性は常に `NotSupportedError$E を投出し，決して値を返さない。
◎
This attribute always throws a NotSupportedError and never returns a value.
 */
  attribute long valueOf;
};

var %d = getDahut();              /* 
`Dahut^T の~instanceを得る。
◎
Obtain an instance of Dahut.
 */
var %et = getExceptionThrower();  /* 
`ExceptionThrower^T の~instanceを得る。
◎
Obtain an instance of ExceptionThrower.
 */

try {
  %d.type = { toString: function() { throw "abc"; } };
} catch (%e) {
  /* 
文字列 `abc^l はここで~catchされる。
何故なら、~native~objから文字列への変換の一環として匿名~関数が呼出され，
`DefaultValue^sl, ToPrimitive, ToString のいずれの~algoも，例外を~catchするように定義されていないので。
◎
The string "abc" is caught here, since as part of the conversion
from the native object to a string, the anonymous function
was invoked, and none of the [[DefaultValue]], ToPrimitive or
ToString algorithms are defined to catch the exception.
 */
}

try {
  %d.type = { toString: { } };
} catch (%e) {
  /* 
例外はここで~catchされる。
toString ~propの値である~native~obj上で `Call^sl の呼出しが試みられるので。
◎
An exception is caught here, since an attempt is made to invoke
[[Call]] on the native object that is the value of toString
property.
 */
}

try {
  %d.type = Symbol();
} catch (%e) {
  /* 
例外はここで~catchされる。
`Symbol^jt 値~上で~ES `ToString$A 抽象~演算を呼出そうと試みられるので。
◎
An exception is caught here, since an attempt is made to invoke
the ECMAScript ToString abstract operation on a Symbol value.
 */
}

%d.type = %et;
  /* 
~catchされなかった `NotSupportedError$E は ここで投出される。
`DefaultValue^sl ~algoは， `ExceptionThrower^T ~obj上の `valueOf^jp ~propの値の取得-を試みるので。
例外はこの~code~blockの外へ伝播する。
◎
An uncaught "NotSupportedError" DOMException is thrown here, since the
[[DefaultValue]] algorithm attempts to get the value of the
"valueOf" property on the ExceptionThrower object. The exception
propagates out of this block of code.
 */