Web IDL

1. はじめに

この節は参考情報です。

この現行標準は、Webブラウザーで実装されることを目的としたインターフェースを記述するためのインターフェース定義言語、Web IDLを定義します。Web IDLは、Webプラットフォームにおける一般的なスクリプトオブジェクトの振る舞いをより容易に指定できるようにする、さまざまな機能を備えたIDLのバリエーションです。Web IDLで記述されたインターフェースがJavaScript実行環境内の構造にどのように対応するかも、ここで詳述します。

具体的には、Web IDLはWebプラットフォームオブジェクトの表面APIを定義するための構文と、APIがJavaScriptの構造としてどのように現れるかを詳細に定義するJavaScriptバインディングを提供します。これにより、グローバルプロパティの追加、数値入力の処理、イテレーション動作の公開などの一般的な作業が、Webプラットフォーム仕様間で一貫性を保てるようになります。各仕様はWeb IDLでインターフェースを記述し、API固有の詳細は文章で規定します。

「JavaScript」という用語は、公式のECMAScriptという名称ではなく、より広く知られているECMA-262を指すために使用しています。

2. インターフェース定義言語

この節では、Web IDLという言語について説明します。これはWebプラットフォームのAPIのインターフェースを定義するために使用できます。Web APIを定義する仕様は、定義しているAPIのインターフェース（オブジェクトが持つ状態や振る舞い）を記述するIDLフラグメントを1つ以上含めることができます。 IDLフラグメントは、Definitions文法記号に一致する定義の列です。 実装がサポートするIDLフラグメントの集合に順序はありません。 完全な文法と記法の説明についてはIDL文法を参照してください。

IDLフラグメントに現れることができる 定義の種類は以下の通りです： インターフェース、 パーシャルインターフェース定義、 インターフェースミックスイン、 パーシャルミックスイン定義、 コールバック関数、 コールバックインターフェース、 名前空間、 パーシャル名前空間定義、 辞書、 パーシャル辞書定義、 型定義、 includes文です。 これらはすべて以下の節で定義されています。

定義（Definitionに一致するもの）は、 拡張属性（ExtendedAttributeListに一致するもの）のリストを前置することができ、 言語バインディングでの定義の扱い方を制御します。 この仕様で定義されている言語バインディング非依存の拡張属性については§ 2.14 拡張属性で、 JavaScriptバインディング固有のものについては§ 3.3 拡張属性で説明します。

[extended_attributes]
interface identifier {
  /* interface_members... */
};

Definitions ::
    ExtendedAttributeList Definition Definitions
    ε

Definition ::
    CallbackOrInterfaceOrMixin
    Namespace
    Partial
    Dictionary
    Enum
    Typedef
    IncludesStatement

[Exposed=Window]
interface Paint { };

[Exposed=Window]
interface SolidColor : Paint {
  attribute double red;
  attribute double green;
  attribute double blue;
};

[Exposed=Window]
interface Pattern : Paint {
  attribute DOMString imageURL;
};

[Exposed=Window]
interface GraphicalWindow {
  constructor();
  readonly attribute unsigned long width;
  readonly attribute unsigned long height;

  attribute Paint currentPaint;

  undefined drawRectangle(double x, double y, double width, double height);

  undefined drawText(double x, double y, DOMString text);
};

2.1. 名前

すべてのインターフェース、 パーシャルインターフェース定義、 名前空間、 パーシャル名前空間定義、 辞書、 パーシャル辞書定義、 列挙型、 コールバック関数、 コールバックインターフェースおよび 型定義（まとめて名前付き定義と呼ぶ）、 そしてすべての定数、 属性、 辞書メンバーには 識別子があり、一部の 操作にも識別子がある。 識別子は宣言内のどこかにidentifierトークンとして現れることで決まる：

• 名前付き定義の場合、 identifierトークンは interface、namespace、 dictionary、enum、 またはcallbackキーワードの直後に現れ、 その定義の識別子を決定する。

  interface interface_identifier { /* interface_members... */ };
  partial interface interface_identifier { /* interface_members... */ };
  namespace namespace_identifier { /* namespace_members... */ };
  partial namespace namespace_identifier { /* namespace_members... */ };
  dictionary dictionary_identifier { /* dictionary_members... */ };
  partial dictionary dictionary_identifier { /* dictionary_members... */ };
  enum enumeration_identifier { "enum", "values" /* , ... */ };
  callback callback_identifier = return_type (/* arguments... */);
  callback interface callback_interface_identifier { /* interface_members... */ };
  

• 属性、 型定義、 辞書メンバーの場合、 宣言末尾のセミコロン直前に現れる最後のidentifierトークンが識別子となる。

  [extended_attributes]
  interface identifier {
    attribute type attribute_identifier;
  };
  
  typedef type typedef_identifier;
  
  dictionary identifier {
    type dictionary_member_identifier;
  };
  

• 定数の場合、 等号の直前のidentifierトークンが識別子となる。

  const type constant_identifier = 42;

• 操作の場合、 戻り値型の後、かつ括弧開きの前に現れるidentifierトークン（すなわちOptionalOperationName文法記号で一致するもの）が操作の識別子となる。もし そのようなidentifierトークンがなければ、操作には識別子はない。

  interface interface_identifier {
    return_type operation_identifier(/* arguments... */);
  };
  

注: 操作は、getterやsetterなど特殊な操作を宣言する際には識別子を持たない場合がある。

これらすべての構造において、識別子はidentifierトークンの値から 先頭のU+005F（_）を除いたものとなる。

注: 先頭のU+005F（_）は、識別子が予約語のように見えるのを回避するために使用される。たとえば「interface」という名前のインターフェースを定義できるようにするためである。識別子を元に戻すために先頭のU+005F（_）は削除される。

操作の引数は識別子としてやや広い範囲を取ることができる。操作宣言において、引数の識別子は型の直後に指定され、identifierトークンか、 ArgumentNameKeyword記号に一致するキーワードのいずれかで与えられる。これらのキーワードが使われる場合、先頭のアンダースコアでエスケープする必要はない。

interface interface_identifier {
  return_type operation_identifier(argument_type argument_identifier /* , ... */);
};

ArgumentNameKeyword ::
    attribute
    callback
    const
    constructor
    deleter
    dictionary
    enum
    getter
    includes
    inherit
    interface
    iterable
    maplike
    mixin
    namespace
    partial
    readonly
    required
    setlike
    setter
    static
    stringifier
    typedef
    unrestricted

もしidentifierトークンが使われた場合、 操作引数の識別子はそのトークンの値から 先頭のU+005F（_）を除いたものとなる。 代わりにArgumentNameKeywordキーワードトークンが使われた場合、 操作引数の識別子はそのトークンそのものとなる。

上記IDL構造の識別子（操作引数以外）は "constructor"、"toString" であってはならず、 またU+005F（_）で始まってはならない。これらは予約済み識別子と呼ばれる。

「toJSON」識別子は予約済み識別子ではないが、 通常の操作でのみ、 オブジェクトをJSON型に変換するために使用しなければならない。 詳細は§ 2.5.3.1 toJSONで説明する。

注: 特定の構造に対する識別子名のさらなる制限は後続の節で規定される場合がある。

ある実装がサポートするIDLフラグメント集合内では、 すべてのインターフェース、 名前空間、 辞書、 列挙型、 コールバック関数、 コールバックインターフェース、 型定義の識別子は、 他のインターフェース、 名前空間、 辞書、 列挙型、 コールバック関数、 コールバックインターフェース、 型定義の識別子と同じであってはならない。

IDLフラグメント内では、 定義への参照は 参照先定義の宣言より後に現れる必要はない。参照はIDLフラグメントをまたいで行うこともできる。

[Exposed=Window]
interface B : A {
  undefined f(SequenceOfLongs x);
};

[Exposed=Window]
interface A {
};

typedef sequence<long> SequenceOfLongs;

// 型定義の識別子: "number"
typedef double number;

// インターフェースの識別子: "System"
[Exposed=Window]
interface System {

  // 操作の識別子:          "createObject"
  // 操作引数の識別子: "interface"
  object createObject(DOMString _interface);

  // 操作引数の識別子: "interface"
  sequence<object> getObjects(DOMString interface);

  // 操作は識別子なし; getterを宣言
  getter DOMString (DOMString keyName);
};

// インターフェースの識別子: "TextField"
[Exposed=Window]
interface TextField {

  // 属性の識別子: "const"
  attribute boolean _const;

  // 属性の識別子: "value"
  attribute DOMString? _value;
};

2.2. インターフェース

IDLフラグメントはオブジェクト指向システムの記述に用いられます。このようなシステムでは、オブジェクトは同一性を持ち、状態と振る舞いのカプセル化である実体です。 インターフェースは （interface InterfaceRestに一致）、 そのインターフェースを実装するオブジェクトが公開する状態と振る舞いを宣言する定義です。

[extended_attributes]
interface identifier {
  /* interface_members... */
};

インターフェースは インターフェースメンバー （InterfaceMembersに一致）として 一連のメンバーを仕様します。これらはインターフェース宣言の中括弧内に現れるメンバーです。

Web IDLのインターフェースは、そのインターフェースを実装するオブジェクトがどのように振る舞うかを記述します。オブジェクト指向言語のバインディングでは、特定のIDLインターフェースを実装するオブジェクトは、その状態の参照・変更、およびインターフェースで記述された振る舞いの呼び出し手段を提供することが期待されます。

インターフェースは他のインターフェースを継承するよう定義できます。 インターフェースの識別子の後に U+003A（:）と識別子が続く場合、 その識別子が継承元インターフェースです。 あるインターフェースが別のインターフェースを継承している場合、そのオブジェクトは継承元インターフェースも実装します。したがって、継承元インターフェースのメンバーも備えます。

interface identifier : identifier_of_inherited_interface {
  /* interface_members... */
};

メンバーの出現順はJavaScriptバインディングのプロパティ列挙に影響します。

インターフェースは、継承元インターフェースと同じ名前のメンバーを指定することもできます。派生インターフェースを実装するオブジェクトは、派生インターフェース上のそのメンバーを公開します。言語バインディングによっては、上書きされたメンバーがオブジェクト上でアクセス可能かどうかは異なります。

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

[Exposed=Window]
interface B : A {
  undefined f();
  undefined g(DOMString x);
};

[Object.prototype: the Object prototype object]
     ↑
[A.prototype: interface prototype object for A]
     ↑
[B.prototype: interface prototype object for B]
     ↑
[instanceOfB]

あるインターフェースAの継承インターフェースは、 Aが直接または間接的に継承するすべてのインターフェースの集合です。Aが他のインターフェースを継承しない場合、その集合は空です。そうでなければ、その集合にはAが継承するインターフェースBと、Bの継承インターフェースすべてが含まれます。

インターフェースの継承階層に循環があってはなりません。つまり、インターフェースAは自分自身を継承できず、 またAを継承するBを継承することもできません（そしてその先も同様）。

一般的なインターフェースの多重継承はサポートされません。また、オブジェクトが任意のインターフェース集合を実装することもできません。オブジェクトは単一のインターフェースAを実装すると定義でき、その場合Aの継承インターフェースすべても実装します。 さらに、includes文を用いることで、 インターフェースAを実装するオブジェクトが、 Aがincludeする インターフェースミックスインのメンバーも常に含むものとできます。

各インターフェースメンバーには、拡張属性（ExtendedAttributeListに一致）のリストを 前置することができ、言語バインディングでの扱い方を制御します。

[extended_attributes]
interface identifier {

  [extended_attributes]
  const type constant_identifier = 42;

  [extended_attributes]
  attribute type identifier;

  [extended_attributes]
  return_type identifier(/* arguments... */);
};

インターフェースのIDLは、 パーシャルインターフェース 定義（partial interface PartialInterfaceRestに一致）によって複数の部分に分割できます。 パーシャルインターフェース定義の識別子は、 インターフェース定義の識別子と一致しなければなりません。各パーシャルインターフェース上のメンバーはすべて、そのインターフェース自体のメンバーとみなされます。

interface SomeInterface {
  /* interface_members... */
};

partial interface SomeInterface {
  /* interface_members... */
};

注: パーシャルインターフェース定義は、仕様の編集上の補助として意図されており、インターフェース定義を文書の複数箇所や複数文書に分割するために利用されます。

インターフェース定義とそのパーシャルインターフェース定義の出現順は問いません。

注: パーシャルインターフェース定義では他のインターフェースの継承を指定できません。継承は元のインターフェース定義で指定します。

インターフェースが言語の構造にどう対応するかは、該当言語バインディングで定まります。

インターフェースに適用可能な拡張属性は以下の通りです： [CrossOriginIsolated]、 [Exposed]、 [Global]、 [LegacyFactoryFunction]、 [LegacyNoInterfaceObject]、 [LegacyOverrideBuiltIns]、 [LegacyWindowAlias]、 [SecureContext]。

パーシャルインターフェースに適用可能な拡張属性は以下の通りです： [CrossOriginIsolated]、 [Exposed]、 [LegacyOverrideBuiltIns]、 [SecureContext]。

