WebAssembly JavaScript 接口

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

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

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

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

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

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

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

    readonly attribute Tag JSTag;
};

将源字节 bytes 编译为 WebAssembly 模块时，执行以下步骤：

1. 设 module 为 module_decode(bytes)。如果 module 是 error，则返回 error。

2. 如果 module_validate(module) 是 error，则返回 error。

3. 返回 module。

对于模块 module、启用的内建项 builtinSetNames 以及 importedStringModule，要验证 WebAssembly 模块的内建项和导入字符串， 请执行以下步骤：

1. 如果对 builtinSetNames 进行内建项集合名称验证的结果为 false，则返回 false。

2. 对 module_imports(module) 的每个 import，逐一执行：

   1. 如果 importedStringModule 不为 null 且 import[0] 等于 importedStringModule，

      1. 设 importExternType 为 import[2]。

      2. 设 stringExternType 为 global const (ref extern)。

      3. 如果 match_externtype(stringExternType, importExternType) 为 false，则返回 false

   2. 否则，

      1. 如果使用 import 和 builtinSetNames 进行内建项导入验证的结果为 false， 则返回 false。

3. 返回 true。

validate(bytes, options) 方法 在调用时执行以下步骤：

1. 设 stableBytes 为缓冲区所持字节的副本 bytes。

2. 将 stableBytes 编译为 WebAssembly 模块，并将结果存为 module。

3. 如果 module 是 error，则返回 false。

4. 设 builtinSetNames 为 options["builtins"]。

5. 设 importedStringModule 为 options["importedStringConstants"]。

6. 如果对于 module 以及 builtinSetNames 和 importedStringModule 进行内建项和导入字符串验证 返回 false，则返回 false。

7. 返回 true。

从模块 module、源字节 bytes、启用的内建项 builtinSetNames 和 importedStringModule 构造一个 WebAssembly 模块对象时，执行以下步骤：

1. 设 moduleObject 为一个新的 Module。

2. 将 moduleObject.[[Module]] 设为 module。

3. 将 moduleObject.[[Bytes]] 设为 bytes。

4. 将 moduleObject.[[BuiltinSets]] 设为 builtinSetNames。

5. 将 moduleObject.[[ImportedStringModule]] 设为 importedStringModule。

6. 返回 moduleObject。

使用可选的任务源 taskSource， 从源字节 bytes 和 WebAssemblyCompileOptions options 异步编译 WebAssembly 模块时，执行以下步骤：

1. 设 promise 为一个新的 promise。

2. 并行运行以下步骤：

   1. 编译 WebAssembly 模块 bytes，并将结果存为 module。

   2. 如果提供了 taskSource，则在其上排入一个任务，执行以下步骤：

      1. 如果 module 是 error，则用一个 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. 兑现 promise，其值为 moduleObject。

3. 返回 promise。

compile(bytes, options) 方法 在调用时执行以下步骤：

1. 设 stableBytes 为缓冲区所持字节的副本 bytes。

2. 使用 options 从 stableBytes 异步编译一个 WebAssembly 模块并返回结果。

使用模块 module 和 importedStringModule 实例化导入字符串时，执行以下步骤：

1. 断言：importedStringModule 不为 null。

2. 设 exportsObject 为 ! OrdinaryObjectCreate(null) 的结果。

3. 对 module_imports(module) 中的每个 (moduleName, componentName, externtype)，逐一执行：

   1. 如果 moduleName 不等于 importedStringModule，则继续。

   2. 设 stringConstant 为 componentName。

   3. 设 status 为 ! CreateDataProperty(exportsObject, stringConstant, stringConstant) 的结果。

   4. 断言：status 为 true。

4. 返回 exportsObject。

从导入对象 importObject 中，为 WebAssembly 模块 module 读取导入， 启用的内建项为 builtinSetNames，导入字符串模块为 importedStringModule， 执行以下步骤：

1. 如果 module.imports 非空， 且 importObject 为 undefined，则抛出一个 TypeError 异常。

2. 设 builtinOrStringImports 为有序映射 « »。

