WebAssembly 자바스크립트 인터페이스

(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(BufferSource bytes, optional WebAssemblyCompileOptions options = {});
    Promise<Module> compile(BufferSource bytes, optional WebAssemblyCompileOptions options = {});

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

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

    readonly attribute Tag JSTag;
};

WebAssembly 모듈 컴파일을 source 바이트 bytes로부터 수행하려면, 다음 단계를 따른다:

1. module을 module_decode(bytes) 결과로 둔다. module이 오류(error)라면, 오류(error)를 반환한다.

2. module_validate(module)가 오류(error)라면, 오류(error)를 반환한다.

3. module을 반환한다.

WebAssembly 모듈에 대해 builtins 및 import된 문자열을 검증을 module module, 활성화된 builtins builtinSetNames, importedStringModule로부터 수행하려면 다음 단계를 따른다:

1. builtin set 이름 검증이 builtinSetNames에 대해 false면, false를 반환한다.

2. 각 import에 대해 module_imports(module)를 순회한다,

   1. importedStringModule이 null이 아니고 import[0]이 importedStringModule과 같으면,

      1. importExternType을 import[2]로 둔다.

      2. stringExternType을 global const (ref extern)으로 둔다.

      3. match_externtype(stringExternType, importExternType)이 false라면, false를 반환한다.

   2. 그 외의 경우,

      1. 내장용 import 검증이 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. builtins 및 import된 문자열 검증이 module, builtinSetNames, importedStringModule에 대해 false를 반환하면, false를 반환한다.

7. true를 반환한다.

WebAssembly 모듈 객체를 구성하려면 모듈 module, 소스 바이트 bytes, 활성화된 builtins builtinSetNames, 그리고 importedStringModule로부터 다음 단계를 수행한다:

1. moduleObject를 새로운 Module 객체로 둔다.

2. moduleObject.[[Module]]를 module로 설정한다.

3. moduleObject.[[Bytes]]를 bytes로 설정한다.

4. moduleObject.[[BuiltinSets]]를 builtinSetNames로 설정한다.

5. moduleObject.[[ImportedStringModule]]를 importedStringModule로 설정한다.

6. moduleObject를 반환한다.

WebAssembly 모듈을 비동기적으로 컴파일하려면 소스 바이트 bytes와 WebAssemblyCompileOptions options을 사용하고, 선택적 작업 소스 taskSource로 다음 단계를 수행한다:

1. promise를 새로운 프로미스로 둔다.

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

   1. WebAssembly 모듈을 컴파일하여 bytes의 결과를 module로 저장한다.

   2. 태스크를 큐에 넣어 다음 단계를 수행한다. taskSource가 제공되었다면, 그 작업 소스에 태스크를 큐에 넣는다.

      1. module이 error이면, promise를 CompileError 예외로 거부한다.

      2. builtinSetNames를 options["builtins"]로 둔다.

      3. importedStringModule를 options["importedStringConstants"]로 둔다.

      4. builtins 및 import된 문자열 검증이 module, builtinSetNames, importedStringModule에 대해 false이면, promise를 CompileError 예외로 거부한다.

      5. 그렇지 않다면,

         1. WebAssembly 모듈 객체를 구성하여 module, bytes, builtinSetNames, importedStringModule로부터 결과를 moduleObject로 둔다.

         2. Resolve promise with moduleObject.

3. promise를 반환한다.

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

1. stableBytes를 버퍼가 보유한 바이트의 복사본 bytes로 둔다.

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

import된 문자열을 인스턴스화하려면 모듈 module과 importedStringModule로 다음 단계를 수행한다:

1. Assert: importedStringModule은 null이 아니다.

2. exportsObject를 ! OrdinaryObjectCreate(null)로 둔다.

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

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

   2. stringConstant를 componentName으로 둔다.

   3. status를 ! CreateDataProperty(exportsObject, stringConstant, stringConstant)로 둔다.

   4. Assert: status는 true이다.

4. exportsObject를 반환한다.

WebAssembly 모듈 module의 import들을, imports 객체 importObject, 활성화된 builtins builtinSetNames, importedStringModule로부터 읽어들인다: 다음 단계를 수행한다:

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

2. builtinOrStringImports를 순서 있는 맵 « »로 둔다.

3. 각 builtinSetName ∈ builtinSetNames에 대해,

   1. Assert: builtinOrStringImports는 builtinSetName을 포함하지 않는다.

   2. builtinSetName이 builtin set을 가리키지 않으면, continue.

   3. exportsObject를 builtin set 인스턴스화의 결과로, builtinSetName을 사용하여 둔다.

   4. builtinSetQualifiedName을 "wasm:" 접두어를 붙인 builtinSetName으로 둔다>

   5. Set builtinOrStringImports[builtinSetQualifiedName] = exportsObject

4. importedStringModule이 null이 아니라면,

   1. exportsObject를 import된 문자열 인스턴스화 결과로, module과 importedStringModule을 사용하여 둔다.

   2. Set builtinOrStringImports[importedStringModule] = exportsObject