インターフェースは必ず[Exposed] 拡張属性で注釈されていなければなりません。

CallbackOrInterfaceOrMixin ::
    callback CallbackRestOrInterface
    interface InterfaceOrMixin

InterfaceOrMixin ::
    InterfaceRest
    MixinRest

InterfaceRest ::
    identifier Inheritance { InterfaceMembers } ;

Partial ::
    partial PartialDefinition

PartialDefinition ::
    interface PartialInterfaceOrPartialMixin
    PartialDictionary
    Namespace

PartialInterfaceOrPartialMixin ::
    PartialInterfaceRest
    MixinRest

PartialInterfaceRest ::
    identifier { PartialInterfaceMembers } ;

InterfaceMembers ::
    ExtendedAttributeList InterfaceMember InterfaceMembers
    ε

InterfaceMember ::
    PartialInterfaceMember
    Constructor

PartialInterfaceMembers ::
    ExtendedAttributeList PartialInterfaceMember PartialInterfaceMembers
    ε

PartialInterfaceMember ::
    Const
    Operation
    Stringifier
    StaticMember
    Iterable
    AsyncIterable
    ReadOnlyMember
    ReadWriteAttribute
    ReadWriteMaplike
    ReadWriteSetlike
    InheritAttribute

Inheritance ::
    : identifier
    ε

[Exposed=Window]
interface Animal {
  attribute DOMString name;
};

[Exposed=Window]
interface Human : Animal {
  attribute Dog? pet;
};

[Exposed=Window]
interface Dog : Animal {
  attribute Human? owner;
};

[Exposed=Window]
interface Node {
  readonly attribute DOMString nodeName;
  readonly attribute Node? parentNode;
  Node appendChild(Node newChild);
  undefined addEventListener(DOMString type, EventListener listener);
};

callback interface EventListener {
  undefined handleEvent(Event event);
};

var node = getNode();                                // Nodeのインスタンス取得

var listener = {
  handleEvent: function(event) {
    // ...
  }
};
node.addEventListener("click", listener);            // これは動作する。

node.addEventListener("click", function() { ... });  // これも同様に動作する。

var node = getNode();  // Nodeのインスタンス取得

var newNode = {
  nodeName: "span",
  parentNode: null,
  appendChild: function(newchild) {
    // ...
  },
  addEventListener: function(type, listener) {
    // ...
  }
};
node.appendChild(newNode);  // これはTypeError例外になる。

2.3. インターフェースミックスイン

インターフェースミックスインは （interface MixinRestに一致する）定義であり、 1つ以上のインターフェースにincludeされることができる状態や振る舞いを宣言し、 そのミックスインをincludeしたインターフェースを実装するオブジェクトによって公開されます。

interface mixin identifier {
  /* mixin_members... */
};

注: インターフェースミックスインはパーシャルインターフェース同様、 仕様の編集補助として意図されており、機能のまとまりをグループ化し、複数のインターフェース（場合によっては複数文書）にincludeできるようにします。 これらは言語バインディングを介して公開されることを目的としたものではありません。 § 2.3.1 ミックスインとパーシャルの利用で、 パーシャルインターフェース、 インターフェースミックスイン、 パーシャルインターフェースミックスイン の使い分けについて案内しています。

インターフェースミックスインは、 インターフェースミックスインメンバー （MixinMembersに一致）を定義します。 これらは、定数、 通常の操作、 通常の属性、 ストリギファイア であり、ミックスイン宣言の中括弧内に現れます。

これらの定数、 通常の操作、 通常の属性、 ストリギファイアは、 それらをincludeした インターフェース上に定義された場合と同様に、 オブジェクトが持つ振る舞いを記述します。

静的属性、 静的操作、 特殊操作、 イテラブル宣言、 非同期イテラブル宣言、 Maplike宣言、 Setlike宣言 は、インターフェースミックスイン宣言には現れません。

インターフェース同様、インターフェースミックスインのIDLは、 パーシャルインターフェースミックスイン 定義（partial interface MixinRestに一致）によって複数部分に分割できます。 パーシャルインターフェースミックスイン定義の識別子は、 インターフェースミックスイン定義の 識別子と一致しなければなりません。 各パーシャルインターフェースミックスイン定義に現れるメンバーは、インターフェースミックスイン自体のメンバーとみなされ、 さらにそのインターフェースミックスインをincludeするインターフェースのメンバーともみなされます。

interface mixin SomeMixin {
  /* mixin_members... */
};

partial interface mixin SomeMixin {
  /* mixin_members... */
};

メンバーの出現順はJavaScriptバインディングのプロパティ列挙に影響します。

なお、インターフェースや辞書とは異なり、 インターフェースミックスインは型を生成しません。

この仕様で定義されている拡張属性のうち、 インターフェースミックスインに適用できるのは [CrossOriginIsolated]、 [Exposed]、 [SecureContext] のみです。

includes文は （IncludesStatementに一致）定義であり、 すべてのインターフェースI （最初の識別子で特定）を実装するオブジェクトが インターフェースミックスインM（2番目の識別子で特定）のメンバーを 追加で含むことを宣言するために使われます。 インターフェースIは インターフェースミックスインM をincludeすると言います。

interface_identifier includes mixin_identifier;

最初の識別子はインターフェースIを参照しなければなりません。 2番目の識別子はインターフェースミックスインMを参照しなければなりません。

Mの各メンバーは、 Mをincludeするすべての インターフェースI、J、K…の メンバーとみなされ、 まるで各メンバーのコピーが作られたかのように扱われます。 つまり、Mのメンバーmについて、インターフェースIはm_Iという メンバーを持ち、 インターフェースJはメンバーm_Jを、 インターフェースKはメンバーm_Kを持つことになります。 ホストインターフェースは、 m_I、m_J、m_Kに対して、それぞれI、J、Kです。

注: JavaScriptでは、インターフェースミックスインMのメンバーとして宣言され、組み込み関数オブジェクトを値とするデータプロパティとして公開される各通常の操作は、関連付けられたインターフェースがMをincludeする各インターフェースプロトタイプオブジェクトにおいて、互いに異なる組み込み関数オブジェクトになります。同様に、属性についても、アクセサプロパティの各コピーのgetterとsetterはそれぞれ異なる組み込み関数オブジェクトを持ちます。

includes文の出現順は、ホストインターフェースがどの順で インターフェースミックスインをincludeするかに影響します。

メンバーの順序は明確に規定されていません。 特にインターフェースミックスインが複数文書で定義される場合は未定義です。 issue #432で議論されています。

この仕様で定義される拡張属性のうち、includes文に適用できるものはありません。

interface Entry {
  readonly attribute unsigned short entryType;
  // ...
};

interface mixin Observable {
  undefined addEventListener(DOMString type,
                        EventListener listener,
                        boolean useCapture);
  // ...
};

Entry includes Observable;

var e = getEntry();          // Entryのインスタンス取得
typeof e.addEventListener;   // "function"になる

CallbackOrInterfaceOrMixin ::
    callback CallbackRestOrInterface
    interface InterfaceOrMixin

InterfaceOrMixin ::
    InterfaceRest
    MixinRest

Partial ::
    partial PartialDefinition

PartialDefinition ::
    interface PartialInterfaceOrPartialMixin
    PartialDictionary
    Namespace

MixinRest ::
    mixin identifier { MixinMembers } ;

MixinMembers ::
    ExtendedAttributeList MixinMember MixinMembers
    ε

MixinMember ::
    Const
    RegularOperation
    Stringifier
    OptionalReadOnly AttributeRest

IncludesStatement ::
    identifier includes identifier ;

2.3.1. ミックスインとパーシャルの利用

この節は参考情報です。

インターフェースミックスインは、属性、定数、操作を 複数のインターフェース間で共有できます。 単一のインターフェースのみ拡張する予定なら、 パーシャルインターフェースの利用を検討してください。

例えば、次のような方法の代わりに：

interface mixin WindowSessionStorage {
  readonly attribute Storage sessionStorage;
};
Window includes WindowSessionStorage;

こうしてください：

partial interface Window {
  readonly attribute Storage sessionStorage;
};

さらに、他の仕様が提供するインターフェースミックスイン を拡張することで、ウィンドウとワーカーの両方のコンテキストで属性、定数、または操作の集合を 公開するといった、一般的なユースケースに対応することもできます。

例えば、よくある冗長な方法の代わりに：

interface mixin GlobalCrypto {
  readonly attribute Crypto crypto;
};

Window includes GlobalCrypto;
WorkerGlobalScope includes GlobalCrypto;

WindowOrWorkerGlobalScope インターフェースミックスインを パーシャルインターフェースミックスインで拡張できます：

partial interface mixin WindowOrWorkerGlobalScope {
  readonly attribute Crypto crypto;
};

2.4. コールバックインターフェース

コールバックインターフェースは、定義であり、 callback interface identifier { CallbackInterfaceMembers } ;に一致します。 § 2.12 インターフェースを実装するオブジェクトで述べるように、どんなオブジェクトでも実装できます。

注: コールバックインターフェースはインターフェースではありません。名前や構文は、以前の規格バージョンでこれらの概念がより共通していた名残です。

コールバックインターフェースは コールバックインターフェースメンバー （CallbackInterfaceMembersに一致）を仕様します。 これはインターフェース宣言の中括弧内に現れるメンバーです。

callback interface identifier {
  /* interface_members... */
};

注: よく似た名前のコールバック関数定義も参照してください。

コールバックインターフェースは、正確に1つの通常の操作を定義しなければなりません。

コールバックインターフェースが定数を宣言する場合は、必ず[Exposed] 拡張属性で注釈しなければなりません。

CallbackRestOrInterface ::
    CallbackRest
    interface identifier { CallbackInterfaceMembers } ;

CallbackInterfaceMembers ::
    ExtendedAttributeList CallbackInterfaceMember CallbackInterfaceMembers
    ε

CallbackInterfaceMember ::
    Const
    RegularOperation

2.5. メンバー

インターフェース、インターフェースミックスイン、名前空間は、それぞれ メンバー （それぞれInterfaceMembers、 MixinMembers、 NamespaceMembersに一致）を仕様します。 これらは中括弧内に現れる定数、 属性、 操作やその他の宣言です。 属性は、その インターフェース、 インターフェースミックスイン、 名前空間を実装するオブジェクトが公開する状態を記述し、 操作はオブジェクト上で呼び出せる振る舞いを記述します。 定数は、システムのオブジェクト利用者に便宜的に公開される名前付き定数値を宣言します。

各種インターフェースやインターフェースミックスインで定義されるメンバーの コンストラクタ手順、 getter手順、 setter手順、 メソッド手順は、 this値（そのメンバーが宣言されるインターフェース型、またはそのメンバーが宣言されるミックスインをincludeするインターフェース型のIDL値）にアクセスできます。

setter手順は、 与えられた値にもアクセスでき、 これは属性が宣言された型のIDL値です。

インターフェース、 インターフェースミックスイン、 コールバックインターフェース、 名前空間は それぞれ異なるセットのメンバーをサポートします。 詳細は§ 2.2 インターフェース、 § 2.3 インターフェースミックスイン、 § 2.4 コールバックインターフェース、 § 2.6 名前空間で規定されており、次の参考表にまとめます：

2.5.1. 定数

定数は、 （Constに一致）名前に定数値を束縛するための宣言です。 定数はインターフェースやコールバックインターフェース上に現れます。

定数はこれまで主に、列挙型スタイルの名前付き整数コードの定義に使われてきましたが、Webプラットフォームではこの設計パターンから文字列の利用へと移行しています。 この機能を使用したい編集者は、進める前に issueを提出 して議論することが強く推奨されます。

const type constant_identifier = 42;

定数の識別子は、 同じインターフェースメンバーやコールバックインターフェースメンバーの識別子と重複してはなりません（同じインターフェース、 またはコールバックインターフェース上）。 また、"length"、"name"、"prototype"であってはなりません。

注: これら3つの名前はJavaScriptバインディングのインターフェースオブジェクト上のプロパティ名です。

定数の型（ConstTypeに一致）は、 プリミティブ型以外であってはなりません。 識別子が使われる場合、それはプリミティブ型の型を持つ型定義を参照しなければなりません。

定数宣言のConstValue部分は定数値を与えます。値は 2つのbooleanリテラルトークン（trueとfalse）、 integerトークン、 decimalトークン、 もしくは3つの浮動小数点定数値（-Infinity、Infinity、NaN）のいずれかです。

注: これらの値（文字列と空のシーケンスも含む）は、辞書メンバーのデフォルト値やオプション引数のデフォルト値にも使えます。 ただし、文字列、空のシーケンス[]、デフォルト辞書{}は定数値にはできません。

booleanリテラルトークンtrue、falseの値はIDLのboolean 値trueとfalseです。

integerトークンの型は、定数・辞書メンバー・オプション引数の型と同じです。 integerトークンの値は、§ 2.13 型に示される型の有効範囲を外れてはなりません。

定数値としてInfinity、-Infinity、NaNを指定した場合も、 型に応じてIEEE 754単精度/倍精度浮動小数点値となります：

型unrestricted float、値Infinity