3. 对 builtinSetNames 中的每个 builtinSetName，逐一执行：

   1. 设 builtinSetQualifiedName 为带有前缀 "wasm:" 的 builtinSetName

   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. 对 module_imports(module) 中的每个 (moduleName, componentName, externtype)，逐一执行：

   1. 如果 builtinOrStringImports 包含 moduleName，

      1. 设 o 为 builtinOrStringImports[moduleName]。

      2. 如果 o 不是对象，或 HasProperty(o, componentName) 为 false，

         1. 将 o 设为 ? Get(importObject, moduleName) 的结果。

   2. 否则，

      1. 设 o 为 ? Get(importObject, moduleName) 的结果。

   3. 如果 o 不是对象，则抛出一个 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, const 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 attribute functype，

      1. 断言：attribute 是 exception。

      2. 如果 v 未实现 Tag， 则抛出一个 LinkError 异常。

      3. 设 tagaddr 为 v.[[Address]]。

      4. 设 externtag 为外部值 tag tagaddr。

      5. 将 externtag 追加到 imports。

7. 返回 imports。

注：该算法仅验证 传入的 JavaScript 值类型是否正确。 对 WebAssembly 类型要求的验证将推迟到 “实例化 WebAssembly 模块核心” 算法中进行。

从 WebAssembly 模块 module 和实例 instance 创建一个导出对象时， 执行以下步骤：

1. 设 exportsObject 为 ! OrdinaryObjectCreate(null) 的结果。

2. 对 module_exports(module) 中的每个 (name, externtype)，逐一执行：

   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 attribute functype，

      1. 断言：attribute 是 exception。

      2. 断言：externval 的形式为 tag tagaddr。

      3. 设 tag tagaddr 为 externval。

      4. 设 tag 为从 tagaddr 创建一个新的 Tag 对象 的结果。

      5. 设 value 为 tag。

   8. 设 status 为 ! CreateDataProperty(exportsObject, name, value) 的结果。

   9. 断言：status 为 true。

   注：在 WebAssembly 模块验证期间执行的有效性和唯一性检查 可确保每个属性名都有效，且没有任何属性被定义两次。

3. 执行 ! SetIntegrityLevel(exportsObject, "frozen")。

4. 返回 exportsObject。

从 WebAssembly 模块 module 和实例 instance 初始化一个实例对象 instanceObject 时，执行以下步骤：

1. 从 module 和 instance 创建一个导出对象，并将结果记为 exportsObject。

2. 将 instanceObject.[[Instance]] 设为 instance。

3. 将 instanceObject.[[Exports]] 设为 exportsObject。

从模块 module 和导入 imports 实例化 WebAssembly 模块的核心时， 执行以下步骤：

1. 设 store 为外围代理的关联存储。

2. 设 result 为 module_instantiate(store, module, imports)。

3. 如果 result 是 error，则抛出适当的异常类型：

   • 对于链接期间发生的大多数情况，抛出一个 LinkError 异常。

   • 如果错误发生在运行启动函数时，则对于大多数来自 WebAssembly 的错误， 抛出一个 RuntimeError， 或抛出从内部 ECMAScript 代码传播出来的错误对象。

   • 如有适用，抛出另一种错误类型，例如 WebAssembly 错误映射中说明的内存不足异常。

4. 设 (store, instance) 为 result。

5. 将外围代理的关联存储设为 store。

6. 返回 instance。

从一个 Module moduleObject 和导入 importObject 异步实例化一个 WebAssembly 模块时，执行以下步骤：

1. 设 promise 为一个新的 promise。

2. 设 module 为 moduleObject.[[Module]]。

3. 设 builtinSetNames 为 moduleObject.[[BuiltinSets]]。

4. 设 importedStringModule 为 moduleObject.[[ImportedStringModule]]。

5. 使用导入 importObject、 builtinSetNames 和 importedStringModule 对 module 读取 导入，并将结果记为 imports。 如果此操作抛出异常，则捕获该异常，拒绝 promise，并返回 promise。

6. 并行运行以下步骤：

   1. 排入一个任务来执行以下步骤： 注：这里可以执行特定于实现的工作。

      1. 用 imports 对 module 实例化 WebAssembly 模块的核心， 并将结果记为 instance。 如果这一步抛出异常，则捕获该异常，拒绝 promise，并 终止这些子步骤。

      2. 设 instanceObject 为一个新的 Instance。

      3. 从 module 和 instance 初始化 instanceObject。 如果这一步抛出异常，则捕获该异常，拒绝 promise，并 终止这些子步骤。

      4. 兑现 promise，其值为 instanceObject。

