WebAssembly JavaScriptインターフェイス

(module
    (import "js" "import1" (func $i1))
    (import "js" "import2" (func $i2))
    (func $main (call $i1))
    (start $main)
    (func (export "f") (call $i2))
)

var importObj = {js: {
    import1: () => console.log("hello,"),
    import2: () => console.log("world!")
}};
fetch('demo.wasm').then(response =>
    response.arrayBuffer()
).then(buffer =>
    WebAssembly.instantiate(buffer, importObj)
).then(({module, instance}) =>
    instance.exports.f()
);

dictionary WebAssemblyInstantiatedSource {
    required Module module;
    required Instance instance;
};

dictionary WebAssemblyCompileOptions {
    USVString? importedStringConstants;
    sequence<USVString> builtins;
};

[Exposed=*]
namespace WebAssembly {
    boolean validate([AllowResizable] AllowSharedBufferSource bytes, optional WebAssemblyCompileOptions options = {});
    Promise<Module> compile([AllowResizable] AllowSharedBufferSource bytes, optional WebAssemblyCompileOptions options = {});

    Promise<WebAssemblyInstantiatedSource> instantiate(
        [AllowResizable] AllowSharedBufferSource bytes, optional object importObject, optional WebAssemblyCompileOptions options = {});

    Promise<Instance> instantiate(
        Module moduleObject, optional object importObject);

    readonly attribute Tag JSTag;
};

To WebAssembly モジュールをコンパイルするには、ソースバイト列 bytes から、次の手順を実行する:

1. module を module_decode(bytes) とする。module が error なら、error を返す。

2. module_validate(module) が error なら、error を返す。

3. module を返す。

モジュール module、有効化されたビルトイン builtinSetNames、および importedStringModule から WebAssembly モジュールに対するビルトインと インポート文字列を検証するには、次の手順を実行する:

1. builtinSetNames に対する ビルトイン集合名の検証 が false なら、false を返す。

2. 各 import について、module_imports(module) の、

   1. importedStringModule が null ではなく、かつ import[0] が importedStringModule に等しい場合、

      1. importExternType を import[2] とする。

      2. stringExternType を global const (ref extern) とする。

      3. match_externtype(stringExternType, importExternType) が false なら、false を返す

   2. それ以外の場合、

      1. import および builtinSetNames に対する ビルトイン用インポートの検証 が false なら、 false を返す。

3. true を返す。

validate(bytes, options) メソッドは、 呼び出されると次の手順を実行する:

1. stableBytes を、バッファが保持するバイト列 のコピー bytes とする。

2. stableBytes を WebAssembly モジュールとして コンパイル し、その結果を module として保持する。

3. module が error なら、false を返す。

4. builtinSetNames を options["builtins"] とする。

5. importedStringModule を options["importedStringConstants"] とする。

6. module に対する ビルトインとインポート文字列の 検証 が、builtinSetNames および importedStringModule を用いて false を返した場合、false を返す。

7. true を返す。

モジュール module、ソースバイト列 bytes、有効化されたビルトイン builtinSetNames、および importedStringModule から WebAssembly モジュールオブジェクトを構築するには、 次の手順を実行する:

1. moduleObject を new Module とする。

2. moduleObject.[[Module]] を module に設定する。

3. moduleObject.[[Bytes]] を bytes に設定する。

4. moduleObject.[[BuiltinSets]] を builtinSetNames に設定する。

5. moduleObject.[[ImportedStringModule]] を importedStringModule に設定する。

6. moduleObject を返す。

ソースバイト列 bytes と WebAssemblyCompileOptions options から、 任意の task source taskSource を用いて WebAssembly モジュールを非同期にコンパイルするには、 次の手順を実行する:

1. promise を 新しい promise とする。

2. 次の手順を 並列に 実行する:

   1. WebAssembly モジュールをコンパイル し、 bytes の結果を module として保持する。

   2. taskSource が与えられていれば、それ上で タスクをキューに入れ、次の手順を実行する:

      1. module が error なら、promise を CompileError 例外で reject して return する。

      2. builtinSetNames を options["builtins"] とする。

      3. importedStringModule を options["importedStringConstants"] とする。

      4. module に対する ビルトインと インポート文字列の検証 が、 builtinSetNames および importedStringModule を用いて false なら、 promise を CompileError 例外で reject する。

      5. それ以外の場合、

         1. module、 bytes、builtinSetNames、 importedStringModule から WebAssembly モジュールオブジェクトを構築 し、その結果を moduleObject とする。

         2. promise を moduleObject で resolve する。

3. promise を返す。

compile(bytes, options) メソッドは、 呼び出されると次の手順を実行する:

1. stableBytes を、バッファが保持するバイト列 のコピー bytes とする。

2. stableBytes から 非同期に WebAssembly モジュールをコンパイル し、options を用いて、その結果を返す。

モジュール module と importedStringModule を用いて インポート文字列をインスタンス化するには、次の手順を実行する:

1. Assert: importedStringModule は null ではない。

2. exportsObject を ! OrdinaryObjectCreate(null) とする。

3. 各 (moduleName, componentName, externtype) について、module_imports(module) の、

   1. moduleName が importedStringModule と等しくなければ、continue する。

   2. stringConstant を componentName とする。

   3. status を ! CreateDataProperty(exportsObject, stringConstant, stringConstant) とする。

   4. Assert: status は true である。

4. exportsObject を返す。

WebAssembly モジュール module から、imports オブジェクト importObject、 有効化されたビルトイン builtinSetNames、および importedStringModule を用いて インポートを読み取るには、 次の手順を実行する:

1. module.imports が 空でない にもかかわらず、importObject が undefined なら、TypeError 例外を throw する。

2. builtinOrStringImports を順序付きマップ « » とする。

3. 各 builtinSetName について builtinSetNames の、

   1. builtinSetQualifiedName を、builtinSetName の前に "wasm:" を付けたものとする。

   2. Assert: builtinOrStringImports は builtinSetQualifiedName を含まない

   3. builtinSetName がビルトイン集合を指していなければ、continue する。

   4. exportsObject を、builtinSetName を用いた ビルトイン集合の インスタンス化 の結果とする

   5. Set builtinOrStringImports[builtinSetQualifiedName] を exportsObject に設定する

4. importedStringModule が null ではない場合、

   1. exportsObject を、module および importedStringModule を用いた インポート文字列のインスタンス化 の結果とする

   2. Set builtinOrStringImports[importedStringModule] を exportsObject に設定する

5. imports を « » とする。

6. 各 (moduleName, componentName, externtype) について、module_imports(module) の、

   1. builtinOrStringImports が 含む moduleName の場合、

      1. o を builtinOrStringImports[moduleName] とする。

      2. o が Object ではない、または HasProperty(o, componentName) が false の場合、

         1. o を ? Get(importObject, moduleName) に設定する。

   2. それ以外の場合、

      1. o を ? Get(importObject, moduleName) とする。

   3. o が Object ではない なら、TypeError 例外を throw する。

   4. v を ? Get(o, componentName) とする。

   5. externtype が func functype の形式である場合、

      1. IsCallable(v) が false なら、LinkError 例外を throw する。

      2. v が [[FunctionAddress]] 内部スロットを持ち、したがって Exported Function である場合、

         1. funcaddr を v の [[FunctionAddress]] 内部スロットの値とする。

      3. それ以外の場合、

         1. v および functype から ホスト関数を作成 し、その結果を funcaddr とする。

         2. index を imports 内の外部関数の数とする。この値 index は、ホスト関数 funcaddr の ホスト関数インデックス と呼ばれる。

      4. externfunc を外部値 func funcaddr とする。

      5. externfunc を imports に 追加 する。

   6. externtype が global mut valtype の形式である場合、

      1. v が implements Global なら、

         1. globaladdr を v.[[Global]] とする。

      2. それ以外の場合、

         1. valtype が i64 であり、かつ v が BigInt では ない 場合、

            1. LinkError 例外を throw する。

         2. valtype が i32、f32、または f64 のいずれかであり、かつ v が Number では ない 場合、

            1. LinkError 例外を throw する。

         3. valtype が v128 の場合、

            1. LinkError 例外を throw する。

         4. value を ToWebAssemblyValue(v, valtype) とする。この操作が TypeError を throw した場合、それを捕捉し、LinkError 例外を throw する。

         5. store を surrounding agent の 関連付けられた store とする。

         6. (store, globaladdr) を global_alloc(store, const valtype, value) とする。

         7. surrounding agent の 関連付けられた store を store に設定する。

      3. externglobal を global globaladdr とする。

      4. externglobal を imports に 追加 する。

   7. externtype が mem memtype の形式である場合、

      1. v が implement Memory しないなら、LinkError 例外を throw する。

      2. externmem を外部値 mem v.[[Memory]] とする。

      3. externmem を imports に 追加 する。

   8. externtype が table tabletype の形式である場合、

      1. v が implement Table しないなら、LinkError 例外を throw する。

      2. tableaddr を v.[[Table]] とする。

      3. externtable を外部値 table tableaddr とする。

      4. externtable を imports に 追加 する。

   9. externtype が tag attribute functype の形式である場合、

      1. Assert: attribute は exception である。

      2. v が implement Tag しないなら、LinkError 例外を throw する。

      3. tagaddr を v.[[Address]] とする。

      4. externtag を外部値 tag tagaddr とする。

      5. externtag を imports に 追加 する。

