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

WebAssembly 모듈을 컴파일하기 위해 소스 바이트 bytes로부터 다음 단계를 수행한다:

1. module을 module_decode(bytes)라고 하자. 만약 module이 error이면, error를 반환한다.

2. 만약 module_validate(module)가 error이면, error를 반환한다.

3. module을 반환한다.

모듈 module, 활성화된 빌트인 builtinSetNames, 그리고 importedStringModule로부터 WebAssembly 모듈에 대한 빌트인 및 imported string을 검증하기 위해 다음 단계를 수행한다:

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로 빌트인에 대한 import 검증을 수행한 결과가 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. 만약 빌트인 및 imported strings 검증을 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를 반환한다.

소스 바이트 bytes와 WebAssemblyCompileOptions options로부터 선택적 task source taskSource를 사용하여 WebAssembly 모듈을 비동기적으로 컴파일하기 위해 다음 단계를 수행한다:

1. promise를 새로운 promise라고 하자.

2. 다음 단계를 병렬로 실행한다:

   1. bytes를 WebAssembly 모듈로 컴파일하고 그 결과를 module로 저장한다.

   2. 제공된 경우 taskSource에서 작업을 큐에 넣어 다음 단계를 수행한다:

      1. 만약 module이 error이면, promise를 CompileError 예외로 reject하고 반환한다.

      2. builtinSetNames를 options["builtins"]라고 하자.

      3. importedStringModule을 options["importedStringConstants"]라고 하자.

      4. 만약 빌트인 및 imported strings 검증을 module에 대해 builtinSetNames 및 importedStringModule와 함께 수행한 결과가 false이면, promise를 CompileError 예외로 reject한다.

      5. 그렇지 않으면,

         1. module, bytes, builtinSetNames, importedStringModule로부터 WebAssembly 모듈 객체를 구성하고, 그 결과를 moduleObject라고 하자.

         2. Resolve를 사용하여 promise를 moduleObject로 이행한다.

3. promise를 반환한다.

compile(bytes, options) 메서드는 호출되면 다음 단계를 수행한다:

1. stableBytes를 버퍼가 보유한 바이트의 복사본 bytes라고 하자.

2. stableBytes로부터 WebAssembly 모듈을 비동기적으로 컴파일하고 options를 사용하여 그 결과를 반환한다.

모듈 module 및 importedStringModule로 imported strings를 인스턴스화하기 위해 다음 단계를 수행한다:

1. 단언: importedStringModule은 null이 아니다.

2. exportsObject를 ! OrdinaryObjectCreate(null)라고 하자.

3. 각각에 대해 module_imports(module)의 (moduleName, componentName, externtype)에 대해,

   1. 만약 moduleName이 importedStringModule과 같지 않다면, continue한다.

   2. stringConstant를 componentName라고 하자.

   3. status를 ! CreateDataProperty(exportsObject, stringConstant, stringConstant)라고 하자.

   4. 단언: status는 true이다.

4. exportsObject를 반환한다.

WebAssembly 모듈 module에서 imports 객체 importObject, 활성화된 빌트인 builtinSetNames, 그리고 importedStringModule로부터 imports를 읽기 위해 다음 단계를 수행한다:

1. 만약 module.imports가 비어 있지 않고, importObject가 undefined이면, TypeError 예외를 던진다.

2. builtinOrStringImports를 순서 있는 맵 « »라고 하자.

3. 각각에 대해 builtinSetName가 builtinSetNames에 있을 때,

   1. builtinSetQualifiedName을 builtinSetName 앞에 "wasm:"를 붙인 것이라고 하자

   2. 단언: builtinOrStringImports는 builtinSetQualifiedName을 포함하지 않는다

   3. 만약 builtinSetName이 빌트인 집합을 가리키지 않는다면, continue한다.

   4. exportsObject를 builtinSetName으로 빌트인 집합을 인스턴스화한 결과라고 하자

   5. Set builtinOrStringImports[builtinSetQualifiedName]를 exportsObject로 설정한다

4. 만약 importedStringModule이 null이 아니면,

   1. exportsObject를 imported strings를 인스턴스화한 결과라고 하자 (module 및 importedStringModule 사용)

   2. Set builtinOrStringImports[importedStringModule]를 exportsObject로 설정한다

5. imports를 « »라고 하자.

6. 각각에 대해 module_imports(module)의 (moduleName, componentName, externtype)에 대해,

   1. 만약 builtinOrStringImports가 moduleName을 포함하면,

      1. o를 builtinOrStringImports[moduleName]라고 하자.

      2. 만약 o가 Object가 아니거나 또는 HasProperty(o, componentName)가 false이면,

         1. o를 ? Get(importObject, moduleName)로 설정한다.

   2. 그렇지 않으면,

      1. o를 ? Get(importObject, moduleName)로 하자.

   3. 만약 o가 Object가 아니면, TypeError 예외를 던진다.

   4. v를 ? Get(o, componentName)라고 하자.

   5. 만약 externtype가 func functype 형태이면,

      1. 만약 IsCallable(v)가 false이면, LinkError 예외를 던진다.

      2. 만약 v가 [[FunctionAddress]] 내부 슬롯을 가져서 Exported Function이라면,

         1. funcaddr를 v의 [[FunctionAddress]] 내부 슬롯 값이라고 하자.

      3. 그렇지 않으면,

         1. v와 functype로부터 호스트 함수를 생성하고, 그 결과를 funcaddr라고 하자.

         2. index를 imports 안의 외부 함수 개수라고 하자. 이 값 index는 호스트 함수 funcaddr의 호스트 함수 인덱스로 알려져 있다.

      4. externfunc를 외부 값 func funcaddr라고 하자.

      5. Append를 사용하여 externfunc를 imports에 추가한다.

7. imports를 반환한다.

참고: 이 알고리즘은 올바른 종류의 JavaScript 값이 전달되었는지만 검증한다. WebAssembly 타입 요구 사항의 검증은 "WebAssembly 모듈의 코어를 인스턴스화" 알고리즘으로 미뤄진다.

WebAssembly 모듈 module과 인스턴스 instance로부터 exports 객체를 생성하기 위해 다음 단계를 수행한다:

1. exportsObject를 ! OrdinaryObjectCreate(null)이라고 하자.

2. 각각에 대해 module_exports(module)의 (name, externtype)에 대해,

   1. externval를 instance_export(instance, name)라고 하자.

   2. 단언: externval은 error가 아니다.

