WebAssembly JavaScript インターフェイス

1. 導入

設計上、WebAssemblyコア仕様scope [WEBASSEMBLY]は、WebAssemblyプログラムが周囲の実行環境とどのように相互作用するかの記述を含みません。その代わりに、WebAssemblyとその環境（埋め込み者と呼ばれる）との間の抽象的な埋め込みインターフェースを定義します。埋め込み者はこのインターフェースを通じてのみWebAssemblyのセマンティクスと関わり、また埋め込み者はホスト環境と埋め込みAPIの接続を実装します。本文書は、WebAssemblyがJavaScript [ECMASCRIPT]環境にどのように埋め込まれるかについて記述します。これには、WebAssemblyモジュールの構築やインスタンス化、インポート・エクスポート関数の呼び出し、データ交換、エラー処理などが含まれます。 JavaScript環境自体がWebブラウザに埋め込まれている場合、Web API仕様[WASMWEB]で、Web環境に関する追加の動作が定義されています。

2. API使用例

このセクションは規範的ではありません。

demo.wat（demo.wasmへエンコードされたもの）:

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

および、ブラウザで実行する以下のJavaScript:

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

3. 記法

この仕様はInfra Standardに依存しています。[INFRA]

WebAssemblyのsequence型は、そこで定義されたlist型と等価です；一方の値は自動的に他方の値として扱われます。

4. 内部ストレージ

4.1. WebAssembly ストアと JavaScript の相互作用

注：WebAssemblyのセマンティクスはWebAssembly抽象マシンの状態を表す抽象的なストアで定義されています。 WebAssemblyの操作はストアを受け取り、更新されたストアを返します。

各エージェントには関連付けられたストアが存在します。新しいエージェントが作成されると、その関連ストアはstore_init()の結果に設定されます。

注：本仕様では、WebAssembly関連のオブジェクト・メモリ・アドレスはエージェントクラスタagent cluster間で共有されません。将来のWebAssemblyバージョンではこの点が変わる可能性があります。

WebAssemblyストアの要素はJavaScript値と紐付けられる場合があります。特に、対応するMemoryオブジェクトを持つ各WebAssemblyのmemory instanceは、JavaScriptのData Blockと対応します；このデータブロックの修正はエージェントのストアもそれに応じて更新されたものとみなされ、その逆も同様です。

4.2. WebAssembly JSオブジェクトキャッシュ

注：いくつかのWebAssemblyオブジェクトには対応するJavaScriptオブジェクトが存在する可能性があります。この対応関係は、各エージェントごとにWebAssemblyアドレスからJavaScriptオブジェクトへのマッピングとして保持されます。このマッピングは、あるエージェントについて、特定のWebAssemblyアドレスにつき最大1つのJavaScriptオブジェクトしか対応しないことを保証するためのものです。ただし、共有オブジェクトにはこの性質は適用されません。

各エージェントには以下の順序付きマップが関連付けられています：

Memoryオブジェクトキャッシュ：メモリアドレスからMemory オブジェクトへのマッピング。
Tableオブジェクトキャッシュ：テーブルアドレスからTableオブジェクトへのマッピング。
エクスポート関数キャッシュ：関数アドレスからエクスポート関数オブジェクトへのマッピング。
エクスポートGCオブジェクトキャッシュ：structアドレスやarrayアドレスからエクスポートGCオブジェクトへのマッピング。
グローバルオブジェクトキャッシュ：グローバルアドレスからGlobal オブジェクトへのマッピング。
タグオブジェクトキャッシュ：タグアドレスからTagオブジェクトへのマッピング。
例外オブジェクトキャッシュ：例外アドレスからException オブジェクトへのマッピング。
ホスト値キャッシュ：ホストアドレスから値へのマッピング。

5. WebAssembly名前空間

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

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

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

    Promise<WebAssemblyInstantiatedSource> instantiate(
        BufferSource bytes, optional object importObject, optional WebAssemblyCompileOptions options = {});

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

    readonly attribute Tag JSTag;
};

WebAssemblyモジュールをコンパイルするために、ソースバイト列bytesから以下の手順を実行します：

moduleをmodule_decode(bytes)とする。module がエラーなら、エラーを返す。
module_validate(module) がエラーであればエラーを返す。
moduleを返す。

WebAssemblyモジュールのビルトイン・インポート文字列を検証するために、module module、有効なビルトインbuiltinSetNames、importedStringModuleを用いて次の手順を実行する：

ビルトインセット名の検証にbuiltinSetNamesを使った結果がfalseならfalseを返す。
各 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の検証をimportとbuiltinSetNamesで試み、falseならfalseを返す。
trueを返す。

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

stableBytes を、buffer が保持するバイト列のコピー bytes とする。
コンパイルにより stableBytes を WebAssembly モジュールとして扱い、その結果を module として保持する。
module が error なら、false を返す。
builtinSetNames を options["builtins"] とする。
importedStringModule を options["importedStringConstants"] とする。
ビルトインおよびインポート文字列の検証を module、builtinSetNames、importedStringModule で行い、 false を返す場合は false を返す。
true を返す。

Module オブジェクトは単一の WebAssembly モジュールを表す。各 Module オブジェクトは次の内部スロットを持つ：

[[Module]] : WebAssembly の module
[[Bytes]] : [[Module]] のソースバイト列。
[[BuiltinSets]] : ビルトインセットの名前の順序付き集合
[[ImportedStringModule]] : 任意の文字列定数をインポートできる、オプションのモジュール指定子文字列。

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

moduleObject を新しい Module オブジェクトとする。
moduleObject.[[Module]] に module を設定する。
moduleObject.[[Bytes]] に bytes を設定する。
moduleObject.[[BuiltinSets]] に builtinSetNames を設定する。
moduleObject.[[ImportedStringModule]] に importedStringModule を設定する。
moduleObject を返す。

WebAssembly モジュールを非同期にコンパイルするために、ソースバイト列 bytes と WebAssemblyCompileOptions options を用い、オプションの task source taskSource を使って、次の手順を実行する：

promise を新しい promise とする。
次の手順を並行して実行する：
1. WebAssembly モジュールをコンパイルして bytes から結果を得て、module とする。
2. タスクをキューに入れる。taskSource が与えられている場合は、そのタスクソース上にキューする。
  1. module が error なら、promise を CompileError 例外で reject する。
  2. builtinSetNames を options["builtins"] とする。
  3. importedStringModule を options["importedStringConstants"] とする。
  4. ビルトインおよびインポート文字列の検証を module、builtinSetNames、importedStringModule で行い、結果が false なら promise を CompileError 例外で reject する。
  5. それ以外の場合、
    1. WebAssembly モジュールオブジェクトを構築し、 module、bytes、builtinSetNames、 importedStringModule から結果を moduleObject とする。
    2. Resolve により promise を moduleObject で解決する。
promise を返す。

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

stableBytes を、buffer が保持するバイト列のコピー bytes とする。
WebAssembly モジュールを非同期にコンパイルし、 stableBytes と options を用いてその結果を返す。

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

表明：importedStringModule は null ではない。
exportsObject を ! OrdinaryObjectCreate(null) とする。
各 (moduleName, componentName, externtype) について、module_imports(module) を繰り返す。
1. moduleName が importedStringModule と等しくなければ、continue する。
2. stringConstant を componentName とする。
3. status を ! CreateDataProperty(exportsObject, stringConstant, stringConstant) とする。
4. 表明：status は true である。
exportsObject を返す。

インポートを読み取るために、 WebAssembly モジュール module、インポーツオブジェクト importObject、有効なビルトイン builtinSetNames、および importedStringModule から次の手順を実行する：

module.imports が空でないかつ importObject が undefined なら、TypeError 例外を投げる。
builtinOrStringImports を順序付きマップ « » とする。
各 builtinSetName について、 builtinSetNames を繰り返す。
1. 表明：builtinOrStringImports は builtinSetName を含まない。
2. builtinSetName がビルトインセットを指さない場合、continue する。
3. exportsObject を、ビルトインセットをインスタンス化することで得られた結果とする（引数は builtinSetName）。
4. builtinSetQualifiedName を "wasm:" で前置した builtinSetName とする。
5. Set により builtinOrStringImports[builtinSetQualifiedName] に exportsObject を設定する。
importedStringModule が null でないなら、
1. exportsObject を、インポートされた文字列をインスタンス化することで module と importedStringModule から得られた結果とする。
2. Set により builtinOrStringImports[importedStringModule] に exportsObject を設定する。
imports を « » とする。
各 (moduleName, componentName, externtype) について、module_imports(module) を繰り返す。
1. builtinOrStringImports が contains moduleName である場合、
  1. o を builtinOrStringImports[moduleName] とする。
  2. o が Object でない、または o が componentName を含まない場合、
    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]] 内部スロットを持ち、したがって Exported Function である場合、
    1. funcaddr を v の [[FunctionAddress]] 内部スロットの値とする。
  3. それ以外の場合、
    1. ホスト関数を作成し、 v と functype から結果を funcaddr とする。
    2. index を imports 内の外部関数の個数とする。この値 index は funcaddr のホスト関数のインデックスとして知られる。
  4. externfunc を external value の func funcaddr とする。
  5. Append により externfunc を imports に追加する。