7. imports を返す。

注: このアルゴリズムは、正しい種類の JavaScript 値が渡されたことだけを検証する。 WebAssembly の型要件の検証は、 「WebAssembly モジュールのコアを インスタンス化する」アルゴリズムに委ねられる。

WebAssembly モジュール module およびインスタンス instance から エクスポート オブジェクトを作成するには、次の手順を実行する:

1. exportsObject を ! OrdinaryObjectCreate(null) とする。

2. 各 (name, externtype) について、module_exports(module) の、

   1. externval を instance_export(instance, name) とする。

   2. Assert: externval は error ではない。

   3. externtype が func functype の形式である場合、

      1. Assert: externval は func funcaddr の形式である。

      2. func funcaddr を externval とする。

      3. func を、funcaddr から 新しい Exported Function を作成した結果とする。

      4. value を func とする。

   4. externtype が global mut globaltype の形式である場合、

      1. Assert: externval は global globaladdr の形式である。

      2. global globaladdr を externval とする。

      3. global を、globaladdr から作成された 新しい Global オブジェクト とする。

      4. value を global とする。

   5. externtype が mem memtype の形式である場合、

      1. Assert: externval は mem memaddr の形式である。

      2. mem memaddr を externval とする。

      3. memory を、memaddr から作成された 新しい Memory オブジェクト とする。

      4. value を memory とする。

   6. externtype が table tabletype の形式である場合、

      1. Assert: externval は table tableaddr の形式である。

      2. table tableaddr を externval とする。

      3. table を、tableaddr から作成された 新しい Table オブジェクト とする。

      4. value を table とする。

   7. externtype が tag attribute functype の形式である場合、

      1. Assert: attribute は exception である。

      2. Assert: externval は tag tagaddr の形式である。

      3. tag tagaddr を externval とする。

      4. tag を、tagaddr から作成された 新しい Tag オブジェクト とする。

      5. value を tag とする。

   8. status を ! CreateDataProperty(exportsObject, name, value) とする。

   9. Assert: status は true である。

   注: WebAssembly モジュール検証 の間に実行される妥当性および一意性の検査により、 各プロパティ名が妥当であり、重複して定義されるプロパティが存在しないことが保証される。

3. exportsObject に対して ! SetIntegrityLevel(exportsObject, "frozen") を実行する。

4. exportsObject を返す。

WebAssembly モジュール module およびインスタンス instance から インスタンス オブジェクトを初期化する instanceObjectには、次の手順を実行する:

1. module および instance から エクスポートオブジェクトを作成 し、その結果を exportsObject とする。

2. instanceObject.[[Instance]] を instance に設定する。

3. instanceObject.[[Exports]] を exportsObject に設定する。

モジュール module およびインポート群 imports から WebAssembly モジュールのコアをインスタンス化するには、 次の手順を実行する:

1. store を surrounding agent の 関連付けられた store とする。

2. result を module_instantiate(store, module, imports) とする。

3. result が error なら、適切な例外型を throw する:

   • リンク時に発生するほとんどの場合については、 LinkError 例外。

   • エラーが start 関数の実行中に発生した場合は、WebAssembly から発生するほとんどのエラーについて RuntimeError を throw するか、内側の ECMAScript コードから伝播したエラーオブジェクトを throw する。

   • 適切であれば別のエラー型。たとえば、 WebAssembly エラー対応付け に記述されているメモリ不足例外など。

4. (store, instance) を result とする。

5. surrounding agent の 関連付けられた store を store に設定する。

6. instance を返す。

Module moduleObject およびインポート群 importObject から WebAssembly モジュールを非同期に インスタンス化するには、次の手順を実行する:

1. promise を 新しい promise とする。

2. module を moduleObject.[[Module]] とする。

3. builtinSetNames を moduleObject.[[BuiltinSets]] とする。

4. importedStringModule を moduleObject.[[ImportedStringModule]] とする。

5. module の インポートを読み取り、 imports importObject、 builtinSetNames および importedStringModule を用い、その結果を imports とする。 この操作が例外を throw した場合、それを捕捉し、reject promise をその例外で行い、promise を返す。

6. 次の手順を 並列に 実行する:

   1. 次の手順を実行するために タスクをキューに入れる: 注: 実装固有の作業がここで行われることがある。

      1. module と imports を用いて WebAssembly モジュールのコアをインスタンス化 し、その結果を instance とする。 これが例外を throw した場合、それを捕捉し、reject promise をその例外で行い、 これらの副手順を終了する。

      2. instanceObject を new Instance とする。

      3. module および instance から instanceObject を 初期化 する。 これが例外を throw した場合、それを捕捉し、reject promise をその例外で行い、 これらの副手順を終了する。

      4. instanceObject で promise を resolve する。

7. promise を返す。

モジュールの promise をインスタンス化する promiseOfModule に imports importObject を用いるには、次の手順を実行する:

1. promise を 新しい promise とする。

2. promiseOfModule に対して 反応 する:

   • promiseOfModule が値 module で fulfill された場合:

     1. module を importObject をインポートして WebAssembly モジュールをインスタンス化 し、その結果を innerPromise とする。

     2. innerPromise に対して 反応 する:

        • innerPromise が値 instance で fulfill された場合。

          1. result を WebAssemblyInstantiatedSource 値 «[ "module" → module, "instance" → instance ]» とする。

          2. result で promise を resolve する。

        • innerPromise が理由 reason で reject された場合:

          1. reason で promise を reject する。

   • promiseOfModule が理由 reason で reject された場合:

     1. reason で promise を reject する。

3. promise を返す。

instantiate(bytes, importObject, options) メソッドは、呼び出されると次の手順を実行する:

1. stableBytes を、バッファが保持するバイト列 のコピー bytes とする。

2. stableBytes から 非同期に WebAssembly モジュールをコンパイル し、options を用い、その結果を promiseOfModule とする。

3. promiseOfModule を インスタンス化 し、 imports importObject を用いて、その結果を返す。

instantiate(moduleObject, importObject) メソッドは、呼び出されると次の手順を実行する:

1. moduleObject を importObject をインポートして 非同期に WebAssembly モジュールをインスタンス化 し、その結果を返す。

enum ImportExportKind {
  "function",
  "table",
  "memory",
  "global",
  "tag"
};

enum AddressType {
  "i32",
  "i64",
};

typedef any AddressValue;

dictionary ModuleExportDescriptor {
  required USVString name;
  required ImportExportKind kind;
  // Note: Other fields such as signature may be added in the future.
};

dictionary ModuleImportDescriptor {
  required USVString module;
  required USVString name;
  required ImportExportKind kind;
};

[LegacyNamespace=WebAssembly, Exposed=*]
interface Module {
  constructor([AllowResizable] AllowSharedBufferSource bytes, optional WebAssemblyCompileOptions options = {});
  static sequence<ModuleExportDescriptor> exports(Module moduleObject);
  static sequence<ModuleImportDescriptor> imports(Module moduleObject);
  static sequence<ArrayBuffer> customSections(Module moduleObject, DOMString sectionName);
};

extern 型の 文字列値 type は次のとおりである

• type が func functype の形式である場合は "function"

• type が table tabletype の形式である場合は "table"

• type が mem memtype の形式である場合は "memory"

• type が global globaltype の形式である場合は "global"

• type が tag tag の形式である場合は "tag"

exports(moduleObject) メソッドは、呼び出されると、 次の手順を実行する:

1. module を moduleObject.[[Module]] とする。

2. exports を « » とする。

3. 各 (name, type) について、module_exports(module) の、

   1. kind を、type の extern 型の文字列値 とする。

   2. obj を «[ "name" → name, "kind" → kind ]» とする。

   3. obj を exports に 追加 する。

4. exports を返す。

imports(moduleObject) メソッドは、呼び出されると、 次の手順を実行する:

1. module を moduleObject.[[Module]] とする。

2. builtinSetNames を moduleObject.[[BuiltinSets]] とする。

3. importedStringModule を moduleObject.[[ImportedStringModule]] とする。

4. imports を « » とする。