7. 返回 promise。

使用导入 importObject 对 promiseOfModule 实例化一个模块 promise时， 执行以下步骤：

1. 设 promise 为一个新的 promise。

2. 对 promiseOfModule 作出响应：

   • 如果 promiseOfModule 以值 module fulfilled：

     1. 用导入 importObject 对 module 实例化 WebAssembly 模块， 并将结果记为 innerPromise。

     2. 对 innerPromise 作出响应：

        • 如果 innerPromise 以值 instance fulfilled。

          1. 设 result 为 WebAssemblyInstantiatedSource 值 «[ "module" → module, "instance" → instance ]»。

          2. 兑现 promise，其值为 result。

        • 如果 innerPromise 以原因 reason rejected：

          1. 拒绝 promise，原因是 reason。

   • 如果 promiseOfModule 以原因 reason rejected：

     1. 拒绝 promise，原因是 reason。

3. 返回 promise。

instantiate(bytes, importObject, options) 方法在调用时执行以下步骤：

1. 设 stableBytes 为缓冲区所持字节的副本 bytes。

2. 使用 options 从 stableBytes 异步编译一个 WebAssembly 模块，并将结果记为 promiseOfModule。

3. 使用导入 importObject 对 promiseOfModule 实例化， 并返回结果。

instantiate(moduleObject, importObject) 方法在调用时执行以下步骤：

1. 使用导入 importObject 异步实例化 WebAssembly 模块 moduleObject，并返回 结果。

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 为

• 如果 type 的形式为 func functype，则为 "function"

• 如果 type 的形式为 table tabletype，则为 "table"

• 如果 type 的形式为 mem memtype，则为 "memory"

• 如果 type 的形式为 global globaltype，则为 "global"

• 如果 type 的形式为 tag tag，则为 "tag"

exports(moduleObject) 方法在调用时， 执行以下步骤：

1. 设 module 为 moduleObject.[[Module]]。

2. 设 exports 为 « »。

3. 对 module_exports(module) 中的每个 (name, type)，逐一执行：

   1. 设 kind 为该 type 的外部类型字符串值。

   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. 对 module_imports(module) 中的每个 (moduleName, name, type)，逐一执行：

   1. 如果对于 (moduleName, name, type) 在 builtinSetNames 中找到一个内建项， 且 builtinSetNames 不为 null，则继续。

   2. 如果 importedStringModule 不为 null 且 moduleName 等于 importedStringModule，则继续。

   3. 设 kind 为该 type 的外部类型字符串值。

   4. 设 obj 为 «[ "module" → moduleName, "name" → name, "kind" → kind ]»。

   5. 将 obj 追加到 imports。

6. 返回 imports。

customSections(moduleObject, sectionName) 方法在调用时执行以下步骤：

1. 设 bytes 为 moduleObject.[[Bytes]]。

2. 设 customSections 为 « »。

3. 对按照模块语法解释的 bytes 中每个 自定义段 customSection，逐一执行，

   1. 设 name 为 customSection 的 name， 按 UTF-8 解码。

   2. 断言：name 不是 failure （moduleObject.[[Module]] 是有效的）。

   3. 如果 name 作为字符串值等于 sectionName，

      1. 将一个新的 ArrayBuffer 追加到 customSections，该缓冲区包含 bytes 中与此 customsec 产生式匹配范围内字节的副本。

4. 返回 customSections。

Module(bytes, options) 构造函数在 调用时执行以下步骤：

1. 设 stableBytes 为缓冲区所持字节的副本 bytes。

2. 将 stableBytes 编译为 WebAssembly 模块， 并将结果存为 module。

3. 如果 module 是 error，则抛出一个 CompileError 异常。

4. 设 builtinSetNames 为 options["builtins"]。

5. 设 importedStringModule 为 options["importedStringConstants"]。

6. 如果对于 module 以及 builtinSetNames 和 importedStringModule 的内建项和导入字符串验证返回 false，则抛出一个 CompileError 异常。

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. 使用导入 importObject、 builtinSetNames 和 importedStringModule 对 module 读取 导入，并将结果记为 imports。

5. 用 imports 对 module 实例化 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 为一个 Data Block，其与 memaddr 的底层 内存对应标识。