5. imports를 « »로 둔다.

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

   1. builtinOrStringImports가 moduleName를 포함한다면,

      1. o를 builtinOrStringImports[moduleName]로 둔다.

      2. o가 객체가 아니거나 또는 o가 componentName을 포함하지 않으면,

         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]] 내부 슬롯을 가지므로 Exported Function이라면,

         1. funcaddr를 v의 [[FunctionAddress]] 내부 슬롯의 값으로 둔다.

      3. 그 외의 경우,

         1. 호스트 함수 생성을 v와 functype으로 수행하고, 결과를 funcaddr로 둔다.

         2. index를 imports 내 외부 함수의 개수로 둔다. 이 값 index는 호스트 함수의 인덱스 funcaddr로 알려진다.

      4. externfunc를 external value func funcaddr로 둔다.

      5. Append externfunc → imports.

   6. externtype이 global mut valtype 형태라면,

      1. v가 implements Global이면,

         1. globaladdr를 v.[[Global]]로 둔다.

      2. 그렇지 않다면,

         1. valtype이 i64이고 v가 BigInt가 아니면,

            1. LinkError 예외를 던진다.

         2. valtype이 i32, f32, f64 중 하나이고 v가 Number가 아니면,

            1. LinkError 예외를 던진다.

         3. valtype이 v128이면,

            1. LinkError 예외를 던진다.

         4. value를 ToWebAssemblyValue(v, valtype)로 둔다. 이 연산이 TypeError를 던지면, 이를 잡아 LinkError 예외를 던진다.

         5. store를 주변 에이전트의 연결된 저장소로 둔다.

         6. (store, globaladdr)를 global_alloc(store, const valtype, value)로 둔다.

         7. 주변 에이전트의 연결된 저장소를 store로 설정한다.

      3. externglobal을 global globaladdr로 둔다.

      4. Append externglobal → imports.

   7. externtype이 mem memtype 형태라면,

      1. v가 implement Memory를 하지 않으면, LinkError 예외를 던진다.

      2. externmem을 external value mem v.[[Memory]]로 둔다.

      3. Append externmem → imports.

   8. externtype이 table tabletype 형태라면,

      1. v가 implement Table을 하지 않으면, LinkError 예외를 던진다.

      2. tableaddr를 v.[[Table]]로 둔다.

      3. externtable을 external value table tableaddr로 둔다.

      4. Append externtable → imports.

   9. externtype이 tag attribute functype 형태라면,

      1. Assert: attribute는 exception이다.

      2. v가 implement Tag를 하지 않으면, LinkError 예외를 던진다.

      3. tagaddr를 v.[[Address]]로 둔다.

      4. externtag를 external value tag tagaddr로 둔다.

      5. Append externtag → imports.

7. imports를 반환한다.

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

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

1. exportsObject를 ! OrdinaryObjectCreate(null)로 둔다.

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

   1. externval을 instance_export(instance, name)로 둔다.

   2. Assert: externval은 error가 아니다.

   3. externtype이 func functype 형태라면,

      1. Assert: externval은 func funcaddr 형태이다.

      2. func funcaddr를 externval로 둔다.

      3. func를 새로운 Exported Function을 funcaddr로부터 생성한 결과로 둔다.

      4. value를 func로 둔다.

   4. externtype이 global mut globaltype 형태라면,

      1. Assert: externval은 global globaladdr 형태이다.

      2. global globaladdr를 externval로 둔다.

      3. global을 새로운 Global 객체로, globaladdr로부터 생성한다.

      4. value를 global로 둔다.

   5. externtype이 mem memtype 형태라면,

      1. Assert: externval은 mem memaddr 형태이다.

      2. mem memaddr를 externval로 둔다.

      3. memory를 새로운 Memory 객체로, memaddr로부터 생성한다.

      4. value를 memory로 둔다.

   6. externtype이 table tabletype 형태라면,

      1. Assert: externval은 table tableaddr 형태이다.

      2. table tableaddr를 externval로 둔다.

      3. table을 새로운 Table 객체로, tableaddr로부터 생성한다.

      4. value를 table로 둔다.

   7. externtype이 tag attribute functype 형태라면,

      1. Assert: attribute는 exception이다.

      2. Assert: externval은 tag tagaddr 형태이다.

      3. tag tagaddr를 externval로 둔다.

      4. tag를 새로운 Tag 객체로, tagaddr로부터 생성한다.

      5. value를 tag로 둔다.

   8. status를 ! CreateDataProperty(exportsObject, name, value)로 둔다.

   9. Assert: status는 true이다.

   Note: WebAssembly 모듈 검증 중 수행되는 유효성 및 고유성 검사는 각 프로퍼티 이름이 유효하며 중복 정의되지 않음을 보장한다.

3. ! SetIntegrityLevel(exportsObject, "frozen")을 수행한다.

4. exportsObject를 반환한다.

WebAssembly 모듈 module과 인스턴스 instance로부터 인스턴스 객체 초기화 instanceObject를 수행하려면 다음 단계를 따른다:

1. exports 객체 생성을 module과 instance로 수행하고, 결과를 exportsObject로 둔다.

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

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

모듈 module과 import들 imports로부터 WebAssembly 모듈의 코어를 인스턴스화하려면, 다음 단계를 수행한다:

1. store를 주변 에이전트의 연결된 저장소로 둔다.

2. result를 module_instantiate(store, module, imports)로 둔다.

3. result가 error이면, 적절한 예외 유형을 던진다:

   • 링킹 중 대부분의 경우에 대해 LinkError 예외.

   • start 함수 실행 중 발생한 오류라면, WebAssembly로부터 발생하는 대부분의 오류에 대해 RuntimeError를, 또는 내부 ECMAScript 코드에서 전파된 오류 객체를 던진다.

   • 그 외 적절하다면 다른 오류 타입(예: out-of-memory 예외). 자세한 내용은 WebAssembly 오류 매핑에 문서화되어 있다.

4. (store, instance)를 result로부터 둔다.

5. 주변 에이전트의 연결된 저장소를 store로 설정한다.

6. instance를 반환한다.

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

1. promise를 새로운 프로미스로 둔다.

2. module를 moduleObject.[[Module]]로 둔다.

3. builtinSetNames를 moduleObject.[[BuiltinSets]]로 둔다.

4. importedStringModule를 moduleObject.[[ImportedStringModule]]로 둔다.

5. import 읽기를 module에 대해, importObject, builtinSetNames, importedStringModule와 함께 수행하고, 결과를 imports로 둔다. 이 연산이 예외를 던지면 이를 잡아, reject promise with 그 예외, 그리고 promise를 반환한다.

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

   1. 태스크를 큐에 넣어 다음 단계를 수행한다: Note: 구현별 작업이 여기서 수행될 수 있다.

      1. WebAssembly 모듈의 코어 인스턴스화를 module과 imports로 수행하고, 결과를 instance로 둔다. 예외가 던져지면 이를 잡아, reject promise with 그 예외, 그리고 이 하위단계를 종료한다.

      2. instanceObject를 new Instance로 둔다.

      3. 초기화를 instanceObject에 대해 module과 instance로 수행한다. 이 연산이 예외를 던지면 이를 잡아, reject promise with 그 예외, 그리고 이 하위단계를 종료한다.

      4. Resolve promise with instanceObject.

7. promise를 반환한다.

모듈의 프로미스를 인스턴스화 promiseOfModule를 imports importObject와 함께 수행하려면, 다음 단계를 따른다:

1. promise를 새로운 프로미스로 둔다.

2. React to promiseOfModule:

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

     1. WebAssembly 모듈 인스턴스화를 module에 대해, importObject를 import하여 수행하고, 결과를 innerPromise로 둔다.

     2. React to innerPromise:

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

          1. result를 WebAssemblyInstantiatedSource 값 «[ "module" → module, "instance" → instance ]»로 둔다.

          2. Resolve promise with result.

        • innerPromise가 이유 reason으로 거부되었다면:

          1. Reject promise with reason.

   • promiseOfModule가 이유 reason으로 거부되었다면:

     1. Reject promise with reason.

3. promise를 반환한다.

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

1. stableBytes를 버퍼가 보유한 바이트의 복사본 bytes로 둔다.

2. WebAssembly 모듈을 비동기적으로 컴파일하여 stableBytes와 options를 사용하고, 결과를 promiseOfModule로 둔다.

3. Instantiate promiseOfModule를 imports importObject와 함께 수행하고 그 결과를 반환한다.

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

1. WebAssembly 모듈을 비동기적으로 인스턴스화 moduleObject를 importObject를 import하여 수행하고, 그 결과를 반환한다.

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

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

typedef any AddressValue;

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

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

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

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

• "function" — type이 func functype 형태인 경우

• "table" — type이 table tabletype 형태인 경우

• "memory" — type이 mem memtype 형태인 경우

• "global" — type이 global globaltype 형태인 경우

• "tag" — type이 tag tag 형태인 경우

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

1. module를 moduleObject.[[Module]]로 둔다.

2. exports를 « »로 둔다.

3. For each (name, type) ∈ module_exports(module)에 대해,

   1. kind를 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. For each (moduleName, name, type) ∈ module_imports(module)에 대해,

   1. (moduleName, name, type) 및 builtinSetNames에 대해 find a builtin 결과가 null이 아니면, continue.

   2. importedStringModule이 null이 아니고 moduleName이 importedStringModule과 같으면, continue.

   3. kind를 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. For each custom section customSection ∈ bytes에 대해, module grammar에 따라 해석한다,

   1. name를 customSection의 name을 UTF-8로 디코딩한 값으로 둔다.

   2. Assert: name은 failure가 아니다 (moduleObject.[[Module]]은 valid이다).

   3. name이 문자열 값으로 sectionName과 같다면,

      1. Append — 이 customsec production이 매치한 범위의 bytes 바이트를 복사해 담은 새로운 ArrayBuffer를 customSections에 추가한다.

4. customSections를 반환한다.

Module(bytes, options) 생성자는, 호출되면 다음 단계를 수행한다:

1. stableBytes를 버퍼가 보유한 바이트의 복사본 bytes로 둔다.

2. WebAssembly 모듈을 컴파일하여 stableBytes의 결과를 module로 저장한다.

3. module이 error라면, CompileError 예외를 던진다.

4. builtinSetNames를 options["builtins"]로 둔다.

5. importedStringModule를 options["importedStringConstants"]로 둔다.

6. builtins 및 import된 문자열 검증이 module, builtinSetNames, importedStringModule에 대해 false를 반환하면, CompileError 예외를 던진다.

7. this.[[Module]]를 module로 설정한다.

8. this.[[Bytes]]를 stableBytes로 설정한다.

9. this.[[BuiltinSets]]를 builtinSetNames로 설정한다.

10. this.[[ImportedStringModule]]를 importedStringModule로 설정한다.

Note: 일부 구현은 bytes에 크기 제한을 적용한다. 비동기 API 사용을 권장하며, 이 API 사용은 지양된다.

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

Instance(module, importObject) 생성자는, 호출되면 다음 단계를 수행한다:

1. module를 module.[[Module]]로 둔다.

2. builtinSetNames를 module.[[BuiltinSets]]로 둔다.

3. importedStringModule를 module.[[ImportedStringModule]]로 둔다.

4. Read the imports를 module에 대해, imports importObject, builtinSetNames, importedStringModule로 수행하고, 결과를 imports로 둔다.

5. WebAssembly 모듈의 코어 인스턴스화를 module과 imports로 수행하고, 결과를 instance로 둔다.

6. Initialize를 통해 this를 module과 instance로부터 초기화한다.

Note: 일부 구현은 인스턴스화 시 장시간 컴파일 작업을 수행할 수 있으므로, 이 동기 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;
};

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

1. block를 Data Block으로 두되, 이는 identified with를 통해 memaddr의 기반 메모리와 연결된다.

2. buffer를 새로운 ArrayBuffer로 두고, 내부 슬롯 [[ArrayBufferData]], [[ArrayBufferByteLength]], [[ArrayBufferDetachKey]]를 갖도록 한다.

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

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

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

6. buffer를 반환한다.

memory address memaddr와 maxsize로부터 리사이즈 가능한 메모리 버퍼를 생성하려면, 다음 단계를 수행한다:

1. block를 Data Block으로 두되, 이는 identified with를 통해 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를 반환한다.

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

1. map을 surrounding agent에 연계된 Memory object cache로 둔다.

2. Assert: map[memaddr]는 exist하지 않는다.

3. buffer를 고정 길이 메모리 버퍼 생성을 memaddr로 수행한 결과로 둔다.

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

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

6. Set map[memaddr] = memory.

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

1. map을 surrounding agent에 연계된 Memory object cache로 둔다.

2. map[memaddr]가 exists이면,

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

3. memory를 new Memory로 둔다.

4. Initialize memory from memaddr.

5. memory를 반환한다.

Memory(descriptor) 생성자는, 호출되면 다음 단계를 수행한다:

1. descriptor["address"]가 exists이면 addrtype을 descriptor["address"]로, 그렇지 않으면 addrtype을 "i32"로 둔다.

2. initial을 ? AddressValueToU64(descriptor["initial"], addrtype)로 둔다.

3. descriptor["maximum"]이 exists이면 maximum을 ? AddressValueToU64(descriptor["maximum"], addrtype)로, 그렇지 않으면 maximum을 empty로 둔다.

4. memtype을 memory type addrtype { min initial, max maximum }로 둔다.

5. memtype이 valid가 아니면, RangeError 예외를 던진다.

6. store를 surrounding agent의 associated store로 둔다.