5. 各 (moduleName, name, type) について、module_imports(module) の、

   1. (moduleName, name, type) に対する ビルトインの検索 が builtinSetNames について null ではないなら、continue する。

   2. importedStringModule が null ではなく、かつ moduleName が importedStringModule に等しいなら、continue する。

   3. kind を、type の extern 型の文字列値 とする。

   4. obj を «[ "module" → moduleName, "name" → name, "kind" → kind ]» とする。

   5. obj を imports に 追加 する。

6. imports を返す。

customSections(moduleObject, sectionName) メソッドは、呼び出されると、次の手順を実行する:

1. bytes を moduleObject.[[Bytes]] とする。

2. customSections を « » とする。

3. 各 custom section customSection について bytes の、 module grammar に従って解釈されたものを、

   1. name を、customSection の name を UTF-8 としてデコード したものとする。

   2. Assert: name は failure ではない （moduleObject.[[Module]] は 妥当 である）。

   3. name が文字列値として sectionName に等しい場合、

      1. この customsec 生成規則に一致した範囲について、 bytes 内のバイト列のコピーを含む新しい ArrayBuffer を customSections に 追加 する。

4. customSections を返す。

Module(bytes, options) コンストラクターは、 呼び出されると、次の手順を実行する:

1. stableBytes を、バッファが保持するバイト列 のコピー bytes とする。

2. stableBytes を WebAssembly モジュールとしてコンパイル し、その結果を module として保持する。

3. module が error なら、CompileError 例外を throw する。

4. builtinSetNames を options["builtins"] とする。

5. importedStringModule を options["importedStringConstants"] とする。

6. module に対する ビルトインと インポート文字列の検証 が、 builtinSetNames および importedStringModule を用いて false を返す場合、 CompileError 例外を throw する。

7. this.[[Module]] を module に設定する。

8. this.[[Bytes]] を stableBytes に設定する。

9. this.[[BuiltinSets]] を builtinSetNames に設定する。

10. this.[[ImportedStringModule]] を importedStringModule に設定する。

注: 実装によっては bytes に対して サイズ制限を課すものがある。この API の使用は推奨されず、非同期 API が推奨される。

[LegacyNamespace=WebAssembly, Exposed=*]
interface Instance {
  constructor(Module module, optional object importObject);
  readonly attribute object exports;
};

Instance(moduleObject, importObject) コンストラクターは、呼び出されると、次の手順を実行する:

1. builtinSetNames を moduleObject.[[BuiltinSets]] とする。

2. importedStringModule を moduleObject.[[ImportedStringModule]] とする。

3. module を moduleObject.[[Module]] とする。

4. module の インポートを読み取り、 imports importObject、 builtinSetNames および importedStringModule を用い、その結果を imports とする。

5. module を imports とともに WebAssembly モジュールのコアとして インスタンス化 し、その結果を instance とする。

6. module および instance から this を 初期化 する。

注: この同期 API の使用は 推奨されない。実装によっては、インスタンス化時に長時間実行されるコンパイル作業を行うことがあるためである。

Instance の exports 属性の getter は、 this.[[Exports]] を返す。

dictionary MemoryDescriptor {
  required AddressValue initial;
  AddressValue maximum;
  AddressType address;
};

[LegacyNamespace=WebAssembly, Exposed=*]
interface Memory {
  constructor(MemoryDescriptor descriptor);
  AddressValue grow(AddressValue delta);
  ArrayBuffer toFixedLengthBuffer();
  ArrayBuffer toResizableBuffer();
  readonly attribute ArrayBuffer buffer;
};

メモリアドレス memaddr から 固定長メモリバッファを作成するには、次の手順を実行する:

1. block を、memaddr の基底メモリと 対応付けられている Data Block とする。

2. buffer を、内部スロット [[ArrayBufferData]]、[[ArrayBufferByteLength]]、および [[ArrayBufferDetachKey]] を持つ新しい ArrayBuffer とする。

3. buffer.[[ArrayBufferData]] を block に設定する。

4. buffer.[[ArrayBufferByteLength]] を block の長さに設定する。

5. buffer.[[ArrayBufferDetachKey]] を "WebAssembly.Memory" に設定する。

6. buffer を返す。

メモリアドレス memaddr および maxsize から リサイズ可能な メモリバッファを作成するには、次の手順を実行する:

1. block を、memaddr の基底メモリと 対応付けられている Data Block とする。

2. length を block の長さとする。

3. buffer を、内部スロット [[ArrayBufferData]]、[[ArrayBufferByteLength]]、 [[ArrayBufferMaxByteLength]]、および [[ArrayBufferDetachKey]] を持つ新しい ArrayBuffer とする。

4. buffer.[[ArrayBufferData]] を block に設定する。

5. buffer.[[ArrayBufferByteLength]] を length に設定する。

6. buffer.[[ArrayBufferMaxByteLength]] を maxsize に設定する。

7. buffer.[[ArrayBufferDetachKey]] を "WebAssembly.Memory" に設定する。

8. buffer を返す。

メモリアドレス memaddr から メモリオブジェクトを 初期化する memoryには、次の手順を実行する:

1. map を、surrounding agent に関連付けられた Memory object cache とする。

2. Assert: map[memaddr] は 存在しない。

3. buffer を、memaddr から 固定長メモリバッファを作成する 結果とする。

4. memory.[[Memory]] を memaddr に設定する。

5. memory.[[BufferObject]] を buffer に設定する。

6. Set map[memaddr] を memory に設定する。

メモリアドレス memaddr から メモリオブジェクトを作成するには、 次の手順を実行する:

1. map を、surrounding agent に関連付けられた Memory object cache とする。

2. map[memaddr] が 存在する 場合、

   1. map[memaddr] を返す。

3. memory を new Memory とする。

4. memaddr から memory を 初期化 する。

5. memory を返す。

Memory(descriptor) コンストラクターは、呼び出されると、 次の手順を実行する:

1. descriptor["address"] が 存在する 場合、 addrtype を descriptor["address"] とする; そうでなければ、 addrtype を "i32" とする。

2. initial を ? AddressValueToU64(descriptor["initial"], addrtype) とする。

3. descriptor["maximum"] が 存在する 場合、 maximum を ? AddressValueToU64(descriptor["maximum"], addrtype) とする; そうでなければ、maximum を empty とする。

4. memtype を memory type addrtype { min initial, max maximum } とする。

5. memtype が 妥当 でない場合、RangeError 例外を throw する。

6. store を、surrounding agent の associated store とする。

7. (store, memaddr) を mem_alloc(store, memtype) とする。 割り当てに失敗した場合、RangeError 例外を throw する。

8. surrounding agent の associated store を store に設定する。

9. memaddr から this を 初期化 する。

memaddr の Memory バッファを更新するには、 次の手順を実行する:

1. map を、surrounding agent に関連付けられた Memory object cache とする。

2. Assert: map[memaddr] は 存在する。

3. memory を map[memaddr] とする。

4. buffer を memory.[[BufferObject]] とする。

5. IsFixedLengthArrayBuffer(buffer) が true の場合、

   1. ! DetachArrayBuffer(buffer, "WebAssembly.Memory") を実行する。

   2. buffer を、memaddr から 固定長メモリバッファを作成する 結果とする。

   3. memory.[[BufferObject]] を buffer に設定する。

6. それ以外の場合、

   1. block を、memaddr の基底メモリと 対応付けられている Data Block とする。

   2. buffer.[[ArrayBufferData]] を block に設定する。

   3. buffer.[[ArrayBufferByteLength]] を block の長さに設定する。

メモリアドレス memaddr に関連付けられた メモリバッファを拡張する には、delta だけ、次の手順を実行する:

1. store を、surrounding agent の associated store とする。

2. ret を mem_size(store, memaddr) とする。

3. store を mem_grow(store, memaddr, delta) とする。

4. store が error なら、RangeError 例外を throw する。

5. surrounding agent の associated store を store に設定する。

6. memaddr の メモリバッファを更新する。

7. ret を返す。

grow(delta) メソッドは、呼び出されると、次の手順を実行する:

1. memaddr を this.[[Memory]] とする。

2. store を、surrounding agent の associated store とする。

3. addrtype を、address type in mem_type(store, memaddr) とする。

4. delta64 を ? AddressValueToU64(delta, addrtype) とする。

5. ret を memaddr に関連付けられた メモリバッファを拡張する 結果とし、 delta64 だけ。

6. U64ToAddressValue(ret, addrtype) を返す。

1. スタック最上部が i32.const (−1) でなく、かつスタック最上部が i64.const (−1) でもない場合、

   1. frame を 現在のフレーム とする。

   2. Assert: 検証により、frame.module.memaddrs[x] は存在する。

   3. memaddr をメモリアドレス frame.module.memaddrs[x] とする。

   4. memaddr の メモリバッファを更新する。

toFixedLengthBuffer() メソッドは、呼び出されると、 次の手順を実行する:

1. buffer を this.[[BufferObject]] とする。

