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 = null;
    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 を返す。

WebAssembly モジュールの組み込み機能とインポートされた 文字列を検証するには、モジュール module、有効な組み込み機能 builtinSetNames、および importedStringModule を指定して、次の手順を実行する：

1. 組み込みセット名の検証で builtinSetNames に対して false が返された場合、false を返す。

2. 各 import（module_imports(module) の要素）について、

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

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

      2. stringExternType を global 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 が エラーである場合、CompileError 例外で promise を 拒否 し、戻る。

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

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

      4. module に対して builtinSetNames および importedStringModule を用いて 組み込みおよび インポートされた文字列を検証する結果が false である場合、CompileError 例外で promise を 拒否する。

      5. それ以外の場合、

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

         2. moduleObject で promise を 解決する。

3. promise を返す。

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

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

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

モジュール module および importedStringModule を用いて インポートされた文字列をインスタンス化するには、 次の手順を実行する。

1. 表明: importedStringModule は null ではない。

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

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

   1. moduleName が importedStringModule と等しくない場合は、次の反復へ進む。

   2. stringConstant を componentName とする。

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

   4. 表明: status は true である。

4. exportsObject を返す。

インポートを読み取るには、 WebAssembly モジュール module、インポートオブジェクト importObject、有効な組み込み機能 builtinSetNames、および importedStringModule を指定して、次の手順を実行する：

1. module_imports(module) が空でなく、かつ importObject が存在しない場合、 TypeError 例外をスローする。

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

3. 各 builtinSetName（ builtinSetNames の要素）について、

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

   2. 表明：builtinOrStringImports は builtinSetQualifiedName を含まない。

   3. builtinSetName が組み込みセットを参照していない場合、次の反復に進む。

   4. exportsObject を builtinSetName を使用して組み込みセットを インスタンス化する結果とする。

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

4. importedStringModule が null でない場合、

   1. exportsObject を インポートされた文字列をインスタンス化する結果とする。 module と importedStringModule を使用する。

   2. 設定する： 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 例外をスローする。

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

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

      1. IsCallable(v) が false の場合、 LinkError 例外をスローする。

      2. v が [[FunctionAddress]] 内部スロットを持ち、したがってエクスポートされた関数である場合、

         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 が Global を実装している場合、

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

      2. それ以外の場合、

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

            1. LinkError 例外をスローする。

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

            1. LinkError 例外をスローする。

         3. valtype が v128 である場合、

            1. LinkError 例外をスローする。

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

         5. store を周囲のエージェントの関連付けられたストアとする。

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

         7. 周囲のエージェントの関連付けられたストアを store に設定する。

      3. externglobal を global globaladdr とする。

      4. 追加する：externglobal を imports に。

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

      1. v が Memory を実装していない場合、 LinkError 例外をスローする。

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

      3. 追加する：externmem を imports に。

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

      1. v が Table を実装していない場合、 LinkError 例外をスローする。

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

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

      4. 追加する：externtable を imports に。

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

      1. v が Tag を実装していない場合、 LinkError 例外をスローする。

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

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

      4. 追加する：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. 表明：externval はerror ではない。

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

      1. 表明：externval は func funcaddr の形式である。

      2. func funcaddr を externval とする。

      3. func を funcaddr から新しい エクスポートされた関数を作成した結果とする。

      4. value を func とする。

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

      1. 表明：externval は global globaladdr の形式である。

      2. global globaladdr を externval とする。

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

      4. value を global とする。

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

      1. 表明：externval は mem memaddr の形式である。

      2. mem memaddr を externval とする。

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

      4. value を memory とする。

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

      1. 表明：externval は table tableaddr の形式である。

      2. table tableaddr を externval とする。

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

      4. value を table とする。

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

      1. 表明：externval は tag tagaddr の形式である。

      2. tag tagaddr を externval とする。

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

      4. value を tag とする。

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

   9. 表明：status は true である。

   注： WebAssembly モジュールの検証中に実行される妥当性と一意性の検査により、各プロパティ名が 有効であり、どのプロパティも重複して定義されていないことが保証される。

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

4. exportsObject を返す。

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

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

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

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

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

1. store を 周囲のエージェントの 関連付けられたストアとする。

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