6. externtype が global mut valtype の形式なら、
  1. v が implements 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 を surrounding agent の associated store とする。
    6. (store, globaladdr) を global_alloc(store、 const valtype、 value) とする。
    7. surrounding agent の associated store を store に設定する。
  3. externglobal を global globaladdr とする。
  4. Append により externglobal を imports に追加する。
7. externtype が mem memtype の形式なら、
  1. v が implement Memory でないなら、LinkError 例外を投げる。
  2. externmem を external value の mem v.[[Memory]] とする。
  3. Append により externmem を imports に追加する。
8. externtype が table tabletype の形式なら、
  1. v が implement Table でないなら、LinkError 例外を投げる。
  2. tableaddr を v.[[Table]] とする。
  3. externtable を external value の table tableaddr とする。
  4. Append により externtable を imports に追加する。
9. externtype が tag attribute functype の形式なら、
  1. 表明：attribute は exception である。
  2. v が implement Tag でないなら、LinkError 例外を投げる。
  3. tagaddr を v.[[Address]] とする。
  4. externtag を external value の tag tagaddr とする。
  5. Append により externtag を imports に追加する。
imports を返す。

注：このアルゴリズムは、正しい種類の JavaScript 値が渡されているかのみを検証する。 WebAssembly の型要件の検証は「instantiate the core of a WebAssembly module」アルゴリズムに委ねられる。

エクスポートオブジェクトを作成するために、 WebAssembly モジュール module とインスタンス instance から、次の手順を実行する：