3. exportsObject를 반환한다.

WebAssembly 모듈 module과 인스턴스 instance로부터 인스턴스 객체 instanceObject를 초기화하기 위해 다음 단계를 수행한다:

1. module과 instance로부터 exports 객체를 생성하고 그 결과를 exportsObject라고 하자.

2. instanceObject.[[Instance]]를 instance로 설정한다.

3. instanceObject.[[Exports]]를 exportsObject로 설정한다.

모듈 module과 imports imports로부터 WebAssembly 모듈의 코어를 인스턴스화하기 위해 다음 단계를 수행한다:

1. store를 주변 agent의 연관 저장소라고 하자.

2. result를 module_instantiate(store, module, imports)라고 하자.

3. 만약 result가 error이면, 적절한 예외 타입을 던진다:

   • 링킹 중 발생하는 대부분의 경우에는 LinkError 예외.

   • 오류가 start 함수를 실행할 때 발생한 경우, WebAssembly에서 발생하는 대부분의 오류에 대해서는 RuntimeError를, 또는 내부 ECMAScript 코드에서 전파된 오류 객체를 던진다.

   • 적절하다면 다른 오류 타입도 가능하며, 예를 들어 WebAssembly 오류 매핑에 문서화된 메모리 부족 예외가 있다.

4. result를 (store, instance)라고 하자.

5. 주변 agent의 연관 저장소를 store로 설정한다.

6. instance를 반환한다.

Module moduleObject와 imports importObject로부터 WebAssembly 모듈을 비동기적으로 인스턴스화하기 위해 다음 단계를 수행한다:

1. promise를 새로운 promise라고 하자.

2. module을 moduleObject.[[Module]]라고 하자.

3. builtinSetNames를 moduleObject.[[BuiltinSets]]라고 하자.

4. importedStringModule를 moduleObject.[[ImportedStringModule]]라고 하자.

5. module의 imports를 읽고, imports importObject, builtinSetNames 및 importedStringModule와 함께 사용하여, 그 결과를 imports라고 하자. 이 연산이 예외를 던지면, 이를 잡아서 reject를 사용해 promise를 그 예외로 reject하고, promise를 반환한다.

6. 다음 단계를 병렬로 실행한다:

   1. 작업을 큐에 넣어 다음 단계를 수행한다: 참고: 구현별 작업이 여기서 수행될 수 있다.

      1. module을 imports와 함께 WebAssembly 모듈의 코어를 인스턴스화하고, 그 결과를 instance라고 하자. 이것이 예외를 던지면, 이를 잡아서 reject를 사용해 promise를 그 예외로 reject하고, 이 하위 단계를 종료한다.

      2. instanceObject를 새로운 Instance라고 하자.

      3. module과 instance로부터 초기화하여 instanceObject를 설정한다. 이것이 예외를 던지면, 이를 잡아서 reject를 사용해 promise를 그 예외로 reject하고, 이 하위 단계를 종료한다.

      4. Resolve를 사용하여 promise를 instanceObject로 이행한다.

7. promise를 반환한다.

모듈의 promise를 인스턴스화하기 위해 promiseOfModule와 imports importObject로 다음 단계를 수행한다:

1. promise를 새로운 promise라고 하자.

2. React를 사용해 promiseOfModule에 반응한다:

   • 만약 promiseOfModule이 값 module로 이행되었다면:

     1. module을 importObject를 import하면서 WebAssembly 모듈로 인스턴스화하고, 그 결과를 innerPromise라고 하자.

     2. React를 사용해 innerPromise에 반응한다:

        • 만약 innerPromise가 값 instance로 이행되었다면.

          1. result를 WebAssemblyInstantiatedSource 값 «[ "module" → module, "instance" → instance ]»라고 하자.

          2. Resolve를 사용하여 promise를 result로 이행한다.

        • 만약 innerPromise가 이유 reason으로 reject되었다면:

          1. Reject를 사용하여 promise를 reason으로 reject한다.

   • 만약 promiseOfModule이 이유 reason으로 reject되었다면:

     1. Reject를 사용하여 promise를 reason으로 reject한다.

3. promise를 반환한다.

instantiate(bytes, importObject, options) 메서드는 호출되면 다음 단계를 수행한다:

1. stableBytes를 버퍼가 보유한 바이트의 복사본 bytes라고 하자.

2. stableBytes로부터 WebAssembly 모듈을 비동기적으로 컴파일하고 options를 사용한 결과를 promiseOfModule라고 하자.

3. promiseOfModule을 importObject와 함께 인스턴스화하고 그 결과를 반환한다.

instantiate(moduleObject, importObject) 메서드는 호출되면 다음 단계를 수행한다:

1. moduleObject를 importObject와 함께 WebAssembly 모듈로 비동기 인스턴스화하고 반환한다.

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

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

typedef any AddressValue;

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

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

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

extern type의 문자열 값 type은 다음과 같다

• 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의 extern type의 문자열 값이라고 하자.

   2. obj를 «[ "name" → name, "kind" → kind ]»라고 하자.

   3. Append를 사용하여 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가 null이 아니면, continue한다.

   2. 만약 importedStringModule이 null이 아니고 moduleName이 importedStringModule과 같다면, continue한다.

   3. kind를 type의 extern type의 문자열 값이라고 하자.

   4. obj를 «[ "module" → moduleName, "name" → name, "kind" → kind ]»라고 하자.

   5. Append를 사용하여 obj를 imports에 추가한다.

6. imports를 반환한다.

customSections(moduleObject, sectionName) 메서드는 호출되면 다음 단계를 수행한다:

1. bytes를 moduleObject.[[Bytes]]라고 하자.

2. customSections를 « »라고 하자.

3. 각각에 대해 bytes의 custom section customSection에 대해, module grammar에 따라 해석한다,

   1. name을 customSection의 name을 UTF-8로 디코드한 것이라고 하자.

   2. 단언: name은 failure가 아니다 (moduleObject.[[Module]]은 유효하다).

   3. 만약 name이 문자 값으로서 sectionName과 같다면,

      1. Append를 사용하여 새로운 ArrayBuffer를 customSections에 추가한다. 이 ArrayBuffer는 이 customsec 생성 규칙에 매치된 범위에 대한 bytes의 복사본 바이트를 포함한다.

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. 만약 빌트인 및 imported strings 검증을 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. module의 imports를 읽고, imports importObject, builtinSetNames, 그리고 importedStringModule와 함께 사용하여, 그 결과를 imports라고 하자.