2. 设 buffer 为一个新的 ArrayBuffer， 带有内部槽 [[ArrayBufferData]]、[[ArrayBufferByteLength]] 和 [[ArrayBufferDetachKey]]。

3. 将 buffer.[[ArrayBufferData]] 设为 block。

4. 将 buffer.[[ArrayBufferByteLength]] 设为 block 的长度。

5. 将 buffer.[[ArrayBufferDetachKey]] 设为 "WebAssembly.Memory"。

6. 返回 buffer。

要从一个内存地址 memaddr 和一个 maxsize 创建可调整大小的 内存缓冲区，执行以下步骤：

1. 设 block 为一个 Data Block，其与 memaddr 的底层 内存对应标识。

2. 设 length 为 block 的长度。

3. 设 buffer 为一个新的 ArrayBuffer， 带有内部槽 [[ArrayBufferData]]、[[ArrayBufferByteLength]]、 [[ArrayBufferMaxByteLength]] 和 [[ArrayBufferDetachKey]]。

4. 将 buffer.[[ArrayBufferData]] 设为 block。

5. 将 buffer.[[ArrayBufferByteLength]] 设为 length。

6. 将 buffer.[[ArrayBufferMaxByteLength]] 设为 maxsize。

7. 将 buffer.[[ArrayBufferDetachKey]] 设为 "WebAssembly.Memory"。

8. 返回 buffer。

要从一个内存地址 memaddr 初始化一个 Memory 对象 memory，执行以下步骤：

1. 设 map 为外围代理关联的 Memory 对象缓存。

2. 断言：map[memaddr] 不存在。

3. 设 buffer 为通过创建固定长度内存缓冲区 从 memaddr 得到的结果。

4. 将 memory.[[Memory]] 设为 memaddr。

5. 将 memory.[[BufferObject]] 设为 buffer。

6. 设定 map[memaddr] 为 memory。

要从一个内存地址 memaddr 创建一个 Memory 对象，执行以下步骤：

1. 设 map 为外围代理关联的 Memory 对象缓存。

2. 如果 map[memaddr] 存在，

   1. 返回 map[memaddr]。

3. 设 memory 为一个新的 Memory。

4. 初始化 memory，来源为 memaddr。

5. 返回 memory。

当调用 Memory(descriptor) 构造函数时， 执行以下步骤：

1. 如果 descriptor["address"] 存在，则令 addrtype 为 descriptor["address"]；否则，令 addrtype 为 "i32"。

2. 设 initial 为 ? AddressValueToU64(descriptor["initial"], addrtype)。

3. 如果 descriptor["maximum"] 存在，则令 maximum 为 ? AddressValueToU64(descriptor["maximum"], addrtype)；否则，令 maximum 为空。

4. 设 memtype 为 内存类型 addrtype { min initial, max maximum }。

5. 如果 memtype 不有效，则抛出一个 RangeError 异常。

6. 设 store 为外围代理的关联存储。

7. 设 (store, memaddr) 为 mem_alloc(store, memtype)。如果 分配失败，则抛出一个 RangeError 异常。

8. 将外围代理的关联存储设为 store。

9. 初始化 this，来源为 memaddr。

要对 memaddr 的 Memory 缓冲区进行刷新，执行以下步骤：

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 为一个 Data 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 为 地址类型，取自 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 中某一个值的 [[BufferObject]]。

   3. 对 map 中的每个 memaddr → mem，逐一执行 ，

      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。

2. 否则，返回 unhandled。

Memory 的 buffer 属性的 getter 返回 this.[[BufferObject]]。

enum TableKind {
  "externref",
  "anyfunc",
  // 注：未来迭代中可能会增加更多值，
  // 例如，带类型的函数引用、带类型的 GC 引用
};

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

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

要从一个表地址 tableaddr 初始化一个 Table 对象 table，执行以下步骤：

1. 设 map 为外围代理关联的 Table 对象缓存。

2. 断言：map[tableaddr] 不存在。

3. 将 table.[[Table]] 设为 tableaddr。

4. 设定 map[tableaddr] 为 table。

要从一个表地址 tableaddr 创建一个表 对象，执行以下步骤：

1. 设 map 为外围代理关联的 Table 对象缓存。

2. 如果 map[tableaddr] 存在，

   1. 返回 map[tableaddr]。

3. 设 table 为一个新的 Table。

4. 初始化 table，来源为 tableaddr。