2. IsFixedLengthArrayBuffer(buffer) が true なら、buffer を返す。

3. memaddr を this.[[Memory]] とする。

4. fixedBuffer を、memaddr から 固定長メモリバッファを作成する 結果とする。

5. ! DetachArrayBuffer(buffer, "WebAssembly.Memory") を実行する。

6. this.[[BufferObject]] を fixedBuffer に設定する。

7. fixedBuffer を返す。

toResizableBuffer() メソッドは、呼び出されると、 次の手順を実行する:

1. memaddr を this.[[Memory]] とする。

2. store を、surrounding agent の associated store とする。

3. memtype を mem_type(store, memaddr) とする。

4. memtype が max を持たない場合、

   1. Throw a TypeError exception.

5. buffer を this.[[BufferObject]] とする。

6. IsFixedLengthArrayBuffer(buffer) が false なら、buffer を返す。

7. Assert: memtype は max を持つ。

8. maxsize を memtype の max 値 * 65536 とする。

9. resizableBuffer を、memaddr と maxsize から リサイズ可能なメモリバッファを作成する 結果とする。

10. ! DetachArrayBuffer(buffer, "WebAssembly.Memory") を実行する。

11. this.[[BufferObject]] を resizableBuffer に設定する。

12. resizableBuffer を返す。

抽象操作 HostResizeArrayBuffer は、 引数 buffer（ArrayBuffer） および newLength を取る。呼び出されたとき、次の手順を実行する。

1. buffer.[[ArrayBufferDetachKey]] が "WebAssembly.Memory" の場合、

   1. map を、surrounding agent に関連付けられた Memory object cache とする。

   2. Assert: buffer は、map 内のちょうど 1 つの値の [[BufferObject]] である。

   3. 各 memaddr → mem について map 内の、

      1. SameValue(mem.[[BufferObject]], buffer) が true の場合、

         1. Assert: buffer.[[ArrayBufferByteLength]] modulo 65536 は 0 である。

         2. lengthDelta を newLength - buffer.[[ArrayBufferByteLength]] とする。

         3. lengthDelta < 0、または lengthDelta modulo 65536 が 0 でない場合、

            1. RangeError 例外を throw する。

         4. delta を lengthDelta ÷ 65536 とする。

         5. memaddr に関連付けられた メモリバッファを拡張する を delta だけ行う。

   4. handled を返す。

2. それ以外の場合、unhandled を返す。

Memory の buffer 属性の getter は、 this.[[BufferObject]] を返す。

enum TableKind {
  "externref",
  "anyfunc",
  // 注: 将来の反復でさらに値が追加される可能性がある,
  // 例: 型付き関数参照, 型付き GC 参照
};

dictionary TableDescriptor {
  required TableKind element;
  required AddressValue initial;
  AddressValue maximum;
  AddressType address;
};

[LegacyNamespace=WebAssembly, Exposed=*]
interface Table {
  constructor(TableDescriptor descriptor, optional any value);
  AddressValue grow(AddressValue delta, optional any value);
  any get(AddressValue index);
  undefined set(AddressValue index, optional any value);
  readonly attribute AddressValue length;
};

テーブルアドレス tableaddr から テーブルオブジェクトを 初期化する tableには、次の手順を実行する:

1. map を、surrounding agent に関連付けられた Table object cache とする。

2. Assert: map[tableaddr] は 存在しない。

3. table.[[Table]] を tableaddr に設定する。

4. Set map[tableaddr] を table に設定する。

テーブルアドレス tableaddr から テーブルオブジェクトを作成するには、 次の手順を実行する:

1. map を、surrounding agent に関連付けられた Table object cache とする。

2. map[tableaddr] が 存在する 場合、

   1. map[tableaddr] を返す。

3. table を new Table とする。

4. tableaddr から table を 初期化 する。

5. table を返す。

Table(descriptor, value) コンストラクターは、呼び出されると、 次の手順を実行する:

1. elementtype を ToValueType(descriptor["element"]) とする。

2. elementtype が reftype でない場合、

   1. Throw a TypeError exception.

3. descriptor["address"] が 存在する 場合、 addrtype を descriptor["address"] とする; そうでなければ、 addrtype を "i32" とする。

4. initial を ? AddressValueToU64(descriptor["initial"], addrtype) とする。

5. descriptor["maximum"] が 存在する 場合、 maximum を ? AddressValueToU64(descriptor["maximum"], addrtype) とする; そうでなければ、maximum を empty とする。

6. type を table type addrtype { min initial, max maximum } elementtype とする。

7. type が 妥当 でない場合、RangeError 例外を throw する。

8. value が欠けている場合、

   1. ref を DefaultValue(elementtype) とする。

   2. Assert: ref は error ではない。

9. それ以外の場合、

   1. ref を ? ToWebAssemblyValue(value, elementtype) とする。

10. store を、surrounding agent の associated store とする。

11. (store, tableaddr) を table_alloc(store, type, ref) とする。割り当てに失敗した場合、RangeError 例外を throw する。

12. surrounding agent の associated store を store に設定する。

13. tableaddr から this を 初期化 する。

grow(delta, value) メソッドは、呼び出されると、 次の手順を実行する:

1. tableaddr を this.[[Table]] とする。

2. store を、surrounding agent の associated store とする。

3. initialSize を table_size(store, tableaddr) とする。

4. (addrtype, limits, elementtype) を table_type(store, tableaddr) とする。

5. delta64 を ? AddressValueToU64(delta, addrtype) とする。

6. value が欠けている場合、

   1. ref を DefaultValue(elementtype) とする。

   2. ref が error なら、TypeError 例外を throw する。

7. それ以外の場合、

   1. ref を ? ToWebAssemblyValue(value, elementtype) とする。

8. result を table_grow(store, tableaddr, delta64, ref) とする。

9. result が error なら、RangeError 例外を throw する。

   注: 上記の例外は、 メモリ不足または無効なサイズパラメーターのいずれかにより発生し得る。

10. surrounding agent の associated store を result に設定する。

11. U64ToAddressValue(initialSize, addrtype) を返す。

Table の length 属性の getter は、呼び出されると、 次の手順を実行する:

1. tableaddr を this.[[Table]] とする。

2. store を、surrounding agent の associated store とする。

3. addrtype を、address type in table_type(store, tableaddr) とする。

4. length64 を table_size(store, tableaddr) とする。

5. U64ToAddressValue(length64, addrtype) を返す。

get(index) メソッドは、呼び出されると、次の手順を実行する:

1. tableaddr を this.[[Table]] とする。

2. store を、surrounding agent の associated store とする。

3. (addrtype, limits, elementtype) を table_type(store, tableaddr) とする。

4. elementtype が matches exnref の場合、

   1. TypeError 例外を throw する。

5. index64 を ? AddressValueToU64(index, addrtype) とする。

6. result を table_read(store, tableaddr, index64) とする。

7. result が error なら、RangeError 例外を throw する。

8. ! ToJSValue(result) を返す。

set(index, value) メソッドは、呼び出されると、 次の手順を実行する:

1. tableaddr を this.[[Table]] とする。

2. store を、surrounding agent の associated store とする。

3. (addrtype, limits, elementtype) を table_type(store, tableaddr) とする。

4. elementtype が matches exnref の場合、

   1. TypeError 例外を throw する。

5. index64 を ? AddressValueToU64(index, addrtype) とする。

6. value が欠けている場合、

   1. ref を DefaultValue(elementtype) とする。

   2. ref が error なら、TypeError 例外を throw する。

7. それ以外の場合、

   1. ref を ? ToWebAssemblyValue(value, elementtype) とする。

8. store を table_write(store, tableaddr, index64, ref) とする。

9. store が error なら、RangeError 例外を throw する。

10. surrounding agent の associated store を store に設定する。

enum ValueType {
  "i32",
  "i64",
  "f32",
  "f64",
  "v128",
  "externref",
  "anyfunc",
};

dictionary GlobalDescriptor {
  required ValueType value;
  boolean mutable = false;
};

[LegacyNamespace=WebAssembly, Exposed=*]
interface Global {
  constructor(GlobalDescriptor descriptor, optional any v);
  any valueOf();
  attribute any value;
};

グローバルアドレス globaladdr から グローバルオブジェクトを 初期化する globalには、次の手順を実行する:

1. map を、surrounding agent に関連付けられた Global object cache とする。

2. Assert: map[globaladdr] は 存在しない。

3. global.[[Global]] を globaladdr に設定する。

4. Set map[globaladdr] を global に設定する。

グローバルアドレス globaladdr から グローバルオブジェクトを作成するには、 次の手順を実行する:

1. map を、surrounding agent に関連付けられた Global object cache とする。

2. map[globaladdr] が 存在する 場合、

   1. map[globaladdr] を返す。

3. global を new Global とする。