値はIEEE 754単精度正の無限大。

型unrestricted double、値Infinity

値はIEEE 754倍精度正の無限大。

型unrestricted float、値-Infinity

値はIEEE 754単精度負の無限大。

型unrestricted double、値-Infinity

値はIEEE 754倍精度負の無限大。

型unrestricted float、値NaN

値はIEEE 754単精度NaN（ビットパターン0x7fc00000）。

型unrestricted double、値NaN

値はIEEE 754倍精度NaN（ビットパターン0x7ff8000000000000）。

decimalトークンの型は、使われる定数・辞書メンバー・オプション引数の型と同じです。 decimalトークンの値は型の有効範囲を超えてはならず（§ 2.13 型参照）、 Infinity、-Infinity、NaNはfloatやdoubleの値として使えません。

nullトークンの値は、nullというヌラブル型の特別な値です。 nullトークンの型は、使われる定数・辞書メンバー・オプション引数の型と同じです。

定数に割り当てる値の型VTと、定数・辞書メンバー・オプション引数自体の型DTについて、型が互換でなければなりません。 互換とは、DTとVTが一致するか、DTがVTを内包するヌラブル型であり、その内側の型がVTである場合です。

定数は、現れるインターフェースやコールバックインターフェースの特定インスタンスとは関連付けられません。インスタンス上で定数が公開されるかは言語バインディング依存です。

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

定数に適用可能な拡張属性は以下の通りです： [CrossOriginIsolated]、 [Exposed]、 [SecureContext]。

Const ::
    const ConstType identifier = ConstValue ;

ConstValue ::
    BooleanLiteral
    FloatLiteral
    integer

BooleanLiteral ::
    true
    false

FloatLiteral ::
    decimal
    -Infinity
    Infinity
    NaN

ConstType ::
    PrimitiveType
    identifier

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

2.5.2. 属性

属性は、 インターフェースメンバーまたは 名前空間メンバー （inherit AttributeRest、 static OptionalReadOnly AttributeRest、 stringifier OptionalReadOnly AttributeRest、 OptionalReadOnly AttributeRest、 またはAttributeRestに一致）であり、 指定された型と識別子を持つデータフィールドを宣言するために使われます。その値は取得でき、（場合によっては）変更できます。属性には2種類あります：

1. 通常の属性：オブジェクトがそのインターフェースを実装する際、指定された識別子のデータフィールドメンバーを持つことを宣言します。

   interface interface_identifier {
     attribute type identifier;
   };
   

2. 静的属性：インターフェースを実装する特定のオブジェクトとは関連しない属性を宣言するために使われます。

   interface interface_identifier {
     static attribute type identifier;
   };
   

属性にstaticキーワードがなければ 通常の属性を宣言し、ある場合は静的属性となります。 また、インターフェースメンバーだけでなく、 読み取り専用通常の属性は名前空間メンバーにもなり得ます。

属性attrのgetter手順は、「attr getter手順は次の通り：」という文＋リスト、または「attr getter手順は...」という文＋インライン説明で記述します。

属性attrのsetter手順は、「attr setter手順は次の通り：」という文＋リスト、または「attr setter手順は...」という文＋インライン説明で記述します。

注: getter手順を定義するときは、暗黙的にthisにアクセスできます。 setter手順の場合は、暗黙的にthisと与えられた値にアクセスできます。

属性の識別子は、 同じインターフェース上の他のインターフェースメンバーと重複してはなりません。 静的属性の識別子は"prototype"であってはなりません。

属性の型は、attributeキーワードの後に現れる型（Typeに一致）で指定されます。 Typeが識別子か、識別子＋?の場合、 その識別子はインターフェース、列挙型、コールバック関数、コールバックインターフェース、型定義を識別しなければなりません。

typedefを解決した後の属性の型は、以下のいずれかの型（ヌラブル/非ヌラブル）であってはなりません：

• シーケンス型

• 非同期シーケンス型

• 辞書型

• レコード型

• ユニオン型で、ヌラブル／非ヌラブルなシーケンス型・辞書型・レコード型を平坦化されたメンバー型の1つとして持つもの

readonlyキーワードがattributeキーワードの前に現れる場合、その属性は読み取り専用です。 この属性を持つインターフェースを実装するオブジェクトは、その属性への代入を許可しません。代入が単に拒否されるか、無視されるか、例外となるかは言語バインディング依存です。

interface interface_identifier {
  readonly attribute type identifier;
};

型がPromise型の属性は必ず読み取り専用でなければなりません。また、[LegacyLenientSetter]、 [PutForwards]、 [Replaceable]、 [SameObject]の いずれの拡張属性も持てません。

通常の属性で読み取り専用でないものは、 祖先インターフェースからgetterを継承するよう宣言できます。これにより、祖先インターフェースで読み取り専用の属性を派生インターフェースで書き込み可能にできます。 属性がinherit付きで宣言されていればgetterを継承します。 getterを継承する元の読み取り専用属性は、継承する属性が定義されているインターフェースの最も近い祖先インターフェースにある、同じ識別子の属性です。getterの継承元と継承先の属性の型は一致していなければなりません。

注: 文法によりinheritは読み取り専用属性や静的属性には使えません。

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

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

通常の属性宣言にstringifierキーワードが使われている場合、 そのインターフェースを実装するオブジェクトは属性値でストリング化されることを示します。詳細は§ 2.5.5 ストリギファイア参照。

interface interface_identifier {
  stringifier attribute DOMString identifier;
};

通常・静的属性に適用可能な拡張属性は以下の通りです： [CrossOriginIsolated]、 [Exposed]、 [SameObject]、 [SecureContext]。

通常属性にのみ適用可能な拡張属性は以下の通りです： [LegacyLenientSetter]、 [LegacyLenientThis]、 [PutForwards]、 [Replaceable]、 [LegacyUnforgeable]。

ReadOnlyMember ::
    readonly ReadOnlyMemberRest

ReadOnlyMemberRest ::
    AttributeRest
    MaplikeRest
    SetlikeRest

ReadWriteAttribute ::
    AttributeRest

InheritAttribute ::
    inherit AttributeRest

AttributeRest ::
    attribute TypeWithExtendedAttributes AttributeName ;

AttributeName ::
    AttributeNameKeyword
    identifier

AttributeNameKeyword ::
    required

OptionalReadOnly ::
    readonly
    ε

[Exposed=Window]
interface Animal {

  // 任意の文字列値を設定できるシンプルな属性
  readonly attribute DOMString name;

  // 値を代入できる属性
  attribute unsigned short age;
};

[Exposed=Window]
interface Person : Animal {

  // Animalからgetter動作を継承する属性。Personの説明に記載不要。
  inherit attribute DOMString name;
};

2.5.3. 操作

操作は、 インターフェースメンバー、 コールバックインターフェースメンバー、 名前空間メンバー （static RegularOperation、 stringifier、 RegularOperationまたは SpecialOperationに一致）であり、 インターフェースを実装するオブジェクト上で呼び出せる振る舞いを定義します。操作には3種類あります：

1. 通常の操作： インターフェースを実装するオブジェクトが、指定された識別子のメソッドを持つことを宣言します。

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

2. 特殊操作： インターフェースを実装するオブジェクト上で、インデックス付きやストリング化などの特殊な振る舞いを宣言します。

   interface interface_identifier {
     /* special_keyword */ return_type identifier(/* arguments... */);
     /* special_keyword */ return_type (/* arguments... */);
   };
   

3. 静的操作： インターフェースを実装する特定のオブジェクトとは関連しない操作を宣言します。

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

操作に識別子があり、staticキーワードがない場合は通常の操作となります。 宣言に特殊キーワード （Specialやstringifierキーワード）を使っていれば、特殊操作となります。1つの操作で通常操作と特殊操作両方を宣言できます。 詳細は§ 2.5.6 特殊操作参照。 通常操作はインターフェースメンバーだけでなく、 コールバックインターフェースメンバーや名前空間メンバーにもなり得ます。

操作に識別子がない場合、特殊キーワードを用いて特殊操作として宣言しなければなりません。

通常の操作や静的操作の識別子は、 同じインターフェース、 コールバックインターフェース、 名前空間上の定数や属性と重複してはなりません。 静的操作の識別子は"prototype"であってはなりません。

注: 識別子は同じインターフェース内の他の操作と重複しても構いません。 これが操作のオーバーロード指定方法です。

注: 静的操作の識別子は、 同じインターフェース上の通常の操作と重複しても構いません。

操作の戻り値型は、 宣言で識別子の前に現れる型（Typeに一致）で指定されます。 戻り値型が識別子＋?の場合、その識別子は インターフェース、 辞書、 列挙型、 コールバック関数、 コールバックインターフェース、 型定義 のいずれかを識別しなければなりません。

操作の引数（ArgumentListに一致）は宣言の括弧内で指定します。各引数は型（Typeに一致）＋識別子 （ArgumentNameに一致）で指定します。

注: 表現力のため、操作引数の識別子はArgumentNameKeywordキーワードでも指定でき、その場合エスケープ不要です。

操作引数の型が識別子＋?の場合、その識別子は インターフェース、 列挙型、 コールバック関数、 コールバックインターフェース、 型定義 を識別しなければなりません。 操作引数の型が?の続かない識別子の場合は、これらに加えて辞書も識別可能です。

typedef解決後、引数型がヌラブル型なら、 内側の型は辞書型であってはなりません。

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

各引数の識別子は、同じ操作宣言内の他の引数の識別子と重複してはなりません。

各引数には、拡張属性（ExtendedAttributeListに一致）を前置でき、 引数として渡された値の言語バインディングでの扱い方を制御できます。

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

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

[Exposed=Window]
interface Button {

  // 引数なし・booleanを返す操作
  boolean isMouseOver();

  // オーバーロードされた操作
  undefined setDimensions(Dimensions size);
  undefined setDimensions(unsigned long width, unsigned long height);
};

操作やコンストラクター操作は、 最後の引数に...トークンを型の直後に使った場合、可変長とみなされます。 可変長操作は、宣言された最後の引数以降に任意個の追加引数を受け取れます。暗黙の追加仮引数は宣言された最後の引数と同じ型です。呼び出し時は最後の引数を省略しても構いません。...は引数リストの最後の引数でのみ使えます。

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

本仕様で定義される拡張属性のうち、引数リストを取るもの （[LegacyFactoryFunction]）や コールバック関数も、 引数リストに...トークンが使われている場合は可変長とみなされます。

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

  undefined union(long... ints);
  undefined intersection(long... ints);
};

var s = getIntegerSet();  // IntegerSetのインスタンス取得

s.union();                // 'ints'に対応する引数なし
s.union(1, 4, 7);         // 'ints'に3引数

引数がoptionalキーワードで宣言されている場合、その引数はオプション引数です。 可変長操作の最後の引数もオプション引数とみなされます。オプション引数の宣言は、操作呼び出し時にその引数を省略できることを示します。可変長操作では最後の引数を明示的にoptionalと宣言してはなりません。

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

オプション引数にはデフォルト値も指定できます。引数識別子の後にU+003D（=）と値（DefaultValue に一致）を続けて指定します。 可変長操作の暗黙的オプション引数にはデフォルト値を指定できません。デフォルト値は、操作呼び出し時に該当引数が省略された場合に仮定される値です。

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

デフォルト値としてtrueをboolean型引数に使うことは強く推奨されません。 著者が暗黙のundefinedデフォルト変換（すなわちfalse）を期待しがちなため、混乱の元となります。 [API-DESIGN-PRINCIPLES]

引数型が辞書型または辞書型を平坦化されたメンバー型の1つとして持つユニオン型で、辞書型や祖先に required メンバーがなく、 引数が最後または以降がオプション引数のみの場合は、その引数をオプション・デフォルト値付きで宣言しなければなりません。

booleanリテラル（trueやfalse）、nullトークン、integerトークン、decimalトークン、浮動小数点リテラル（Infinity、-Infinity、NaN）をデフォルト値に使った場合は、定数の場合と同様に解釈されます。

undefinedトークンをデフォルト値に使った場合、その値はIDLのundefined値となります。

オプション引数の型が列挙型の場合、 デフォルト値はその列挙型値のいずれかでなければなりません。

オプション引数のデフォルト値として、空のシーケンス値を表す2トークン値[]も使えます。この値の型は、デフォルト値として使われるオプション引数の型と同じです。その型は、シーケンス型、内部型がシーケンス型であるヌラブル型、または平坦化されたメンバー型にシーケンス型を持つユニオン型もしくはヌラブルユニオン型でなければなりません。

オプション引数のデフォルト値として、ESのnullまたはプロパティを持たないオブジェクトから得られるような、デフォルト初期化された辞書値を表す2トークン値{}も使えます。この値の型は、デフォルト値として使われるオプション引数の型と同じです。その型は、辞書型、または平坦化されたメンバー型に辞書型を持つユニオン型でなければなりません。

[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);
};

dictionary LookupOptions {
  boolean caseSensitive = false;
};

[Exposed=Window]
interface AddressBook {
  boolean hasAddressForName(USVString name, optional LookupOptions options = {});
};