5. module을 imports와 함께 WebAssembly 모듈의 코어로 인스턴스화하고, 그 결과를 instance라고 하자.

6. module과 instance로부터 초기화하여 this를 설정한다.

참고: 이 동기 API의 사용은 권장되지 않는다. 일부 구현에서는 인스턴스화할 때 때때로 오래 걸리는 컴파일 작업을 수행하기 때문이다.

Instance의 exports 속성 getter는 this.[[Exports]]를 반환한다.

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

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

메모리 주소 memaddr로부터 고정 길이 메모리 버퍼를 생성하려면, 다음 단계를 수행한다:

1. block을 memaddr의 기저 메모리와 식별되는 Data Block이라고 하자.

2. buffer를 내부 슬롯 [[ArrayBufferData]], [[ArrayBufferByteLength]], 그리고 [[ArrayBufferDetachKey]]를 가진 새 ArrayBuffer 라고 하자.

3. buffer.[[ArrayBufferData]]를 block으로 설정한다.

4. buffer.[[ArrayBufferByteLength]]를 block의 길이로 설정한다.

5. buffer.[[ArrayBufferDetachKey]]를 "WebAssembly.Memory"로 설정한다.

6. buffer를 반환한다.

메모리 주소 memaddr 및 maxsize로부터 크기 조절 가능한 메모리 버퍼를 생성하려면, 다음 단계를 수행한다:

1. block을 memaddr의 기저 메모리와 식별되는 Data Block이라고 하자.

2. length를 block의 길이라고 하자.

3. buffer를 내부 슬롯 [[ArrayBufferData]], [[ArrayBufferByteLength]], [[ArrayBufferMaxByteLength]], 그리고 [[ArrayBufferDetachKey]]를 가진 새 ArrayBuffer 라고 하자.

4. buffer.[[ArrayBufferData]]를 block으로 설정한다.

5. buffer.[[ArrayBufferByteLength]]를 length로 설정한다.

6. buffer.[[ArrayBufferMaxByteLength]]를 maxsize로 설정한다.

7. buffer.[[ArrayBufferDetachKey]]를 "WebAssembly.Memory"로 설정한다.

8. buffer를 반환한다.

메모리 주소 memaddr로부터 메모리 객체 memory를 초기화하려면, 다음 단계를 수행한다:

1. map을 현재 agent에 연관된 Memory 객체 캐시라고 하자.

2. 단언: map[memaddr]는 존재하지 않는다.

3. buffer를 고정 길이 메모리 버퍼를 생성하여 memaddr로부터 얻은 결과라고 하자.

4. memory.[[Memory]]를 memaddr로 설정한다.

5. memory.[[BufferObject]]를 buffer로 설정한다.

6. Set map[memaddr]를 memory로 설정한다.

메모리 주소 memaddr로부터 메모리 객체를 생성하려면, 다음 단계를 수행한다:

1. map을 현재 agent에 연관된 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를 현재 agent의 연관 저장소라고 하자.

7. (store, memaddr)를 mem_alloc(store, memtype)라고 하자. 만약 할당이 실패하면, RangeError 예외를 던진다.

8. 현재 agent의 연관 저장소를 store로 설정한다.

9. 초기화하여 this를 memaddr로부터 설정한다.

memaddr의 Memory 버퍼를 새로 고치기 위해, 다음 단계를 수행한다:

1. map을 현재 agent에 연관된 Memory 객체 캐시라고 하자.

2. 단언: map[memaddr]는 존재한다.

3. memory를 map[memaddr]라고 하자.

4. buffer를 memory.[[BufferObject]]라고 하자.

5. 만약 IsFixedLengthArrayBuffer(buffer)가 true이면,

   1. ! DetachArrayBuffer(buffer, "WebAssembly.Memory")를 수행한다.

   2. buffer를 고정 길이 메모리 버퍼를 생성하여 memaddr로부터 얻은 결과라고 하자.

   3. memory.[[BufferObject]]를 buffer로 설정한다.

6. 그렇지 않으면,

   1. block을 memaddr의 기저 메모리와 식별되는 Data Block이라고 하자.

   2. buffer.[[ArrayBufferData]]를 block으로 설정한다.

   3. buffer.[[ArrayBufferByteLength]]를 block의 길이로 설정한다.

메모리 주소 memaddr와 연관된 메모리 버퍼를 delta만큼 증가시키려면, 다음 단계를 수행한다:

1. store를 현재 agent의 연관 저장소라고 하자.

2. ret를 mem_size(store, memaddr)라고 하자.

3. store를 mem_grow(store, memaddr, delta)라고 하자.

4. 만약 store가 error이면, RangeError 예외를 던진다.

5. 현재 agent의 연관 저장소를 store로 설정한다.

6. memaddr의 메모리 버퍼를 새로 고친다.

7. ret를 반환한다.

grow(delta) 메서드는 호출되면, 다음 단계를 수행한다:

1. memaddr를 this.[[Memory]]라고 하자.

2. store를 현재 agent의 연관 저장소라고 하자.

3. addrtype를 주소 타입 in mem_type(store, memaddr)라고 하자.

4. delta64를 ? AddressValueToU64(delta, addrtype)라고 하자.

5. ret를 memaddr와 연관된 메모리 버퍼를 증가시켜 delta64만큼 늘린 결과라고 하자.

6. U64ToAddressValue(ret, addrtype)를 반환한다.

1. 만약 스택의 top이 i32.const (−1)이 아니고, 스택의 top이 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를 현재 agent의 연관 저장소라고 하자.

3. memtype을 mem_type(store, memaddr)라고 하자.

4. 만약 memtype에 max가 없으면,

   1. Throw a TypeError exception.

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을 현재 agent에 연관된 Memory 객체 캐시라고 하자.

   2. 단언: buffer는 map의 정확히 하나의 값의 [[BufferObject]]이다.

   3. 각각에 대해 memaddr → mem in map,

      1. 만약 SameValue(mem.[[BufferObject]], buffer)가 true이면,

         1. 단언: buffer.[[ArrayBufferByteLength]] modulo 65536은 0이다.

         2. lengthDelta를 newLength - buffer.[[ArrayBufferByteLength]]라고 하자.

         3. 만약 lengthDelta < 0 이거나 lengthDelta modulo 65536이 0이 아니면,

            1. RangeError 예외를 던진다.

         4. delta를 lengthDelta ÷ 65536이라고 하자.

         5. memaddr와 연관된 메모리 버퍼를 증가시켜 delta만큼 늘린다.

   4. handled를 반환한다.