4. globaladdr から global を 初期化 する。

5. global を返す。

アルゴリズム ToValueType(s) は、次の手順を実行する:

1. s が "i32" に等しい場合、i32 を返す。

2. s が "i64" に等しい場合、i64 を返す。

3. s が "f32" に等しい場合、f32 を返す。

4. s が "f64" に等しい場合、f64 を返す。

5. s が "v128" に等しい場合、v128 を返す。

6. s が "anyfunc" に等しい場合、funcref を返す。

7. s が "externref" に等しい場合、externref を返す。

8. Assert: この段階には到達しない。

アルゴリズム DefaultValue(valuetype) は、次の手順を実行する:

1. valuetype が externref に等しい場合、! ToWebAssemblyValue(undefined, valuetype) を返す。

2. val_default(valuetype) を返す。

Global(descriptor, v) コンストラクターは、呼び出されると、 次の手順を実行する:

1. mutable を descriptor["mutable"] とする。

2. valuetype を ToValueType(descriptor["value"]) とする。

3. valuetype が matches v128 または exnref の場合、

   1. TypeError 例外を throw する。

4. v が欠けている場合、

   1. value を DefaultValue(valuetype) とする。

   2. Assert: value は error ではない。

5. それ以外の場合、

   1. value を ? ToWebAssemblyValue(v, valuetype) とする。

6. mutable が true の場合、globaltype を var valuetype とする; そうでなければ、 globaltype を const valuetype とする。

7. store を、surrounding agent の associated store とする。

8. (store, globaladdr) を global_alloc(store, globaltype, value) とする。

9. surrounding agent の associated store を store に設定する。

10. globaladdr から this を 初期化 する。

アルゴリズム GetGlobalValue(Global global) は、次の手順を実行する:

1. store を、surrounding agent の associated store とする。

2. globaladdr を global.[[Global]] とする。

3. globaltype を global_type(store, globaladdr) とする。

4. globaltype が mut valuetype の形式であり、 valuetype が matches v128 または exnref の場合、TypeError を throw する。

5. value を global_read(store, globaladdr) とする。

6. ! ToJSValue(value) を返す。

Global の value 属性の getter は、呼び出されると、 次の手順を実行する:

1. GetGlobalValue(this) を返す。

Global の value 属性の setter は、 呼び出されると、次の手順を実行する:

1. store を、surrounding agent の associated store とする。

2. globaladdr を this.[[Global]] とする。

3. mut valuetype を global_type(store, globaladdr) とする。

4. valuetype が matches v128 または exnref の場合、TypeError を throw する。

5. mut が const の場合、TypeError を throw する。

6. value を ? ToWebAssemblyValue(the given value, valuetype) とする。

7. store を global_write(store, globaladdr, value) とする。

8. store が error なら、RangeError 例外を throw する。

9. surrounding agent の associated store を store に設定する。

valueOf() メソッドは、呼び出されると、次の手順を実行する:

1. GetGlobalValue(this) を返す。

WebAssembly 関数の名前 funcaddr は、次の手順を実行して求められる:

1. store を 周囲の agent の 関連付けられた store とする。

2. funcinst を store.funcs[funcaddr] とする。

3. funcinst が {type functype, hostcode hostfunc} の形式である場合、

   1. Assert: hostfunc は JavaScript オブジェクトであり、IsCallable(hostfunc) は true である。

   2. index を、ホスト関数 funcaddr の ホスト関数インデックス とする。

4. それ以外の場合、

   1. moduleinst を funcinst.module とする。

   2. Assert: funcaddr は moduleinst.funcaddrs に含まれている。

   3. index を、funcaddr が見つかる moduleinst.funcaddrs のインデックスとする。

5. ! ToString(index) を返す。

WebAssembly の 関数アドレス funcaddr から 新しい Exported Function を作成するには、次の手順を実行する:

1. map を 周囲の agent の関連する Exported Function cache とする。

2. map[funcaddr] が 存在する 場合、

   1. map[funcaddr] を返す。

3. steps を「"Exported Function を呼び出す funcaddr with arguments."」とする。

4. realm を 現在の Realm とする。

5. store を 周囲の agent の 関連付けられた store とする。

6. functype を func_type(store, funcaddr) とする。

7. [paramTypes] → [resultTypes] を functype とする。

8. arity を paramTypes の size とする。

9. name を、funcaddr に対応する WebAssembly 関数の名前 とする。

10. function を ! CreateBuiltinFunction(steps, arity, name, « [[FunctionAddress]] », realm) とする。

11. function.[[FunctionAddress]] を funcaddr に設定する。

12. Set map[funcaddr] を function に設定する。

13. function を返す。

関数アドレス funcaddr と、 JavaScript 引数の リスト argValues を用いて Exported Function を呼び出すには、次の手順を実行する:

1. store を 周囲の agent の 関連付けられた store とする。

2. functype を func_type(store, funcaddr) とする。

3. [parameters] → [results] を functype とする。

4. parameters または results のいずれかの型が matches v128 または exnref である場合、TypeError を throw する。

   注: 上記のエラーは、 [[Call]] メソッドが呼び出されるたびに throw される。

5. args を « » とする。

6. i を 0 とする。

7. 各 t について parameters の、

   1. argValues の size > i なら、arg を argValues[i] とする。

   2. それ以外の場合、arg を undefined とする。

   3. Append ? ToWebAssemblyValue(arg, t) を args に追加する。

   4. i を i + 1 に設定する。

8. (store, ret) を func_invoke(store, funcaddr, args) の結果とする。

9. 周囲の agent の 関連付けられた store を store に設定する。

10. ret が error なら、例外を throw する。この例外は、 特に WebAssembly エラー対応付け に別段の記載がない限り、 WebAssembly の RuntimeError 例外であるべきである。

11. ret が exception exnaddr である場合、

    1. tagaddr を exn_tag(store, exnaddr) とする。

    2. payload を exn_read(store, exnaddr) とする。

    3. jsTagAddr を、JavaScript 例外タグを取得する 結果とする。

    4. tagaddr が jsTagAddr と等しい場合、

       1. ! ToJSValue(payload[0]) を throw する。

    5. それ以外の場合、

       1. exception を、exnaddr から作成された 新しい Exception とする。

       2. exception を throw する。

12. outArity を ret の size とする。

13. outArity が 0 なら、undefined を返す。

14. それ以外で、outArity が 1 なら、! ToJSValue(ret[0]) を返す。

15. それ以外の場合、

    1. values を « » とする。

    2. 各 r について ret の、

       1. Append ! ToJSValue(r) を values に追加する。

    3. CreateArrayFromList(values) を返す。

JavaScript オブジェクト func、型 functype、 および リスト の WebAssembly 値 arguments から ホスト関数を実行するには、 次の手順を実行する:

1. [parameters] → [results] を functype とする。

2. parameters または results のいずれかの型が matches v128 または exnref である場合、TypeError を throw する。

3. jsArguments を « » とする。

4. 各 arg について arguments の、

   1. Append ! ToJSValue(arg) を jsArguments に追加する。

5. ret を ? Call(func, undefined, jsArguments) の結果とする。

6. resultsSize を results の size とする。

7. resultsSize が 0 なら、« » を返す。

8. それ以外で、resultsSize が 1 なら、« ? ToWebAssemblyValue(ret, results[0]) » を返す。

9. それ以外の場合、

   1. method を ? GetMethod(ret, %Symbol.iterator%) とする。

   2. method が undefined なら、throw a TypeError。

   3. values を ? IteratorToList(? GetIteratorFromMethod(ret, method)) とする。

   4. wasmValues を新しい空の リスト とする。

   5. values の size が resultsSize でない場合、TypeError 例外を throw する。

   6. values の各 value と results の各 resultType を線形に対応付けて、

      1. Append ? ToWebAssemblyValue(value, resultType) を wasmValues に追加する。

   7. wasmValues を返す。

JavaScript オブジェクト func と型 functype から ホスト関数を作成するには、 次の手順を実行する:

1. Assert: IsCallable(func)。

2. stored settings を 現在の設定オブジェクト とする。

3. hostfunc を、引数 arguments で呼び出されたときに 次の手順を実行する ホスト関数 とする:

   1. realm を func の 関連付けられた Realm とする。

   2. relevant settings を realm の settings object とする。

   3. Prepare to run script with relevant settings.

   4. Prepare to run a callback with stored settings.

   5. result を、func、functype、および arguments から ホスト関数を実行する 結果とする。

   6. Clean up after running a callback with stored settings.

   7. Clean up after running script with relevant settings.

   8. Assert: result.[[Type]] は throw または normal である。

   9. store を 周囲の agent の 関連付けられた store とする。

   10. result.[[Type]] が throw の場合、:

       1. v を result.[[Value]] とする。

       2. v が implements Exception の場合、

          1. address を v.[[Address]] とする。

       3. それ以外の場合、

          1. type を、JavaScript 例外タグを取得する 結果とする。

          2. payload を ! ToWebAssemblyValue(v, externref) とする。

          3. (store, address) を exn_alloc(store, type, « payload ») とする。

          4. 周囲の agent の 関連付けられた store を store に設定する。

       4. WebAssembly 命令 (ref.exn address) (throw_ref) を実行する。

   11. それ以外の場合、result.[[Value]] を返す。