操作に適用可能な拡張属性は以下の通りです： [CrossOriginIsolated]、 [Default]、 [Exposed]、 [LegacyUnforgeable]、 [NewObject]、 [SecureContext]。

操作operationのメソッド手順は、「operation(arg1, arg2, ...)メソッド手順は次の通り：」という文＋リスト、または「operation(arg1, arg2, ...)メソッド手順は...」という文＋インライン説明で記述します。

注: メソッド手順を定義する際は暗黙的にthisにアクセスできます。

DefaultValue ::
    ConstValue
    string
    [ ]
    { }
    null
    undefined

Operation ::
    RegularOperation
    SpecialOperation

RegularOperation ::
    Type OperationRest

SpecialOperation ::
    Special RegularOperation

Special ::
    getter
    setter
    deleter

OperationRest ::
    OptionalOperationName ( ArgumentList ) ;

OptionalOperationName ::
    OperationName
    ε

OperationName ::
    OperationNameKeyword
    identifier

OperationNameKeyword ::
    includes

ArgumentList ::
    Argument Arguments
    ε

Arguments ::
    , Argument Arguments
    ε

Argument ::
    ExtendedAttributeList ArgumentRest

ArgumentRest ::
    optional TypeWithExtendedAttributes ArgumentName Default
    Type Ellipsis ArgumentName

ArgumentName ::
    ArgumentNameKeyword
    identifier

Ellipsis ::
    ...
    ε

ArgumentNameKeyword ::
    attribute
    callback
    const
    constructor
    deleter
    dictionary
    enum
    getter
    includes
    inherit
    interface
    iterable
    maplike
    mixin
    namespace
    partial
    readonly
    required
    setlike
    setter
    static
    stringifier
    typedef
    unrestricted

2.5.3.1. toJSON

toJSON 通常の操作を宣言することで、 インターフェースは、 それを実装するオブジェクトをJSON型に変換する方法を指定します。

toJSON 通常の操作はこの用途に予約されています。 引数はゼロでなければならず、戻り値はJSON型でなければなりません。

JSON型は次の通りです：

• 数値型

• boolean

• 文字列型

• ヌラブル型（内側の型がJSON型）

• 注釈型（内側の型がJSON型）

• ユニオン型（メンバー型がすべてJSON型）

• 型定義（新しい名前が与えられている型がJSON型）

• シーケンス型（パラメータ化型がJSON型）

• フローズン配列型（パラメータ化型がJSON型）

• 辞書型（辞書と継承辞書のすべてのメンバー型がJSON型）

• レコード（すべての値がJSON型）

• object

• インターフェース型（自身または継承インターフェースにtoJSON操作を持つもの）

toJSON 通常の操作をオブジェクト上でどう公開するか、 JSON型をどうJSON文字列に変換するかは、言語バインディング依存です。

注: JavaScriptバインディングでは、toJSONメソッドが公開され、 その返すJSON型はJavaScript値となり、JSON.stringify() 関数でJSON文字列に変換できます。 また、JavaScriptバインディングではtoJSON操作に[Default] 拡張属性を付与でき、この場合はデフォルトtoJSON手順が公開されます。

[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のインスタンス取得
var txn = getTransaction();

// 次のようなオブジェクトになる：
// {
//   from: "Bob",
//   to: "Alice",
//   amount: 50,
//   description: "books"
// }
txn.toJSON();

// 次のような文字列になる：
// '{"from":"Bob","to":"Alice","amount":50,"description":"books"}'
JSON.stringify(txn);

2.5.4. コンストラクター操作

あるインターフェースに コンストラクター操作メンバー（Constructorに一致）がある場合、 そのインターフェースを実装するオブジェクトを コンストラクターで生成できることを示します。

1つのインターフェースに 複数のコンストラクター操作を定義できます。 そのインターフェース上の各コンストラクター操作ごとに、 指定された引数でインスタンスを生成しようとする手段が提供されます。

インターフェース名interfaceのコンストラクター操作の コンストラクター手順は、 「new interface(arg1, arg2, ...)コンストラクター手順は次の通り：」という文＋リスト、 または「new interface(arg1, arg2, ...)コンストラクター手順は...」という文＋インライン説明で記述します。

コンストラクター手順は、何もしない・渡された値で thisを初期化する・例外をスローする、いずれかの動作を行う必要があります。

コンストラクターが thisを初期化しない場合は 「new Example(init)コンストラクター手順は何もしない」と記述できます。

コンストラクター操作の実装方法については § 3.7.1 インターフェースオブジェクトを参照してください。

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

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

var x = new Circle();      // 引数なしコンストラクターでCircleインターフェースを実装する
                           // プラットフォームオブジェクト参照を生成

var y = new Circle(1.25);  // 1引数コンストラクターでCircleオブジェクト生成

var z = new NodeList();    // コンストラクター未宣言なのでTypeErrorになる

Constructor ::
    constructor ( ArgumentList ) ;

ArgumentList ::
    Argument Arguments
    ε

Arguments ::
    , Argument Arguments
    ε

Argument ::
    ExtendedAttributeList ArgumentRest

ArgumentRest ::
    optional TypeWithExtendedAttributes ArgumentName Default
    Type Ellipsis ArgumentName

ArgumentName ::
    ArgumentNameKeyword
    identifier

Ellipsis ::
    ...
    ε

ArgumentNameKeyword ::
    attribute
    callback
    const
    constructor
    deleter
    dictionary
    enum
    getter
    includes
    inherit
    interface
    iterable
    maplike
    mixin
    namespace
    partial
    readonly
    required
    setlike
    setter
    static
    stringifier
    typedef
    unrestricted

2.5.5. ストリギファイア

あるインターフェースにストリギファイアがある場合、 そのインターフェースを実装するオブジェクトはデフォルト以外の文字列変換を持つことを意味します。ストリギファイアはstringifierキーワードで指定でき、 単独で使うとストリギファイア操作を生成します。

interface interface_identifier {
  stringifier;
};

インターフェースの付随する本文で、そのインターフェースのストリギファイ挙動を定義しなければなりません。

stringifierキーワードは属性にも付けられます。 この場合、オブジェクトを文字列に変換した際の値はその属性値となります。stringifierキーワードは、 属性がDOMString またはUSVString型でない限り付与できません。 また、静的属性には付与できません。

interface interface_identifier {
  stringifier attribute DOMString identifier;
};

1つのインターフェースにはストリギファイアは最大1つだけ存在できます。

Stringifier ::
    stringifier StringifierRest

StringifierRest ::
    OptionalReadOnly AttributeRest
    ;

[Exposed=Window]
interface Student {
  constructor();
  attribute unsigned long id;
  stringifier attribute DOMString name;
};

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

var greeting = 'Hello, ' + s + '!';  // greeting == 'Hello, 周杰倫!'

[Exposed=Window]
interface Student {
  constructor();
  attribute unsigned long id;
  attribute DOMString? familyName;
  attribute DOMString givenName;

  stringifier;
};

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

var greeting = 'Hi ' + s;  // greeting == 'Hi Alan Smithee'

2.5.6. 特殊操作

特殊操作は、 その宣言が現れるインターフェースを実装するオブジェクト上で特定の特殊な挙動を宣言するものです。 特殊操作は、操作宣言内で特殊キーワードを使って宣言します。

特殊操作には3種類あります。以下の表は、各特殊操作の種類ごとに宣言に使う特殊キーワードとその目的を示します：

すべての言語バインディングが全ての特殊オブジェクト挙動をサポートするわけではありません。識別子なしで宣言された特殊操作は、その挙動をサポートしない言語バインディングでは単に機能しません。

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

  getter double (DOMString propertyName);
  setter undefined (DOMString propertyName, double propertyValue);
};

特殊操作に識別子を付けて宣言することは、識別子なしの特殊操作宣言を独立して分離するのと同等です。この方法はインターフェースのメソッド手順の単純化に役立ちます。

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

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

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

  double getProperty(DOMString propertyName);
  undefined setProperty(DOMString propertyName, double propertyValue);

  getter double (DOMString propertyName);
  setter undefined (DOMString propertyName, double propertyValue);
};

1つの操作に同じ特殊キーワードを2回使ってはなりません。

ゲッターとセッターには2種類あり、プロパティ名としてDOMStringを取るものは 名前付きプロパティゲッター・ 名前付きプロパティセッター、 プロパティインデックスとしてunsigned longを取るものは インデックス付きプロパティゲッター・ インデックス付きプロパティセッターです。 デリーターは1種類のみで、 名前付きプロパティデリーターです。 詳細は§ 2.5.6.1 インデックス付きプロパティ、 § 2.5.6.2 名前付きプロパティ参照。

1つのインターフェース上には、 名前付きプロパティデリーターは最大1つ、 ゲッター・セッター各種も最大1つずつしか存在できません。

インターフェースがある種類のセッターを持つ場合は、同じ種類のゲッターも持たなければなりません。名前付きプロパティデリーターを持つ場合は、 名前付きプロパティゲッターも持たなければなりません。

操作で宣言する特殊操作は可変長や オプション引数を持ってはなりません。

オブジェクトが、同じ特殊操作を定義する複数のインターフェースを実装する場合、その操作でどちらの特殊操作が呼ばれるかは未定義です。

2.5.6.1. インデックス付きプロパティ

インデックス付きプロパティゲッター を定義する インターフェイス は、インデックス付きプロパティをサポートすると言います。 拡張として、プラットフォームオブジェクト は、インターフェイスを 実装している場合、そのインターフェイスがインデックス付きプロパティをサポートしていれば インデックス付きプロパティをサポートすると言います。

もしインターフェイスがインデックス付きプロパティをサポートする 場合、インターフェイス定義には オブジェクトがどのインデックスでインデックス可能かという説明が伴わなければなりません。 これらのインデックスはサポートされるプロパティインデックスと呼ばれます。

インデックス付きプロパティをサポートするインターフェイスは、 "length" という名前の 整数型 属性を定義しなければなりません。

インデックス付きプロパティゲッターは 一つの unsigned long 引数を取るように宣言されなければなりません。 インデックス付きプロパティセッターは 二つの引数を取り、最初の引数が unsigned long でなければなりません。

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

  getter type (unsigned long identifier);
  setter type (unsigned long identifier, type identifier);
};

インデックス付きプロパティゲッターとセッターの定義には以下の要件が適用されます：

• インデックス付きプロパティゲッターが オペレーション と 識別子を使って指定された場合、 オブジェクトを サポートされるプロパティインデックス でインデックス付けしたときに返される値は、そのオペレーションをインデックスを唯一の引数として呼び出したときに返される値となります。 インデックス付きプロパティゲッターを宣言するために使われたオペレーションに識別子がなかった場合、インターフェイス定義には 指定されたインデックスに対して インデックス付きプロパティの値を決定する方法 の説明が伴わなければなりません。

• インデックス付きプロパティセッターが オペレーションと識別子を使って指定された場合、 オブジェクトをサポートされるプロパティインデックスと値でプロパティ代入のためにインデックス付けしたときの挙動は、 そのオペレーションを最初の引数にインデックス、二番目の引数に値を渡して呼び出した場合と同じとなります。 インデックス付きプロパティセッターを宣言するために使われたオペレーションに識別子がなかった場合、インターフェイス定義には 指定されたプロパティインデックスと値に対して 既存のインデックス付きプロパティの値を設定する方法 と 新しいインデックス付きプロパティの値を設定する方法 の説明が伴わなければなりません。

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

var a = getA();

a.toWord(0);  // "zero" が評価される。
a[0];         // これも "zero" が評価される。

a.toWord(5);  // "five" が評価される。
a[5];         // プロパティ "5" が存在しないため undefined になる。

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

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

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

// map は OrderedMap インターフェイスを実装するレガシープラットフォームオブジェクトと仮定する。
var map = getOrderedMap();
var x, y;

x = map[0];       // map.length > 0 の場合、これは次と等価：
                  //
                  //   x = map.getByIndex(0)
                  //
                  // "0" というプロパティが map に作成されているため。
                  // それ以外では "0" プロパティが存在せず undefined になる。

map[1] = false;   // 次と等価：
                  //
                  //   map.setByIndex(1, false)

y = map.apple;    // "apple" という名前付きプロパティが存在する場合、
                  // 次と等価：
                  //
                  //   y = map.get('apple')
                  //
                  // "apple" プロパティが map に作成されているため。
                  // 存在しなければ undefined になる。

map.berry = 123;  // 次と等価：
                  //
                  //   map.set('berry', 123)

delete map.cake;  // "cake" という名前付きプロパティが存在する場合、
                  // その "cake" プロパティが削除され、次と等価な処理が行われる：
                  //
                  //   map.remove("cake")

2.5.6.2. 名前付きプロパティ

名前付きプロパティゲッター を定義する インターフェイス は、名前付きプロパティをサポートすると言います。 拡張として、プラットフォームオブジェクト は、そのオブジェクトが インターフェイス を実装し、そのインターフェイス自体が名前付きプロパティをサポートしている場合、 名前付きプロパティをサポートすると言います。