2. 그렇지 않으면, unhandled를 반환한다.

Memory의 buffer 속성 getter는 this.[[BufferObject]]를 반환한다.

enum TableKind {
  "externref",
  "anyfunc",
  // 참고: 향후 반복에서 더 많은 값이 추가될 수 있음,
  // 예: typed function references, typed GC references
};

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

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

테이블 주소 tableaddr로부터 테이블 객체 table을 초기화하려면, 다음 단계를 수행한다:

1. map을 현재 agent에 연관된 Table 객체 캐시라고 하자.

2. 단언: map[tableaddr]는 존재하지 않는다.

3. table.[[Table]]를 tableaddr로 설정한다.

4. Set map[tableaddr]를 table로 설정한다.

테이블 주소 tableaddr로부터 테이블 객체를 생성하려면, 다음 단계를 수행한다:

1. map을 현재 agent에 연관된 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. Throw a TypeError exception.

3. 만약 descriptor["address"]가 존재하면, addrtype을 descriptor["address"]로 하고; 그렇지 않으면 addrtype을 "i32"로 한다.

4. initial을 ? AddressValueToU64(descriptor["initial"], addrtype)라고 하자.

5. 만약 descriptor["maximum"]이 존재하면, maximum을 ? AddressValueToU64(descriptor["maximum"], addrtype)라고 하고; 그렇지 않으면, maximum을 비어 있음으로 한다.

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를 현재 agent의 연관 저장소라고 하자.

11. (store, tableaddr)를 table_alloc(store, type, ref)라고 하자. 할당이 실패하면, RangeError 예외를 던진다.

12. 현재 agent의 연관 저장소를 store로 설정한다.

13. 초기화하여 this를 tableaddr로부터 설정한다.

grow(delta, value) 메서드는 호출되면, 다음 단계를 수행한다:

1. tableaddr를 this.[[Table]]라고 하자.

2. store를 현재 agent의 연관 저장소라고 하자.

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. 현재 agent의 연관 저장소를 result로 설정한다.

11. U64ToAddressValue(initialSize, addrtype)를 반환한다.

Table의 length 속성 getter는 호출되면, 다음 단계를 수행한다:

1. tableaddr를 this.[[Table]]라고 하자.

2. store를 현재 agent의 연관 저장소라고 하자.

3. addrtype을 주소 타입 in table_type(store, tableaddr)라고 하자.

4. length64를 table_size(store, tableaddr)라고 하자.

5. U64ToAddressValue(length64, addrtype)를 반환한다.

get(index) 메서드는 호출되면, 다음 단계를 수행한다:

1. tableaddr를 this.[[Table]]라고 하자.

2. store를 현재 agent의 연관 저장소라고 하자.

3. (addrtype, limits, elementtype)를 table_type(store, tableaddr)라고 하자.

4. 만약 elementtype이 matches 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를 현재 agent의 연관 저장소라고 하자.

3. (addrtype, limits, elementtype)를 table_type(store, tableaddr)라고 하자.

4. 만약 elementtype이 matches 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. 현재 agent의 연관 저장소를 store로 설정한다.

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

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

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

전역 주소 globaladdr로부터 전역 객체 global을 초기화하려면, 다음 단계를 수행한다:

1. map을 현재 agent에 연관된 Global 객체 캐시라고 하자.

2. 단언: map[globaladdr]는 존재하지 않는다.

3. global.[[Global]]를 globaladdr로 설정한다.

4. Set map[globaladdr]를 global로 설정한다.

전역 주소 globaladdr로부터 전역 객체를 생성하려면, 다음 단계를 수행한다:

1. map을 현재 agent에 연관된 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이 matches 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를 현재 agent의 연관 저장소라고 하자.

8. (store, globaladdr)를 global_alloc(store, globaltype, value)라고 하자.

9. 현재 agent의 연관 저장소를 store로 설정한다.

10. 초기화하여 this를 globaladdr로부터 설정한다.

알고리즘 GetGlobalValue(Global global)는 다음 단계를 수행한다:

1. store를 현재 agent의 연관 저장소라고 하자.

2. globaladdr를 global.[[Global]]라고 하자.

3. globaltype을 global_type(store, globaladdr)라고 하자.

4. 만약 globaltype이 mut valuetype 형식이고, 여기서 valuetype이 matches v128 또는 exnref이면, TypeError를 던진다.

5. value를 global_read(store, globaladdr)라고 하자.

6. ! ToJSValue(value)를 반환한다.

Global의 value 속성 getter는 호출되면, 다음 단계를 수행한다:

1. GetGlobalValue(this)를 반환한다.

Global의 value 속성 setter는 호출되면, 다음 단계를 수행한다:

1. store를 현재 agent의 연관 저장소라고 하자.

2. globaladdr를 this.[[Global]]라고 하자.

3. mut valuetype를 global_type(store, globaladdr)라고 하자.

4. 만약 valuetype이 matches v128 또는 exnref이면, TypeError를 던진다.

5. 만약 mut가 const이면, TypeError를 던진다.

6. value를 ? ToWebAssemblyValue(주어진 값, valuetype)라고 하자.

7. store를 global_write(store, globaladdr, value)라고 하자.

8. 만약 store가 error이면, RangeError 예외를 던진다.

9. 현재 agent의 연관 저장소를 store로 설정한다.

valueOf() 메서드는 호출되면, 다음 단계를 수행한다:

1. GetGlobalValue(this)를 반환한다.

WebAssembly 함수의 이름 funcaddr는 다음 단계를 수행하여 찾는다:

1. store를 현재 agent의 연관 저장소라고 하자.

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를 funcaddr가 발견되는 moduleinst.funcaddrs에서의 인덱스라고 하자.

5. ! ToString(index)를 반환한다.

WebAssembly 함수 주소 funcaddr로부터 새로운 내보낸 함수를 생성하려면, 다음 단계를 수행한다:

1. map을 현재 agent에 연관된 내보낸 함수 캐시라고 하자.

2. 만약 map[funcaddr]가 존재하면,

   1. map[funcaddr]를 반환한다.

3. steps를 "내보낸 함수 호출 funcaddr with arguments."라고 하자.

4. realm을 현재 Realm이라고 하자.