4. store を 周囲の agent の 関連付けられた store とする。

5. (store, funcaddr) を func_alloc(store, functype, hostfunc) とする。

6. 周囲の agent の 関連付けられた store を store に設定する。

7. funcaddr を返す。

アルゴリズム ToJSValue(w) は、 WebAssembly 値 を JavaScript 値へ強制変換する。 次の手順を実行する:

1. Assert: w は v128.const v128 の形式ではない。

2. Assert: w は ref.exn exnaddr の形式ではない。

3. w が i64.const u64 の形式である場合、

   1. i64 を signed_64(u64) とする。

   2. ℤ(i64 interpreted as a 数学的値) を返す。

4. w が i32.const u32 の形式である場合、

   1. i32 を signed_32(u32) とする。

   2. 𝔽(i32 interpreted as a 数学的値) を返す。

5. w が f32.const f32 の形式である場合、

   1. f32 が +∞ または −∞ の場合、それぞれ +∞_𝔽 または -∞_𝔽 を返す。

   2. f32 が nan の場合、NaN を返す。

   3. 𝔽(f32 interpreted as a 数学的値) を返す。

6. w が f64.const f64 の形式である場合、

   1. f64 が +∞ または −∞ の場合、それぞれ +∞_𝔽 または -∞_𝔽 を返す。

   2. f64 が nan の場合、NaN を返す。

   3. 𝔽(f64 interpreted as a 数学的値) を返す。

7. w が ref.null t の形式である場合、null を返す。

8. w が ref.i31 u31 の形式である場合、

   1. i31 を signed_31(u31) とする。

   2. 𝔽(i31) を返す。

9. w が ref.struct structaddr の形式である場合、新しい Exported GC Object を structaddr と "struct" から作成した結果を返す。

10. w が ref.array arrayaddr の形式である場合、新しい Exported GC Object を arrayaddr と "array" から作成した結果を返す。

11. w が ref.func funcaddr の形式である場合、新しい Exported Function を funcaddr から作成した結果を返す。

12. w が ref.host hostaddr の形式である場合、ホスト値を取得する を hostaddr から行った結果を返す。

13. w が ref.extern ref の形式である場合、ToJSValue(ref) を返す。

注: NaN に等しい Number 値は、 観測可能なさまざまな NaN ペイロードを持ち得る; 詳細は NumericToRawBytes を参照。

ホスト値を取得する ために、ホストアドレス hostaddr から、次の手順を実行する:

1. map を 周囲の agent の関連する host value cache とする。

2. Assert: map[hostaddr] は 存在する。

3. map[hostaddr] を返す。

アルゴリズム ToWebAssemblyValue(v, type) は、JavaScript 値を WebAssembly 値 に強制変換する。 次の手順を実行する:

1. Assert: type は v128 ではない。

2. Assert: type は match exnref しない。

3. type が i64 の場合、

   1. i64 を ? ToBigInt64(v) とする。

   2. u64 を、i64 が signed_64(u64) となるような符号なし整数とする。

   3. i64.const u64 を返す。

4. type が i32 の場合、

   1. i32 を ? ToInt32(v) とする。

   2. u32 を、i32 が signed_32(u32) となるような符号なし整数とする。

   3. i32.const u32 を返す。

5. type が f32 の場合、

   1. number を ? ToNumber(v) とする。

   2. number が NaN の場合、

      1. n を、canon₃₂ ≤ n < 2^signif(32) を満たす 実装定義の整数とする。

      2. f32 を nan(n) とする。

   3. それ以外の場合、

      1. f32 を、IEEE 754-2019 の最近接丸め・同値の場合偶数丸めモードを用いて、 number を最も近い表現可能値へ丸めたものとする。[IEEE-754]

   4. f32.const f32 を返す。

6. type が f64 の場合、

   1. number を ? ToNumber(v) とする。

   2. number が NaN の場合、

      1. n を、canon₆₄ ≤ n < 2^signif(64) を満たす 実装定義の整数とする。

      2. f64 を nan(n) とする。

   3. それ以外の場合、

      1. f64 を number とする。

   4. f64.const f64 を返す。

7. type が ref null heaptype の形式である場合、

   1. v が null の場合、

      1. r を ref.null heaptype とする。

   2. Else if match_valtype(type, ref null extern) の場合、

      1. ref を ! ToWebAssemblyValue(v, ref any) とする。

      2. r を ref.extern ref とする。

   3. Else if v が Exported Function であり、かつ match_valtype(type, ref null func) の場合、

      1. funcaddr を v の [[FunctionAddress]] 内部スロットの値とする。

      2. r を ref.func funcaddr とする。

   4. Else if v が Number であり、 v が ? ToInt32(v) と等しく、かつ ℝ(v) < 2³⁰ かつ ℝ(v) ⩾ -2³⁰ の場合、

      1. i31 を ? ToInt32(v) とする。

      2. u31 を、i31 が signed_31(u31) となるような符号なし整数とする。

      3. r を ref.i31 u31 とする。

   5. Else if v が Exported GC Object の場合、

      1. objectaddr を v の [[ObjectAddress]] 内部スロットの値とする。

      2. objectkind を v の [[ObjectKind]] 内部スロットの値とする。

      3. objectkind が "array" の場合、

         1. r を ref.array objectaddr とする。

      4. Else if objectkind が "struct" の場合、

         1. r を ref.struct objectaddr とする。

   6. Else,

      1. map を 周囲の agent の関連する host value cache とする。

      2. map[hostaddr] が v と同一であるような host address hostaddr が存在する場合、

         1. ref.host hostaddr を返す。

      3. map[hostaddr] exists が false であるような最小の host address hostaddr をとる。

      4. Set map[hostaddr] を v に設定する。

      5. r を ref.host hostaddr とする。

   7. store を 周囲の agent の 関連付けられた store とする。

   8. actualtype を ref_type(store, r) とする。

   9. match_valtype(actualtype, type) が false の場合、

      1. TypeError を throw する。

   10. r を返す。

8. Assert: この段階には到達しない。

アルゴリズム AddressValueToU64(v, addrtype) は、JavaScript 値を埋め込み操作で使用するための WebAssembly u64 に変換する。これは、 AddressType "i32" に対しては [EnforceRange] unsigned long のように振る舞うよう設計されており、 さらにその意味論を AddressType "i64" に拡張する。次の手順を実行する:

1. addrtype が "i32" の場合、

   1. n を ? ConvertToInt(v, 32, "unsigned") とする。ここで、宛先型は [EnforceRange] に関連付けられている。

      注: これは、JS conversion rules for [EnforceRange] unsigned long と等価である。

   2. WebAssembly の u64 として ℝ(n) を返す。

2. addrtype が "i64" の場合、

   1. n を ? ToBigInt(v) とする。

   2. n < 0 または n > 2⁶⁴ − 1 の場合、throw a TypeError。

      注: この操作は、 [EnforceRange] を模倣するよう設計されている。

   3. WebAssembly の u64 として ℝ(n) を返す。

3. Assert: この段階には到達しない。

アルゴリズム U64ToAddressValue(v, addrtype) は、 WebAssembly 埋め込み操作から得られた u64 値を、正しい種類の AddressValue に変換する。これは AddressType に対するものであり、次の手順を実行する:

1. addrtype が "i32" の場合、𝔽(v interpreted as a 数学的値) を返す。

2. Else if addrtype が "i64" の場合、ℤ(v interpreted as a 数学的値) を返す。

3. Assert: この段階には到達しない。

dictionary TagType {
  required sequence<ValueType> parameters;
};

[LegacyNamespace=WebAssembly, Exposed=(Window,Worker,Worklet)]
interface Tag {
  constructor(TagType type);
};

Tag オブジェクトを初期化する ために、タグアドレス tagAddress から tag を初期化するには、 次の手順を実行する:

1. map を 周囲の agent に関連付けられた Tag object cache とする。

2. Assert: map[tagAddress] は 存在しない。

3. tag.[[Address]] を tagAddress に設定する。

4. Set map[tagAddress] を tag に設定する。

Tag オブジェクトを作成する ために、タグアドレス tagAddress から、次の手順を実行する:

1. map を 周囲の agent に関連付けられた Tag object cache とする。

2. map[tagAddress] が 存在する 場合、

   1. map[tagAddress] を返す。

3. tag を new Tag とする。