7. (store, memaddr)를 mem_alloc(store, memtype)으로 둔다. 할당이 실패하면 RangeError 예외를 던진다.

8. surrounding agent의 associated store를 store로 설정한다.

9. Initialize this from memaddr.

memaddr의 Memory 버퍼를 새로고침하려면, 다음 단계를 수행한다:

1. map을 surrounding agent에 연계된 Memory object cache로 둔다.

2. Assert: map[memaddr]가 exists이다.

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으로 두되, 이는 identified with를 통해 memaddr의 기반 메모리와 연결된다.

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

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

memory address memaddr에 연결된 메모리 버퍼를 delta만큼 확장하려면, 다음 단계를 수행한다:

1. store를 surrounding agent의 associated store로 둔다.

2. ret를 mem_size(store, memaddr)로 둔다.

3. store를 mem_grow(store, memaddr, delta)로 둔다.

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

5. surrounding agent의 associated store를 store로 설정한다.

6. Refresh the memory buffer를 memaddr에 대해 수행한다.

7. ret를 반환한다.

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

1. memaddr를 this.[[Memory]]로 둔다.

2. store를 surrounding agent의 associated store로 둔다.

3. addrtype를 address type in mem_type(store, memaddr)로 둔다.

4. delta64를 ? AddressValueToU64(delta, addrtype)로 둔다.

5. ret를 메모리 버퍼 확장을 memaddr에 대해 delta64만큼 수행한 결과로 둔다.

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

1. 스택의 최상단이 i32.const (−1)이 아니라면,

   1. frame을 current frame으로 둔다.

   2. Assert: 검증에 의해, frame.module.memaddrs[0]가 존재한다.

   3. memaddr를 메모리 주소 frame.module.memaddrs[0]로 둔다.

   4. Refresh the memory buffer를 memaddr에 대해 수행한다.

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

1. buffer를 this.[[BufferObject]]로 둔다.

2. IsFixedLengthArrayBuffer(buffer)가 true이면, buffer를 반환한다.

3. memaddr를 this.[[Memory]]로 둔다.

4. fixedBuffer를 고정 길이 메모리 버퍼 생성을 memaddr로 수행한 결과로 둔다.

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

6. this.[[BufferObject]]를 fixedBuffer로 설정한다.

7. fixedBuffer를 반환한다.

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

1. memaddr를 this.[[Memory]]로 둔다.

2. store를 surrounding agent의 associated store로 둔다.

3. memtype을 mem_type(store, memaddr)로 둔다.

4. memtype에 max가 없으면,

   1. Throw TypeError 예외.

5. buffer를 this.[[BufferObject]]로 둔다.

6. IsFixedLengthArrayBuffer(buffer)가 false이면, buffer를 반환한다.

7. Assert: memtype은 max를 가진다.

8. maxsize를 memtype의 max 값 * 65536으로 둔다.

9. resizableBuffer를 리사이즈 가능한 메모리 버퍼 생성을 memaddr과 maxsize로 수행한 결과로 둔다.

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

11. this.[[BufferObject]]를 resizableBuffer로 설정한다.

12. resizableBuffer를 반환한다.

추상 연산 HostResizeArrayBuffer는 인수 buffer ( ArrayBuffer) 와 newLength를 받고, 호출 시 다음 단계를 수행한다.

1. buffer.[[ArrayBufferDetachKey]]가 "WebAssembly.Memory"라면,

   1. map을 surrounding agent에 연계된 Memory object cache로 둔다.

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

   3. For each memaddr → mem ∈ map,

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

         1. Assert: buffer.[[ArrayBufferByteLength]] mod 65536 == 0.

         2. lengthDelta를 newLength - buffer.[[ArrayBufferByteLength]]로 둔다.

         3. lengthDelta < 0 이거나 lengthDelta mod 65536 != 0 이면,

            1. RangeError 예외를 던진다.

         4. delta를 lengthDelta ÷ 65536으로 둔다.

         5. Grow the memory buffer — memaddr에 연결된 버퍼를 delta만큼 확장한다.

   4. handled를 반환한다.

2. 그 외의 경우, unhandled를 반환한다.

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

enum TableKind {
  "externref",
  "anyfunc",
  // Note: More values may be added in future iterations,
  // e.g., 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;
};

테이블 객체 초기화를 table address tableaddr로부터 table에 대해 수행하려면, 다음 단계를 따른다:

1. map을 주변 에이전트에 연계된 Table object cache로 둔다.

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

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

4. Set map[tableaddr] = table.

table address tableaddr로부터 테이블 객체 생성을 수행하려면, 다음 단계를 따른다:

1. map을 주변 에이전트에 연계된 Table object cache로 둔다.

2. map[tableaddr]가 exists이면,

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

3. table를 new Table로 둔다.

4. Initialize를 실행하여 tableaddr로부터 table을 초기화한다.

5. table를 반환한다.

Table(descriptor, value) 생성자는, 호출되면 다음 단계를 수행한다:

1. elementtype를 ToValueType(descriptor["element"])로 둔다.

2. elementtype이 reftype이 아니면,

   1. Throw TypeError 예외.

3. descriptor["address"]가 exists이면 addrtype을 그 값으로, 그렇지 않으면 addrtype을 "i32"로 둔다.

4. initial을 ? AddressValueToU64(descriptor["initial"], addrtype)로 둔다.

5. descriptor["maximum"]이 exists이면 maximum을 ? AddressValueToU64(descriptor["maximum"], addrtype)로, 그렇지 않으면 maximum을 empty로 둔다.

6. type을 table type addrtype { min initial, max maximum } elementType로 둔다.

7. type이 valid가 아니면, RangeError 예외를 던진다.

8. value가 제공되지 않았다면,

   1. ref를 DefaultValue(elementtype)로 둔다.

   2. Assert: ref는 error가 아니다.

9. 그 외의 경우,

   1. ref를 ? ToWebAssemblyValue(value, elementType)로 둔다.

10. store를 주변 에이전트의 associated store로 둔다.

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

12. 주변 에이전트의 associated store를 store로 설정한다.

13. Initialize를 통해 tableaddr로부터 this를 초기화한다.

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

1. tableaddr를 this.[[Table]]로 둔다.

2. store를 주변 에이전트의 associated store로 둔다.