もしインターフェイスが名前付きプロパティをサポートする 場合、インターフェイス定義には オブジェクトをインデックス付けするために任意の時点で利用できる名前の順序付き集合の説明が伴わなければなりません。 これらの名前は サポートされるプロパティ名 と呼ばれます。

名前付きプロパティゲッターおよびデリーターは 一つの DOMString 引数を取るように宣言されなければなりません。 名前付きプロパティセッターは 二つの引数を取り、最初の引数が DOMString でなければなりません。

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

  getter type (DOMString identifier);
  setter type (DOMString identifier, type identifier);
  deleter type (DOMString identifier);
};

名前付きプロパティゲッター・セッター・デリーターの定義には以下の要件が適用されます：

• 名前付きプロパティゲッターが オペレーション と 識別子を使って指定された場合、 オブジェクトを サポートされるプロパティ名 でインデックス付けしたときに返される値は、そのオペレーションを名前を唯一の引数として呼び出した場合に返される値です。 名前付きプロパティゲッターを宣言するために使われたオペレーションに識別子がなかった場合、インターフェイス定義には 指定されたプロパティ名に対して 名前付きプロパティの値を決定する方法 の説明が伴わなければなりません。

• 名前付きプロパティセッターが オペレーションと識別子を使って指定された場合、 オブジェクトをサポートされるプロパティ名と値でプロパティ代入のためにインデックス付けしたときの挙動は、 そのオペレーションを最初の引数に名前、二番目の引数に値を渡して呼び出した場合と同じとなります。 名前付きプロパティセッターを宣言するために使われたオペレーションに識別子がなかった場合、インターフェイス定義には 指定されたプロパティ名と値に対して 既存の名前付きプロパティの値を設定する方法 と 新しい名前付きプロパティの値を設定する方法 の説明が伴わなければなりません。

• 名前付きプロパティデリーターが オペレーションと識別子を使って指定された場合、 オブジェクトをサポートされるプロパティ名でプロパティ削除のためにインデックス付けしたときの挙動は、 そのオペレーションを名前を唯一の引数として呼び出した場合と同じとなります。 名前付きプロパティデリーターを宣言するために使われたオペレーションに識別子がなかった場合、インターフェイス定義には 指定されたプロパティ名に対して 既存の名前付きプロパティを削除する方法 の説明が伴わなければなりません。

注: インデックス付きプロパティと同様に、 名前付きプロパティゲッター、 セッター または デリーター がオペレーションと 識別子を使って指定された場合、 オブジェクトを サポートされるプロパティ名ではない 名前でインデックス付けしても、 そのオペレーションでその名前を渡して呼び出した場合と同じ挙動になるとは限りません。 挙動は言語バインディングによって異なります。

2.5.7. 静的属性および操作

静的属性 および 静的操作 とは、 宣言された インターフェイス の特定のインスタンスには関連付けられず、インターフェイス自体に関連付けられるものです。 静的属性および操作は宣言に static キーワードを使用して宣言されます。

静的操作や静的属性をインターフェイスのインスタンス参照を通じて呼び出すことができるかどうかは、言語バインディングごとに異なります。

StaticMember ::
    static StaticMemberRest

StaticMemberRest ::
    OptionalReadOnly AttributeRest
    RegularOperation

[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 オブジェクトの配列

typeof Circle.triangulate;            // "function" と評価される
typeof Circle.triangulationCount;     // "number" と評価される
Circle.prototype.triangulate;         // undefined となる
Circle.prototype.triangulationCount;  // これも undefined となる
circles[0].triangulate;               // こちらも同様
circles[0].triangulationCount;        // これも同じ

// 静的操作の呼び出し
var triangulationPoint = Circle.triangulate(circles[0], circles[1], circles[2]);

// 何回三角測量を行ったか調べる
window.alert(Circle.triangulationCount);

2.5.8. オーバーロード

インターフェイス上に定義された 通常の操作 または 静的操作 が、同じ種類（通常または静的）の操作として同じ 識別子を持つ別の操作と重複している場合、 その操作は オーバーロードされていると言います。 オーバーロードされた操作の識別子を使って、 インターフェイスを実装するオブジェクト上で操作を呼び出した場合、 渡された引数の数や型によって、どのオーバーロードされた操作が実際に呼び出されるかが決定されます。 コンストラクタ操作も オーバーロード可能です。 オーバーロードされた操作やコンストラクタが取ることができる引数にはいくつか制約があり、 これらの制約を説明するために 有効なオーバーロード集合 という概念が使われます。

オーバーロードされた 操作の集合は、次のいずれかでなければなりません：

• 操作の 戻り値の型が Promise型 であるものを一切含まない；

• 含まれる操作すべての 戻り値の型が Promise型 である。

操作は インターフェイス、 部分インターフェイス、 インターフェイスミックスイン、 部分インターフェイスミックスイン の定義をまたいでオーバーロードしてはなりません。

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

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

partial interface A {
  undefined g(DOMString x);
};

有効なオーバーロード集合は、 特定の操作、 コンストラクタ操作 または [LegacyFactoryFunction]、 コールバック関数 の許容される呼び出しを表します。 有効なオーバーロード集合を計算するアルゴリズムは、 以下の4種類のIDL構成要素のいずれかに対して動作し、必要な入力は以下の通りです。

通常の操作の場合

静的操作の場合

• 操作が見つかる インターフェイス

• 操作の 識別子

• 渡される引数の数

コンストラクタの場合

• コンストラクタ操作が見つかる インターフェイス

• 渡される引数の数

レガシーファクトリ関数の場合

• [LegacyFactoryFunction] 拡張属性 が見つかるインターフェイス

• レガシーファクトリ関数の 識別子

• 渡される引数の数

有効なオーバーロード集合は、インターフェイス上で指定されたオーバーロード操作やコンストラクタに 曖昧さがないかどうかなどを判断するために使われます。

項目は 有効なオーバーロード集合の タプルであり、 (呼び出し可能, 型リスト, オプショナリティリスト) という形式です。それぞれの 項目は以下の通りです：

• 呼び出し可能は、 有効なオーバーロード集合が 通常の操作、 静的操作、 コンストラクタ操作の場合は 操作です。 有効なオーバーロード集合が レガシーファクトリ関数の場合は 拡張属性 です。

• 型リストは IDL型の リスト です。

• オプショナリティリストは 3つの オプショナリティ値 （"required"、"optional"、"variadic"）の リストです。 これは、引数が オプションか、 可変長か、 インデックスごとに示します。

各タプルは、 その操作・コンストラクタ・コールバック関数を、指定された型の引数値リストで呼び出せることを表します。 オプション引数 や 可変長操作・コンストラクタにより、 同じ操作やコンストラクタを識別する 有効なオーバーロード集合に 複数の項目が含まれる場合があります。

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

«
  (f1, « DOMString »,                           « required »),
  (f2, « Node, DOMString »,                     « required, required »),
  (f2, « Node, DOMString, double »,             « required, required, variadic »),
  (f2, « Node, DOMString, double, double »,     « required, required, variadic, variadic »),
  (f3, « »,                                     « »),
  (f4, « Event, DOMString »,                    « required, required »),
  (f4, « Event, DOMString, DOMString »,         « required, required, optional »),
  (f4, « Event, DOMString, DOMString, double », « required, required, optional, variadic »)
»

2つの型は、次のアルゴリズムがtrueを返す場合、 識別可能と言います。

1. 一方の型がnullable型を含み、 もう一方もnullable型を含むか、 ユニオン型であり フラット化されたメンバー型が 辞書型を含むか、 辞書型なら、 falseを返す。

   次のペアはどれも識別できません：

   • double? と Dictionary1
   • (Interface1 or long)? と (Interface2 or DOMString)?
   • (Interface1 or long?) と (Interface2 or DOMString)?
   • (Interface1 or long?) と (Interface2 or DOMString?)
   • (Dictionary1 or long) と (Interface2 or DOMString)?
   • (Dictionary1 or long) と (Interface2 or DOMString?)

2. 両方の型がユニオン型またはnullableなユニオン型なら、 一方の各メンバー型が他方の各メンバー型と識別可能であればtrue、そうでなければfalseを返す。

3. 一方の型がユニオン型またはnullableなユニオン型なら、 そのユニオン型の各 メンバー型 が非ユニオン型と識別可能であればtrue、そうでなければfalseを返す。

4. 各型のinner type が注釈付き型ならそれを取り、 さらにinner typeがnullable型ならそれを取った2つの「最も内側の型」を考える。 これら2つの型が次の表に現れるかカテゴリに属し、対応する欄に「●」があるか、文字があり追加要件を満たすならtrueを返す。 そうでなければfalseを返す。

   カテゴリ：

   interface-like

   • インターフェイスタイプ

   • バッファソース型

   dictionary-like

   • 辞書型

   • レコード型

   • コールバックインターフェイスタイプ

   sequence-like

   • シーケンスタイプ

   • フローズン配列型

   	undefined	boolean	numeric types	bigint	string types	object	symbol	interface-like	callback function	dictionary-like	async sequence	sequence-like
   undefined		●	●	●	●	●	●	●	●		●	●
   boolean			●	●	●	●	●	●	●	●	●	●
   numeric types				(b)	●	●	●	●	●	●	●	●
   bigint					●	●	●	●	●	●	●	●
   string types						●	●	●	●	●	(d)	●
   object							●
   symbol								●	●	●	●	●
   interface-like								(a)	●	●	●	●
   callback function										(c)	●	●
   dictionary-like										●	●	●
   async sequence
   sequence-like

   1. 識別された2つのinterface-like型が同じでなく、どのプラットフォームオブジェクトも両方の型を実装しない場合。

   2. 型は識別可能だが、オーバーロードでの利用には別の制約があり、 これら型のユニオン利用についての助言も参照。

   3. コールバック関数が [LegacyTreatNonObjectAsNull] 拡張属性を持たない場合、辞書型カテゴリの型と識別可能。

      例えば、ECMAScript値から コールバック関数と辞書型を含む ユニオン型に変換する場合、 値がcallableなら コールバック関数に変換し、それ以外は辞書型に変換される。

   4. 型は識別可能だが、ECMAScript値から変換する際、 文字列オブジェクトは 非同期シーケンスタイプ には変換されない（%Symbol.iterator%メソッドがあっても）。 文字列型がオーバーロード集合やユニオンに含まれる場合の規則です。

   double と DOMString は、numeric型とstring型の交差点に●があるので識別可能です。
   double と longは、 両方ともnumeric型で、numeric型とnumeric型の交差点に●や文字がないため識別できません。
   例：

   callback interface CBIface {
       undefined handle();
   };
   
   [Exposed=Window]
   interface Iface {
       attribute DOMString attr2;
   };
   
   dictionary Dict {
       DOMString field1;
   };
   

   CBIfaceはIfaceとは識別可能ですが（dictionary-likeとinterface-likeの交差点に●があるため）、 Dictとは識別できません（dictionary-like同士の交差点に●がないため）。

   Promise型は上記の表に現れず、 他の型とは識別できません。

有効なオーバーロード集合に 型リストサイズが同じ 項目が複数ある場合、 それらの項目について、各ペアの型リストのインデックスiの型が 識別可能である 必要がある。 この最も小さいインデックスを、 識別引数インデックス と呼び、これはその型リストサイズを持つ有効なオーバーロード集合の項目に対するインデックスである。

有効なオーバーロード集合には、 型リストサイズが同じ 項目が 2つ以上含まれてはならず、 そのうち一方の項目の 識別引数インデックス位置に bigint 型の引数があり、 他方にはnumeric型の引数が識別引数インデックス位置にある場合は不可。

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

さらに、型リストサイズが同じアイテム群について、 識別引数インデックスより小さい各インデックスjにおいて、 すべての型リストの型は同じであり、 すべてのオプショナリティリストのインデックスjのオプショナリティ値も同じでなければなりません。

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

«
  (f1, « DOMString »,                       « required »),
  (f2, « long, double, Node, Node »,        « required, required, required, required »),
  (f3, « double, double, DOMString, Node », « required, required, required, required »)
»

2.5.8.1. オーバーロードとユニオン型の違い

この節は参考情報です。

interface CanvasDrawPathExcerpt {
  undefined stroke();
  undefined stroke(Path2D path);
};

interface CanvasDrawPathExcerptOptional {
  undefined stroke(optional Path2D path);
};

2.5.9. イテラブル宣言

インターフェイスは、インターフェイス本体内で イテラブル をイテラブル宣言 （Iterableに合致）を使って宣言できます。

interface interface_identifier {
  iterable<value_type>;
  iterable<key_type, value_type>;
};

イテラブルとして宣言されたインターフェイスを実装するオブジェクトは、値の列として反復処理（イテレーション）できます。

注: JavaScript言語バインディングでは、イテラブルなインターフェイスは entries, forEach, keys, values, %Symbol.iterator% プロパティをインターフェイスプロトタイプオブジェクト上に持ちます。

型パラメータが1つだけ指定されている場合、そのインターフェイスは 値イテレータとなり、指定された型の値を提供します。 型パラメータが2つ指定されている場合、そのインターフェイスは ペアイテレータとなり、 指定された型の値ペアを提供します。

値ペアとは、キー型と値型が与えられた場合、 2つの構造体アイテムを持つ アイテムのことです：

1. アイテムの名前が"key"で、 値ペアの キーと呼ばれ、値はキー型のIDL値です。

2. アイテムの名前が"value"で、 値ペアの 値と呼ばれ、値は値型のIDL値です。

値イテレータは、必ず インデックス付きプロパティをサポートする インターフェイスにのみ宣言できます。 この値イテレータの値型は、 インデックス付きプロパティゲッターが返す型と同じでなければなりません。 値イテレータは、 オブジェクトのインデックス付きプロパティをイテレートするものとして暗黙的に定義されます。

ペアイテレータは、 インデックス付きプロパティをサポートする インターフェイスには宣言できません。

ペアイテレータを持つインターフェースに付随する説明文では、 インターフェースの各インスタンスごとに リストとして 値ペアを定義する必要があります。 このリストがイテレートする値ペアです。

注: これは配列イテレータオブジェクトの仕組みです。 インデックス付きプロパティをサポートするインターフェイスでは、 entries, keys, values, %Symbol.iterator% が返すイテレータオブジェクトは実際に配列イテレータオブジェクトです。

イテラブル宣言を持つ インターフェイスは entries, forEach, keys, valuesという名前の 属性、 定数、 通常の操作を持ってはならず、 またこれらの名前の属性、定数、通常の操作を持つ継承インターフェイスを持ってもいけません。

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

  iterable<DOMString, Session>;
};

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