exportsObject を ! OrdinaryObjectCreate(null) とする。
各 (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 を、新しい Exported Function を funcaddr から作成した結果とする。
  4. value を func とする。
4. externtype が global mut globaltype の形式なら、
  1. 表明：externval は global globaladdr の形式である。
  2. global globaladdr を externval とする。
  3. global を新しい Global オブジェクト（globaladdr から作成）とする。
  4. value を global とする。
5. externtype が mem memtype の形式なら、
  1. 表明：externval は mem memaddr の形式である。
  2. mem memaddr を externval とする。
  3. memory を新しい Memory オブジェクト（memaddr から作成）とする。
  4. value を memory とする。
6. externtype が table tabletype の形式なら、
  1. 表明：externval は table tableaddr の形式である。
  2. table tableaddr を externval とする。
  3. table を新しい Table オブジェクト（tableaddr から作成）とする。
  4. value を table とする。
7. externtype が tag attribute functype の形式なら、
  1. 表明：attribute は exception である。
  2. 表明：externval は tag tagaddr の形式である。
  3. tag tagaddr を externval とする。
  4. tag を新しい Tag オブジェクト（tagaddr から作成）とする。
  5. value を tag とする。
8. status を ! CreateDataProperty(exportsObject, name, value) とする。
9. 表明：status は true である。
注： WebAssembly モジュールの検証で行われる妥当性と一意性の検査により、各プロパティ名は妥当であり、同じプロパティが二重に定義されないことが保証される。
! SetIntegrityLevel(exportsObject, "frozen") を実行する。
exportsObject を返す。

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

エクスポートオブジェクトを作成し、 module と instance から結果を exportsObject とする。
instanceObject.[[Instance]] に instance を設定する。
instanceObject.[[Exports]] に exportsObject を設定する。

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

store を surrounding agent の associated store とする。
result を module_instantiate(store、 module、imports) とする。
result が error なら、適切な例外型を投げる：
- リンク時に発生するほとんどの場合には、LinkError 例外。
- start 関数の実行中に発生したエラーであれば、WebAssembly からの多くのエラーには RuntimeError、もしくは内側の ECMAScript コードから伝播したエラーオブジェクト。
- 必要に応じて別のエラー型（例：メモリ不足例外）。詳細は WebAssembly のエラー対応表を参照。
(store, instance) を result とする。
surrounding agent の associated store を store に設定する。
instance を返す。

WebAssembly モジュールを非同期にインスタンス化するために、 Module moduleObject とインポート importObject から、次の手順を実行する：

promise を新しい promise とする。
module を moduleObject.[[Module]] とする。
builtinSetNames を moduleObject.[[BuiltinSets]] とする。
importedStringModule を moduleObject.[[ImportedStringModule]] とする。
インポートを読み取るを実行し、 module、importObject、builtinSetNames、importedStringModule を用いて結果を imports とする。この操作が例外を投げた場合は、捕捉して reject により promise をその例外で拒否し、promise を返す。
次の手順を並行して実行する：
1. タスクをキューに入れる：注：ここで実装依存の処理が行われることがある。
  1. WebAssembly モジュールのコアをインスタンス化し、 module と imports を用いて結果を instance とする。これが例外を投げた場合は捕捉し、reject により promise をその例外で拒否し、これ以降のサブステップを終了する。
  2. instanceObject を new な Instance とする。
  3. 初期化により instanceObject を module と instance から初期化する。これが例外を投げた場合は捕捉し、reject により promise をその例外で拒否し、これ以降のサブステップを終了する。
  4. Resolve により promise を instanceObject で解決する。
promise を返す。

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

promise を新しい promise とする。
React により promiseOfModule に反応する：
- promiseOfModule が値 module で fulfilled された場合：
  1. WebAssembly モジュールをインスタンス化し、 module に importObject をインポートして結果を innerPromise とする。
  2. React により innerPromise に反応する：
    - innerPromise が値 instance で fulfilled された場合、
      1. result を WebAssemblyInstantiatedSource 値 «[ "module" → module、"instance" → instance ]» とする。
      2. Resolve により promise を result で解決する。
    - innerPromise が理由 reason で rejected された場合：
      1. Reject により promise を reason で拒否する。
- promiseOfModule が理由 reason で rejected された場合：
  1. Reject により promise を reason で拒否する。
promise を返す。

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

stableBytes を、buffer が保持するバイト列のコピー bytes とする。
WebAssembly モジュールを非同期にコンパイルし、 stableBytes と options を用いて結果を promiseOfModule とする。
インスタンス化により promiseOfModule を importObject をインポートして実行し、その結果を返す。

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

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

注：追補のストリーミング API は WebAssembly Web API に記載されている。

JSTag 属性の getter（WebAssembly 名前空間のもの）は、呼び出されると次の手順を実行する：

JSTagAddr を、JavaScript 例外タグを取得した結果とする。
JSTagObject を、Tag オブジェクトを作成し JSTagAddr から得た結果とする。
JSTagObject を返す。

5.1. モジュール

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(BufferSource 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 は、次のとおりである。

type が func functype の形式である場合は "function"
type が table tabletype の形式である場合は "table"
type が mem memtype の形式である場合は "memory"
type が global globaltype の形式である場合は "global"
type が tag tag の形式である場合は "tag"

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

module を moduleObject.[[Module]] とする。
exports を « » とする。
各 (name, type) について、module_exports(module) を繰り返す。
1. kind を、外部型の文字列表現 type とする。
2. obj を «[ "name" → name, "kind" → kind ]» とする。
3. Append により obj を exports に追加する。
exports を返す。

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

module を moduleObject.[[Module]] とする。
builtinSetNames を moduleObject.[[BuiltinSets]] とする。
importedStringModule を moduleObject.[[ImportedStringModule]] とする。
imports を « » とする。
各 (moduleName, name, type) について、module_imports(module) を繰り返す。
1. (moduleName, name, type) と builtinSetNames に対するビルトインの検索が null でないなら、 continue。
2. importedStringModule が null でなく、かつ moduleName が importedStringModule に等しいなら、 continue。
3. kind を、外部型の文字列表現 type とする。
4. obj を «[ "module" → moduleName, "name" → name, "kind" → kind ]» とする。
5. Append により obj を imports に追加する。
imports を返す。

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

bytes を moduleObject.[[Bytes]] とする。
customSections を « » とする。
各カスタムセクション customSection を、モジュール文法に従って解釈した bytes から取り出して処理する。
1. name を customSection の name を UTF-8 デコードした値とする。
2. 表明：name は失敗ではない (moduleObject.[[Module]] は valid である)。
3. name が文字列値として sectionName に等しい場合、
  1. この customsec 生成規則に一致する範囲の bytes のコピーを格納した新しい ArrayBuffer を Append により customSections に追加する。
customSections を返す。

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

stableBytes を、buffer が保持するバイト列のコピー bytes とする。
WebAssembly モジュールをコンパイルして stableBytes から結果を得て、module とする。
module が error なら、CompileError 例外を投げる。
builtinSetNames を options["builtins"] とする。
importedStringModule を options["importedStringConstants"] とする。
ビルトインおよびインポート文字列の検証を module、builtinSetNames、importedStringModule で行い、false を返す場合は CompileError 例外を投げる。
this.[[Module]] に module を設定する。
this.[[Bytes]] に stableBytes を設定する。
this.[[BuiltinSets]] に builtinSetNames を設定する。
this.[[ImportedStringModule]] に importedStringModule を設定する。

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

5.2. インスタンス

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

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

module を module.[[Module]] とする。
builtinSetNames を module.[[BuiltinSets]] とする。
importedStringModule を module.[[ImportedStringModule]] とする。
インポートを読み取るを実行し、 module に対し importObject、builtinSetNames、importedStringModule を用いて結果を imports とする。
WebAssembly モジュールのコアをインスタンス化するを実行し、 module と imports から結果を instance とする。
初期化により、this を module と instance から初期化する。

注：一部の実装ではインスタンス化時に長時間のコンパイル処理を行うことがあるため、この同期 API の使用は推奨されない。

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

5.3. メモリ

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

Memory オブジェクトは、複数の Instance オブジェクトから同時に参照可能な単一のメモリインスタンスを表す。各 Memory オブジェクトは次の内部スロットを持つ。

[[Memory]] : メモリアドレス
[[BufferObject]] : データブロックが上記のメモリアドレスと同定されている ArrayBuffer

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

block を、データブロックであって、同定される対象が memaddr の基礎メモリであるものとする。
buffer を、新しい ArrayBuffer とし、内部スロット [[ArrayBufferData]]、[[ArrayBufferByteLength]]、[[ArrayBufferDetachKey]] を持つものとする。
buffer.[[ArrayBufferData]] に block を設定する。
buffer.[[ArrayBufferByteLength]] に block の長さを設定する。
buffer.[[ArrayBufferDetachKey]] に "WebAssembly.Memory" を設定する。
buffer を返す。

メモリアドレス memaddr と maxsize から可変長メモリバッファを作成するには、次の手順を実行する。

block を、データブロックであって、同定される対象が memaddr の基礎メモリであるものとする。
length を block の長さとする。
buffer を、新しい ArrayBuffer とし、内部スロット [[ArrayBufferData]]、[[ArrayBufferByteLength]]、[[ArrayBufferMaxByteLength]]、[[ArrayBufferDetachKey]] を持つものとする。
buffer.[[ArrayBufferData]] に block を設定する。
buffer.[[ArrayBufferByteLength]] に length を設定する。
buffer.[[ArrayBufferMaxByteLength]] は maxsize とする。
buffer.[[ArrayBufferDetachKey]] に "WebAssembly.Memory" を設定する。
buffer を返す。

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

map を、surrounding agent に関連付けられた Memory object cache とする。
表明：map[memaddr] は存在しない。
buffer を、固定長メモリバッファの作成を memaddr に対して実行した結果とする。
memory.[[Memory]] に memaddr を設定する。
memory.[[BufferObject]] に buffer を設定する。
Set により map[memaddr] に memory を設定する。

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

map を、surrounding agent に関連付けられた Memory object cache とする。
もし map[memaddr] が存在するならば、
1. map[memaddr] を返す。
memory を、new な Memory とする。
初期化により memory を memaddr から初期化する。
memory を返す。

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

もし descriptor["address"] が存在するなら addrtype を descriptor["address"] とし、そうでなければ addrtype を "i32" とする。
initial を、? AddressValueToU64(descriptor["initial"], addrtype) の結果とする。
もし descriptor["maximum"] が存在するなら maximum を ? AddressValueToU64(descriptor["maximum"], addrtype) の結果とし、そうでなければ maximum を空とする。
memtype をメモリ型 addrtype { min initial, max maximum } とする。
memtype が valid でなければ、RangeError 例外を投げる。
store を、surrounding agent の associated store とする。
(store, memaddr) を mem_alloc(store, memtype) とする。もし割り当てに失敗したら、RangeError 例外を投げる。
surrounding agent の associated store を store に設定する。
初期化により this を memaddr から初期化する。

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

map を、surrounding agent に関連付けられた Memory object cache とする。
表明：map[memaddr] は存在する。
memory を map[memaddr] とする。
buffer を memory.[[BufferObject]] とする。
もし IsFixedLengthArrayBuffer(buffer) が true なら、
1. ! DetachArrayBuffer(buffer,"WebAssembly.Memory") を実行する。
2. buffer を、固定長メモリバッファの作成を memaddr に対して実行した結果とする。
3. memory.[[BufferObject]] に buffer を設定する。
それ以外の場合、
1. block を、データブロックであって、同定される対象が memaddr の基礎メモリであるものとする。
2. buffer.[[ArrayBufferData]] に block を設定する。
3. buffer.[[ArrayBufferByteLength]] に block の長さを設定する。

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

store を、surrounding agent の associated store とする。
ret を、mem_size(store, memaddr) とする。
store を、mem_grow(store, memaddr, delta) とする。
store が error なら、RangeError 例外を投げる。
surrounding agent の associated store を store に設定する。
Memory バッファを更新するを memaddr に対して実行する。
ret を返す。

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

memaddr を this.[[Memory]] とする。
store を、surrounding agent の associated store とする。
addrtype を、アドレス型における mem_type(store, memaddr) の値とする。
delta64 を、? AddressValueToU64(delta, addrtype) の結果とする。
ret を、メモリバッファの拡張を memaddr に対して delta64 分行った結果とする。
U64ToAddressValue(ret, addrtype) を返す。

WebAssembly の memory.grow 命令の実行直後に、次の手順を実行する。

スタックの先頭が i32.const (−1) でない場合、
1. frame を現在のフレームとする。
2. 表明：検証により、frame.module.memaddrs[0] は存在する。
3. memaddr を、 frame.module.memaddrs[0] のメモリアドレスとする。
4. Memory バッファを更新するを memaddr に対して実行する。

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

buffer を this.[[BufferObject]] とする。
もし IsFixedLengthArrayBuffer(buffer) が true なら、 buffer を返す。
memaddr を this.[[Memory]] とする。
fixedBuffer を、固定長メモリバッファの作成を memaddr に対して実行した結果とする。
! DetachArrayBuffer(buffer, "WebAssembly.Memory") を実行する。
this.[[BufferObject]] に fixedBuffer を設定する。
fixedBuffer を返す。

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

memaddr を this.[[Memory]] とする。
store を、surrounding agent の associated store とする。
memtype を、mem_type(store, memaddr) とする。
memtype に max がない場合、
1. Throw により TypeError 例外を投げる。
buffer を this.[[BufferObject]] とする。
もし IsFixedLengthArrayBuffer(buffer) が false なら、 buffer を返す。
表明：memtype は max を持つ。
maxsize を memtype の max 値 × 65536 とする。
resizableBuffer を、可変長メモリバッファの作成を memaddr と maxsize に対して実行した結果とする。
! DetachArrayBuffer(buffer, "WebAssembly.Memory") を実行する。
this.[[BufferObject]] に resizableBuffer を設定する。
resizableBuffer を返す。

ArrayBuffer は、Memory オブジェクトから返される場合、そのサイズが WebAssembly のページサイズ（定数 65536）の倍数でなければならない。この理由により、HostResizeArrayBuffer は次のように再定義される。

抽象操作 HostResizeArrayBuffer は、引数 buffer（ArrayBuffer）と newLength を取り、呼び出し時に次の手順を実行する。

もし buffer.[[ArrayBufferDetachKey]] が "WebAssembly.Memory" なら、
1. map を、surrounding agent に関連付けられた Memory object cache とする。
2. 表明：buffer は map 内のちょうど 1 つの値の [[BufferObject]] である。
3. 各 memaddr → mem について map を反復する。
  1. もし SameValue(mem.[[BufferObject]], buffer) が true なら、
    1. 表明：buffer.[[ArrayBufferByteLength]] の 65536 による剰余は 0 である。
    2. lengthDelta を newLength − buffer.[[ArrayBufferByteLength]] とする。
    3. もし lengthDelta < 0 または lengthDelta の 65536 による剰余が 0 でないなら、
      1. RangeError 例外を投げる。
    4. delta を lengthDelta ÷ 65536 とする。
    5. メモリバッファの拡張を memaddr に対して delta 分行う。
4. handled を返す。
それ以外の場合、unhandled を返す。

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

5.4. テーブル

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

Table オブジェクトは、複数の Instance オブジェクトから同時に参照可能な単一の table instance を表す。各 Table オブジェクトは [[Table]] という内部スロットを持ち、これは table address である。

table オブジェクトを初期化するために、 table address tableaddr から table を初期化する手順は次のとおり：

map を、surrounding agent に関連付けられた Table object cache とする。
表明：map[tableaddr] は存在しない。
table.[[Table]] に tableaddr を設定する。
Set により map[tableaddr] を table に設定する。

table address tableaddr から table オブジェクトを作成するには、次の手順を実行する：

map を、surrounding agent に関連付けられた Table object cache とする。
もし map[tableaddr] が存在するなら、
1. map[tableaddr] を返す。
table を、new な Table とする。
初期化により table を tableaddr から初期化する。
table を返す。

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

elementtype を ToValueType(descriptor["element"]) とする。
もし elementtype が reftype でなければ、
1. Throw により TypeError 例外を投げる。
もし descriptor["address"] が存在するなら addrtype を descriptor["address"] とし、そうでなければ addrtype を "i32" とする。
initial を、? AddressValueToU64(descriptor["initial"], addrtype) の結果とする。
もし descriptor["maximum"] が存在するなら maximum を ? AddressValueToU64(descriptor["maximum"], addrtype) の結果とし、そうでなければ maximum を空とする。
type を、table type addrtype { min initial, max maximum } elementType とする。
もし type が valid でなければ、RangeError 例外を投げる。
もし value が与えられていなければ、
1. ref を DefaultValue(elementtype) とする。
2. 表明：ref は error ではない。
それ以外の場合、
1. ref を ? ToWebAssemblyValue(value, elementType) とする。
store を、surrounding agent の associated store とする。
(store, tableaddr) を table_alloc(store, type, ref) とする。割り当てに失敗した場合は、RangeError 例外を投げる。
surrounding agent の associated store を store に設定する。
初期化により this を tableaddr から初期化する。

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

tableaddr を this.[[Table]] とする。
store を、surrounding agent の associated store とする。
initialSize を table_size(store, tableaddr) とする。
(addrtype, limits, elementtype) を table_type(store, tableaddr) とする。
delta64 を、? AddressValueToU64(delta, addrtype) の結果とする。
もし value が与えられていなければ、
1. ref を DefaultValue(elementtype) とする。
2. もし ref が error なら、TypeError 例外を投げる。
それ以外の場合、
1. ref を ? ToWebAssemblyValue(value, elementtype) とする。
result を table_grow(store, tableaddr, delta64, ref) とする。
もし result が error なら、RangeError 例外を投げる。

注：上記の例外は、メモリ不足または不正なサイズ引数により発生することがある。
surrounding agent の associated store を result に設定する。
initialSize を返す。

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

tableaddr を this.[[Table]] とする。
store を、surrounding agent の associated store とする。
addrtype を、address type における table_type(store, tableaddr) の値とする。
length64 を table_size(store, tableaddr) とする。
U64ToAddressValue(length64, addrtype) を返す。

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

tableaddr を this.[[Table]] とする。
store を、surrounding agent の associated store とする。
(addrtype, limits, elementtype) を table_type(store, tableaddr) とする。
もし elementtype が matches exnref なら、
1. TypeError 例外を投げる。
index64 を、? AddressValueToU64(index, addrtype) の結果とする。
result を table_read(store, tableaddr, index64) とする。
もし result が error なら、RangeError 例外を投げる。
ToJSValue(result) を返す。

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

tableaddr を this.[[Table]] とする。
store を、surrounding agent の associated store とする。
(addrtype, limits, elementtype) を table_type(store, tableaddr) とする。
もし elementtype が matches exnref なら、
1. TypeError 例外を投げる。
index64 を、? AddressValueToU64(index, addrtype) の結果とする。
もし value が与えられていなければ、
1. ref を DefaultValue(elementtype) とする。
2. もし ref が error なら、TypeError 例外を投げる。
それ以外の場合、
1. ref を ? ToWebAssemblyValue(value, elementtype) とする。
store を table_write(store, tableaddr, index64, ref) とする。
もし store が error なら、RangeError 例外を投げる。
surrounding agent の associated store を store に設定する。

5.5. グローバル

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

注：この型は将来の WebAssembly のバージョンで追加のケースによって拡張される可能性がある。

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

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

Global オブジェクトは、複数の Instance オブジェクトから同時に参照可能な単一の global instance を表す。各 Global オブジェクトは 1 つの内部スロットを持つ：

[[Global]] : global address

global オブジェクトを初期化するために、 global address globaladdr から global を初期化する手順は次のとおり：

map を、surrounding agent に関連付けられた Global object cache とする。
表明：map[globaladdr] は存在しない。
global.[[Global]] に globaladdr を設定する。
Set により map[globaladdr] を global に設定する。

global address globaladdr から global オブジェクトを作成するには、次の手順を実行する：

map を、surrounding agent に関連付けられた Global object cache とする。
もし map[globaladdr] が存在するなら、
1. map[globaladdr] を返す。
global を、new な Global とする。
初期化により global を globaladdr から初期化する。
global を返す。

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

もし s が "i32" に等しければ、i32 を返す。
もし s が "i64" に等しければ、i64 を返す。
もし s が "f32" に等しければ、f32 を返す。
もし s が "f64" に等しければ、f64 を返す。
もし s が "v128" に等しければ、v128 を返す。
もし s が "anyfunc" に等しければ、funcref を返す。
もし s が "externref" に等しければ、externref を返す。
表明：このステップには到達しない。

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

もし valuetype が externref に等しければ、ToWebAssemblyValue(undefined, valuetype) を返す。
val_default(valuetype) を返す。

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

mutable を descriptor["mutable"] とする。
valuetype を ToValueType(descriptor["value"]) とする。
もし valuetype が matches v128 または exnref なら、
1. TypeError 例外を投げる。
もし v が与えられていなければ、
1. value を DefaultValue(valuetype) とする。
2. 表明：value は error ではない。
それ以外の場合、
1. value を ToWebAssemblyValue(v, valuetype) とする。
もし mutable が true なら globaltype を var valuetype とし、そうでなければ globaltype を const valuetype とする。
store を現在のエージェントの associated store とする。
(store, globaladdr) を global_alloc(store, globaltype, value) とする。
現在のエージェントの associated store を store に設定する。
初期化により this を globaladdr から初期化する。

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

store を現在のエージェントの associated store とする。
globaladdr を global.[[Global]] とする。
globaltype を global_type(store, globaladdr) とする。
もし globaltype が mut valuetype の形式で、その valuetype が matches v128 または exnref なら、TypeError を投げる。
value を global_read(store, globaladdr) とする。
ToJSValue(value) を返す。

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

GetGlobalValue(this) を返す。

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

store を現在のエージェントの associated store とする。
globaladdr を this.[[Global]] とする。
mut valuetype を global_type(store, globaladdr) とする。
もし valuetype が matches v128 または exnref なら、TypeError を投げる。
もし mut が const なら、TypeError を投げる。
value を ToWebAssemblyValue(与えられた値, valuetype) とする。
store を global_write(store, globaladdr, value) とする。
もし store が error なら、RangeError 例外を投げる。
現在のエージェントの associated store を store に設定する。

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

GetGlobalValue(this) を返す。

5.6. エクスポートされた関数

WebAssembly の関数は、JavaScript では Exported Function として利用可能になる。 Exported Function は、組み込み関数オブジェクトでありコンストラクターではなく、[[FunctionAddress]] 内部スロットを持つ。このスロットは、function address を、surrounding agent の associated store に対して相対的に保持する。

WebAssembly 関数の名前 funcaddr は、次の手順で求められる：

store を、surrounding agent の associated store とする。
funcinst を store.funcs[funcaddr] とする。
funcinst が {type functype, hostcode hostfunc} の形式であるなら、
1. 表明：hostfunc は JavaScript オブジェクトであり、IsCallable(hostfunc) は true である。
2. index を、ホスト関数のインデックス funcaddr とする。
それ以外の場合、
1. moduleinst を funcinst.module とする。
2. 表明：funcaddr は moduleinst.funcaddrs に含まれている。
3. index を、moduleinst.funcaddrs 内で funcaddr が見つかる位置のインデックスとする。
! ToString(index) を返す。

WebAssembly の function address funcaddr から新しい Exported Function を作成するには、次の手順を実行する：

map を、surrounding agent に関連付けられた Exported Function cache とする。
もし map[funcaddr] が存在するなら、
1. map[funcaddr] を返す。
steps を「引数付きで Exported Function を呼び出す funcaddr」とする。
realm を現在の Realm とする。
store を、surrounding agent の associated store とする。
functype を func_type(store, funcaddr) とする。
[paramTypes] → [resultTypes] を functype とする。
arity を paramTypes の大きさとする。
name を、WebAssembly 関数の名前 funcaddr とする。
function を、! CreateBuiltinFunction(steps, arity, name, « [[FunctionAddress]] », realm) とする。
function.[[FunctionAddress]] に funcaddr を設定する。
Set により map[funcaddr] に function を設定する。
function を返す。

function address funcaddr と JavaScript 引数のリスト argValues を用いて、Exported Function を呼び出すには、次の手順を実行する：

store を、surrounding agent の associated store とする。
functype を func_type(store, funcaddr) とする。
[parameters] → [results] を functype とする。
もし parameters または results 内のいずれかの型が matches v128 または exnref なら、TypeError を投げる。

注：上記のエラーは [[Call]] メソッドが呼び出されるたびに投げられる。
args を « » とする。
i を 0 とする。
各 t について、parameters を繰り返す。
1. もし argValues の大きさ > i なら、arg を argValues[i] とする。
2. それ以外なら、arg を undefined とする。
3. Append により ToWebAssemblyValue(arg, t) を args に追加する。
4. i を i + 1 に設定する。
(store, ret) を、func_invoke(store, funcaddr, args) の結果とする。
surrounding agent の associated store を store に設定する。
もし ret が error なら、例外を投げる。この例外は、特に指定がない限り WebAssembly のエラー対応表に従って、WebAssembly の RuntimeError であるべきである。
もし ret が THROW ref.exn exnaddr なら、
1. tagaddr を exn_tag(store, exnaddr) とする。
2. payload を exn_read(store, exnaddr) とする。
3. jsTagAddr を、JavaScript 例外タグを取得した結果とする。
4. もし tagaddr が jsTagAddr に等しいなら、
  1. ホスト値の取得の結果 payload[0] を投げる。
5. それ以外の場合、
  1. exception を、新しい Exception（exnaddr から作成）とする。
  2. exception を投げる。
outArity を ret の大きさとする。
もし outArity が 0 なら、undefined を返す。
それ以外で outArity が 1 なら、ToJSValue(ret[0]) を返す。
それ以外の場合、
1. values を « » とする。
2. 各 r について、ret を繰り返す。
  1. Append により ToJSValue(r) を values に追加する。
3. CreateArrayFromList(values) を返す。

注： Exported Function の呼び出しは、組み込み関数オブジェクトの定義に従い、呼び出し先 Exported Function の [[Realm]] で実行される。

注： Exported Function は [[Construct]] メソッドを持たないため、new 演算子で呼び出すことはできない。

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

[parameters] → [results] を functype とする。
もし parameters または results 内のいずれかの型が matches v128 または exnref なら、TypeError を投げる。
jsArguments を « » とする。
各 arg について、arguments を繰り返す。
1. Append により ! ToJSValue(arg) を jsArguments に追加する。
ret を、? Call(func, undefined, jsArguments) とする。
resultsSize を results の大きさとする。
もし resultsSize が 0 なら、« » を返す。
それ以外で resultsSize が 1 なら、« ? ToWebAssemblyValue(ret, results[0]) » を返す。
それ以外の場合、
1. method を、? GetMethod(ret, %Symbol.iterator%) とする。
2. もし method が undefined なら、throw により TypeError を投げる。
3. values を、? IteratorToList(? GetIteratorFromMethod(ret, method)) とする。
4. wasmValues を新しい空のリストとする。
5. もし values の大きさが resultsSize と等しくなければ、TypeError 例外を投げる。
6. values と results の各 value および resultType を同順で対応付けて反復し、
  1. Append により ToWebAssemblyValue(value, resultType) を wasmValues に追加する。
7. wasmValues を返す。

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

表明：IsCallable(func)。
stored settings をインカンベント設定オブジェクトとする。
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 を、surrounding agent の associated 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. surrounding agent の associated store を store に設定する。
  4. WebAssembly 命令 (ref.exn address)（throw_ref）を実行する。
11. それ以外の場合、result.[[Value]] を返す。
(store, funcaddr) を func_alloc(store, functype, hostfunc) とする。
surrounding agent の associated store を store に設定する。
funcaddr を返す。

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

表明：w は v128.const v128 の形式ではない。
表明：w は ref.exn exnaddr の形式ではない。
もし w が i64.const u64 の形式なら、
1. i64 を signed_64(u64) とする。
2. ℤ(i64 を数学的値として解釈したもの) を返す。
もし w が i32.const u32 の形式なら、
1. i32 を signed_32(u32) とする。
2. 𝔽(i32 を数学的値として解釈したもの) を返す。
もし w が f32.const f32 の形式なら、
1. もし f32 が +∞ または −∞ なら、それぞれ +∞_𝔽 または -∞_𝔽 を返す。
2. もし f32 が nan なら、NaN を返す。
3. 𝔽(f32 を数学的値として解釈したもの) を返す。
もし w が f64.const f64 の形式なら、
1. もし f64 が +∞ または −∞ なら、それぞれ +∞_𝔽 または -∞_𝔽 を返す。
2. もし f64 が nan なら、NaN を返す。
3. 𝔽(f64 を数学的値として解釈したもの) を返す。
もし w が ref.null t の形式なら、null を返す。
もし w が ref.i31 u31 の形式なら、
1. i31 を signed_31(u31) とする。
2. return 𝔽(i31) とする。
もし w が ref.struct structaddr の形式なら、新しい Exported GC Object を structaddr と "struct" から作成した結果を返す。
もし w が ref.array arrayaddr の形式なら、新しい Exported GC Object を arrayaddr と "array" から作成した結果を返す。
もし w が ref.func funcaddr の形式なら、新しい Exported Function を funcaddr から作成した結果を返す。
もし w が ref.host hostaddr の形式なら、ホスト値の取得を hostaddr に対して行った結果を返す。
もし w が ref.extern ref の形式なら、ToJSValue(ref) を返す。

注： NaN と等しい数値は、観測可能な NaN ペイロードがさまざまであり得る。詳細は NumericToRawBytes を参照。

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

map を、surrounding agent に関連付けられた host value cache とする。
表明：map[hostaddr] は存在する。
map[hostaddr] を返す。

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

表明：type は v128 ではない。
表明：type は match しない（exnref）。
もし type が i64 なら、
1. i64 を、? ToBigInt64(v) とする。
2. u64 を、i64 が signed_64(u64) となるような符号なし整数とする。
3. i64.const u64 を返す。
もし type が i32 なら、
1. i32 を、? ToInt32(v) とする。
2. u32 を、i32 が signed_32(u32) となるような符号なし整数とする。
3. i32.const u32 を返す。
もし 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 を返す。
もし 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 を返す。
もし 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(i31) となるような符号なし整数とする。
  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. もし objectkind が "struct" なら、
    1. r を ref.struct objectaddr とする。
6. Else、
  1. map を、surrounding agent に関連付けられた host value cache とする。
  2. もし host address hostaddr が存在し、 map[hostaddr] が v と同一であるなら、
    1. ref.host hostaddr を返す。
  3. host address hostaddr を、 map[hostaddr] が存在しないとなる最小のアドレスとする。
  4. Set により map[hostaddr] に v を設定する。
  5. r を ref.host hostaddr とする。
7. store を、現在のエージェントの associated store とする。
8. actualtype を、ref_type(store, r) とする。
9. もし match_valtype(actualtype, type) が false なら、
  1. TypeError を投げる。
10. r を返す。
表明：このステップには到達しない。

アルゴリズム AddressValueToU64(v, addrtype) は、埋め込み操作で使用する WebAssembly の u64 に JavaScript 値を変換する。これは [EnforceRange] の unsigned long を AddressType "i32" に対して模倣し、さらに AddressType "i64" に対してそのセマンティクスを拡張することを意図しており、次の手順を実行する：

もし addrtype が "i32" なら、
1. n を、? ConvertToInt(v, 32, "unsigned") とし、変換先型は [EnforceRange] に従うものとする。
  
  注：これは JS 変換規則における [EnforceRange] unsigned long と同等である。
2. WebAssembly の u64 として ℝ(n) を返す。
もし addrtype が "i64" なら、
1. n を、? ToBigInt(v) とする。
2. もし n < 0 または n > 2⁶⁴ − 1 なら、throw により TypeError を投げる。
  
  注：この操作は [EnforceRange] を模倣するよう設計されている。
3. WebAssembly の u64 として ℝ(n) を返す。
表明：このステップには到達しない。

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

もし addrtype が "i32" なら、𝔽(v を数学的値として解釈したもの) を返す。
Else if addrtype が "i64" なら、ℤ(v を数学的値として解釈したもの) を返す。
表明：このステップには到達しない。

5.7. タグ

tag_alloc(store, parameters) アルゴリズムは、store 内の parameters に対する新しい tag address を作成し、更新された store と tag address を返す。

5.7.1. タグの型

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

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

Tag 値は例外タグを表す。

tag address tagAddress から Tag オブジェクトを初期化する tag には、次の手順を実行する：

map を、surrounding agent に関連付けられた Tag object cache とする。
表明：map[tagAddress] は存在しない。
tag.[[Address]] に tagAddress を設定する。
Set により map[tagAddress] に tag を設定する。

tag address tagAddress から Tag オブジェクトを作成するには、次の手順を実行する：

map を、surrounding agent に関連付けられた Tag object cache とする。
もし map[tagAddress] が存在するなら、
1. map[tagAddress] を返す。
tag を、new な Tag とする。
初期化により tag を tagAddress から初期化する。
tag を返す。

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

parameters を type["parameters"] とする。
wasmParameters を «» とする。
各 type について、parameters を繰り返す。
1. Append により ToValueType(type) を wasmParameters に追加する。
store を、現在のエージェントの associated store とする。
(store, tagAddress) を tag_alloc(store, wasmParameters) とする。
現在のエージェントの associated store を store に設定する。
初期化により this を tagAddress から初期化する。

5.8. ガーベジコレクション対象オブジェクト

WebAssembly の struct または array は、JavaScript では Exported GC Object として利用可能になる。 Exported GC Object は、ガーベジコレクトされる WebAssembly の参照値をラップするエキゾチックオブジェクトである。 Exported GC Object に対する多くの JavaScript 操作は、例外を投げるか undefined を返す。

注：これらの操作は将来的に改良され、JavaScript から WebAssembly の struct や array とより豊かな相互作用が可能になるかもしれない。

Exported GC Object は、 [[ObjectAddress]] 内部スロットを含み、これは object address を surrounding agent の associated store に相対的に保持する。また [[ObjectKind]] 内部スロットを含み、これは "struct" または "array" の文字列値を保持する。

Exported GC Object の内部メソッドは次の実装を用いる。

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

null を返す。

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

false を返す。

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

false を返す。

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

false を返す。

Exported GC Object の [[GetOwnProperty]] 内部メソッド O は引数 P（プロパティキー）を取り、undefined を返す。呼び出されたとき次の手順を実行する：

undefined を返す。

Exported GC Object の [[DefineOwnProperty]] 内部メソッド O は引数 P（プロパティキー）と Desc（プロパティ記述子）を取り、boolean を返す。呼び出されたとき次の手順を実行する：

false を返す。

Exported GC Object の [[HasProperty]] 内部メソッド O は引数 P（プロパティキー）を取り、boolean を返す。呼び出されたとき次の手順を実行する：

false を返す。

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

undefined を返す。

Exported GC Object の [[Set]] 内部メソッド O は引数 P（プロパティキー）、V（ECMAScript 言語値）、Receiver（ECMAScript 言語値）を取り、例外を投げる。呼び出されたとき次の手順を実行する：

TypeError を投げる。

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

TypeError を投げる。

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

keys を新しい空のリストとする。
keys を返す。

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

表明：objectkind は "array" または "struct" のいずれかである。
map を、surrounding agent に関連付けられた exported GC object cache とする。
もし map[objectaddr] が存在するなら、
1. map[objectaddr] を返す。
object を、MakeBasicObject(« [[ObjectAddress]] ») とする。
object.[[ObjectAddress]] に objectaddr を設定する。
object.[[ObjectKind]] に objectkind を設定する。
object.[[GetPrototypeOf]] を、[[GetPrototypeOf]] 内部メソッドに規定されたとおりに設定する。
object.[[SetPrototypeOf]] を、[[SetPrototypeOf]] 内部メソッドに規定されたとおりに設定する。
object.[[IsExtensible]] を、[[IsExtensible]] 内部メソッドに規定されたとおりに設定する。
object.[[PreventExtensions]] を、[[PreventExtensions]] 内部メソッドに規定されたとおりに設定する。
object.[[GetOwnProperty]] を、[[GetOwnProperty]] 内部メソッドに規定されたとおりに設定する。
object.[[DefineOwnProperty]] を、[[DefineOwnProperty]] 内部メソッドに規定されたとおりに設定する。
object.[[HasProperty]] を、[[HasProperty]] 内部メソッドに規定されたとおりに設定する。
object.[[Get]] を、[[Get]] 内部メソッドに規定されたとおりに設定する。
object.[[Set]] を、[[Set]] 内部メソッドに規定されたとおりに設定する。
object.[[Delete]] を、[[Delete]] 内部メソッドに規定されたとおりに設定する。
object.[[OwnPropertyKeys]] を、[[OwnPropertyKeys]] 内部メソッドに規定されたとおりに設定する。
Set により map[objectaddr] に object を設定する。
object を返す。

5.9. 例外

dictionary ExceptionOptions {
  boolean traceStack = false;
};

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

Exception 値は例外を表す。

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

map を、surrounding agent に関連付けられた Exception object cache とする。
表明：map[exnAddress] は存在しない。
exn.[[Address]] に exnAddress を設定する。
Set により map[exnAddress] に exn を設定する。
store を、surrounding agent の associated store とする。
tagaddr を exn_tag(store, exnAddress) とする。
payload を exn_read(store, exnAddress) とする。
exn.[[Type]] に tagaddr を設定する。
exn.[[Payload]] に payload を設定する。
exn.[[Stack]] に undefined を設定する。

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

map を、surrounding agent に関連付けられた Exception object cache とする。
もし map[exnAddress] が存在するなら、
1. map[exnAddress] を返す。
exn を、new な Exception とする。
初期化により exn を exnAddress から初期化する。
exn を返す。

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

JSTagAddr を、JavaScript 例外タグを取得した結果とする。
もし exceptionTag.[[Address]] が JSTagAddr に等しければ、
1. TypeError を投げる。
store を、surrounding agent の associated store とする。
[types] → [] を、tag_type(store, exceptionTag.[[Address]]) とする。
もし types の大きさが payload の大きさと等しくなければ、
1. TypeError を投げる。
wasmPayload を « » とする。
各 value および resultType について、payload と types を同順で対応付けて反復する。
1. もし resultType が matches v128 または exnref なら、
  1. TypeError を投げる。
2. Append により ? ToWebAssemblyValue(value, resultType) を wasmPayload に追加する。
(store, exceptionAddr) を exn_alloc(store, exceptionTag.[[Address]], wasmPayload) とする。
surrounding agent の associated store を store に設定する。
初期化により this を exceptionAddr から初期化する。
もし options["traceStack"] が true なら、
1. this.[[Stack]] に、現在のコールスタックの DOMString 表現または undefined のいずれかを設定する。

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

store を、surrounding agent の associated store とする。
tagaddr を exn_tag(store, this.[[Address]]) とする。
payload を exn_read(store, this.[[Address]]) とする。
表明：tagaddr は this.[[Type]] に等しい。
もし index ≥ payload の大きさなら、
1. RangeError を投げる。
[types] → [] を tag_type(store, tagaddr) とする。
もし types[index] が matches v128 または exnref なら、
1. TypeError を投げる。
ToJSValue(payload[index]) を返す。

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

もし this.[[Type]] が exceptionTag.[[Address]] に等しくなければ、
1. false を返す。
true を返す。

stack 属性の getter の手順は次のとおり：

this.[[Stack]] を返す。

5.9.1. JavaScript 例外

JavaScript 例外タグは、surrounding agent に関連付けられた tag address である。初回使用時にエージェントの associated store に割り当てられ、キャッシュされる。常に tag type « externref » → « » を持つ。

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

もし surrounding agent に関連付けられた JavaScript 例外タグが初期化済みなら、
1. surrounding agent に関連付けられた JavaScript 例外タグを返す。
store を、surrounding agent の associated store とする。
(store, tagAddress) を tag_alloc(store, « externref » → « ») とする。
現在のエージェントの associated store を store に設定する。
現在のエージェントに関連付けられた JavaScript 例外タグを tagAddress に設定する。
tagAddress を返す。

5.10. エラーオブジェクト

WebAssembly は次の Error クラスを定義する：CompileError、LinkError、および RuntimeError。

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

namespaceObject を、namespace object とする。
各 error（« "CompileError", "LinkError", "RuntimeError" »）について、
1. constructor を、新しいオブジェクトで、NativeError Object Structure を実装し、 NativeError を error に設定したものとする。
2. ! DefineMethodProperty(namespaceObject, error, constructor, false) を実行する。

注：これは、当仕様で定義される API によって生成される、CompileError、 LinkError、および RuntimeError クラスを WebAssembly 名前空間上に定義する。これらは、TypeError や RangeError のようなネイティブの JavaScript エラーと同じインターフェイスを公開する。

注：現時点では、この挙動を Web IDL を用いて定義することはできない。

6. ビルトイン

JS-API は、モジュールのコンパイル時に options を通じてインポートできるビルトイン関数の集合を定義する。WebAssembly のビルトイン関数は既存の JavaScript のビルトインを反映しつつ、オーバーヘッドを最小化して WebAssembly 関数として直接利用できるよう適合させる。

すべてのビルトイン関数はセットにグループ化される。各ビルトインセットは、WebAssemblyCompileOptions で使用される name と、インポート検索で使用される wasm: 接頭辞付きの qualified name を持つ。

ビルトインセットのビルトインを取得するために builtinSetName を与えたとき、次の手順を実行する。

この節で定義された、名前が builtinSetName であるセットに対する (name, funcType, steps) のリストを返す。

ビルトインを検索するために、 import と有効なビルトイン builtinSetNames を与えて次の手順を実行する：

表明：validate builtin set names(builtinSetNames) は true である。
importModuleName を import[0] とする。
importName を import[1] とする。
各 builtinSetName について、builtinSetNames を反復する。
1. もし builtinSetName がビルトインセットを指していなければ、continue。
2. builtinSetQualifiedName を "wasm:" を前置した builtinSetName とする。
3. もし importModuleName が builtinSetQualifiedName に等しければ、
  1. builtins を、ビルトインセットのビルトインを取得する(builtinSetName) の結果とする。
  2. 各 builtin について、builtins を反復する。
    1. builtinName を builtin[0] とする。
    2. もし importName が builtinName に等しければ、(builtinSetName, builtin) を返す。
null を返す。

ビルトインセット名を検証するために builtinSetNames を与えたとき、次の手順を実行する：

もし builtinSetNames に重複が含まれていれば、false を返す。
true を返す。

型 funcType と実行手順 steps からビルトイン関数を作成するには、次の手順を実行する：

hostfunc を、呼び出されたときに steps を実行する host function とする。
(store, funcaddr) を func_alloc(store, functype, hostfunc) とする。
surrounding agent の associated store を store に設定する。
funcaddr を返す。

名前 builtinSetName のビルトインセットをインスタンス化するには、次の手順を実行する：

builtins を、ビルトインセットのビルトインを取得する(builtinSetName) の結果とする。
exportsObject を、! OrdinaryObjectCreate(null) とする。
各 (name, funcType, steps) について、builtins を反復する。
1. funcaddr を、ビルトイン関数を作成する(funcType, steps) の結果とする。
2. func を、新しい Exported Function を funcaddr から作成した結果とする。
3. value を func とする。
4. status を、! CreateDataProperty(exportsObject, name, value) とする。
5. 表明：status は true である。
exportsObject を返す。

ビルトイン用のインポートを検証するために、import と有効なビルトイン builtinSetNames を与えて次の手順を実行する：

表明：validate builtin set names(builtinSetNames) は true である。
maybeBuiltin を、ビルトインを検索する(import, builtinSetNames) の結果とする。
もし maybeBuiltin が null なら、true を返す。
importExternType を import[2] とする。
builtinFuncType を maybeBuiltin[0][1] とする。
builtinExternType を func |builtinFuncType| とする。
match_externtype(builtinExternType, importExternType) を返す。

6.1. 文字列ビルトイン

文字列ビルトインは、String ビルトインオブジェクトのインターフェイスを適合させる。このセットの name は js-string、qualified name は wasm:js-string である。

注：この節のアルゴリズムは、String 上に定義された JS のビルトインを参照する。これらは実際のビルトインを参照し、String オブジェクト上で動的な参照を行うものではない。

6.1.1. 抽象操作

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

もし v がString でないなら、
1. trap が実行されたかのように、RuntimeError 例外を投げる。
v を返す。

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

表明：v は i32 型である。
! Call(String.fromCharCode, undefined, « ToJSValue(v) ») を返す。

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

表明：index は i32 型である。
! Call(String.prototype.charCodeAt, string, « ToJSValue(index) ») を返す。

6.1.2. cast

このビルトインの funcType は (rec (type (func (param externref) (result externref)))).0 である。

このビルトインが引数 v で呼び出されたとき、次の手順を実行する：

? UnwrapString(v) を返す。

6.1.3. test

このビルトインの funcType は (rec (type (func (param externref) (result i32)))).0 である。

このビルトインが引数 v で呼び出されたとき、次の手順を実行する：

もし v がString でないなら、
1. 0 を返す。
1 を返す。

6.1.4. fromCharCodeArray

arrayType を (rec (type (array (mut i16)))).0 とする。

このビルトインの funcType は (rec (type (func (param (ref null arrayType) i32 i32) (result externref)))).0 である。

このビルトインが引数 array, start, end で呼び出されたとき、次の手順を実行する：

もし array が null なら、
1. trap が実行されたかのように、RuntimeError 例外を投げる。
length を array の要素数とする。
もし start > end または end > length なら、
1. trap が実行されたかのように、RuntimeError 例外を投げる。
result を空文字列とする。
i を start とする。
i < end の間、次を行う：
1. charCode を、array のインデックス i に格納された要素の値とする。
2. charCodeString を、FromCharCode(charCode) とする。
3. result を、result と charCodeString の連結とする。
4. i を i + 1 に設定する。
result を返す。

6.1.5. intoCharCodeArray

arrayType を (rec (type (array (mut i16)))).0 とする。

このビルトインの funcType は (rec (type (func (param externref (ref null arrayType) i32) (result i32)))).0 である。

このビルトインが引数 string, array, start で呼び出されたとき、次の手順を実行する：

もし array が null なら、
1. trap が実行されたかのように、RuntimeError 例外を投げる。
string を、? UnwrapString(string) とする。
stringLength を、string の長さとする。
arrayLength を array の要素数とする。
もし start + stringLength > arrayLength なら、
1. trap が実行されたかのように、RuntimeError 例外を投げる。
i を 0 とする。
i < stringLength の間、次を行う：
1. charCode を、CharCodeAt(string, i) とする。
2. array のインデックス start + i にある要素を、ToWebAssemblyValue(charCode) に設定する。
3. i を i + 1 に設定する。
stringLength を返す。

6.1.6. fromCharCode

このビルトインの funcType は (rec (type (func (param i32) (result externref)))).0 である。

このビルトインが引数 v で呼び出されたとき、次の手順を実行する：

FromCharCode(v) を返す。

6.1.7. fromCodePoint

このビルトインの funcType は (rec (type (func (param i32) (result externref)))).0 である。

このビルトインが引数 v で呼び出されたとき、次の手順を実行する：

もし v > 0x10ffff なら、
1. trap が実行されたかのように、RuntimeError 例外を投げる。
! Call(String.fromCodePoint, undefined, « ToJSValue(v) ») を返す。

6.1.8. charCodeAt

この関数の型は (rec (type (func (param externref i32) (result i32)))).0 である。

このビルトインが引数 string と index で呼び出されたとき、次の手順を実行する：

string を、? UnwrapString(string) とする。
length を、length（長さ）を用いて string の長さとする。
もし index >= length なら、
1. trap が実行されたかのように、RuntimeError 例外を投げる。
CharCodeAt(string, index) を返す。

6.1.9. codePointAt

この関数の型は (rec (type (func (param externref i32) (result i32)))).0である。

このビルトインが引数 string と index で呼び出されたとき、次の手順を実行する：

string を、? UnwrapString(string) とする。
length を、length（長さ）を用いて string の長さとする。
もし index >= length なら、
1. trap が実行されたかのように、RuntimeError 例外を投げる。
! Call(String.prototype.codePointAt, string, « ToJSValue(index) ») を返す。

6.1.10. length

このビルトインの funcType は (rec (type (func (param externref) (result i32)))).0 である。

このビルトインが引数 v で呼び出されたとき、次の手順を実行する：

string を、? UnwrapString(v) とする。
length（長さ）を用いた string の長さを返す。

6.1.11. concat

このビルトインの funcType は (rec (type (func (param externref externref) (result externref)))).0 である。

このビルトインが引数 first と second で呼び出されたとき、次の手順を実行する：

first を、? UnwrapString(first) とする。
second を、? UnwrapString(second) とする。
! Call(String.prototype.concat, first, « second ») を返す。

6.1.12. substring

このビルトインの funcType は (rec (type (func (param externref i32 i32) (result externref)))).0 である。

このビルトインが引数 string、start、end で呼び出されたとき、次の手順を実行する：

string を、? UnwrapString(string) とする。
length を、length（長さ）を用いて string の長さとする。
もし start > end または start > length なら、
1. 空文字列を返す。
! Call(String.prototype.substring, string, « ToJSValue(start), ToJSValue(end) ») を返す。

6.1.13. equals

このビルトインの funcType は (rec (type (func (param externref externref) (result i32)))).0 である。

注：意味のある比較であるため、null 文字列同士の等値比較を明示的に許可する。

このビルトインが引数 first と second で呼び出されたとき、次の手順を実行する：

もし first が null ではなく、かつ first がString でないなら、
1. trap が実行されたかのように、RuntimeError 例外を投げる。
もし second が null ではなく、かつ second がString でないなら、
1. trap が実行されたかのように、RuntimeError 例外を投げる。
もし ! IsStrictlyEqual(first, second) が true なら、
1. 1 を返す。
0 を返す。

6.1.14. compare

このビルトインの funcType は (rec (type (func (param externref externref) (result i32)))).0 である。

このビルトインが引数 first と second で呼び出されたとき、次の手順を実行する：

first を、? UnwrapString(first) とする。
second を、? UnwrapString(second) とする。
もし ! IsStrictlyEqual(first, second) が true なら、
1. 0 を返す。
もし ! IsLessThan(first, second, true) が true なら、
1. -1 を返す。
1 を返す。

7. エラー条件の JavaScript へのマッピング

WebAssembly プログラムの実行中に、WebAssembly コードの実行を停止させる特定の事象に遭遇することがある。 WebAssembly コード（現時点では）はこれらの条件を捕捉する手段を持たないため、例外は必然的に外側の非 WebAssembly 呼び出し元（ブラウザー、 JavaScript、または別のランタイムシステム）へ伝播し、通常の JavaScript 例外として扱われる。

WebAssembly が import を介して JavaScript を呼び出し、その JavaScript が例外を投げた場合、その例外は WebAssembly のアクティベーションを通過して外側の呼び出し元に伝播する。

JavaScript の例外は処理でき、かつ trap が処理された後に JavaScript から WebAssembly のエクスポートを引き続き呼び出すことができるため、trap は一般に将来の実行を妨げるものではない。

7.1. スタックオーバーフロー

WebAssembly コードでスタックオーバーフローが発生した場合は常に、 JavaScript におけるスタックオーバーフローと同じ種類の例外が投げられる。どの例外になるかは、いずれの場合も実装定義である。

注： ECMAScript はスタックオーバーフロー時の挙動を規定していない。実装では RangeError、 InternalError、あるいは Error を投げることが観測されている。いずれもここでは妥当である。

7.2. メモリ不足（Out of Memory）

検証、コンパイル、またはインスタンス化の過程でメモリ不足になった場合は常に、 JavaScript のメモリ不足時と同じ種類の例外が投げられる。どの例外になるかは、いずれの場合も実装定義である。

注： ECMAScript は OOM（メモリ不足）時の挙動を規定していない。実装では OOMError を投げたりクラッシュすることが観測されている。どちらもここでは妥当である。

大きな table や memory の確保に失敗した場合、次のいずれかの結果になり得る：

RangeError（Memory の grow() および Table の grow() 操作で規定されているとおり）
memory.grow 命令として -1 を返すこと
この節で述べる UA 固有の OOM の挙動

将来の改訂では、大量のメモリ確保に対して、より信頼でき回復可能なエラーの再検討を行う可能性がある。

詳細は Issue 879 を参照。

8. 実装定義の制限

WebAssembly コア仕様は、実装がモジュールの構文構造に制限を設けることを許容している。各埋め込みは独自の制限を定義してもよいが、予測可能性のために、本書で記述する標準的な WebAssembly JavaScript インターフェイスは以下の正確な制限を定義する。実装は、以下のいずれかの制限を超えるモジュールを CompileError で拒否しなければならない。実際には、これらの制限未満の妥当なモジュールであっても、実装のリソースが不足する場合がある。

モジュールの最大サイズは 1,073,741,824 バイト（1 GiB）。
types セクションで定義される型の最大数は 1,000,000。
types セクションで定義される再帰グループの最大数は 1,000,000。
1 つの再帰グループ内で定義される型の最大数は 1,000,000。
定義されたサブタイプ階層の最大深さは 63（上位型なしで定義された型の深さは 0）。
モジュールで定義される関数の最大数は 1,000,000。
モジュールで宣言される import の最大数は 1,000,000。
モジュールで宣言される export の最大数は 1,000,000。
モジュールで定義される global の最大数は 1,000,000。
モジュールで定義される tag の最大数は 1,000,000。
モジュールで定義されるデータセグメントの最大数は 100,000。
宣言または import された table を含む table の最大数は 100,000。
table の最大サイズは 10,000,000。
任意の table 初期化における table エントリの最大数は 10,000,000。
定義および import を含む memory の最大数は 100。
32 ビット memory の min または max フィールドの最大値は 65,536 ページ（4 GiB）。
64 ビット memory の min または max フィールドの最大値は 2^37-1 ページ（2^53 - 2^16 バイト）。
任意の関数またはブロックに対する引数（parameters）の最大数は 1,000。
任意の関数またはブロックに対する戻り値の最大数は 1,000。
ローカル宣言を含む関数本体の最大サイズは 7,654,321 バイト。
パラメータとして暗黙に宣言されたものを含む、関数で宣言されるローカルの最大数は 50,000。
struct のフィールドの最大数は 10,000。
array.new_fixed のオペランドの最大数は 10,000。

実行時に以下のいずれかの制限を超えた場合、実装は RuntimeError を投げなければならない。実際には、これらの制限未満の妥当なモジュールであっても、実装のリソースが不足する場合がある。

table の最大サイズは 10,000,000。
32 ビット memory の最大サイズは 65,536 ページ（4 GiB）。
64 ビット memory の最大サイズは 262,144 ページ（16 GiB）。

9. セキュリティおよびプライバシーに関する考慮事項

この節は規範的ではない（非規範的）。

本書は WebAssembly のホスト環境を定義する。これにより WebAssembly のインスタンスは、import を用いて import object から JavaScript のオブジェクトや関数を取り込むことができるが、それ以外に埋め込み環境へのアクセスは提供されない。したがって WebAssembly インスタンスは JavaScript と同じ制約に拘束される。

10. 変更履歴

この節は規範的ではない（非規範的）。

WebAssembly 仕様の初版 1.0 以降、多数の拡張提案が統合されている。以下の節では、何が変更されたかの概要を示す。

10.1. リリース 2.0

複数値

複数の値は、Array オブジェクトとして JavaScript の関数との間で返したり受け渡したりできる。

BigInt の統合

WebAssembly の i64 値は、（import/export された）global、table の get/set 操作、関数の戻り値や引数を介して JavaScript と相互に受け渡しが可能であり、BigInt オブジェクトとして扱われる。

参照型（Reference Types）

JavaScript の値は、（import/export された）global、table の set/get 操作、関数の引数や戻り値を介して WebAssembly と相互に受け渡しでき、 externref 値として扱われる。

複数のテーブル

複数の table を JavaScript との間で export/import できる。

10.2. リリース 3.0

複数のメモリ

複数の memory を JavaScript との間で export/import できる。

JS 文字列ビルトイン

モジュールをコンパイルする際の builtins オプションを追加し、JS の文字列を操作するためのビルトイン関数群を追加した。

WebAssembly JavaScript インターフェイス

概要

この文書の位置付け

1. 導入

2. API使用例

3. 記法

4. 内部ストレージ

4.1. WebAssembly ストアと JavaScript の相互作用

4.2. WebAssembly JSオブジェクトキャッシュ

5. WebAssembly名前空間

5.1. モジュール

5.2. インスタンス

5.3. メモリ

5.4. テーブル

5.5. グローバル

5.6. エクスポートされた関数

5.7. タグ

5.7.1. タグの型

5.8. ガーベジコレクション対象オブジェクト

5.9. 例外

5.9.1. JavaScript 例外

5.10. エラーオブジェクト

6. ビルトイン

6.1. 文字列ビルトイン

6.1.1. 抽象操作

6.1.2. cast

6.1.3. test

6.1.4. fromCharCodeArray

6.1.5. intoCharCodeArray

6.1.6. fromCharCode

6.1.7. fromCodePoint

6.1.8. charCodeAt

6.1.9. codePointAt

6.1.10. length

6.1.11. concat

6.1.12. substring

6.1.13. equals

6.1.14. compare

7. エラー条件の JavaScript へのマッピング

7.1. スタックオーバーフロー

7.2. メモリ不足（Out of Memory）

8. 実装定義の制限

9. セキュリティおよびプライバシーに関する考慮事項

10. 変更履歴

10.1. リリース 2.0

複数値

BigInt の統合

参照型（Reference Types）

複数のテーブル

10.2. リリース 3.0

複数のメモリ

JS 文字列ビルトイン

適合性

文書の規約

適合的なアルゴリズム

索引

本仕様で定義される用語

参照によって定義される用語

参照

規範参照

参考（情報）

IDL 索引

課題索引