5. 返回 table。

当调用 Table(descriptor, value) 构造函数时， 执行以下步骤：

1. 设 elementtype 为 ToValueType(descriptor["element"])。

2. 如果 elementtype 不是一个 reftype，

   1. 抛出一个 TypeError 异常。

3. 如果 descriptor["address"] 存在，则令 addrtype 为 descriptor["address"]；否则，令 addrtype 为 "i32"。

4. 设 initial 为 ? AddressValueToU64(descriptor["initial"], addrtype)。

5. 如果 descriptor["maximum"] 存在，则令 maximum 为 ? AddressValueToU64(descriptor["maximum"], addrtype)；否则，令 maximum 为空。

6. 设 type 为 表类型 addrtype { min initial, max 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 属性的 getter 时， 执行以下步骤：

1. 设 tableaddr 为 this.[[Table]]。

2. 设 store 为外围代理的关联存储。

3. 设 addrtype 为 地址类型，取自 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 对象 global，执行以下步骤：

1. 设 map 为外围代理关联的 Global 对象缓存。

2. 断言：map[globaladdr] 不存在。

3. 将 global.[[Global]] 设为 globaladdr。

4. 设定 map[globaladdr] 为 global。

要从一个全局地址 globaladdr 创建一个全局 对象，执行以下步骤：

1. 设 map 为外围代理关联的 Global 对象缓存。

2. 如果 map[globaladdr] 存在，

   1. 返回 map[globaladdr]。

3. 设 global 为一个新的 Global。

4. 初始化 global，来源为 globaladdr。

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 为 var valuetype；否则，令 globaltype 为 const 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)。

当调用 Global 的 value 属性的 getter 时， 执行以下步骤：

1. 返回 GetGlobalValue(this)。

Global 的 value 属性的 setter 在调用时，执行以下步骤：

1. 设 store 为外围代理的关联存储。

2. 设 globaladdr 为 this.[[Global]]。

3. 设 mut valuetype 为 global_type(store, globaladdr)。

4. 如果 valuetype 匹配 v128 或 exnref，则抛出一个 TypeError。