5. store를 현재 agent의 연관 저장소라고 하자.

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. Set map[funcaddr]를 function로 설정한다.

13. function을 반환한다.

함수 주소 funcaddr 및 JavaScript 인수들의 리스트 argValues로 내보낸 함수 호출을 하려면, 다음 단계를 수행한다:

1. store를 현재 agent의 연관 저장소라고 하자.

2. functype를 func_type(store, funcaddr)라고 하자.

3. [parameters] → [results]를 functype라고 하자.

4. 만약 parameters 또는 results 안의 어떤 타입이든 matches v128 또는 exnref이면, TypeError를 던진다.

   참고: 위 오류는 [[Call]] 메서드가 호출될 때마다 던져진다.

5. args를 « »라고 하자.

6. i를 0이라고 하자.

7. 각각에 대해 t of parameters,

   1. 만약 argValues의 크기 > i이면, arg를 argValues[i]라고 하자.

   2. 그렇지 않으면, arg를 undefined라고 하자.

   3. Append ? ToWebAssemblyValue(arg, t) to args.

   4. i를 i + 1로 설정한다.

8. (store, ret)를 func_invoke(store, funcaddr, args)의 결과라고 하자.

9. 현재 agent의 연관 저장소를 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을 새로운 Exception created from exnaddr라고 하자.

       2. exception을 던진다.

12. outArity를 ret의 크기라고 하자.

13. 만약 outArity가 0이면, undefined를 반환한다.

14. 그렇지 않고 outArity가 1이면, ! ToJSValue(ret[0])를 반환한다.

15. 그렇지 않으면,

    1. values를 « »라고 하자.

    2. 각각에 대해 r of ret,

       1. Append ! ToJSValue(r) to values.

    3. CreateArrayFromList(values)를 반환한다.

JavaScript 객체 func, 타입 functype, 그리고 리스트 of WebAssembly 값 arguments로부터 호스트 함수 실행을 하려면, 다음 단계를 수행한다:

1. [parameters] → [results]를 functype라고 하자.

2. 만약 parameters 또는 results 안의 어떤 타입이든 matches v128 또는 exnref이면, TypeError를 던진다.

3. jsArguments를 « »라고 하자.

4. 각각에 대해 arg of arguments,

   1. Append ! ToJSValue(arg) to 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이면, throw a TypeError.

   3. values를 ? IteratorToList(? GetIteratorFromMethod(ret, method))라고 하자.

   4. wasmValues를 새롭고 비어 있는 리스트라고 하자.

   5. 만약 values의 크기가 resultsSize와 같지 않으면, TypeError 예외를 던진다.

   6. values의 각 value와 results의 각 resultType에 대해, 선형적으로 짝지어,

      1. Append ? ToWebAssemblyValue(value, resultType) to wasmValues.

   7. wasmValues를 반환한다.

JavaScript 객체 func 및 타입 functype로부터 호스트 함수 생성을 하려면, 다음 단계를 수행한다:

1. 단언: IsCallable(func).

2. stored settings를 incumbent 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를 현재 agent의 연관 저장소라고 하자.

   10. 만약 result.[[Type]]가 throw이면:

       1. v를 result.[[Value]]라고 하자.

       2. 만약 v가 implements Exception이면,

          1. address를 v.[[Address]]라고 하자.

       3. 그렇지 않으면,

          1. type을 JavaScript 예외 태그 가져오기의 결과라고 하자.

          2. payload를 ! ToWebAssemblyValue(v, externref)라고 하자.

          3. (store, address)를 exn_alloc(store, type, « payload »)라고 하자.

          4. 현재 agent의 연관 저장소를 store로 설정한다.

       4. WebAssembly 명령어 (ref.exn address) (throw_ref)를 실행한다.

   11. 그렇지 않으면, result.[[Value]]를 반환한다.

4. store를 현재 agent의 연관 저장소라고 하자.

5. (store, funcaddr)를 func_alloc(store, functype, hostfunc)라고 하자.

6. 현재 agent의 연관 저장소를 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 interpreted as a 수학적 값)를 반환한다.

4. 만약 w가 i32.const u32 형태이면,

   1. i32를 signed_32(u32)라고 하자.

   2. 𝔽(i32 interpreted as a 수학적 값)를 반환한다.

5. 만약 w가 f32.const f32 형태이면,

   1. 만약 f32가 +∞ 또는 −∞이면, 각각 +∞_𝔽 또는 -∞_𝔽를 반환한다.

   2. 만약 f32가 nan이면, NaN을 반환한다.

   3. 𝔽(f32 interpreted as a 수학적 값)를 반환한다.

6. 만약 w가 f64.const f64 형태이면,

   1. 만약 f64가 +∞ 또는 −∞이면, 각각 +∞_𝔽 또는 -∞_𝔽를 반환한다.

   2. 만약 f64가 nan이면, NaN을 반환한다.

   3. 𝔽(f64 interpreted as a 수학적 값)를 반환한다.

7. 만약 w가 ref.null t 형태이면, null을 반환한다.

8. 만약 w가 ref.i31 u31 형태이면,

   1. i31를 signed_31(u31)라고 하자.

   2. 𝔽(i31)를 반환한다.

9. 만약 w가 ref.struct structaddr 형태이면, structaddr와 "struct"로부터 새로운 Exported GC Object를 생성한 결과를 반환한다.

10. 만약 w가 ref.array arrayaddr 형태이면, arrayaddr와 "array"로부터 새로운 Exported GC Object를 생성한 결과를 반환한다.

11. 만약 w가 ref.func funcaddr 형태이면, funcaddr로부터 새로운 내보낸 함수를 생성한 결과를 반환한다.

12. 만약 w가 ref.host hostaddr 형태이면, 호스트 값 가져오기를 hostaddr로부터 수행한 결과를 반환한다.

13. 만약 w가 ref.extern ref 형태이면, ToJSValue(ref)를 반환한다.

참고: NaN과 같은 Number 값은 관찰 가능한 여러 NaN payload를 가질 수 있다; 자세한 내용은 NumericToRawBytes를 참조하라.

호스트 주소 hostaddr로부터 호스트 값을 가져오기 위해, 다음 단계를 수행한다:

1. map을 현재 agent에 연관된 host value cache라고 하자.

2. 단언: map[hostaddr]는 존재한다.

3. map[hostaddr]를 반환한다.