3. result が error の場合、適切な例外型を投げる。

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

   • 開始関数の実行時にエラーが発生した場合、WebAssembly から発生するほとんどのエラーについては RuntimeError を投げるか、内部の ECMAScript コードから伝播されたエラーオブジェクトを投げる。

   • 適切であれば別のエラー型。例えば、WebAssembly エラーマッピングに記載されている メモリ不足例外など。

4. 周囲のエージェントの 関連付けられたストアを store に設定する。

5. result を返す。

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

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

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

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

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

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

6. 次の手順を 並行して実行する:

   1. 次の手順を実行するための タスクをキューに入れる: 注記: 実装固有の作業をここで実行してもよい。

      1. imports を用いて module の WebAssembly モジュールの コアをインスタンス化し、instance をその結果とする。 これが例外を投げた場合、それを捕捉し、例外で 拒否する promise とし、 これらのサブステップを終了する。

      2. instanceObject を 新しい Instance とする。

      3. module および instance から instanceObject を 初期化する。 これが例外を投げた場合、それを捕捉し、例外で 拒否する promise とし、 これらのサブステップを終了する。

      4. instanceObject で promise を 解決する。

7. promise を返す。

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

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

2. promiseOfModule に 反応する:

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

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

     2. innerPromise に 反応する:

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

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

          2. result で promise を 解決する。

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

          1. reason で promise を 拒否する。

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

     1. reason で promise を 拒否する。

3. promise を返す。

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

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

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

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

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

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

WebAssembly 名前空間の JSTag 属性の getter は、呼び出されたとき、次の手順を実行する:

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

2. JSTagObject を、JSTagAddr から Tag オブジェクトを作成した結果とする。

3. JSTagObject を返す。

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

この 外部型の文字列 値 type は次のとおりである：

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

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

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

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

• "tag"：type が 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 を ToValueType(descriptor["address"]) とする。それ以外の場合、 addrtype を i32 とする。

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

3. descriptor["maximum"] が存在する場合、 maximum を ? AddressValueToU64(descriptor["maximum"], addrtype) とする。それ以外の場合、maximum を空とする。

4. memtype をメモリ型 addrtype [initial .. maximum] page とする。

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

6. store を周囲のエージェントの関連付けられたストアとする。

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

8. 周囲のエージェントの関連付けられたストアを store に設定する。

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

Memory バッファーを更新するには、memaddr について次の手順を実行する：

1. map を周囲のエージェントに関連付けられたMemory オブジェクトキャッシュとする。

2. 表明：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 の基底メモリとデータブロックとして同一視される ものとする。

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

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

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

1. store を周囲のエージェントの関連付けられたストアとする。

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

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

4. store が error の場合、RangeError 例外をスローする。

5. 周囲のエージェントの関連付けられたストアを store に設定する。

6. メモリバッファーを更新する。対象は memaddr である。

7. ret を返す。

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

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

2. store を周囲のエージェントの関連付けられたストアとする。

3. (addrtype, limits) を 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. 表明: 検証により、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 を 周囲のエージェントの 関連付けられたストアとする。

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

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

   1. TypeError 例外を 投げる。

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

6. IsFixedLengthArrayBuffer(buffer) が false の場合、buffer を返す。

7. 表明: 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 を 周囲のエージェントに関連付けられた Memory オブジェクトキャッシュとする。

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

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

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

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

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

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

            1. RangeError 例外を投げる。

         4. delta を lengthDelta ÷ 65536 とする。

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

   4. handled を返す。

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

Memory の buffer 属性のゲッターは、 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. TypeError 例外をスローする。

3. descriptor["address"] が存在する場合、 addrtype を ToValueType(descriptor["address"]) とする。それ以外の場合、 addrtype を i32 とする。

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

5. descriptor["maximum"] が存在する場合、 maximum を ? AddressValueToU64(descriptor["maximum"], addrtype) とする。それ以外の場合、maximum を空とする。

6. type をテーブル型 addrtype [initial .. maximum] elementtype とする。

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

8. value が存在しない場合、

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

   2. 表明：ref は error ではない。

9. それ以外の場合、

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

10. store を周囲のエージェントの関連付けられたストアとする。

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

12. 周囲のエージェントの関連付けられたストアを store に設定する。

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

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

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

2. 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 例外をスローする。

7. それ以外の場合、

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

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