3. initialSize를 table_size(store, tableaddr)로 둔다.

4. (addrtype, limits, elementtype)을 table_type(store, tableaddr)로 둔다.

5. delta64를 ? AddressValueToU64(delta, addrtype)로 둔다.

6. value가 제공되지 않았다면,

   1. ref를 DefaultValue(elementtype)로 둔다.

   2. ref가 error이면, TypeError 예외를 던진다.

7. 그 외의 경우,

   1. ref를 ? ToWebAssemblyValue(value, elementtype)로 둔다.

8. result를 table_grow(store, tableaddr, delta64, ref)로 둔다.

9. result가 error이면, RangeError 예외를 던진다.

   참고: 위 예외는 메모리 부족 또는 잘못된 크기 매개변수로 인해 발생할 수 있다.

10. 주변 에이전트의 associated store를 result로 설정한다.

11. initialSize를 반환한다.

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

1. tableaddr를 this.[[Table]]로 둔다.

2. store를 주변 에이전트의 associated store로 둔다.

3. addrtype을 address type in table_type(store, tableaddr)로 둔다.

4. length64를 table_size(store, tableaddr)로 둔다.

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

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

1. tableaddr를 this.[[Table]]로 둔다.

2. store를 주변 에이전트의 associated store로 둔다.

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를 주변 에이전트의 associated store로 둔다.

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. 주변 에이전트의 associated store를 store로 설정한다.

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

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

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

global address globaladdr로부터 global 글로벌 객체를 초기화하려면, 다음 단계를 따른다:

1. map을 주변 에이전트에 연계된 Global object cache로 둔다.

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

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

4. Set map[globaladdr] = global.

global address globaladdr로부터 글로벌 객체 생성을 수행하려면, 다음 단계를 따른다:

1. map을 주변 에이전트에 연계된 Global object cache로 둔다.

2. map[globaladdr]가 exists이면,

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

3. global을 new Global로 둔다.

4. Initialize를 실행하여 globaladdr로부터 global을 초기화한다.

5. global을 반환한다.

알고리즘 ToValueType(s)은 다음 단계를 수행한다:

1. s가 "i32"와 같으면, i32를 반환한다.

2. s가 "i64"와 같으면, i64를 반환한다.

3. s가 "f32"와 같으면, f32를 반환한다.

4. s가 "f64"와 같으면, f64를 반환한다.

5. s가 "v128"과 같으면, v128을 반환한다.

6. s가 "anyfunc"과 같으면, funcref를 반환한다.

7. s가 "externref"와 같으면, externref를 반환한다.

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

알고리즘 DefaultValue(valuetype)는 다음 단계를 수행한다:

1. valuetype이 externref와 같으면, ToWebAssemblyValue(undefined, valuetype)를 반환한다.

2. val_default(valuetype)를 반환한다.

Global(descriptor, v) 생성자는, 호출되면 다음 단계를 수행한다:

1. mutable을 descriptor["mutable"]로 둔다.

2. valuetype을 ToValueType(descriptor["value"])로 둔다.

3. valuetype이 matches v128 또는 exnref이면,

   1. TypeError 예외를 던진다.

4. v가 제공되지 않았다면,

   1. value를 DefaultValue(valuetype)로 둔다.

   2. Assert: value는 error가 아니다.

5. 그 외의 경우,

   1. value를 ToWebAssemblyValue(v, valuetype)로 둔다.

6. mutable이 true이면 globaltype을 var valuetype으로, 그렇지 않으면 globaltype을 const valuetype으로 둔다.

7. store를 현재 에이전트의 associated store로 둔다.

8. (store, globaladdr)를 global_alloc(store, globaltype, value)로 둔다.

9. 현재 에이전트의 associated store를 store로 설정한다.

10. Initialize를 통해 globaladdr로부터 this를 초기화한다.

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

1. store를 현재 에이전트의 associated store로 둔다.

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를 현재 에이전트의 연결된 저장소로 둔다.

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. 현재 에이전트의 연결된 저장소를 store로 설정한다.

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

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

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

1. store를 주변 에이전트의 연결된 저장소로 둔다.

2. funcinst를 store.funcs[funcaddr]로 둔다.

3. funcinst가 {type functype, hostcode hostfunc} 형태라면,

   1. Assert: hostfunc는 JavaScript 객체이며 IsCallable(hostfunc)는 true이다.

   2. index를 호스트 함수의 인덱스 funcaddr로 둔다.

4. 그 밖의 경우,

   1. moduleinst를 funcinst.module로 둔다.

   2. Assert: funcaddr는 moduleinst.funcaddrs에 포함되어 있다.

   3. index를 moduleinst.funcaddrs에서 funcaddr가 발견되는 인덱스로 둔다.

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

WebAssembly function address funcaddr로부터 새로운 Exported Function을 생성하려면, 다음 단계를 수행한다:

1. map을 주변 에이전트에 연계된 Exported Function 캐시로 둔다.

2. map[funcaddr]가 exists이면,

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

3. steps를 "Exported Function 호출 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. Set map[funcaddr] = function.

13. function을 반환한다.

function address funcaddr와 JavaScript 인수의 리스트 argValues로 Exported Function을 호출하려면, 다음 단계를 수행한다:

1. store를 주변 에이전트의 연결된 저장소로 둔다.

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 ∈ parameters에 대해,

   1. argValues의 크기 > i이면, arg를 argValues[i]로 둔다.

   2. 그렇지 않으면, arg를 undefined로 둔다.

   3. Append ToWebAssemblyValue(arg, t) → args.

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

8. (store, ret)를 func_invoke(store, funcaddr, args)의 결과로 둔다.

9. 주변 에이전트의 연결된 저장소를 store로 설정한다.

10. ret이 error이면, 예외를 던진다. 이 예외는 WebAssembly 오류 매핑에 달리 명시되지 않는 한 WebAssembly RuntimeError 예외여야 한다.

11. ret이 THROW ref.exn exnaddr라면,

    1. tagaddr를 exn_tag(store, exnaddr)로 둔다.

    2. payload를 exn_read(store, exnaddr)로 둔다.

    3. jsTagAddr를 JavaScript 예외 태그 가져오기의 결과로 둔다.

    4. tagaddr가 jsTagAddr와 같다면,

       1. 호스트 값 조회를 payload[0]에 대해 수행한 결과를 던진다.

    5. 그 외의 경우,

       1. exception을 새로운 Exception으로, exnaddr로부터 생성한다.

       2. exception을 던진다.