알고리즘 ToWebAssemblyValue(v, type)는 JavaScript 값을 WebAssembly 값으로 강제 변환하며, 다음 단계를 수행한다:

1. 단언: type은 v128이 아니다.

2. 단언: type은 match exnref를 하지 않는다.

3. 만약 type이 i64이면,

   1. i64를 ? ToBigInt64(v)라고 하자.

   2. u64를 i64가 signed_64(u64)인 그러한 부호 없는 정수라고 하자.

   3. i64.const u64를 반환한다.

4. 만약 type이 i32이면,

   1. i32를 ? ToInt32(v)라고 하자.

   2. u32를 i32가 signed_32(u32)인 그러한 부호 없는 정수라고 하자.

   3. i32.const u32를 반환한다.

5. 만약 type이 f32이면,

   1. number를 ? ToNumber(v)라고 하자.

   2. 만약 number가 NaN이면,

      1. n을 구현 정의 정수라고 하자. 이 값은 canon₃₂ ≤ n < 2^signif(32)를 만족한다.

      2. f32를 nan(n)이라고 하자.

   3. 그렇지 않으면,

      1. f32를 IEEE 754-2019의 nearest representable value using round to nearest, ties to even mode로 반올림한 number라고 하자. [IEEE-754]

   4. f32.const f32를 반환한다.

6. 만약 type이 f64이면,

   1. number를 ? ToNumber(v)라고 하자.

   2. 만약 number가 NaN이면,

      1. n을 구현 정의 정수라고 하자. 이 값은 canon₆₄ ≤ n < 2^signif(64)를 만족한다.

      2. f64를 nan(n)이라고 하자.

   3. 그렇지 않으면,

      1. f64를 number라고 하자.

   4. f64.const f64를 반환한다.

7. 만약 type이 ref null heaptype 형태이면,

   1. 만약 v가 null이면,

      1. r을 ref.null heaptype라고 하자.

   2. 그렇지 않고 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가 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. 그렇지 않으면,

      1. map을 현재 agent에 연관된 host value cache라고 하자.

      2. 만약 어떤 호스트 주소 hostaddr가 존재하여 map[hostaddr]가 v와 동일하면,

         1. ref.host hostaddr를 반환한다.

      3. 호스트 주소 hostaddr를 map[hostaddr]가 존재하지 않는 가장 작은 주소라고 하자.

      4. Set map[hostaddr]를 v로 설정한다.

      5. r을 ref.host hostaddr라고 하자.

   7. store를 현재 agent의 연관 저장소라고 하자.

   8. actualtype을 ref_type(store, r)라고 하자.

   9. 만약 match_valtype(actualtype, type)가 false이면,

      1. TypeError를 던진다.

   10. r을 반환한다.

8. 단언: 이 단계에는 도달하지 않는다.

알고리즘 AddressValueToU64(v, addrtype)는 JavaScript 값을 임베딩 연산에 사용하기 위한 WebAssembly u64로 변환한다. 이것은 [EnforceRange] unsigned long처럼 동작하도록 설계되었으며, AddressType "i32"에 대해, 그리고 이러한 의미를 AddressType "i64"로 확장하기 위해, 다음 단계를 수행한다:

1. 만약 addrtype가 "i32"이면,

   1. n을 ? ConvertToInt(v, 32, "unsigned")라고 하자. 여기서 대상 타입은 [EnforceRange]와 연관된다.

      참고: 이것은 JS 변환 규칙 for [EnforceRange] unsigned long과 동등하다.

   2. ℝ(n)을 WebAssembly u64로서 반환한다.

2. 만약 addrtype가 "i64"이면,

   1. n을 ? ToBigInt(v)라고 하자.

   2. 만약 n < 0 또는 n > 2⁶⁴ − 1이면, throw a TypeError.

      참고: 이 연산은 [EnforceRange]를 에뮬레이션하도록 설계되었다.

   3. ℝ(n)을 WebAssembly u64로서 반환한다.

3. 단언: 이 단계에는 도달하지 않는다.

알고리즘 U64ToAddressValue(v, addrtype)는 WebAssembly 임베딩 연산으로부터의 u64 값을 올바른 변형의 AddressValue for an AddressType로 변환하며, 다음 단계를 수행한다:

1. 만약 addrtype가 "i32"이면, 𝔽(v interpreted as a 수학적 값)를 반환한다.

2. 그렇지 않고 addrtype가 "i64"이면, ℤ(v interpreted as a 수학적 값)를 반환한다.

3. 단언: 이 단계에는 도달하지 않는다.

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

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

Tag 객체를 초기화하려면, 태그 주소 tagAddress로부터 tag에 대해 다음 단계를 수행한다:

1. map을 현재 agent에 연관된 Tag 객체 캐시라고 하자.

2. 단언: map[tagAddress]는 존재하지 않는다.

3. tag.[[Address]]를 tagAddress로 설정한다.

4. Set map[tagAddress]를 tag로 설정한다.

태그 주소 tagAddress로부터 Tag 객체를 생성하려면, 다음 단계를 수행한다:

1. map을 현재 agent에 연관된 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. 각각에 대해 paramType of parameters,

   1. Append ToValueType(paramType)를 wasmParameters에 추가한다.

4. store를 현재 agent의 연관 저장소라고 하자.

5. (store, tagAddress)를 tag_alloc(store, wasmParameters → « »)라고 하자.

6. 현재 agent의 연관 저장소를 store로 설정한다.

7. 초기화하여 this를 tagAddress로부터 설정한다.

Exported GC Object의 [[GetPrototypeOf]] 내부 메서드 O는 인수를 받지 않고 null을 반환한다. 호출되면 다음 단계를 수행한다:

1. null을 반환한다.

Exported GC Object의 [[SetPrototypeOf]] 내부 메서드 O는 인수 V (Object 또는 null)를 받고 boolean을 반환한다. 호출되면 다음 단계를 수행한다:

1. false를 반환한다.

Exported GC Object의 [[IsExtensible]] 내부 메서드 O는 인수를 받지 않고 boolean을 반환한다. 호출되면 다음 단계를 수행한다:

1. false를 반환한다.

Exported GC Object의 [[PreventExtensions]] 내부 메서드 O는 인수를 받지 않고 boolean을 반환한다. 호출되면 다음 단계를 수행한다:

1. false를 반환한다.

Exported GC Object의 [[GetOwnProperty]] 내부 메서드 O는 인수 P (property key)를 받고 undefined를 반환한다. 호출되면 다음 단계를 수행한다:

1. undefined를 반환한다.

Exported GC Object의 [[DefineOwnProperty]] 내부 메서드 O는 인수 P (property key) 및 Desc (property descriptor)를 받고 boolean을 반환한다. 호출되면 다음 단계를 수행한다:

1. false를 반환한다.

Exported GC Object의 [[HasProperty]] 내부 메서드 O는 인수 P (property key)를 받고 boolean을 반환한다. 호출되면 다음 단계를 수행한다:

1. false를 반환한다.

Exported GC Object의 [[Get]] 내부 메서드 O는 인수 P (property key) 및 Receiver (ECMAScript 언어 값)를 받고 undefined를 반환한다. 호출되면 다음 단계를 수행한다:

1. undefined를 반환한다.

Exported GC Object의 [[Set]] 내부 메서드 O는 인수 P (property key), V (ECMAScript 언어 값), 그리고 Receiver (ECMAScript 언어 값)를 받고 예외를 던진다. 호출되면 다음 단계를 수행한다:

1. TypeError를 던진다.

Exported GC Object의 [[Delete]] 내부 메서드 O는 인수 P (property key)를 받고 예외를 던진다. 호출되면 다음 단계를 수행한다:

1. TypeError를 던진다.

Exported GC Object의 [[OwnPropertyKeys]] 내부 메서드 O는 인수를 받지 않고 리스트를 반환한다. 호출되면 다음 단계를 수행한다:

1. keys를 새롭고 비어 있는 리스트라고 하자.

2. keys를 반환한다.

WebAssembly object address objectaddr 및 문자열 objectkind로부터 새로운 Exported GC Object를 생성하려면, 다음 단계를 수행한다:

1. 단언: objectkind는 "array" 또는 "struct" 중 하나이다.

2. map을 현재 agent에 연관된 exported GC object cache라고 하자.

3. 만약 map[objectaddr]가 존재하면,

   1. map[objectaddr]를 반환한다.

4. object를 MakeBasicObject(« [[ObjectAddress]], [[ObjectKind]] »)라고 하자.

5. object.[[ObjectAddress]]를 objectaddr로 설정한다.

6. object.[[ObjectKind]]를 objectkind로 설정한다.

7. object.[[GetPrototypeOf]]를 Exported GC Object의 [[GetPrototypeOf]] 내부 메서드에 명시된 대로 설정한다.

8. object.[[SetPrototypeOf]]를 Exported GC Object의 [[SetPrototypeOf]] 내부 메서드에 명시된 대로 설정한다.

9. object.[[IsExtensible]]를 Exported GC Object의 [[IsExtensible]] 내부 메서드에 명시된 대로 설정한다.

10. object.[[PreventExtensions]]를 Exported GC Object의 [[PreventExtensions]] 내부 메서드에 명시된 대로 설정한다.

11. object.[[GetOwnProperty]]를 Exported GC Object의 [[GetOwnProperty]] 내부 메서드에 명시된 대로 설정한다.

12. object.[[DefineOwnProperty]]를 Exported GC Object의 [[DefineOwnProperty]] 내부 메서드에 명시된 대로 설정한다.

13. object.[[HasProperty]]를 Exported GC Object의 [[HasProperty]] 내부 메서드에 명시된 대로 설정한다.

14. object.[[Get]]를 Exported GC Object의 [[Get]] 내부 메서드에 명시된 대로 설정한다.

15. object.[[Set]]를 Exported GC Object의 [[Set]] 내부 메서드에 명시된 대로 설정한다.

16. object.[[Delete]]를 Exported GC Object의 [[Delete]] 내부 메서드에 명시된 대로 설정한다.

17. object.[[OwnPropertyKeys]]를 Exported GC Object의 [[OwnPropertyKeys]] 내부 메서드에 명시된 대로 설정한다.

18. Set map[objectaddr]를 object로 설정한다.

19. object를 반환한다.

dictionary ExceptionOptions {
  boolean traceStack = false;
};

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

Exception 객체를 초기화하려면, Exception address exnAddress로부터 exn에 대해 다음 단계를 수행한다:

1. map을 현재 agent에 연관된 Exception 객체 캐시라고 하자.

2. 단언: map[exnAddress]는 존재하지 않는다.

3. exn.[[Address]]를 exnAddress로 설정한다.

4. Set map[exnAddress]를 exn로 설정한다.

5. store를 현재 agent의 연관 저장소라고 하자.

6. tagaddr를 exn_tag(store, exnAddress)라고 하자.

7. payload를 exn_read(store, exnAddress)라고 하자.

8. exn.[[Type]]를 tagaddr로 설정한다.

9. exn.[[Payload]]를 payload로 설정한다.

10. exn.[[Stack]]를 undefined로 설정한다.

Exception 객체를 생성하려면, exception address exnAddress로부터 다음 단계를 수행한다:

1. map을 현재 agent에 연관된 Exception 객체 캐시라고 하자.

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를 현재 agent의 연관 저장소라고 하자.

4. [types] → []를 tag_type(store, exceptionTag.[[Address]])라고 하자.

5. 만약 types의 크기가 payload의 크기와 같지 않으면,

   1. TypeError를 던진다.

6. wasmPayload를 « »라고 하자.

7. 각각에 대해 value 및 resultType of payload and types, 선형적으로 짝지어,

   1. 만약 resultType이 matches v128 또는 exnref이면,

      1. TypeError를 던진다.

   2. Append ? ToWebAssemblyValue(value, resultType)를 wasmPayload에 추가한다.

8. (store, exceptionAddr)를 exn_alloc(store, exceptionTag.[[Address]], wasmPayload)라고 하자.

9. 현재 agent의 연관 저장소를 store로 설정한다.

10. 초기화하여 this를 exceptionAddr로부터 설정한다.

11. 만약 options["traceStack"]가 true이면,

    1. this.[[Stack]]를 현재 호출 스택의 DOMString 표현 또는 undefined 중 하나로 설정한다.

getArg(exceptionTag, index) 메서드 단계는 다음과 같다:

1. store를 현재 agent의 연관 저장소라고 하자.

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]가 matches 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. 만약 현재 agent에 연관된 JavaScript exception tag가 초기화되어 있으면,

   1. 현재 agent에 연관된 JavaScript exception tag를 반환한다

2. store를 현재 agent의 연관 저장소라고 하자.

3. (store, tagAddress)를 tag_alloc(store, « externref » → « »)라고 하자.