9. result が error の場合、RangeError 例外をスローする。

   注：上記の例外は、 メモリ不足または無効なサイズパラメーターによって発生する可能性がある。

10. 周囲のエージェントの関連付けられたストアを result に設定する。

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

Table の length 属性のゲッターは、呼び出されると、 次の手順を実行する：

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

2. store を周囲のエージェントの関連付けられたストアとする。

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

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

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

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

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

2. store を周囲のエージェントの関連付けられたストアとする。

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

4. elementtype が 一致する対象が exnref である場合、

   1. TypeError 例外をスローする。

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

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

7. result が error の場合、RangeError 例外をスローする。

8. ToJSValue(result) を返す。

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

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

2. store を周囲のエージェントの関連付けられたストアとする。

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

4. elementtype が 一致する対象が exnref である場合、

   1. TypeError 例外をスローする。

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

6. value が存在しない場合、

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

   2. ref が error の場合、TypeError 例外をスローする。

7. それ以外の場合、

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

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

9. store が error の場合、RangeError 例外をスローする。

10. 周囲のエージェントの関連付けられたストアを 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. 表明：この手順には到達しない。

アルゴリズム 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 が 一致する対象が v128 または exnref である場合、

   1. TypeError 例外をスローする。

4. v が存在しない場合、

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

   2. 表明：value は error ではない。

5. それ以外の場合、

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

6. mutable が true の場合、globaltype を mut valuetype とする。それ以外の場合、globaltype を valuetype とする。

7. store を周囲のエージェントの関連付けられたストアとする。

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

9. 周囲のエージェントの関連付けられたストアを store に設定する。

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

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

1. store を周囲のエージェントの関連付けられたストアとする。

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

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

4. globaltype が mut valuetype の形式であり、 valuetype が 一致する対象が v128 または exnref である場合、TypeError をスローする。

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

6. ToJSValue(value) を返す。

value 属性のゲッターは、Global について呼び出されると、 次の手順を実行する：

1. GetGlobalValue(this) を返す。

Global の value 属性のセッターは、呼び出されると、 次の手順を実行する：

1. store を周囲のエージェントの関連付けられたストアとする。

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

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

4. valuetype が 一致する対象が v128 または exnref である場合、TypeError をスローする。

5. mut が空の場合、TypeError をスローする。

6. value を ? ToWebAssemblyValue(与えられた値, valuetype) とする。

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

8. store が error の場合、RangeError 例外をスローする。

9. 周囲のエージェントの関連付けられたストアを store に設定する。

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

1. GetGlobalValue(this) を返す。

WebAssembly 関数の 名前 funcaddr は、次の手順を実行することで求められる。

1. store を 周囲のエージェントの 関連付けられたストアとする。

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

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

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

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

4. それ以外の場合、

   1. moduleinst を funcinst.module とする。

   2. 表明: funcaddr は moduleinst.funcs に含まれる。

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

5. ! ToString(index) を返す。

WebAssembly の関数アドレス funcaddr から新しい エクスポートされた関数を作成するには、次の手順を実行する：

1. map を周囲のエージェントに関連付けられたエクスポートされた関数の キャッシュとする。

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

   1. map[funcaddr] を返す。

3. steps を「エクスポートされた関数 funcaddr を 引数付きで呼び出す」とする。

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

5. store を周囲のエージェントの関連付けられたストアとする。

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

7. func paramTypes → resultTypes を functype の展開とする。

8. arity を paramTypes のサイズとする。

9. name をWebAssembly 関数の名前 funcaddr とする。

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

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

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

13. function を返す。

関数アドレス funcaddr と JavaScript 引数のリスト argValues を使用してエクスポートされた 関数を呼び出すには、次の手順を実行する：

1. store を周囲のエージェントの関連付けられたストアとする。

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

3. func parameters → results を展開された functype とする。

4. parameters または results 内のいずれかの型が 一致する対象が v128 または exnref である場合、TypeError をスローする。

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

5. args を « » とする。

6. i を 0 とする。

7. parameters の各 t について、

   1. argValues のサイズ > i の場合、arg を argValues[i] とする。

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

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

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

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

9. 周囲のエージェントの関連付けられたストアを store に設定する。

10. ret が error の場合、例外をスローする。この例外は、 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]) をスローする。

    5. それ以外の場合、

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

       2. exception をスローする。