12. outArity를 크기 ret로 둔다.

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

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

15. 그 외의 경우,

    1. values를 « »로 둔다.

    2. 각 r ∈ ret에 대해,

       1. Append ToJSValue(r) → values.

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

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

1. [parameters] → [results]를 functype으로 둔다.

2. parameters 또는 results의 어떤 타입이라도 matches v128 또는 exnref이면, TypeError를 던진다.

3. jsArguments를 « »로 둔다.

4. 각 arg ∈ arguments에 대해,

   1. Append ! 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이면, throw TypeError.

   3. values를 ? IteratorToList(? GetIteratorFromMethod(ret, method))로 둔다.

   4. wasmValues를 새로운 빈 리스트로 둔다.

   5. values의 크기가 resultsSize와 다르면, TypeError 예외를 던진다.

   6. values와 results의 각 value, resultType을 선형으로 짝지어,

      1. Append ToWebAssemblyValue(value, resultType) → wasmValues.

   7. wasmValues를 반환한다.

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

1. Assert: IsCallable(func).

2. stored settings를 incumbent settings object로 둔다.

3. 다음 단계를 인수 arguments와 함께 호출될 때 수행하는 호스트 함수 hostfunc를 둔다:

   1. realm을 func의 associated 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. Assert: result.[[Type]]은 throw 또는 normal이다.

   9. store를 주변 에이전트의 연결된 저장소로 둔다.

   10. result.[[Type]]이 throw라면:

       1. v를 result.[[Value]]로 둔다.

       2. v가 implements Exception이면,

          1. address를 v.[[Address]]로 둔다.

       3. 그 외의 경우,

          1. type을 JavaScript 예외 태그 가져오기의 결과로 둔다.

          2. payload를 ! ToWebAssemblyValue(v, externref)로 둔다.

          3. (store, address)를 exn_alloc(store, type, « payload »)으로 둔다.

          4. 주변 에이전트의 연결된 저장소를 store로 설정한다.

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

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

4. (store, funcaddr)를 func_alloc(store, functype, hostfunc)으로 둔다.

5. 주변 에이전트의 연결된 저장소를 store로 설정한다.

6. funcaddr를 반환한다.

알고리즘 ToJSValue(w)는 다음 단계를 수행하여 WebAssembly 값을 JavaScript 값으로 변환한다:

1. Assert: w는 v128.const v128 형태가 아니다.

2. Assert: w는 ref.exn exnaddr 형태가 아니다.

3. w가 i64.const u64 형태이면,

   1. i64를 signed_64(u64)로 둔다.

   2. ℤ(i64를 수학적 값으로 해석한 값)을 반환한다.

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 형태이면, a new Exported GC Object를 structaddr와 "struct"로부터 생성한 결과를 반환한다.

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

11. w가 ref.func funcaddr 형태이면, a new Exported Function을 funcaddr로부터 생성한 결과를 반환한다.

12. w가 ref.host hostaddr 형태이면, 호스트 값 조회를 hostaddr에 대해 수행한 결과를 반환한다.

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

참고: NaN과 같은 숫자 값은 관찰 가능한 다양한 NaN 페이로드를 가질 수 있다. 자세한 내용은 NumericToRawBytes를 참조하라.

host address hostaddr로부터 호스트 값 조회를 수행하려면, 다음 단계를 따른다:

1. map을 주변 에이전트에 연계된 host value cache로 둔다.

2. Assert: map[hostaddr]가 exists이다.

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

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

1. Assert: type은 v128이 아니다.

2. Assert: type은 match exnref가 아니다.

3. type이 i64이면,

   1. i64를 ? ToBigInt64(v)로 둔다.

   2. u64를 부호 없는 정수로 두되, i64가 signed_64(u64)인 것과 같도록 한다.

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

4. type이 i32이면,

   1. i32를 ? ToInt32(v)로 둔다.

   2. u32를 부호 없는 정수로 두되, i32가 signed_32(u32)인 것과 같도록 한다.

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

5. type이 f32이면,

   1. number를 ? ToNumber(v)로 둔다.

   2. number가 NaN이면,

      1. n을 구현 정의된 정수로 두되, canon₃₂ ≤ n < 2^signif(32)를 만족하도록 한다.

      2. f32를 nan(n)으로 둔다.

   3. 그 밖의 경우,

      1. f32를 IEEE 754-2019 반올림 규칙(최근접, 동가일 경우 짝수)으로 표현 가능한 가장 가까운 값으로 반올림한 number로 둔다. [IEEE-754]

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

6. type이 f64이면,

   1. number를 ? ToNumber(v)로 둔다.

   2. number가 NaN이면,

      1. n을 구현 정의된 정수로 두되, canon₆₄ ≤ n < 2^signif(64)를 만족하도록 한다.

      2. f64를 nan(n)으로 둔다.

   3. 그 밖의 경우,

      1. f64를 number로 둔다.

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

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

   1. v가 null이면,

      1. r를 ref.null heaptype으로 둔다.

   2. 그렇지 않고 match_valtype(type, ref null extern)이면,

      1. ref를 ToWebAssemblyValue(v, ref any)로 둔다.

      2. r를 ref.extern ref로 둔다.

   3. 그렇지 않고 v가 Exported Function이며 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(i31)인 것과 같도록 한다.

      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을 주변 에이전트에 연계된 host value cache로 둔다.

      2. 어떤 host address hostaddr가 존재하여 map[hostaddr]가 v와 동일하다면,

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

      3. host address hostaddr를 map[hostaddr] exists가 false인 가장 작은 주소로 둔다.

      4. Set 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. Assert: 이 단계에는 도달하지 않는다.

알고리즘 AddressValueToU64(v, addrtype)는 JavaScript 값을 임베딩 연산에서 사용할 WebAssembly u64로 변환한다. 이는 [EnforceRange] unsigned long의 동작을 AddressType "i32"에 대해 모사하고, 이를 AddressType "i64"로 확장한다. 다음 단계를 수행한다:

1. addrtype이 "i32"이면,

   1. n을 ? ConvertToInt(v, 32, "unsigned")로 두되, 대상 타입은 [EnforceRange]에 연계된다.

      참고: 이는 JS 변환 규칙 중 [EnforceRange] unsigned long과 동일하다.

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

2. addrtype이 "i64"이면,

   1. n을 ? ToBigInt(v)로 둔다.

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

      참고: 이 연산은 [EnforceRange]를 모사하도록 설계되었다.

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

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

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

1. addrtype이 "i32"이면, 𝔽(v를 수학적 값으로 해석한 값)를 반환한다.

2. 그렇지 않고 addrtype이 "i64"이면, ℤ(v를 수학적 값으로 해석한 값)를 반환한다.

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

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

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

tag address tagAddress로부터 tag Tag 객체 초기화를 수행하려면, 다음 단계를 따른다:

1. map을 주변 에이전트에 연계된 Tag object cache로 둔다.

2. Assert: map[tagAddress]는 exist하지 않는다.

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

4. Set map[tagAddress] = tag.

tag address tagAddress로부터 Tag 객체 생성을 수행하려면, 다음 단계를 따른다:

1. map을 주변 에이전트에 연계된 Tag object cache로 둔다.

2. map[tagAddress]가 exists이면,

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

3. tag를 new Tag로 둔다.

4. Initialize tag from tagAddress.

5. tag를 반환한다.

new Tag(type) 생성자 단계는 다음과 같다:

1. parameters를 type["parameters"]로 둔다.

2. wasmParameters를 «»로 둔다.

3. 각 type ∈ parameters에 대해,

   1. Append ToValueType(type) → wasmParameters.

4. store를 현재 에이전트의 연결된 저장소로 둔다.

5. (store, tagAddress)를 tag_alloc(store, wasmParameters)로 둔다.

6. 현재 에이전트의 연결된 저장소를 store로 설정한다.

7. Initialize this from tagAddress.

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

1. null을 반환한다.

Exported GC Object의 [[SetPrototypeOf]] 내부 메서드 O는 인수 V(객체 또는 null)를 받아 불리언을 반환한다. 호출 시 다음 단계를 수행한다:

1. false를 반환한다.

Exported GC Object의 [[IsExtensible]] 내부 메서드 O는 인수를 받지 않으며 불리언을 반환한다. 호출 시 다음 단계를 수행한다:

1. false를 반환한다.

Exported GC Object의 [[PreventExtensions]] 내부 메서드 O는 인수를 받지 않으며 불리언을 반환한다. 호출 시 다음 단계를 수행한다:

1. false를 반환한다.

Exported GC Object의 [[GetOwnProperty]] 내부 메서드 O는 인수 P(프로퍼티 키)를 받아 undefined를 반환한다. 호출 시 다음 단계를 수행한다:

1. undefined를 반환한다.

Exported GC Object의 [[DefineOwnProperty]] 내부 메서드 O는 인수 P(프로퍼티 키)와 Desc(프로퍼티 서술자)를 받아 불리언을 반환한다. 호출 시 다음 단계를 수행한다:

1. false를 반환한다.

Exported GC Object의 [[HasProperty]] 내부 메서드 O는 인수 P(프로퍼티 키)를 받아 불리언을 반환한다. 호출 시 다음 단계를 수행한다:

1. false를 반환한다.

Exported GC Object의 [[Get]] 내부 메서드 O는 인수 P(프로퍼티 키), Receiver(ECMAScript 언어 값)를 받아 undefined를 반환한다. 호출 시 다음 단계를 수행한다:

1. undefined를 반환한다.

Exported GC Object의 [[Set]] 내부 메서드 O는 인수 P(프로퍼티 키), V(ECMAScript 언어 값), Receiver(ECMAScript 언어 값)를 받아 예외를 던진다. 호출 시 다음 단계를 수행한다:

1. TypeError를 던진다.

Exported GC Object의 [[Delete]] 내부 메서드 O는 인수 P(프로퍼티 키)를 받아 예외를 던진다. 호출 시 다음 단계를 수행한다:

1. TypeError를 던진다.

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

1. keys를 새로운 빈 리스트로 둔다.

2. keys를 반환한다.

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

1. Assert: objectkind는 "array" 또는 "struct"이다.

2. map을 주변 에이전트에 연계된 exported GC object cache로 둔다.

3. map[objectaddr]가 exists이면,

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

4. object를 MakeBasicObject(« [[ObjectAddress]] »)로 둔다.

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([EnforceRange] unsigned long index);
  boolean is(Tag exceptionTag);
  readonly attribute (DOMString or undefined) stack;
};

Exception 객체를 초기화하여 exn을 Exception address exnAddress로부터 생성하려면, 다음 단계를 수행한다:

1. map을 주변 에이전트에 연계된 Exception object cache로 둔다.

2. Assert: map[exnAddress]는 exist하지 않는다.

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

4. Set 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로 설정한다.

Exception 객체를 생성하기 위해 exception address exnAddress로부터 다음 단계를 수행한다:

1. map을 주변 에이전트에 연계된 Exception object cache로 둔다.

2. map[exnAddress]가 exists이면,

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

3. exn을 new Exception으로 둔다.

4. Initialize exn from 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. 각 value 및 resultType을 payload와 types에서 선형으로 짝지어,

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

      1. TypeError를 던진다.

   2. Append ? ToWebAssemblyValue(value, resultType) → wasmPayload.

8. (store, exceptionAddr)를 exn_alloc(store, exceptionTag.[[Address]], wasmPayload)로 둔다.

9. 주변 에이전트의 연결된 저장소를 store로 설정한다.

10. Initialize this from exceptionAddr.

11. options["traceStack"]이 true이면,

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

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

1. store를 주변 에이전트의 연결된 저장소로 둔다.

2. tagaddr를 exn_tag(store, this.[[Address]])로 둔다.

3. payload를 exn_read(store, this.[[Address]])로 둔다.

4. Assert: tagaddr는 this.[[Type]]과 같다.

5. index ≥ payload의 크기이면,

   1. RangeError를 던진다.

6. [types] → []를 tag_type(store, tagaddr)로 둔다.

7. types[index]이 matches v128 또는 exnref이면,

   1. TypeError를 던진다.

8. ToJSValue(payload[index])를 반환한다.