4. 현재 agent의 연관 저장소를 store로 설정한다.

5. 현재 agent에 연관된 JavaScript exception tag를 tagAddress로 설정한다.

6. tagAddress를 반환한다.

WebAssembly 네임스페이스의 namespace object가 생성될 때, 다음 단계를 실행해야 한다:

1. namespaceObject를 그 namespace object라고 하자.

2. 각각에 대해 error of « "CompileError", "LinkError", "RuntimeError" »,

   1. constructor를 새 객체라고 하자. 이 객체는 NativeError Object Structure를 구현하며, NativeError가 error로 설정된다.

   2. ! DefineMethodProperty(namespaceObject, error, constructor, false)를 수행한다.

빌트인 집합의 빌트인 가져오기를 builtinSetName으로 수행하려면, 다음 단계를 수행한다:

1. 이 절 안에서 정의된 이름 builtinSetName을 가진 집합에 대해, (name, funcType, steps)의 리스트를 반환한다.

빌트인 찾기를 import와 활성화된 빌트인 builtinSetNames로 수행하려면, 다음 단계를 수행한다:

1. 단언: 빌트인 집합 이름 검증 builtinSetNames는 true이다.

2. importModuleName을 import[0]이라고 하자.

3. importName을 import[1]이라고 하자.

4. 각각에 대해 builtinSetName of builtinSetNames,

   1. 만약 builtinSetName이 빌트인 집합을 가리키지 않으면, continue한다.

   2. builtinSetQualifiedName을 builtinSetName 앞에 "wasm:"를 붙인 것이라고 하자.

   3. 만약 importModuleName이 builtinSetQualifiedName과 같으면,

      1. builtins를 빌트인 집합의 빌트인 가져오기 builtinSetName의 결과라고 하자.

      2. 각각에 대해 builtin of builtins,

         1. builtinName을 builtin[0]이라고 하자.

         2. 만약 importName이 builtinName과 같으면, (builtinSetName, builtin)를 반환한다.

5. null을 반환한다.

빌트인 집합 이름 검증을 builtinSetNames로 수행하려면, 다음 단계를 수행한다:

1. 만약 builtinSetNames가 중복을 하나라도 포함하면, false를 반환한다.

2. true를 반환한다.

빌트인 함수 생성을 타입 funcType 및 실행 단계 steps로부터 수행하려면, 다음 단계를 수행한다:

1. hostfunc를 호스트 함수라고 하며, 호출되면 steps를 실행한다.

2. store를 현재 agent의 연관 저장소라고 하자.

3. (store, funcaddr)를 func_alloc(store, funcType, hostfunc)라고 하자.

4. 현재 agent의 연관 저장소를 store로 설정한다.

5. funcaddr를 반환한다.

빌트인 집합 인스턴스화를 이름 builtinSetName으로 수행하려면, 다음 단계를 수행한다:

1. builtins를 빌트인 집합의 빌트인 가져오기 builtinSetName의 결과라고 하자.

2. exportsObject를 ! OrdinaryObjectCreate(null)이라고 하자.

3. 각각에 대해 (name, funcType, steps) of builtins,

   1. funcaddr를 빌트인 함수 생성을 funcType 및 steps로 수행한 결과라고 하자.

   2. func를 funcaddr로부터 새로운 Exported Function을 생성한 결과라고 하자.

   3. value를 func라고 하자.

   4. status를 ! CreateDataProperty(exportsObject, name, value)라고 하자.

   5. 단언: status는 true이다.

4. exportsObject를 반환한다.

빌트인에 대한 import 검증을 import, 활성화된 빌트인 builtinSetNames로 수행하려면, 다음 단계를 수행한다:

1. 단언: 빌트인 집합 이름 검증 builtinSetNames는 true이다.

2. maybeBuiltin을 빌트인 찾기를 import와 builtinSetNames로 수행한 결과라고 하자.

3. 만약 maybeBuiltin이 null이면, true를 반환한다.

4. importExternType을 import[2]라고 하자.

5. builtinFuncType을 maybeBuiltin[1][1]이라고 하자.

6. builtinExternType을 func |builtinFuncType|이라고 하자.

7. match_externtype(builtinExternType, importExternType)를 반환한다.

추상 연산 UnwrapString(v)은 호출되면, 다음 단계를 수행한다:

1. 만약 v가 String이 아니면,

   1. 트랩이 실행된 것처럼 RuntimeError 예외를 던진다.

2. v를 반환한다

추상 연산 FromCharCode(v)는 호출되면, 다음 단계를 수행한다:

1. 단언: v는 i32 타입이다.

2. ! Call(String.fromCharCode, undefined, « ToJSValue(v) »)를 반환한다.

추상 연산 CharCodeAt(string, index)는 호출되면 다음 단계를 수행한다:

1. 단언: index는 i32 타입이다.

2. ! Call(String.prototype.charCodeAt, string, « ToJSValue(index) »)를 반환한다.

이 빌트인이 매개변수 v와 함께 호출되면, 다음 단계를 실행해야 한다:

1. ? UnwrapString(v)를 반환한다

이 빌트인이 매개변수 v와 함께 호출되면, 다음 단계를 실행해야 한다:

1. 만약 v가 String이 아니면,

   1. 0을 반환한다.

2. 1을 반환한다.

이 빌트인이 매개변수 array, start, 그리고 end와 함께 호출되면, 다음 단계를 실행해야 한다:

1. 만약 array가 null이면,

   1. 트랩이 실행된 것처럼 RuntimeError 예외를 던진다.

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가 String이 아니면,

   1. 트랩이 실행된 것처럼 RuntimeError 예외를 던진다.

2. 만약 second가 null이 아니고 second가 String이 아니면,

   1. 트랩이 실행된 것처럼 RuntimeError 예외를 던진다.

3. 만약 ! IsStrictlyEqual(first, second)가 true이면,

   1. 1을 반환한다.

4. 0을 반환한다.

이 빌트인이 매개변수 first 및 second와 함께 호출되면, 다음 단계를 실행해야 한다:

1. first를 ? UnwrapString(first)라고 하자.

2. second를 ? UnwrapString(second)라고 하자.

3. 만약 ! IsStrictlyEqual(first, second) 가 true이면,

   1. 0을 반환한다.

4. 만약 ! IsLessThan(first, second, true)가 true이면,

   1. -1을 반환한다.

5. 1을 반환한다.