12. outArity を ret のサイズとする。

13. outArity が 0 の場合、undefined を返す。

14. それ以外で outArity が 1 の場合、ToJSValue(ret[0]) を返す。

15. それ以外の場合、

    1. values を « » とする。

    2. ret の各 r について、

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

    3. CreateArrayFromList(values) を返す。

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

1. func parameters → results を functype の展開とする。

2. parameters または results 内のいずれかの型が 一致する対象が v128 または exnref である場合、TypeError をスローする。

3. jsArguments を « » とする。

4. arguments の各 arg について、

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

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

6. resultsSize を results のサイズとする。

7. resultsSize が 0 の場合、« » を返す。

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

9. それ以外の場合、

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

   2. method が undefined の場合、TypeError をスローする。

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

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

   5. values のサイズが resultsSize と等しくない場合、TypeError 例外をスローする。

   6. values と results 内の各 value と resultType について、 順番に対応付けて、

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

   7. wasmValues を返す。

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

1. 表明：IsCallable(func)。

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

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

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

   2. relevant settings を realm の設定オブジェクトとする。

   3. relevant settings を使用してスクリプトを実行する準備をする。

   4. stored settings を使用してコールバックを実行する準備をする。

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

   6. stored settings を使用してコールバック実行後の後処理を行う。

   7. relevant settings を使用してスクリプト実行後の後処理を行う。

   8. 表明：result.[[Type]] は throw または normal である。

   9. store を周囲のエージェントの関連付けられたストアとする。

   10. result.[[Type]] が throw の場合：

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

       2. v が Exception を実装している場合、

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

       3. それ以外の場合、

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

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

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

          4. 周囲のエージェントの関連付けられたストアを store に設定する。

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

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

4. store を周囲のエージェントの関連付けられたストアとする。

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

6. 周囲のエージェントの関連付けられたストアを store に設定する。

7. funcaddr を返す。

アルゴリズム ToJSValue(w) は、次の手順を実行してWebAssembly 値を JavaScript 値に変換する：

1. 表明：w は v128.const v128 の形式ではない。

2. 表明：w は ref.exn exnaddr の形式ではない。

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

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

   2. ℤ(i64 を数学的な値として解釈したもの) を返す。

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

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

   2. 𝔽(i32 を数学的な値として解釈したもの) を返す。

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

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

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

   3. 𝔽(f32 を数学的な値として解釈したもの) を返す。

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

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

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

   3. 𝔽(f64 を数学的な値として解釈したもの) を返す。

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

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

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

   2. 𝔽(i31 を数学的な値として解釈したもの) を返す。

9. w が ref.struct structaddr の形式である場合、新しいエクスポートされた GC オブジェクトを structaddr と "struct" から作成した結果を返す。

10. w が ref.array arrayaddr の形式である場合、新しいエクスポートされた GC オブジェクトを arrayaddr と "array" から作成した結果を返す。

11. w が ref.func funcaddr の形式である場合、新しい エクスポートされた関数を funcaddr から作成した結果を返す。

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

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

注：NaN に等しい Number 値には、 観測可能なさまざまな NaN ペイロードが存在する場合がある。詳細については NumericToRawBytes を参照。

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

1. map を周囲のエージェントに関連付けられたホスト値キャッシュとする。

2. 表明：map[hostaddr] が存在する。

3. map[hostaddr] を返す。

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

1. 表明：type は v128 ではない。