// SessionManagerのインスタンスを取得
// "anna"と"brian"の2ユーザーのセッションがあると仮定
var sm = getSessionManager();

typeof SessionManager.prototype.values;            // "function"と評価される
var it = sm.values();                              // values()はイテレータオブジェクトを返す
String(it);                                        // "[object SessionManager Iterator]"と評価される
typeof it.next;                                    // "function"と評価される

// このループは"anna"と"brian"を順に出力
for (;;) {
  let result = it.next();
  if (result.done) {
    break;
  }
  let session = result.value;
  console.log(session.username);
}

// このループも"anna"と"brian"を順に出力
for (let username of sm.keys()) {
  console.log(username);
}

// もう1つの方法
for (let [username, session] of sm) {
  console.log(username);
}

インターフェイスは複数のイテラブル宣言を持ってはなりません。 イテラブル宣言を持つインターフェイスの 継承インターフェイスもイテラブル宣言を持ってはなりません。 イテラブル宣言を持つインターフェイスおよびその継承インターフェイスは、 maplike宣言、 setlike宣言、 非同期イテラブル宣言を持ってはなりません。

次の拡張属性はイテラブル宣言に適用できます： [CrossOriginIsolated]、 [Exposed]、 [SecureContext]。

Iterable ::
    iterable < TypeWithExtendedAttributes OptionalType > ;

OptionalType ::
    , TypeWithExtendedAttributes
    ε

2.5.10. 非同期イテラブル宣言

インターフェイスは、 ボディ内で 非同期イテラブル宣言 (AsyncIterable に一致) を使用することで、 非同期で繰り返し可能であると宣言できます。 この宣言は インターフェイス の中で行います。

interface interface_identifier {
  async_iterable<value_type>;
  async_iterable<value_type>(/* arguments... */);
  async_iterable<key_type, value_type>;
  async_iterable<key_type, value_type>(/* arguments... */);
};

インターフェイスを非同期イテラブルとして宣言した場合、 それを実装するオブジェクトは値の列を非同期にイテレートできます。

型パラメータが1つだけの場合、そのインターフェイスは 値非同期イテラブル宣言となり、指定した型の値を非同期で提供します。 型パラメータが2つの場合、そのインターフェイスは ペア非同期イテラブル宣言となり、指定した型の 値ペアを非同期で提供します。

引数が指定されている場合、非同期イテラブル宣言の引数（ArgumentListに合致）はすべて オプション引数でなければなりません。

非同期イテラブル宣言を持つインターフェイスには、 次のイテレーション結果を取得する アルゴリズムを定義する必要があります。 このアルゴリズムは、イテレートされるインターフェイスのインスタンスと、非同期イテレータ自身（状態保存などに利用可能）を受け取ります。 戻り値はPromiseであり、rejectされるか、 イテレーション終了のための特別なイテレーション終了値で解決するか、 以下のいずれかで解決します：

値非同期イテラブル宣言の場合：

宣言で指定した型の値

ペア非同期イテラブル宣言の場合：

宣言で指定した型の値2つからなるタプル

記述には、非同期イテレータreturnアルゴリズムを定義してもよいです。 このアルゴリズムは、イテレートされるインターフェイスのインスタンス・非同期イテレータ自身・any型の値1つを受け取ります。 非同期イテレータの途中終了時に呼ばれ、Promiseを返します。 Fulfillされた場合、値は無視され、Rejectされた場合はAPI利用側に伝播します。

JavaScriptバインディングでは、このアルゴリズムでasync iteratorのreturn()メソッド呼び出し時の挙動をカスタマイズできます。 breakやreturnでfor-await-ofループから抜ける時などに使われます。

同様のthrow()用フックも追加可能です。現状需要はありませんが、必要なら issueを提出してください。

記述には非同期イテレータ初期化手順も定義できます。 これらは、イテレートされるインターフェイスのインスタンス・新規作成されたイテレータオブジェクト・渡された引数（IDL値のリスト）を受け取ります。

非同期イテラブル宣言を持つインターフェイスは、 entries, keys, valuesという名前の 属性、 定数、 通常の操作を持ってはならず、 またこれらの名前の属性、定数、通常の操作を持つ継承インターフェイスも持ってはなりません。

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

  async_iterable<DOMString, Session>;
};

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

// SessionManagerのインスタンスを取得
// "anna"と"brian"の2ユーザーのセッションがあると仮定
var sm = getSessionManager();

typeof SessionManager.prototype.values;            // "function"と評価される
var it = sm.values();                              // values()はイテレータオブジェクトを返す
typeof it.next;                                    // "function"と評価される

// このループは"anna"と"brian"を順に出力
for await (let username of sm.keys()) {
  console.log(username);
}

// もう1つの方法
for await (let [username, session] of sm) {
  console.log(username);
}

インターフェイスは複数の 非同期イテラブル宣言を持ってはなりません。 非同期イテラブル宣言を持つインターフェイスの 継承インターフェイスも非同期イテラブル宣言を持ってはなりません。 非同期イテラブル宣言を持つインターフェイス及びその継承インターフェイスは、 maplike宣言、 setlike宣言、 イテラブル宣言を持ってはなりません。

次の拡張属性は非同期イテラブル宣言に適用できます： [CrossOriginIsolated]、 [Exposed]、 [SecureContext]。

これらの拡張属性は現時点では考慮されていません。 今後考慮される場合は、期待通りの効果となります。

AsyncIterable ::
    async_iterable < TypeWithExtendedAttributes OptionalType > OptionalArgumentList ;

OptionalArgumentList ::
    ( ArgumentList )
    ε

2.5.11. maplike宣言

インターフェイスは、 インターフェイス本体内で maplike をmaplike宣言 （ReadWriteMaplike または readonly MaplikeRest） を使って宣言できます。

interface interface_identifier {
  readonly maplike<key_type, value_type>;
  maplike<key_type, value_type>;
};

maplikeとして宣言されたインターフェイスを実装するオブジェクトは、 最初は空の順序付きマップ（key–valueペア）を表します。 これはそのオブジェクトのマップエントリです。 キーと値の型はmaplike宣言の山括弧内で指定されます。キーは一意でなければなりません。

仕様策定者はマップエントリの内容を変更できます。 この変更はJavaScriptコードからオブジェクトの内容を観測した時にも自動的に反映されます。

maplikeインターフェイスは、言語バインディングに応じてマップエントリの問い合わせAPIをサポートします。 readonlyキーワードが使われていない場合は、マップエントリの変更APIもサポートします。

注: JavaScript言語バインディングでは、 マップエントリ操作APIはJavaScriptの Map オブジェクトに似ています。 readonlyキーワードの場合はentries、 forEach、get、 has、keys、 values、 %Symbol.iterator% メソッド、およびsizeゲッターが含まれます。 読み書き可能なmaplikeにはさらにclear、 delete、setメソッドも含まれます。

maplikeインターフェイスは、属性、定数、通常の操作で "entries", "forEach", "get", "has", "keys", "size", "values" という名前を持つものを持ってはならず、 また、これらの名前を持つ属性、定数、通常の操作を持つ継承インターフェイスも持てません。

読み書き可能なmaplikeインターフェイスは、 属性や 定数で "clear", "delete", "set" という名前を持つものを持ってはならず、 また、これらの名前を持つ属性、定数を持つ継承インターフェイスも持てません。

注: 読み書き可能なmaplikeインターフェイスは 通常の操作として "clear", "delete", "set"の名前を持つことができ、 これらはデフォルト実装（§ 3.7.11 maplike宣言で定義）を上書きします。 その場合、入力・出力仕様はデフォルト実装セクションの期待と一致させる必要があります。

インターフェイスは複数の maplike宣言 を持ってはなりません。 maplikeインターフェイスの継承インターフェイスも maplike宣言を持ってはなりません。 maplikeインターフェイスとその継承インターフェイスは、 イテラブル宣言、 非同期イテラブル宣言、 setlike宣言、 インデックス付きプロパティゲッター を持ってはなりません。

ReadOnlyMember ::
    readonly ReadOnlyMemberRest

ReadOnlyMemberRest ::
    AttributeRest
    MaplikeRest
    SetlikeRest

ReadWriteMaplike ::
    MaplikeRest

MaplikeRest ::
    maplike < TypeWithExtendedAttributes , TypeWithExtendedAttributes > ;

この仕様で定義された拡張属性は、 maplike宣言 には適用できません。

例を追加。

2.5.12. setlike宣言

インターフェイスは、 インターフェイス本体内で setlike をsetlike宣言 （ReadWriteSetlike または readonly SetlikeRest） を使って宣言できます。

interface interface_identifier {
  readonly setlike<type>;
  setlike<type>;
};

setlikeとして宣言されたインターフェイスを実装するオブジェクトは、 最初は空の順序付き集合（値のセット）を表します。 これはそのオブジェクトのセットエントリです。 値の型はsetlike宣言の山括弧内で指定されます。値は一意でなければなりません。

仕様策定者はセットエントリの内容を変更できます。 この変更はJavaScriptコードからオブジェクトの内容を観測した時にも自動的に反映されます。

setlikeインターフェイスは、言語バインディングに応じてセットエントリの問い合わせAPIをサポートします。 readonlyキーワードが使われていない場合は、セットエントリの変更APIもサポートします。

注: JavaScript言語バインディングでは、 セットエントリ操作APIはJavaScriptの Set オブジェクトに似ています。 readonlyキーワードの場合はentries、 forEach、has、 keys、values、 %Symbol.iterator% メソッド、およびsizeゲッターが含まれます。 読み書き可能なsetlikeにはさらにadd、 clear、deleteメソッドも含まれます。

setlikeインターフェイスは、属性、定数、通常の操作で "entries", "forEach", "has", "keys", "size", "values" という名前を持つものを持ってはならず、 また、これらの名前を持つ属性、定数、通常の操作を持つ継承インターフェイスも持てません。

読み書き可能なsetlikeインターフェイスは、 属性や 定数で "add", "clear", "delete" という名前を持つものを持ってはならず、 また、これらの名前を持つ属性、定数を持つ継承インターフェイスも持てません。

注: 読み書き可能なsetlikeインターフェイスは 通常の操作として "add", "clear", "delete"の名前を持つことができ、 これらはデフォルト実装（§ 3.7.12 setlike宣言で定義）を上書きします。 その場合、入力・出力仕様はデフォルト実装セクションの期待と一致させる必要があります。

インターフェイスは複数の setlike宣言 を持ってはなりません。 setlikeインターフェイスの継承インターフェイスも setlike宣言を持ってはなりません。 setlikeインターフェイスとその継承インターフェイスは、 イテラブル宣言、 非同期イテラブル宣言、 maplike宣言、 インデックス付きプロパティゲッター を持ってはなりません。

ReadOnlyMember ::
    readonly ReadOnlyMemberRest

ReadOnlyMemberRest ::
    AttributeRest
    MaplikeRest
    SetlikeRest

ReadWriteSetlike ::
    SetlikeRest

SetlikeRest ::
    setlike < TypeWithExtendedAttributes > ;

この仕様で定義された拡張属性は、 setlike宣言 には適用できません。

例を追加。

2.6. 名前空間

名前空間は、グローバルなシングルトンと関連する振る舞いを宣言する定義（Namespaceに合致）です。

namespace identifier {
  /* namespace_members... */
};

名前空間は、名前空間メンバー（NamespaceMembersに合致）、 すなわち波括弧内で宣言された通常の操作、 読み取り専用 通常の属性、 定数の集合の仕様です。 これらの操作や属性が名前空間にパッケージ化された振る舞いを記述します。