4. Initialize tag を tagAddress から行う。

5. tag を返す。

new Tag(type) コンストラクターの手順は次のとおり:

1. parameters を type["parameters"] とする。

2. wasmParameters を «» とする。

3. 各 paramType について parameters の、

   1. Append ToValueType(paramType) を wasmParameters に追加する。

4. store を 周囲の agent の 関連付けられた store とする。

5. (store, tagAddress) を tag_alloc(store, wasmParameters → « ») とする。

6. 周囲の agent の 関連付けられた store を store に設定する。

7. Initialize this を tagAddress から行う。

Exported GC Object の [[GetPrototypeOf]] 内部メソッド O は引数を取らず null を返す。呼び出されたとき、次の手順を実行する:

1. null を返す。

Exported GC Object の [[SetPrototypeOf]] 内部メソッド O は引数 V（Object または null）を取り、 boolean を返す。呼び出されたとき、次の手順を実行する:

1. false を返す。

Exported GC Object の [[IsExtensible]] 内部メソッド O は引数を取らず boolean を返す。呼び出されたとき、 次の手順を実行する:

1. false を返す。

Exported GC Object の [[PreventExtensions]] 内部メソッド O は引数を取らず boolean を返す。呼び出されたとき、 次の手順を実行する:

1. false を返す。

Exported GC Object の [[GetOwnProperty]] 内部メソッド O は引数 P（property key）を取り、 undefined を返す。呼び出されたとき、次の手順を実行する:

1. undefined を返す。

Exported GC Object の [[DefineOwnProperty]] 内部メソッド O は引数 P（property key）および Desc（property descriptor）を取り、boolean を返す。呼び出されたとき、 次の手順を実行する:

1. false を返す。

Exported GC Object の [[HasProperty]] 内部メソッド O は引数 P（property key）を取り、 boolean を返す。呼び出されたとき、次の手順を実行する:

1. false を返す。

Exported GC Object の [[Get]] 内部メソッド O は引数 P（property key）および Receiver（ECMAScript 言語値） を取り、undefined を返す。呼び出されたとき、次の手順を実行する:

1. undefined を返す。

Exported GC Object の [[Set]] 内部メソッド O は引数 P（property key）、V（ECMAScript 言語値）、 および Receiver（ECMAScript 言語値）を取り、例外を投げる。 呼び出されたとき、次の手順を実行する:

1. TypeError を throw する。

Exported GC Object の [[Delete]] 内部メソッド O は引数 P（property key）を取り、 例外を投げる。呼び出されたとき、次の手順を実行する:

1. TypeError を throw する。

Exported GC Object の [[OwnPropertyKeys]] 内部メソッド O は引数を取らず list を返す。呼び出されたとき、 次の手順を実行する:

1. keys を新しい空の list とする。

2. keys を返す。

新しい Exported GC Object を WebAssembly の object address objectaddr と文字列 objectkind から作成するには、次の手順を実行する:

1. Assert: objectkind は "array" または "struct" のいずれかである。

2. map を 周囲の agent に関連付けられた exported GC object cache とする。

3. map[objectaddr] が 存在する 場合、

   1. map[objectaddr] を返す。

4. object を MakeBasicObject(« [[ObjectAddress]], [[ObjectKind]] ») とする。

5. object.[[ObjectAddress]] を objectaddr に設定する。

6. object.[[ObjectKind]] を objectkind に設定する。

7. object.[[GetPrototypeOf]] を Exported GC Object の [[GetPrototypeOf]] 内部メソッド で指定されるものに設定する。

8. object.[[SetPrototypeOf]] を Exported GC Object の [[SetPrototypeOf]] 内部メソッド で指定されるものに設定する。

9. object.[[IsExtensible]] を Exported GC Object の [[IsExtensible]] 内部メソッド で指定されるものに設定する。

10. object.[[PreventExtensions]] を Exported GC Object の [[PreventExtensions]] 内部メソッド で指定されるものに設定する。

11. object.[[GetOwnProperty]] を Exported GC Object の [[GetOwnProperty]] 内部メソッド で指定されるものに設定する。

12. object.[[DefineOwnProperty]] を Exported GC Object の [[DefineOwnProperty]] 内部メソッド で指定されるものに設定する。

13. object.[[HasProperty]] を Exported GC Object の [[HasProperty]] 内部メソッド で指定されるものに設定する。

14. object.[[Get]] を Exported GC Object の [[Get]] 内部メソッド で指定されるものに設定する。

15. object.[[Set]] を Exported GC Object の [[Set]] 内部メソッド で指定されるものに設定する。

16. object.[[Delete]] を Exported GC Object の [[Delete]] 内部メソッド で指定されるものに設定する。

17. object.[[OwnPropertyKeys]] を Exported GC Object の [[OwnPropertyKeys]] 内部メソッド で指定されるものに設定する。

18. Set map[objectaddr] を object に設定する。

19. object を返す。

dictionary ExceptionOptions {
  boolean traceStack = false;
};

[LegacyNamespace=WebAssembly, Exposed=(Window,Worker,Worklet)]
interface Exception {
  constructor(Tag exceptionTag, sequence<any> payload, optional ExceptionOptions options = {});
  any getArg(Tag exceptionTag, [EnforceRange] unsigned long index);
  boolean is(Tag exceptionTag);
  readonly attribute (DOMString or undefined) stack;
};

Exception オブジェクトを初期化する ために、exn を Exception address exnAddress から初期化するには、 次の手順を実行する:

1. map を 周囲の agent に関連付けられた Exception object cache とする。

2. Assert: map[exnAddress] は 存在しない。

3. exn.[[Address]] を exnAddress に設定する。

4. Set map[exnAddress] を exn に設定する。

5. store を 周囲の agent の 関連付けられた store とする。

6. tagaddr を exn_tag(store, exnAddress) とする。

7. payload を exn_read(store, exnAddress) とする。

8. exn.[[Type]] を tagaddr に設定する。

9. exn.[[Payload]] を payload に設定する。

10. exn.[[Stack]] を undefined に設定する。

Exception オブジェクトを作成する ために、exception address exnAddress から、 次の手順を実行する:

1. map を 周囲の agent に関連付けられた Exception object cache とする。

2. map[exnAddress] が 存在する 場合、

   1. map[exnAddress] を返す。

3. exn を new Exception とする。

4. Initialize exn を exnAddress から行う。

5. exn を返す。

new Exception(exceptionTag, payload, options) コンストラクターの手順は次のとおり:

1. JSTagAddr を JavaScript 例外タグを取得する 結果とする。

2. exceptionTag.[[Address]] が JSTagAddr と等しい場合、

   1. TypeError を throw する。

3. store を 周囲の agent の 関連付けられた store とする。

4. [types] → [] を tag_type(store, exceptionTag.[[Address]]) とする。

5. types の size が payload の size と等しくない場合、

   1. TypeError を throw する。

6. wasmPayload を « » とする。

7. 各 value と resultType について、 payload と types を線形に対応付けて、

   1. resultType が matches v128 または exnref の場合、

      1. TypeError を throw する。

   2. Append ? ToWebAssemblyValue(value, resultType) を wasmPayload に追加する。

8. (store, exceptionAddr) を exn_alloc(store, exceptionTag.[[Address]], wasmPayload) とする。

9. 周囲の agent の 関連付けられた store を store に設定する。

10. Initialize this を exceptionAddr から行う。

11. options["traceStack"] が true の場合、

    1. this.[[Stack]] を、現在のコールスタックの DOMString 表現または undefined のいずれかに設定する。

getArg(exceptionTag, index) メソッドの手順は次のとおり:

1. store を 周囲の agent の 関連付けられた store とする。

2. this.[[Type]] が exceptionTag.[[Address]] と等しくない場合、

   1. TypeError を throw する。

3. tagaddr を exn_tag(store, this.[[Address]]) とする。

4. payload を exn_read(store, this.[[Address]]) とする。

5. Assert: tagaddr は this.[[Type]] と等しい。

6. index ≥ payload の size の場合、

   1. RangeError を throw する。

7. [types] → [] を tag_type(store, tagaddr) とする。

8. types[index] が matches v128 または exnref の場合、

   1. TypeError を throw する。

9. ! ToJSValue(payload[index]) を返す。

is(exceptionTag) メソッドの手順は次のとおり:

1. this.[[Type]] が exceptionTag.[[Address]] と等しくない場合、

   1. false を返す。

2. true を返す。

stack getter の手順は次のとおり:

1. this.[[Stack]] を返す。

JavaScript 例外タグを取得する には、次の手順を実行する:

1. 周囲の agent に関連付けられた JavaScript exception tag が初期化済みである場合、

   1. 周囲の agent に関連付けられた JavaScript exception tag を返す

2. store を 周囲の agent の 関連付けられた store とする。