5. 如果 mut 是 const，则抛出一个 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.funcaddrs 中。

   3. 设 index 为在 moduleinst.funcaddrs 中找到 funcaddr 的索引。

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. 设 [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. 设 [parameters] → [results] 为 functype。

4. 如果 parameters 或 results 中任一类型匹配 v128 或 exnref，则抛出一个 TypeError。

   Note: 每次调用 [[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. 设 [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 为现任 settings object。

3. 设 hostfunc 为一个宿主函数，其在以参数 arguments 调用时执行以下步骤：

   1. 设 realm 为 func 的关联 Realm。

   2. 设 relevant settings 为 realm 的settings object。

   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 t，则返回 null。

8. 如果 w 的形式为 ref.i31 u31，

   1. 设 i31 为 signed_31(u31)。

   2. 返回 𝔽(i31)。

9. 如果 w 的形式为 ref.struct structaddr，则返回从 structaddr 和 "struct" 创建新的导出 GC 对象的结果。

10. 如果 w 的形式为 ref.array arrayaddr，则返回从 arrayaddr 和 "array" 创建新的导出 GC 对象的结果。

11. 如果 w 的形式为 ref.func funcaddr，则返回从 新的 导出函数 中由 funcaddr 创建的结果。

12. 如果 w 的形式为 ref.host hostaddr，则返回从 hostaddr 检索宿主值 的结果。

13. 如果 w 的形式为 ref.extern ref，则返回 ToJSValue(ref)。

Note: 等于 NaN 的 Number 值可能具有 各种可观察到的 NaN payload；详见 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 舍入到最接近的可表示值， 并使用 round to nearest, ties to even 模式得到的结果。[IEEE-754]

   4. 返回 f32.const f32。

6. 如果 type 是 f64，

   1. 设 number 为 ? ToNumber(v)。

   2. 如果 number 是 NaN，

      1. 设 n 为一个实现定义的整数，使得 canon₆₄ ≤ n < 2^signif(64)。

      2. 设 f64 为 nan(n)。

   3. 否则，

      1. 设 f64 为 number。

   4. 返回 f64.const f64。

7. 如果 type 的形式为 ref null heaptype，

   1. 如果 v 为 null，

      1. 设 r 为 ref.null heaptype。

   2. 否则如果 match_valtype(type, ref null extern)，

      1. 设 ref 为 ! ToWebAssemblyValue(v, ref any)。

      2. 设 r 为 ref.extern ref。

   3. 否则如果 v 是一个导出函数，并且 match_valtype(type, ref null func)，

      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] 不存在的最小地址。

      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) 将 JavaScript 值转换为用于嵌入操作的 WebAssembly u64。它被设计为在 AddressType 为 "i32" 时，其行为类似于 [EnforceRange] unsigned long，并通过执行以下步骤将这些语义扩展到 AddressType "i64"：

1. 如果 addrtype 是 "i32"，

   1. 设 n 为 ? ConvertToInt(v, 32, "unsigned")，其中目标类型与 [EnforceRange] 相关联。

      Note: 这等价于 JS 转换规则 中对于 [EnforceRange] unsigned long 的规定。

   2. 返回 ℝ(n) 作为一个 WebAssembly u64。

2. 如果 addrtype 是 "i64"，

   1. 设 n 为 ? ToBigInt(v)。

   2. 如果 n < 0 或 n > 2⁶⁴ − 1，则抛出一个 TypeError。

      Note: 此操作被设计为 模拟 [EnforceRange]。

   3. 返回 ℝ(n) 作为一个 WebAssembly u64。

3. 断言：不会到达这一步。

算法 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=(Window,Worker,Worklet)]
interface Tag {
  constructor(TagType type);
};

要从一个标签地址 tagAddress 初始化一个 Tag 对象 tag，执行以下步骤：

1. 设 map 为外围代理关联的 Tag 对象缓存。

2. 断言：map[tagAddress] 不存在。

3. 将 tag.[[Address]] 设为 tagAddress。

4. 设定 map[tagAddress] 为 tag。

要从一个标签地址 tagAddress 创建一个 Tag 对象，执行以下步骤：

1. 设 map 为外围代理关联的 Tag 对象缓存。

2. 如果 map[tagAddress] 存在，

   1. 返回 map[tagAddress]。

3. 设 tag 为一个新的 Tag。

4. 初始化 tag，来源为 tagAddress。

5. 返回 tag。

new Tag(type) 构造函数步骤如下：

1. 设 parameters 为 type["parameters"]。

2. 设 wasmParameters 为 «»。

3. 对于 parameters 中的每个 paramType，

   1. 追加 ToValueType(paramType) 到 wasmParameters。

4. 设 store 为外围代理的关联存储。

5. 设 (store, tagAddress) 为 tag_alloc(store, wasmParameters → « »)。

6. 将外围代理的关联存储设为 store。

7. 初始化 this，来源为 tagAddress。

导出 GC 对象的 [[GetPrototypeOf]] 内部方法 O 不接受参数并返回 null。调用时执行以下 步骤：

1. 返回 null。

导出 GC 对象的 [[SetPrototypeOf]] 内部方法 O 接受参数 V（对象或 null）并返回一个 boolean。调用时执行以下步骤：

1. 返回 false。

导出 GC 对象的 [[IsExtensible]] 内部方法 O 不接受参数并返回一个 boolean。调用时执行以下 步骤：

1. 返回 false。

导出 GC 对象的 [[PreventExtensions]] 内部方法 O 不接受参数并返回一个 boolean。调用时执行以下 步骤：

1. 返回 false。

导出 GC 对象的 [[GetOwnProperty]] 内部方法 O 接受参数 P（属性键）并返回 undefined。调用时执行以下步骤：

1. 返回 undefined。

导出 GC 对象的 [[DefineOwnProperty]] 内部方法 O 接受参数 P（属性键）和 Desc（属性描述符）并返回一个 boolean。调用时执行以下步骤：

1. 返回 false。

导出 GC 对象的 [[HasProperty]] 内部方法 O 接受参数 P（属性键）并返回一个 boolean。调用时 执行以下步骤：

1. 返回 false。

导出 GC 对象的 [[Get]] 内部方法 O 接受参数 P（属性键）和 Receiver（ECMAScript 语言 值）并返回 undefined。调用时执行以下步骤：

1. 返回 undefined。

导出 GC 对象的 [[Set]] 内部方法 O 接受参数 P（属性键）、V（ECMAScript 语言值）以及 Receiver（ECMAScript 语言值）并抛出一个异常。调用时执行以下步骤 ：

1. 抛出一个 TypeError。

导出 GC 对象的 [[Delete]] 内部方法 O 接受参数 P（属性键）并抛出一个异常。它 在调用时执行以下步骤：

1. 抛出一个 TypeError。

导出 GC 对象的 [[OwnPropertyKeys]] 内部方法 O 不接受参数并返回一个列表。调用时执行以下 步骤：

1. 令 keys 为一个新的空列表。

2. 返回 keys。

要从一个 WebAssembly 对象地址 objectaddr 和一个字符串 objectkind 创建新的 导出 GC 对象，执行以下步骤：

1. 断言：objectkind 是 "array" 或 "struct" 之一。

2. 设 map 为外围代理关联的 导出 GC 对象 缓存。

3. 如果 map[objectaddr] 存在，

   1. 返回 map[objectaddr]。

4. 设 object 为 MakeBasicObject(« [[ObjectAddress]], [[ObjectKind]] »)。

5. 将 object.[[ObjectAddress]] 设为 objectaddr。

6. 将 object.[[ObjectKind]] 设为 objectkind。

7. 将 object.[[GetPrototypeOf]] 设为 导出 GC 对象的 [[GetPrototypeOf]] 内部方法中指定的内容。

8. 将 object.[[SetPrototypeOf]] 设为 导出 GC 对象的 [[SetPrototypeOf]] 内部方法中指定的内容。

9. 将 object.[[IsExtensible]] 设为 导出 GC 对象的 [[IsExtensible]] 内部方法中指定的内容。

10. 将 object.[[PreventExtensions]] 设为 导出 GC 对象的 [[PreventExtensions]] 内部方法中指定的内容。

11. 将 object.[[GetOwnProperty]] 设为 导出 GC 对象的 [[GetOwnProperty]] 内部方法中指定的内容。

12. 将 object.[[DefineOwnProperty]] 设为 导出 GC 对象的 [[DefineOwnProperty]] 内部方法中指定的内容。

13. 将 object.[[HasProperty]] 设为 导出 GC 对象的 [[HasProperty]] 内部方法中指定的内容。

14. 将 object.[[Get]] 设为 导出 GC 对象的 [[Get]] 内部方法中指定的内容。

15. 将 object.[[Set]] 设为 导出 GC 对象的 [[Set]] 内部方法中指定的内容。

16. 将 object.[[Delete]] 设为 导出 GC 对象的 [[Delete]] 内部方法中指定的内容。

17. 将 object.[[OwnPropertyKeys]] 设为 导出 GC 对象的 [[OwnPropertyKeys]] 内部方法中指定的内容。

18. 设定 map[objectaddr] 为 object。

19. 返回 object。

dictionary ExceptionOptions {
  boolean traceStack = false;
};

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

要从一个Exception 地址 exnAddress 初始化一个 Exception 对象 exn，执行以下 步骤：

1. 设 map 为外围代理关联的 Exception 对象 缓存。

2. 断言：map[exnAddress] 不存在。

3. 将 exn.[[Address]] 设为 exnAddress。

4. 设定 map[exnAddress] 为 exn。

5. 设 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。

要从一个异常地址 exnAddress 创建一个 Exception 对象，执行以下步骤：

1. 设 map 为外围代理关联的 Exception 对象 缓存。

2. 如果 map[exnAddress] 存在，

   1. 返回 map[exnAddress]。

3. 设 exn 为一个新的 Exception。

4. 初始化 exn，来源为 exnAddress。

5. 返回 exn。

new Exception(exceptionTag, payload, options) 构造函数步骤如下：

1. 设 JSTagAddr 为获取 JavaScript 异常标签的结果。

2. 如果 exceptionTag.[[Address]] 等于 JSTagAddr，

   1. 抛出一个 TypeError。

3. 设 store 为外围代理的关联存储。

4. 设 [types] → [] 为 tag_type(store, exceptionTag.[[Address]])。

5. 如果 types 的大小 不等于 payload 的大小，

   1. 抛出一个 TypeError。

6. 设 wasmPayload 为 « »。

7. 对于 payload 和 types 中按线性方式配对的每个 value 和 resultType，

   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. 设 [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 getter 步骤如下：

1. 返回 this.[[Stack]]。

要获取 JavaScript 异常标签，执行以下步骤：

1. 如果外围代理关联的 JavaScript 异常 标签已经初始化，

   1. 返回外围代理关联的 JavaScript 异常标签

2. 设 store 为外围代理的关联存储。

3. 设 (store, tagAddress) 为 tag_alloc(store, « externref » → « »)。

4. 将外围代理的关联存储设为 store。

5. 将外围代理关联的 JavaScript 异常 标签设为 tagAddress。

6. 返回 tagAddress。

当为 WebAssembly 命名空间创建命名空间对象时， 必须运行以下步骤：

1. 设 namespaceObject 为该命名空间对象。

2. 对于 « "CompileError", "LinkError", "RuntimeError" » 中的每个 error，

   1. 设 constructor 为一个新对象，实现 NativeError 对象结构，其中 NativeError 被设为 error。

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

要获取名称为 builtinSetName 的内建项集合中的 内建项，执行以下步骤：

1. 返回一个 (name, funcType, steps) 的列表， 对应于本节中定义的名称为 builtinSetName 的集合。

要根据 import 和启用的内建项 builtinSetNames 查找一个内建项， 执行以下步骤：

1. 断言：验证内建项集合名称 builtinSetNames 的结果为 true。

2. 设 importModuleName 为 import[0]。

3. 设 importName 为 import[1]。

4. 对于 builtinSetNames 中的每个 builtinSetName，

   1. 如果 builtinSetName 未指向一个内建项集合，则 继续。

   2. 设 builtinSetQualifiedName 为在 builtinSetName 前加上前缀 "wasm:"。

   3. 如果 importModuleName 等于 builtinSetQualifiedName，

      1. 设 builtins 为获取一个内建项集合中的内建项 builtinSetName 的结果。

      2. 对于 builtins 中的每个 builtin，

         1. 设 builtinName 为 builtin[0]。

         2. 如果 importName 等于 builtinName，则返回 (builtinSetName, builtin)。

5. 返回 null。

要根据 builtinSetNames 验证 内建项集合名称，执行以下步骤：

1. 如果 builtinSetNames 包含任何重复项，则返回 false。

2. 返回 true。

要根据类型 funcType 和执行步骤 steps 创建一个 内建函数，执行以下步骤：

1. 设 hostfunc 为一个宿主函数，调用时执行 steps。

2. 设 store 为外围代理的关联存储。

3. 设 (store, funcaddr) 为 func_alloc(store, funcType, hostfunc)。

4. 将外围代理的关联存储设为 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 不是字符串，

   1. 抛出一个 RuntimeError 异常，就像执行了一个陷阱一样。

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 不是字符串，

   1. 返回 0。

2. 返回 1。

当使用参数 array、start 和 end 调用该内建项时，必须执行 以下步骤：

1. 如果 array 是 null，

   1. 抛出一个 RuntimeError 异常，就像执行了一个陷阱一样。

2. 设 length 为 array 中元素的个数。

3. 如果 start > end 或 end > length，

   1. 抛出一个 RuntimeError 异常，就像执行了一个陷阱一样。

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 异常，就像执行了一个陷阱一样。

2. 设 string 为 ? UnwrapString(string)。

3. 设 stringLength 为 string 的长度。

4. 设 arrayLength 为 array 中元素的个数。

5. 如果 start + stringLength > arrayLength，

   1. 抛出一个 RuntimeError 异常，就像执行了一个陷阱一样。

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 异常，就像执行了一个陷阱一样。

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

当使用参数 string 和 index 调用该内建项时，必须执行以下步骤 ：

1. 设 string 为 ? UnwrapString(string)。

2. 设 length 为 string 的长度。

3. 如果 index >= length，

   1. 抛出一个 RuntimeError 异常，就像执行了一个陷阱一样。

4. 返回 CharCodeAt(string, index)。

当使用参数 string 和 index 调用该内建项时，必须执行以下步骤 ：

1. 设 string 为 ? UnwrapString(string)。

2. 设 length 为 string 的长度。

3. 如果 index >= length，

   1. 抛出一个 RuntimeError 异常，就像执行了一个陷阱一样。

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 不是字符串，

   1. 抛出一个 RuntimeError 异常，就像执行了一个陷阱一样。

2. 如果 second 不为 null，且 second 不是字符串，

   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。