インターフェイスと同様に、名前空間のIDLはpartial namespace定義（partial Namespaceに合致）によって複数に分割できます。 partial namespace定義の識別子は、名前空間定義の識別子と同じでなければなりません。 各partial namespace定義に現れるメンバーは全て、名前空間自身のメンバーとみなされます。

namespace SomeNamespace {
  /* namespace_members... */
};

partial namespace SomeNamespace {
  /* namespace_members... */
};

注: partial interface定義と同様、partial namespace定義は仕様編集上の補助を目的としており、 名前空間の定義を文書の複数のセクションや複数文書に分散できます。

メンバーの出現順は、JavaScriptバインディングにおけるプロパティの列挙で意味を持ちます。

インターフェイスや辞書型とは異なり、名前空間は型を生成しません。

この仕様で定義された拡張属性のうち、 [CrossOriginIsolated]、 [Exposed]、 [SecureContext] 拡張属性のみが名前空間に適用可能です。

名前空間は必ず [Exposed] 拡張属性を注釈しなければなりません。

Partial ::
    partial PartialDefinition

PartialDefinition ::
    interface PartialInterfaceOrPartialMixin
    PartialDictionary
    Namespace

Namespace ::
    namespace identifier { NamespaceMembers } ;

NamespaceMembers ::
    ExtendedAttributeList NamespaceMember NamespaceMembers
    ε

NamespaceMember ::
    RegularOperation
    readonly AttributeRest
    Const

namespace VectorUtils {
  readonly attribute Vector unit;
  double dotProduct(Vector x, Vector y);
  Vector crossProduct(Vector x, Vector y);
};

Object.getPrototypeOf(VectorUtils);                         // Object.prototype となる。
Object.keys(VectorUtils);                                   // ["dotProduct", "crossProduct"] となる。
Object.getOwnPropertyDescriptor(VectorUtils, "dotProduct"); // { value: <関数>, enumerable: true, configurable: true, writable: true } となる。
Object.getOwnPropertyDescriptor(VectorUtils, "unit");       // { get: <関数>, enumerable: true, configurable: true } となる。

2.7. 辞書型

辞書型は、 Dictionaryに合致する定義であり、 固定された順序付きの順序付きマップデータ型を定義するために使用されます。 このマップのエントリは、 辞書メンバーと呼ばれ、 キーは文字列で、 値は定義内で指定された特定の型となります。

dictionary identifier {
  /* dictionary_members... */
};

辞書インスタンスは、その言語固有の表現（例：対応するJavaScriptオブジェクト）への参照を保持しません。 たとえば、操作から辞書を返す場合は、 辞書の現在の値から新しいJavaScriptオブジェクトが作成されます。 また、操作が引数として辞書を受け取る場合は、 渡されたJavaScript値から一度だけ変換が行われ、辞書が作成されます。 辞書の変更は対応するJavaScriptオブジェクトには反映されず、逆も同様です。

辞書型は属性や定数の型として使用してはなりません。

辞書型は、他の辞書型から継承するように定義できます。 辞書型の識別子の後にコロンと識別子が続く場合、 その識別子が継承元の辞書型を表します。識別子は必ず辞書型を指す必要があります。

辞書型は、その継承階層に循環があってはなりません。 つまり、辞書型Aが自分自身を継承してはならず、 また他の辞書型BがAを継承し、AがBを継承するような循環も不可です。

dictionary Base {
  /* dictionary_members... */
};

dictionary Derived : Base {
  /* dictionary_members... */
};

継承辞書型とは、 辞書型Dが直接または間接的に継承する全ての辞書型の集合です。 Dが他の辞書型を継承しなければ空集合です。 そうでなければ、Dが継承するEと、そのEの 継承辞書型も含みます。

辞書メンバーは 必須 として指定できます。言語固有値を辞書型に変換する際、そのメンバーの値を必ず指定する必要があります。 必須でない辞書メンバーは オプション です。

辞書メンバーを必須と指定しても、 それが観測可能になるのは他の表現（例えば操作の引数としてJavaScript値を渡す場合）をIDL辞書型に変換するときのみです。 仕様策定者は、辞書型が操作の戻り値としてのみ使われる場合などは、メンバーはすべて オプションにするべきです。

辞書型Dの値は、Dおよびその 継承辞書型 に定義された各辞書メンバーに対するエントリを持ちます。 必須メンバーや デフォルト値を持つメンバーには必ず対応する エントリが存在します。 それ以外のメンバーのエントリは辞書値に存在する場合としない場合があります。

JavaScriptバインディングでは、辞書メンバーに対応するプロパティの値がundefinedの場合、 そのプロパティが省略された場合と同じ扱いになります。 そのため、メンバーが必須ならエラーとなり、 デフォルト値があればそれが使われ、 それ以外はそのメンバーのエントリが辞書値に存在しません。

操作引数のデフォルト値と同様に、 boolean型 辞書メンバーのデフォルト値に trueを使うことは強く非推奨です。これは、undefinedのデフォルト変換として falseを期待する著者を混乱させるためです。 [API-DESIGN-PRINCIPLES]

文字列キーの順序付きマップは、 すべてのエントリが 辞書型Dの辞書メンバーに対応し、 それらの型が正しく、かつ必須またはデフォルト値付きメンバーに対応する エントリが存在すれば、暗黙的にその辞書型の値とみなされます。

dictionary Descriptor {
  DOMString name;
  sequence<unsigned long> serviceIdentifiers;
};

各辞書メンバー （DictionaryMemberに合致）は、 型（Typeに合致）と 識別子 （型の後にidentifierトークン）が続きます。 識別子はキー名となります。 型が識別子に ?が続く場合、識別子は インターフェイス、 列挙型、 コールバック関数、 コールバックインターフェイス、 typedefのいずれかを指す必要があります。 ?が付いていない場合は、これらのいずれかまたは 辞書型を指す必要があります。

辞書メンバーの型（typedef展開後）がnullable型の場合、 そのinner typeは 辞書型であってはなりません。

dictionary identifier {
  type identifier;
};

オプションの辞書メンバーの識別子の後に U+003D（=）と値（DefaultValueに合致）が続く場合、 そのメンバーのデフォルト値となり、 著者コードや仕様本文で値が指定されない場合に使われる値です。

dictionary identifier {
  type identifier = "value";
};

デフォルト値としてbooleanリテラル（trueまたはfalse）、 nullトークン、 integerトークン、 decimalトークン、 3つの特殊な浮動小数点リテラル値（Infinity、-Infinity、NaN）、 stringトークン、 []の2トークン、{}の2トークンが使われた場合、 操作の オプション引数デフォルト値と同じ解釈をします。

辞書メンバーの型が列挙型の場合、 デフォルト値（指定されていれば）は列挙型の値のいずれかでなければなりません。

辞書メンバーの型の前にrequiredキーワードが付いている場合、 そのメンバーは必須 辞書メンバーとなります。

dictionary identifier {
  required type identifier;
};

辞書メンバーの型は、その辞書型自身を含んではなりません。型が辞書型Dを含むとは、以下のいずれかが真である場合です：

• 型がDそのものである

• 型が辞書型で、継承先がDである

• 型がnullable型で、 inner typeがDを含む

• 型がsequence型または frozen array型で、 要素型がDを含む

• 型がユニオン型で、 メンバー型のいずれかがDを含む

• 型が辞書型で、そのメンバーや継承メンバーの型がDを含む

• 型がrecord<K, V>で、 VがDを含む

インターフェイスと同様に、辞書型のIDLは partial dictionary 定義（partial Dictionaryに合致）で分割できます。 partial dictionary定義の識別子は 本体の辞書型と同じでなければなりません。各partial dictionary定義のメンバーは全て辞書型自身のメンバーとみなされます。

dictionary SomeDictionary {
  /* dictionary_members... */
};

partial dictionary SomeDictionary {
  /* dictionary_members... */
};

注: partial interface定義と同様、partial dictionary定義は仕様編集上の補助を目的としており、 インターフェイス定義を文書の複数セクションや複数文書に分割できます。

辞書型の辞書メンバーの順序は、 継承辞書型のメンバーが非継承メンバーより前になり、 本体（およびpartial dictionary定義）に現れるメンバーは識別子のUnicodeコードポイント順（辞書順）になります。

辞書値の エントリーは常に、対応する 辞書 メンバーの順序であり、それらが 設定された順序には関係しない。

dictionary B : A {
  long b;
  long a;
};

dictionary A {
  long c;
  long g;
};

dictionary C : B {
  long e;
  long f;
};

partial dictionary A {
  long h;
  long d;
};

[Exposed=Window]
interface Something {
  undefined f(A a);
};

var something = getSomething();  // Somethingのインスタンス取得
var x = 0;

var dict = { };
Object.defineProperty(dict, "d", { get: function() { return ++x; } });
Object.defineProperty(dict, "c", { get: function() { return ++x; } });

something.f(dict);

その結果、2つの辞書値の エントリーが同じ キーと 等しい 値を持つ場合、それらは 等しい。そのエントリーが どの順序で 設定されたかには関係しない。

辞書メンバーの識別子は、 その辞書で定義されている別の辞書メンバーの識別子、または その辞書の 継承された辞書で定義されているものと同じであってはならない。

辞書には 拡張 属性は適用されない。

Partial ::
    partial PartialDefinition

PartialDefinition ::
    interface PartialInterfaceOrPartialMixin
    PartialDictionary
    Namespace

Dictionary ::
    dictionary identifier Inheritance { DictionaryMembers } ;

DictionaryMembers ::
    DictionaryMember DictionaryMembers
    ε

DictionaryMember ::
    ExtendedAttributeList DictionaryMemberRest

DictionaryMemberRest ::
    required TypeWithExtendedAttributes identifier ;
    Type identifier Default ;

PartialDictionary ::
    dictionary identifier { DictionaryMembers } ;

Default ::
    = DefaultValue
    ε

DefaultValue ::
    ConstValue
    string
    [ ]
    { }
    null
    undefined

Inheritance ::
    : identifier
    ε

[Exposed=Window]
interface Point {
  constructor();
  attribute double x;
  attribute double y;
};

dictionary PaintOptions {
  DOMString fillPattern = "black";
  DOMString strokePattern;
  Point position;
};

[Exposed=Window]
interface GraphicsContext {
  undefined drawRectangle(double width, double height, optional PaintOptions options);
};

// GraphicsContextのインスタンスを取得
var ctx = getGraphicsContext();

// 四角形を描画
ctx.drawRectangle(300, 200, { fillPattern: "red", position: new Point(10, 10) });

2.8. 例外

例外は、 エラーを表すオブジェクトの一種であり、実装によってthrowされたり第一級値として扱われたりします。 Web IDLには仕様が参照・throwできる多くの事前定義された例外があり、 操作や属性等の定義で使用できます。カスタム例外型も、 インターフェイスとして DOMException を継承することで定義可能です。

単純例外は、 以下の型で識別されます：

• EvalError

• RangeError

• ReferenceError

• TypeError

• URIError

これらは、JavaScript のすべての エラーオブジェクトに対応するが、 以下のものを除く。 AggregateError および SuppressedError、 これらは他のエラーをラップするためだけに設計されている。SyntaxError、 これは JavaScript パーサーによる使用のために予約されている。また、Error、 これは使用が予約されており、 作者による使用を目的とする。各 単純例外 の意味は、JavaScript 仕様における対応するエラーオブジェクトの意味と 一致する。

2番目の例外はDOMExceptionであり、 発生したエラーに関する詳細情報（name）をプログラム的に取得できます。 これらnameは 以下のDOMException名テーブルから選ばれます。

DOMException はインターフェイスタイプなので、 IDLで型として使えます。 例えば操作の戻り値型として DOMException を宣言できます。ただし例外はthrowされるべきものであり、戻り値で返すべきではないため、通常は推奨されません。

最後の例外はDOMExceptionの派生インターフェイスです。 これらはより複雑なため、専用の節§ 2.8.2 DOMException派生インターフェイスで説明します。

単純例外は 型名を指定することで生成できます。 DOMException はnameと DOMException を指定して生成できます。 例外はまたthrowすることもでき、 生成時と同じ情報を指定します。両ケースとも、例外の意味を説明する追加情報を指定可能であり、 これは例外メッセージの構築に有用です。

例外の生成・throwの結果的な挙動は言語バインディングごとに異なります。

§ 3.14.3 例外の生成とthrowも参照ください。 JavaScriptバインディングにおける例外の生成・throwの詳細について記載されています。

2.8.1. 基本 DOMException エラー名

以下のDOMException名テーブルは、 基本のDOMException インターフェイスのインスタンスに許可されるnameの一覧と、 それらの意味、およびレガシーの数値エラーコード値を示します。

DOMException を継承するインターフェイス（§ 2.8.2 DOMException 派生インターフェイス参照）は 独自のnameを持ち、本テーブルには掲載されません。

DOMException を生成または throwする際は、仕様は必ずこの一覧のnameを使わなければなりません。 適切なnameがない場合は、issueを提出し、 共有名前空間への追加を議論してください。APIで複数のエラー条件をWeb開発者が区別する必要がある場合のみ、 新たなユースケース固有nameの追加が重要です。