3. (store, tagAddress) を tag_alloc(store, « externref » → « ») とする。

4. 周囲の agent の 関連付けられた store を store に設定する。

5. 周囲の agent に関連付けられた JavaScript exception tag を tagAddress に設定する。

6. tagAddress を返す。

WebAssembly 名前空間の namespace object が 作成される とき、次の手順を実行しなければならない:

1. namespaceObject を namespace object とする。

2. 各 error について « "CompileError", "LinkError", "RuntimeError" » の、

   1. constructor を、NativeError Object Structure を実装する 新しいオブジェクトとし、NativeError を error に設定する。

   2. ! DefineMethodProperty(namespaceObject, error, constructor, false)。

ビルトイン集合の ビルトインを取得する ために、builtinSetName を用いて、 次の手順を実行する:

1. この節内で定義された、名前 builtinSetName を持つ集合について、 (name, funcType, steps) のリストを返す。

ビルトインを見つける ために、import および有効化されたビルトイン builtinSetNames を用いて、 次の手順を実行する:

1. Assert: ビルトイン集合名を検証する builtinSetNames は true である。

2. importModuleName を import[0] とする。

3. importName を import[1] とする。

4. 各 builtinSetName について builtinSetNames の、

   1. builtinSetName がビルトイン集合を指さない場合、continue する。

   2. builtinSetQualifiedName を builtinSetName に "wasm:" を接頭させたものとする。

   3. importModuleName が builtinSetQualifiedName と等しい場合、

      1. builtins を ビルトイン集合のビルトインを取得する builtinSetName の結果とする。

      2. 各 builtin について builtins の、

         1. builtinName を builtin[0] とする。

         2. importName が builtinName と等しい場合、 (builtinSetName, builtin) を返す。

5. null を返す。

ビルトイン集合名を検証する ために、builtinSetNames を用いて、次の手順を実行する:

1. builtinSetNames に重複が含まれている場合、false を返す。

2. true を返す。

ビルトイン関数を作成する ために、型 funcType および実行手順 steps から、 次の手順を実行する:

1. hostfunc を、呼び出されたときに steps を実行する host function とする。

2. store を 周囲の agent の 関連付けられた store とする。

3. (store, funcaddr) を func_alloc(store, funcType, hostfunc) とする。

4. 周囲の agent の 関連付けられた store を store に設定する。

5. funcaddr を返す。

ビルトイン集合を実体化する ために、名前 builtinSetName を用いて、次の手順を実行する:

1. builtins を ビルトイン集合のビルトインを取得する builtinSetName の結果とする。

2. exportsObject を ! OrdinaryObjectCreate(null) とする。

3. 各 (name, funcType, steps) について builtins の、

   1. funcaddr を ビルトイン関数を作成する funcType と steps を用いた結果とする。

   2. func を、funcaddr から 新しい Exported Function を作成する結果とする。

   3. value を func とする。

   4. status を ! CreateDataProperty(exportsObject, name, value) とする。

   5. Assert: status は true である。

4. exportsObject を返す。

ビルトインに対するインポートを検証する ために、import、 有効化されたビルトイン builtinSetNames を用いて、次の手順を実行する:

1. Assert: ビルトイン集合名を検証する builtinSetNames は true である。

2. maybeBuiltin を ビルトインを見つける import と builtinSetNames に対する結果とする。

3. maybeBuiltin が null なら、true を返す。

4. importExternType を import[2] とする。

5. builtinFuncType を maybeBuiltin[1][1] とする。

6. builtinExternType を func |builtinFuncType| とする。

7. match_externtype(builtinExternType, importExternType) を返す。

UnwrapString(v) 抽象操作は、呼び出されると、 次の手順を実行する:

1. v が String ではない 場合、

   1. RuntimeError 例外を、あたかも trap が実行されたかのように throw する。

2. v を返す

FromCharCode(v) 抽象操作は、呼び出されると、 次の手順を実行する:

1. Assert: v は i32 型である。

2. ! Call(String.fromCharCode, undefined, « ToJSValue(v) ») を返す。

CharCodeAt(string, index) 抽象 操作は、呼び出されると、次の手順を実行する:

1. Assert: index は i32 型である。

2. ! Call(String.prototype.charCodeAt, string, « ToJSValue(index) ») を返す。

このビルトインがパラメータ v で呼び出されたとき、次の手順を実行しなければならない:

1. ? UnwrapString(v) を返す

このビルトインがパラメータ v で呼び出されたとき、次の手順を実行しなければならない:

1. v が String ではない 場合、

   1. 0 を返す。

2. 1 を返す。

このビルトインがパラメータ array, start, および end で呼び出されたとき、 次の手順を実行しなければならない:

1. array が null の場合、

   1. RuntimeError 例外を、あたかも trap が実行されたかのように throw する。

2. length を array 内の要素数とする。

3. start > end または end > length の場合、

   1. RuntimeError 例外を、あたかも trap が実行されたかのように throw する。

4. result を空文字列とする。

5. i を start とする。

6. i < end の間:

   1. charCode を、array のインデックス i に格納された要素の値と する。

   2. charCodeString を FromCharCode(charCode) とする。

   3. result を result と charCodeString の連結とする。

   4. i を i + 1 に設定する。

7. result を返す。

このビルトインがパラメータ string, array, および start で呼び出されたとき、 次の手順を実行しなければならない:

1. array が null の場合、

   1. RuntimeError 例外を、あたかも trap が実行されたかのように throw する。

2. string を ? UnwrapString(string) とする。

3. stringLength を string の 長さ とする。

4. arrayLength を array 内の要素数とする。

5. start + stringLength > arrayLength の場合、

   1. RuntimeError 例外を、あたかも trap が実行されたかのように throw する。

6. i を 0 とする。

7. i < stringLength の間:

   1. charCode を CharCodeAt(string, i) とする。

   2. array のインデックス start + i にある要素を ToWebAssemblyValue(charCode, i32) に設定する。

   3. i を i + 1 に設定する。

8. stringLength を返す。

このビルトインがパラメータ v で呼び出されたとき、次の手順を実行しなければならない:

1. FromCharCode(v) を返す。

このビルトインがパラメータ v で呼び出されたとき、次の手順を実行しなければならない:

1. v > 0x10ffff の場合、

   1. RuntimeError 例外を、あたかも trap が実行されたかのように throw する。

2. ! Call(String.fromCodePoint, undefined, « ToJSValue(v) ») を返す。

このビルトインがパラメータ string および index で呼び出されたとき、次の手順 を実行しなければならない:

1. string を ? UnwrapString(string) とする。

2. length を string の 長さ とする。

3. index >= length の場合、

   1. RuntimeError 例外を、あたかも trap が実行されたかのように throw する。

4. CharCodeAt(string, index) を返す。

このビルトインがパラメータ string および index で呼び出されたとき、次の手順 を実行しなければならない:

1. string を ? UnwrapString(string) とする。

2. length を string の 長さ とする。

3. index >= length の場合、

   1. RuntimeError 例外を、あたかも trap が実行されたかのように throw する。

4. ! Call(String.prototype.codePointAt, string, « ToJSValue(index) ») を返す。

このビルトインがパラメータ v で呼び出されたとき、次の手順を実行しなければならない:

1. string を ? UnwrapString(v) とする。

2. string の 長さ を返す。

このビルトインがパラメータ first および second で呼び出されたとき、次の手順 を実行しなければならない:

1. first を ? UnwrapString(first) とする。

2. second を ? UnwrapString(second) とする。

3. ! Call(String.prototype.concat, first, « second ») を返す。

このビルトインがパラメータ string, start, および end で呼び出されたとき、 次の手順を実行しなければならない:

1. string を ? UnwrapString(string) とする。

2. length を string の 長さ とする。

3. start > end または start > length の場合、

   1. 空文字列を返す。

4. ! Call(String.prototype.substring, string, « ToJSValue(start), ToJSValue(end) ») を返す。

このビルトインがパラメータ first および second で呼び出されたとき、次の手順 を実行しなければならない:

1. first が null ではなく、かつ first が String ではない 場合、

   1. RuntimeError 例外を、あたかも trap が実行されたかのように throw する。

2. second が null ではなく、かつ second が String ではない 場合、

   1. RuntimeError 例外を、あたかも trap が実行されたかのように throw する。

3. ! IsStrictlyEqual(first, second) が true の場合、

   1. 1 を返す。

4. 0 を返す。

このビルトインがパラメータ first および second で呼び出されたとき、次の手順 を実行しなければならない:

1. first を ? UnwrapString(first) とする。

2. second を ? UnwrapString(second) とする。

3. ! IsStrictlyEqual(first, second) が true である場合、

   1. 0 を返す。

4. ! IsLessThan(first, second, true) が true である場合、

   1. -1 を返す。

5. 1 を返す。