is(exceptionTag) 메서드 단계는 다음과 같다:

1. this.[[Type]]이 exceptionTag.[[Address]]와 같지 않으면,

   1. false를 반환한다.

2. true를 반환한다.

stack getter 단계는 다음과 같다:

1. this.[[Stack]]을 반환한다.

JavaScript 예외 태그를 가져오기 위해 다음 단계를 수행한다:

1. 주변 에이전트에 연계된 JavaScript exception tag가 초기화되어 있다면,

   1. return the surrounding agent’s associated JavaScript exception tag

2. store를 주변 에이전트의 연결된 저장소로 둔다.

3. (store, tagAddress)를 tag_alloc(store, « externref » → « »)로 둔다.

4. 현재 에이전트의 연결된 저장소를 store로 설정한다.

5. 현재 에이전트에 연계된 JavaScript exception tag를 tagAddress로 설정한다.

6. return tagAddress.

WebAssembly 네임스페이스에 대한 네임스페이스 객체가 생성될 때, 다음 단계를 수행해야 한다:

1. namespaceObject를 네임스페이스 객체로 둔다.

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

   1. constructor를 새로운 객체로 두되, 이는 NativeError 객체 구조를 구현하고, NativeError를 error로 설정한다.

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

builtinSetName에 대한 내장 함수 집합의 함수들을 가져오려면, 다음 단계를 수행한다:

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

import와 활성화된 내장 집합 builtinSetNames에 대해 내장 함수를 찾으려면, 다음 단계를 수행한다:

1. Assert: validate builtin set names builtinSetNames는 true이다.

2. importModuleName을 import[0]으로 둔다.

3. importName을 import[1]로 둔다.

4. 각 builtinSetName ∈ builtinSetNames에 대해,

   1. builtinSetName이 내장 함수 집합을 가리키지 않으면, continue.

   2. builtinSetQualifiedName을 "wasm:"이 접두사로 붙은 builtinSetName으로 둔다.

   3. importModuleName이 builtinSetQualifiedName과 같다면,

      1. builtins를 get the builtins for a builtin set builtinSetName의 결과로 둔다.

      2. 각 builtin ∈ builtins에 대해,

         1. builtinName을 builtin[0]으로 둔다.

         2. importName이 builtinName과 같다면, (builtinSetName, builtin)을 반환한다.

5. null을 반환한다.

builtinSetNames에 대해 내장 집합 이름을 검증하려면, 다음 단계를 수행한다:

1. builtinSetNames에 중복이 하나라도 있으면, false를 반환한다.

2. true를 반환한다.

타입 funcType과 실행 단계 steps로부터 내장 함수를 생성하려면, 다음 단계를 수행한다:

1. hostfunc를 호출 시 steps를 실행하는 호스트 함수로 둔다.

2. (store, funcaddr)를 func_alloc(store, functype, hostfunc)로 둔다.

3. 주변 에이전트의 연결된 저장소를 store로 설정한다.

4. funcaddr를 반환한다.

이름이 builtinSetName인 내장 집합을 인스턴스화하려면, 다음 단계를 수행한다:

1. builtins를 get the builtins for a builtin set builtinSetName의 결과로 둔다.

2. exportsObject를 ! OrdinaryObjectCreate(null)로 둔다.

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

   1. funcaddr를 create a builtin function (funcType, steps)의 결과로 둔다.

   2. func를 a new Exported Function을 funcaddr로부터 생성한 결과로 둔다.

   3. value를 func로 둔다.

   4. status를 ! CreateDataProperty(exportsObject, name, value)로 둔다.

   5. Assert: status는 true이다.

4. exportsObject를 반환한다.

import와 활성화된 내장 집합 builtinSetNames에 대해 내장 함수용 import를 검증하려면, 다음 단계를 수행한다:

1. Assert: validate builtin set names builtinSetNames는 true이다.

2. maybeBuiltin을 find a builtin(import, builtinSetNames)의 결과로 둔다.

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

4. importExternType을 import[2]로 둔다.

5. builtinFuncType을 maybeBuiltin[0][1]로 둔다.

6. builtinExternType을 func |builtinFuncType|로 둔다.

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

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

1. v가 String이 아니면,

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

2. v를 반환한다

FromCharCode(v) 추상 연산은 호출 시 다음 단계를 수행한다:

1. Assert: v는 i32 타입이다.

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

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

1. Assert: index는 i32 타입이다.

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

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

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

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

1. v가 String이 아니면,

   1. 0을 반환한다.

2. 1을 반환한다.

이 빌트인이 매개변수 array, start, end로 호출되면, 다음 단계를 수행해야 한다:

1. array가 null이면,

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

2. length를 array의 요소 개수로 둔다.

3. start > end 또는 end > length이면,

   1. trap이 실행된 것처럼 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. trap이 실행된 것처럼 RuntimeError 예외를 던진다.

2. string을 ? UnwrapString(string)으로 둔다.

3. stringLength를 length(string)로 둔다.

4. arrayLength를 array의 요소 개수로 둔다.

5. start + stringLength > arrayLength이면,

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

6. i를 0으로 둔다.

7. i < stringLength인 동안:

   1. charCode를 CharCodeAt(string, i)로 둔다.

   2. array의 인덱스 start + i에 저장된 요소를 ToWebAssemblyValue(charCode)로 설정한다.

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

8. stringLength를 반환한다.

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

1. FromCharCode(v)를 반환한다.

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

1. v > 0x10ffff이면,

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

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

이 빌트인이 매개변수 string 및 index로 호출되면, 다음 단계를 수행해야 한다:

1. string을 ? UnwrapString(string)으로 둔다.

2. length를 length(string)로 둔다.

3. index ≥ length이면,

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

4. CharCodeAt(string, index)를 반환한다.

이 빌트인이 매개변수 string 및 index로 호출되면, 다음 단계를 수행해야 한다:

1. string을 ? UnwrapString(string)으로 둔다.

2. length를 length(string)로 둔다.

3. index ≥ length이면,

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

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

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

1. string을 ? UnwrapString(v)으로 둔다.

2. string의 length를 반환한다.

이 빌트인이 매개변수 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를 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. trap이 실행된 것처럼 RuntimeError 예외를 던진다.

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

   1. trap이 실행된 것처럼 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을 반환한다.