DOMException のうち「非推奨」と記載されたnameはレガシー目的で保持されていますが、利用は推奨されません。

注: ここで定義される"SyntaxError" DOMException と、JavaScriptのSyntaxError を混同しないでください。 "SyntaxError" DOMException はWeb APIのパースエラー（例：セレクタのパースなど）を報告するために使用されます。 一方、JavaScriptのSyntaxError はJSパーサ専用です。 誤解を避けるため、SyntaxError DOMException の表記を使い、単にSyntaxError だけでDOMException を指すことは避けてください。 [DOM]

2.8.2. DOMException 派生インターフェイス

例外がDOMExceptionの name以上の情報をプログラム的に取得できる必要がある場合、仕様策定者は インターフェイスを定義し、 DOMExceptionを継承できます。 このようなインターフェイスは、開発者に予測可能な形を提供するため、以下の規則に従う必要があります。具体的には：

• インターフェイスの 識別子は Errorで終わり、かつDOMException名テーブルに載っている名前であってはなりません。

• インターフェイスは コンストラクタ操作を持ち、 インスタンスのnameを インターフェイスの識別子に設定する必要があります。

• そのコンストラクタ操作は 最初の引数にDOMString型の optionalなmessage（デフォルトは空文字列）を取り、インスタンスの messageを messageで設定する必要があります。

• そのコンストラクタ操作は 2番目の引数として追加情報を含む辞書型を取るべきです。

• コンストラクタ辞書の各メンバーと同じ名前の読み取り専用 属性を持ち、 コンストラクタ操作で受け取った値を返すべきです。

• シリアライズ可能オブジェクトであり、 シリアライズ手順と デシリアライズ手順が追加情報も保持するべきです。

これらの要件により、これらインターフェイスに継承されたcode プロパティは常に0を返します。

DOMException 派生インターフェイスを生成・ throwするには、 インターフェイスの識別子と 構築に必要な追加情報を指定します。

2.8.3. 事前定義されたDOMException 派生インターフェイス

現行標準では1つの事前定義済みDOMException 派生インターフェイスを定義しています：

[Exposed=*, Serializable]
interface QuotaExceededError : DOMException {
  constructor(optional DOMString message = "", optional QuotaExceededErrorOptions options = {});

  readonly attribute double? quota;
  readonly attribute double? requested;
};

dictionary QuotaExceededErrorOptions {
  double quota;
  double requested;
};

QuotaExceededError 例外はクォータ超過時にthrowできます。プロパティが2つあり、それぞれ開発者に要求値とクォータ値の比較情報を提供します。

以前の現行標準では"QuotaExceededError"は 基本DOMExceptionエラー名の一つでしたが、 追加情報の対応のため完全なインターフェイスに引き上げられました。

全てのQuotaExceededError インスタンスは、requestedと quota（いずれも数値またはnull）を持ち、初期値はnullです。

quotaのgetter手順は thisのquotaを返す。

requestedのgetter手順は thisのrequestedを返す。

QuotaExceededError インターフェイスはDOMException インターフェイスのcode getterを継承し、常に22を返します。ただしこの値に依存するのは非推奨です（QuotaExceededErrorでもDOMExceptionでも）。 name getterを使う方がよいです。

QuotaExceededError オブジェクトはシリアライズ可能オブジェクトです。

作成またはスローによってQuotaExceededError を生成する仕様は、 requestedおよびquotaの両方がnullでなく、 かつrequestedがquotaより小さい場合を提供してはならない。

2.9. 列挙型

列挙型は、 Enumに合致する定義であり、 有効な値が事前定義された文字列集合となる型を宣言します。列挙型は、 DOMString に割り当てられる値や 属性、 操作の引数として渡される値を制限できます。

enum identifier { "enum", "values" /* , ... */ };

列挙値は、 カンマ区切りのstringリテラルとして指定されます。 列挙値のリストに重複は許されません。

列挙値はすべて小文字で、複数語はハイフン区切りまたは区切りなしとすることが強く推奨されます。 別の命名方式を使う特別な理由がなければこの推奨に従ってください。 例えば「createobject」または「create-object」など。 関連API間で命名方式を統一するよう検討してください。

型が列挙型の場合、属性への代入や操作引数として有効でない文字列値を使った場合の挙動は言語バインディング依存です。

注: JavaScriptバインディングでは、属性への無効な文字列値の代入は無視されますが、 操作引数など他の文脈で渡した場合は例外がthrowされます。

この仕様で定義された拡張属性は 列挙型には適用できません。

Enum ::
    enum identifier { EnumValueList } ;

EnumValueList ::
    string EnumValueListComma

EnumValueListComma ::
    , EnumValueListString
    ε

EnumValueListString ::
    string EnumValueListComma
    ε

enum MealType { "rice", "noodles", "other" };

[Exposed=Window]
interface Meal {
  attribute MealType type;
  attribute double size;     // in grams

  undefined initialize(MealType type, double size);
};

var meal = getMeal();                // Mealのインスタンス取得

meal.initialize("rice", 200);        // 通常通り操作が呼ばれる

try {
  meal.initialize("sandwich", 100);  // TypeErrorがthrowされる
} catch (e) {
}

meal.type = "noodles";               // 属性代入は通常通り
meal.type = "dumplings";             // 属性代入は無視される
meal.type == "noodles";              // trueと評価される

2.10. コールバック関数

「Custom DOM Elements」仕様では、プラットフォームオブジェクト提供関数にコールバック関数型を使いたい意図があります。 「コールバック関数」という呼称を「関数」に変更し、両方の用途に使えることを明確にした方がよいでしょうか？

コールバック関数は、 callback CallbackRestに合致する定義であり、 関数型を宣言するために使います。

callback identifier = return_type (/* arguments... */);

注: 類似名のコールバックインターフェイスも参照ください。

イコール記号の左側の識別子が コールバック関数の名前となり、 右側の戻り値型・引数リスト（Type・ArgumentListに合致）が コールバック関数型のシグネチャとなります。

コールバック関数は 定数の型として使うことはできません。

コールバック関数型に適用可能な拡張属性は以下のみです： [LegacyTreatNonObjectAsNull]。

CallbackOrInterfaceOrMixin ::
    callback CallbackRestOrInterface
    interface InterfaceOrMixin

CallbackRest ::
    identifier = Type ( ArgumentList ) ;

callback AsyncOperationCallback = undefined (DOMString status);

[Exposed=Window]
interface AsyncOperations {
  undefined performOperation(AsyncOperationCallback whenFinished);
};

var ops = getAsyncOperations();  // AsyncOperationsのインスタンス取得

ops.performOperation(function(status) {
  window.alert("Operation finished, status is " + status + ".");
});

2.11. typedef

typedefは、 Typedefに合致する定義であり、 型に新しい名前を与えるために使われます。この新しい名前は言語バインディングでは公開されず、 純粋にIDL内で型参照の簡略化のために使われます。

typedef type identifier;

新しい名前が与えられる型は typedefキーワードの後（TypeWithExtendedAttributesに合致）に指定され、 型の後ろのidentifierトークンが名前を表します。

Typeは、 同じまたは他のtypedefの識別子であってはなりません。

この仕様で定義された拡張属性は typedefには適用できません。

Typedef ::
    typedef TypeWithExtendedAttributes identifier ;

[Exposed=Window]
interface Point {
  attribute double x;
  attribute double y;
};

typedef sequence<Point> Points;

[Exposed=Window]
interface Widget {
  boolean pointWithinBounds(Point p);
  boolean allPointsWithinBounds(Points ps);
};

2.12. インターフェイスを実装するオブジェクト

特定のIDLフラグメントセットの実装において、 オブジェクトはプラットフォームオブジェクトと見なされる場合があります。

プラットフォームオブジェクトは、 インターフェイスを実装するオブジェクトです。

レガシープラットフォームオブジェクトは、 プラットフォームオブジェクトであり、 [Global] 拡張属性を持たず、 インデックス付きプロパティ、 名前付きプロパティ、または両方をサポートするインターフェイスを実装します。

例えばブラウザでは、 DOMオブジェクト（NodeやDocumentなどのインターフェイスを実装）が JavaScriptからWebページ内容へアクセスを提供する場合、それらは プラットフォームオブジェクトです。 これらはC++などで実装されたエキゾチックオブジェクトの場合もあれば、ネイティブJavaScriptオブジェクトの場合もあります。 いずれにせよ、IDLフラグメントセットの実装は、 生成された全てのプラットフォームオブジェクトを認識できる必要があります。 実装内部状態でオブジェクトがプラットフォームオブジェクトかどうか記録したり、 内部C++クラス実装かどうかで判定するなど、認識方法は実装依存です。

それ以外のシステム上のオブジェクトはプラットフォームオブジェクト扱いされません。 例えば、WebページがJavaScriptライブラリでDOM Coreを実装する場合、 これはブラウザとは別実装と見なされ、 ライブラリが生成したNodeインターフェイス実装オブジェクトは、 ブラウザ実装におけるNodeプラットフォームオブジェクトとはされません。

コールバックインターフェイスは一方で、 任意のJavaScriptオブジェクトで実装可能です。 これによりWeb APIは著者定義操作を呼び出せます。 例えばDOM Events実装では、 EventListener インターフェイスを実装したオブジェクトをコールバック登録できます。

2.13. 型

この節では、Web IDLがサポートする型、各型に対応する値やInfra型、そしてその型の定数の表現方法を一覧します。

以下の型は整数型と呼ばれます： byte, octet, short, unsigned short, long, unsigned long, long long および unsigned long longです。

以下の型は数値型です： 整数型全て、 float, unrestricted float, double、 unrestricted doubleです。

プリミティブ型は bigint, boolean と 数値型全てです。

文字列型は DOMString, 全ての列挙型, ByteString, USVStringです。

バッファ型は ArrayBuffer と SharedArrayBufferです。

型付き配列型は Int8Array, Int16Array, Int32Array, Uint8Array, Uint16Array, Uint32Array, Uint8ClampedArray, BigInt64Array, BigUint64Array, Float16Array, Float32Array、 Float64Arrayです。

バッファビュー型は DataView および 型付き配列型全てです。

バッファソース型は バッファ型と バッファビュー型全てです。

object型、 全てのインターフェイス型、 全てのコールバックインターフェイス型は オブジェクト型です。

言語バインディング固有型からIDL型への変換は、操作を呼び出す時や 属性に値を代入する時、指定機能の実行前に全て行われます。 変換できない場合、操作は実行されず属性も更新されません。 言語バインディングによっては型変換失敗時に例外がthrowされる場合があり、 その場合例外は操作呼び出し元や属性代入元に伝播されます。

Type ::
    SingleType
    UnionType Null

TypeWithExtendedAttributes ::
    ExtendedAttributeList Type

SingleType ::
    DistinguishableType
    any
    PromiseType

UnionType ::
    ( UnionMemberType or UnionMemberType UnionMemberTypes )

UnionMemberType ::
    ExtendedAttributeList DistinguishableType
    UnionType Null

UnionMemberTypes ::
    or UnionMemberType UnionMemberTypes
    ε

DistinguishableType ::
    PrimitiveType Null
    StringType Null
    identifier Null
    sequence < TypeWithExtendedAttributes > Null
    async_sequence < TypeWithExtendedAttributes > Null
    object Null
    symbol Null
    BufferRelatedType Null
    FrozenArray < TypeWithExtendedAttributes > Null
    ObservableArray < TypeWithExtendedAttributes > Null
    RecordType Null
    undefined Null

ConstType ::
    PrimitiveType
    identifier

PrimitiveType ::
    UnsignedIntegerType
    UnrestrictedFloatType
    boolean
    byte
    octet
    bigint

UnrestrictedFloatType ::
    unrestricted FloatType
    FloatType

FloatType ::
    float
    double

UnsignedIntegerType ::
    unsigned IntegerType
    IntegerType

IntegerType ::
    short
    long OptionalLong

OptionalLong ::
    long
    ε

StringType ::
    ByteString
    DOMString
    USVString

PromiseType ::
    Promise < Type >

RecordType ::
    record < StringType , TypeWithExtendedAttributes >

Null ::
    ?
    ε

2.13.1. any

any型は 他の全ての非ユニオン型の 和集合です。

any型は 判別付きユニオン型に似ていて、その値ごとに 特定の非any型が 紐付いています。例えばany型の値に unsigned longの150や、 longの150があり、 これは異なる値です。

any値の型は 具体型と呼ばれます。 （ユニオン型の値も 具体型を持ちます。）

2.13.2. undefined

undefined型は 一意な値を持ちます。

undefinedの 定数値はIDLでundefinedトークンで表されます。

undefinedは いかなる場合も引数型（操作、 コールバック関数、 コンストラクタ操作等）や 辞書メンバー型 （直接でもユニオンでも）として使ってはなりません。 代わりにoptional引数や 非必須 辞書メンバーを使ってください。

注: この値は以前voidと綴られ、使用制限もより厳格でした。

2.13.3. boolean

boolean型は boolean値に対応します。