2. 表明：type は 一致しない対象が 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 を number を表現可能な最も近い値に丸めたものとする。 IEEE 754-2019 の最近接丸め（同点時は偶数への丸め）を使用する。[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 とする。

   2. それ以外で match_valtype(type, ref null extern) が true の場合、

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

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

   3. それ以外で v がエクスポートされた関数であり、かつ match_valtype(type, ref null func) が true の場合、

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

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

   4. それ以外で 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. それ以外で v がエクスポートされた GC オブジェクトである場合、

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

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

      3. objectkind が "array" の場合、

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

      4. それ以外で objectkind が "struct" の場合、

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

   6. それ以外の場合、

      1. map を周囲のエージェントに関連付けられたホスト値キャッシュとする。

      2. ホストアドレス hostaddr が存在し、 map[hostaddr] が v と同一である場合、

         1. ref.host hostaddr を返す。

      3. hostaddr を、map[hostaddr] が存在するという条件が false となる最小のホストアドレスとする。

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

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

   7. store を周囲のエージェントの関連付けられたストアとする。

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

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

      1. TypeError をスローする。

   10. r を返す。

8. 表明：この手順には到達しない。

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

1. jsValue を、v をJavaScript 値に変換したものとする。

   注：IDL の any 型は、 JavaScript 値の透過的なラッパーではなく、判別可能な共用体である。

2. addrtype が i32 の場合、

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

      注：これは、 [EnforceRange] unsigned long のJS 変換規則と等価である。

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

3. addrtype が i64 の場合、

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

   2. r を ℝ(n) とする。

   3. r < 0 または r > 2⁶⁴ − 1 の場合、TypeError をスローする。

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

   4. r を WebAssembly のu64 として返す。

4. 表明：この手順には到達しない。

アルゴリズム U64ToAddressValue(v, addrtype) は、WebAssembly の埋め込み操作から得たu64 値を、AddressType に対応する AddressValue の適切なバリアントに変換するため、次の手順を実行する：

1. addrtype が i32 の場合、𝔽(v を数学的な値として解釈したもの) を返す。

2. それ以外で addrtype が i64 の場合、ℤ(v を数学的な値として解釈したもの) を返す。

3. 表明：この手順には到達しない。

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

[LegacyNamespace=WebAssembly, Exposed=*]
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. 追加する：ToValueType(paramType) を wasmParameters に。

4. tagtype を、定義型とする。ただし、func wasmParameters → « » は展開（tagtype のもの）である。

5. store を周囲のエージェントの関連付けられたストアとする。

6. (store, tagAddress) を tag_alloc(store, tagtype) とする。

7. 周囲のエージェントの関連付けられたストアを store に設定する。

8. 初期化する：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. « » を返す。

新しい 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=*]
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 をスローする。

3. store を周囲のエージェントの関連付けられたストアとする。

4. func types → « » を展開された tag_type(store, exceptionTag.[[Address]]) とする。

5. types のサイズが payload のサイズと等しくない場合、

   1. TypeError をスローする。

6. wasmPayload を « » とする。

7. 各 value と resultType（ payload と types の要素）を順番に対応付けて、

   1. resultType が一致する対象が v128 または exnref である場合、

      1. TypeError をスローする。

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

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

9. 周囲のエージェントの関連付けられたストアを store に設定する。

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

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

    1. this.[[Stack]] を、現在の呼び出しスタックを表す DOMString または undefined に設定する。

この getArg(exceptionTag, index) メソッドの手順は次のとおりである：

1. store を周囲のエージェントの関連付けられたストアとする。

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

   1. TypeError をスローする。

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

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

5. 表明：tagaddr は this.[[Type]] に等しい。

6. index ≥ payload のサイズである場合、

   1. RangeError をスローする。

7. func types → « » を展開された tag_type(store, tagaddr) とする。

8. types[index] が一致する対象が v128 または exnref である場合、

   1. TypeError をスローする。

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

この is(exceptionTag) メソッドの手順は次のとおりである：

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

   1. false を返す。

2. true を返す。

この stack ゲッターの手順は次のとおりである：

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

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

1. 周囲のエージェントに関連付けられたJavaScript 例外 タグが初期化されている場合、

   1. 周囲のエージェントに関連付けられたJavaScript 例外タグを返す。

2. tagtype を、定義型とする。ただし、func « externref » → « » がtagtype の展開であるものとする。

3. store を周囲のエージェントの関連付けられたストアとする。

4. (store, tagAddress) を tag_alloc(store, tagtype) とする。

5. 周囲のエージェントの関連付けられたストアを store に設定する。

6. 周囲のエージェントに関連付けられたJavaScript 例外 タグを tagAddress に設定する。

7. 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. builtins の 各 (name, funcType, steps) について、

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

   2. func を、funcaddr から 新しいエクスポートされた 関数を作成した結果とする。

   3. value を func とする。

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

   5. 表明: status は true である。

4. exportsObject を返す。

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

1. 表明: ビルトインセット名を検証する 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. 表明: v は i32 型である。

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

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

1. 表明: 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 例外を投げる。

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

   1. トラップが実行されたかのように、RuntimeError 例外を投げる。

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 を返す。