16 ECMAScript 언어: 스크립트와 모듈

16.1 스크립트

구문

Script : ScriptBodyopt ScriptBody : StatementList[~Yield, ~Await, ~Return]

16.1.1 Static Semantics: 조기 오류

Script : ScriptBody ScriptBody : StatementList

16.1.2 Static Semantics: ScriptIsStrict

The syntax-directed operation ScriptIsStrict takes no arguments and returns 불리언. It is defined piecewise over the following productions:

Script : ScriptBodyopt
  1. ScriptBody가 존재하고 ScriptBody의 Directive Prologue가 Use Strict Directive를 포함하면, true를 반환한다.
  2. false를 반환한다.

16.1.3 Runtime Semantics: Evaluation

Script : [empty]
  1. undefined를 반환한다.

16.1.4 Script Records

Script Record는 평가 중인 스크립트에 대한 정보를 캡슐화한다. 각 script record는 Table 34에 나열된 필드를 포함한다.

Table 34: Script Record Fields
필드 이름 값 타입 의미
[[Realm]] Realm Record 이 스크립트가 생성된 realm.
[[ECMAScriptCode]] Script 파스 노드 이 스크립트의 소스 텍스트를 파싱한 결과.
[[LoadedModules]] LoadedModuleRequest Records의 List 이 스크립트가 import한 지정자 문자열에서 해석된 Module Record로의 맵. 이 list는 ModuleRequestsEqual(r1, r2)가 true인 서로 다른 Record r1과 r2를 포함하지 않는다.
[[HostDefined]] 아무 값(기본값은 empty) 스크립트와 추가 정보를 연결해야 하는 호스트 환경에서 사용하도록 예약된 필드.

16.1.5 ParseScript ( sourceText, realm, hostDefined )

The abstract operation ParseScript takes arguments sourceText (ECMAScript 소스 텍스트), realm (Realm Record), and hostDefined (아무 값) and returns Script Record 또는 비어 있지 않은 SyntaxError 객체들의 List. sourceText를 Script로 파싱한 결과에 기반하여 Script Record를 생성한다. It performs the following steps when called:

  1. script를 ParseText(sourceText, Script)로 둔다.
  2. script가 오류들의 List이면, script를 반환한다.
  3. Script Record { [[Realm]]: realm, [[ECMAScriptCode]]: script, [[LoadedModules]]: « », [[HostDefined]]: hostDefined }를 반환한다.
 Note

구현체는 해당 스크립트 소스 텍스트에 대해 ParseScript를 평가하기 전에 스크립트 소스 텍스트를 파싱하고 조기 오류 조건을 분석할 수 있다. 그러나 모든 오류 보고는 이 명세가 실제로 해당 소스 텍스트에 대해 ParseScript를 수행하는 시점까지 지연되어야 한다.

16.1.6 ScriptEvaluation ( scriptRecord )

The abstract operation ScriptEvaluation takes argument scriptRecord (Script Record) and returns ECMAScript 언어 값을 포함하는 정상 완료 또는 갑작스러운 완료. It performs the following steps when called:

  1. globalEnv를 scriptRecord.[[Realm]].[[GlobalEnv]]로 둔다.
  2. scriptContext를 새로운 ECMAScript 코드 실행 컨텍스트로 둔다.
  3. scriptContext의 Function을 null로 설정한다.
  4. scriptContext의 Realm을 scriptRecord.[[Realm]]으로 설정한다.
  5. scriptContext의 ScriptOrModule을 scriptRecord로 설정한다.
  6. scriptContext의 VariableEnvironment를 globalEnv로 설정한다.
  7. scriptContext의 LexicalEnvironment를 globalEnv로 설정한다.
  8. scriptContext의 PrivateEnvironment를 null로 설정한다.
  9. 실행 중인 실행 컨텍스트를 일시 중단한다.
  10. scriptContext를 실행 컨텍스트 스택에 푸시한다; scriptContext는 이제 실행 중인 실행 컨텍스트이다.
  11. script를 scriptRecord.[[ECMAScriptCode]]로 둔다.
  12. result를 Completion(GlobalDeclarationInstantiation(script, globalEnv))으로 둔다.
  13. result가 정상 완료이면,
    1. result를 Completion(script의 Evaluation)으로 설정한다.
    2. result가 정상 완료이고 result.[[Value]]가 empty이면,
      1. result를 NormalCompletion(undefined)으로 설정한다.
  14. scriptContext를 일시 중단하고 실행 컨텍스트 스택에서 제거한다.
  15. Assert: 실행 컨텍스트 스택은 비어 있지 않다.
  16. 이제 실행 컨텍스트 스택의 맨 위에 있는 컨텍스트를 실행 중인 실행 컨텍스트로 재개한다.
  17. ? result를 반환한다.

16.1.7 GlobalDeclarationInstantiation ( script, env )

The abstract operation GlobalDeclarationInstantiation takes arguments script (Script 파스 노드) and env (Global Environment Record) and returns unused를 포함하는 정상 완료 또는 던짐 완료. script는 실행 컨텍스트가 설정되는 Script이다. env는 바인딩이 생성될 전역 환경이다.

Note 1

스크립트를 평가하기 위해 실행 컨텍스트가 설정될 때, 선언은 현재 전역 환경에서 인스턴스화된다. 코드에서 선언된 각 전역 바인딩이 인스턴스화된다.

호출될 때 다음 단계를 수행한다:

  1. lexNames를 script의 LexicallyDeclaredNames로 둔다.
  2. varNames를 script의 VarDeclaredNames로 둔다.
  3. lexNames의 각 원소 name에 대해, 다음을 수행한다
    1. HasLexicalDeclaration(env, name)이 true이면, SyntaxError 예외를 던진다.
    2. hasRestrictedGlobal을 ? HasRestrictedGlobalProperty(env, name)로 둔다.
    3. NOTE: 전역 var와 function 바인딩(비엄격 직접 eval에 의해 도입된 것은 제외)은 구성 불가능하므로 제한된 전역 속성이다.
    4. hasRestrictedGlobal이 true이면, SyntaxError 예외를 던진다.
  4. varNames의 각 원소 name에 대해, 다음을 수행한다
    1. HasLexicalDeclaration(env, name)이 true이면, SyntaxError 예외를 던진다.
  5. varDeclarations를 script의 VarScopedDeclarations로 둔다.
  6. functionsToInitialize를 새로운 빈 List로 둔다.
  7. declaredFunctionNames를 새로운 빈 List로 둔다.
  8. varDeclarations의 각 원소 varDecl에 대해, List의 역순으로 다음을 수행한다
    1. varDecl이 VariableDeclaration, ForBinding, 또는 BindingIdentifier 중 하나가 아니면,
      1. Assert: varDecl은 FunctionDeclaration, GeneratorDeclaration, AsyncFunctionDeclaration, 또는 AsyncGeneratorDeclaration 중 하나이다.
      2. NOTE: 같은 이름에 대해 여러 함수 선언이 있으면, 마지막 선언이 사용된다.
      3. fn을 varDecl의 BoundNames의 유일한 원소로 둔다.
      4. declaredFunctionNames가 fn을 포함하지 않으면,
        1. fnDefinable을 ? CanDeclareGlobalFunction(env, fn)으로 둔다.
        2. fnDefinable이 false이면, TypeError 예외를 던진다.
        3. fn을 declaredFunctionNames에 추가한다.
        4. varDecl을 functionsToInitialize의 첫 번째 원소로 삽입한다.
  9. declaredVarNames를 새로운 빈 List로 둔다.
  10. varDeclarations의 각 원소 varDecl에 대해, 다음을 수행한다
    1. varDecl이 VariableDeclaration, ForBinding, 또는 BindingIdentifier 중 하나이면,
      1. varDecl의 BoundNames의 각 String vn에 대해, 다음을 수행한다
        1. declaredFunctionNames가 vn을 포함하지 않으면,
          1. vnDefinable을 ? CanDeclareGlobalVar(env, vn)로 둔다.
          2. vnDefinable이 false이면, TypeError 예외를 던진다.
          3. declaredVarNames가 vn을 포함하지 않으면,
            1. vn을 declaredVarNames에 추가한다.
  11. NOTE: 전역 객체가 일반 객체이면 이 알고리즘 단계 이후 비정상 종료는 발생하지 않는다. 그러나 전역 객체가 Proxy exotic 객체이면 다음 단계 중 일부에서 비정상 종료를 유발하는 동작을 보일 수 있다.
  12. Normative Optional
    호스트가 웹 브라우저이거나 달리 Block-Level Function Declaration 웹 Legacy 호환성 의미론를 지원하면,
    1. strict를 script의 ScriptIsStrict로 둔다.
    2. strict가 false이면,
      1. declaredFunctionOrVarNames를 declaredFunctionNames와 declaredVarNames의 list-concatenation으로 둔다.
      2. script Contains x가 true인 임의의 Block, CaseClause, 또는 DefaultClause x의 StatementList에 직접 포함된 각 FunctionDeclaration f에 대해, 다음을 수행한다
        1. funcName을 f의 BindingIdentifier의 StringValue로 둔다.
        2. FunctionDeclaration f를 BindingIdentifier로 funcName을 가진 VariableStatement로 대체해도 script에 대해 조기 오류가 발생하지 않으면,
          1. HasLexicalDeclaration(env, funcName)이 false이면,
            1. fnDefinable을 ? CanDeclareGlobalVar(env, funcName)로 둔다.
            2. fnDefinable이 true이면,
              1. NOTE: funcName에 대한 var 바인딩은 그것이 VarDeclaredName도 아니고 다른 FunctionDeclaration의 이름도 아닐 때만 여기서 인스턴스화된다.
              2. declaredFunctionOrVarNames가 funcName을 포함하지 않으면,
                1. ? CreateGlobalVarBinding(env, funcName, false)를 수행한다.
                2. funcName을 declaredFunctionOrVarNames에 추가한다.
              3. FunctionDeclaration f가 평가될 때, 15.2.6에 제공된 FunctionDeclaration Evaluation 알고리즘 대신 다음 단계를 수행한다:
                1. gEnv를 실행 중인 실행 컨텍스트의 VariableEnvironment로 둔다.
                2. bEnv를 실행 중인 실행 컨텍스트의 LexicalEnvironment로 둔다.
                3. fObj를 ! bEnv.GetBindingValue(funcName, false)로 둔다.
                4. ? gEnv.SetMutableBinding(funcName, fObj, false)를 수행한다.
                5. unused를 반환한다.
  13. lexDeclarations를 script의 LexicallyScopedDeclarations로 둔다.
  14. privateEnv를 null로 둔다.
  15. lexDeclarations의 각 원소 lexDecl에 대해, 다음을 수행한다
    1. NOTE: 렉시컬하게 선언된 이름은 여기서 인스턴스화만 되고 초기화되지는 않는다.
    2. lexDecl의 BoundNames의 각 원소 dn에 대해, 다음을 수행한다
      1. lexDecl의 IsConstantDeclaration이 true이면,
        1. ? env.CreateImmutableBinding(dn, true)를 수행한다.
      2. 그렇지 않으면,
        1. ? env.CreateMutableBinding(dn, false)를 수행한다.
  16. functionsToInitialize의 각 Parse Node f에 대해, 다음을 수행한다
    1. fn을 f의 BoundNames의 유일한 원소로 둔다.
    2. fo를 인수 env 및 privateEnv와 함께 f의 InstantiateFunctionObject로 둔다.
    3. ? CreateGlobalFunctionBinding(env, fn, fo, false)를 수행한다.
  17. declaredVarNames의 각 String vn에 대해, 다음을 수행한다
    1. ? CreateGlobalVarBinding(env, vn, false)를 수행한다.
  18. unused를 반환한다.
 Note 2

16.1.1에 지정된 조기 오류는 단일 Script 내에 포함된 선언에 대해 function/var 선언과 let/const/class 선언 사이의 이름 충돌 및 let/const/class 바인딩의 재선언을 방지한다. 그러나 둘 이상의 Script에 걸친 이러한 충돌과 재선언은 GlobalDeclarationInstantiation 중 런타임 오류로 감지된다. 그러한 오류가 감지되면, 해당 스크립트에 대해 어떤 바인딩도 인스턴스화되지 않는다. 그러나 전역 객체가 Proxy exotic 객체를 사용하여 정의되면 충돌 선언에 대한 런타임 테스트가 신뢰할 수 없어 갑작스러운 완료가 발생하고 일부 전역 선언이 인스턴스화되지 않을 수 있다. 이런 일이 발생하면 Script의 코드는 평가되지 않는다.

명시적인 var 또는 function 선언과 달리, 전역 객체에 직접 생성된 속성은 let/const/class 선언에 의해 가려질 수 있는 전역 바인딩을 생성한다.

16.2 모듈

구문

Module : ModuleBodyopt ModuleBody : ModuleItemList ModuleItemList : ModuleItem ModuleItemList ModuleItem ModuleItem : ImportDeclaration ExportDeclaration StatementListItem[~Yield, +Await, ~Return] ModuleExportName : IdentifierName StringLiteral

16.2.1 모듈 의미론

16.2.1.1 Static Semantics: 조기 오류

ModuleBody : ModuleItemList Note

중복 ExportedNames 규칙은 ModuleBody 내에 여러 개의 export default ExportDeclaration 항목이 존재하면 구문 오류가 됨을 의미한다. 충돌 또는 중복 선언과 관련된 추가 오류 조건은 모듈 평가 이전의 모듈 링크 단계에서 검사된다. 이러한 오류가 발견되면 해당 Module은 평가되지 않는다.

 ModuleExportName : StringLiteral

16.2.1.2 Static Semantics: ImportedLocalNames ( importEntries )

The abstract operation ImportedLocalNames takes argument importEntries (ImportEntry Record들의 List) and returns String들의 List. importEntries에 의해 정의된 모든 로컬 이름 바인딩의 List를 생성한다. It performs the following steps when called:

  1. localNames를 새로운 빈 List로 둔다.
  2. importEntries의 각 ImportEntry Record i에 대해, 다음을 수행한다
    1. i.[[LocalName]]을 localNames에 추가한다.
  3. localNames를 반환한다.

16.2.1.3 ModuleRequest Records

ModuleRequest Record는 주어진 import 속성과 함께 모듈을 가져오기 위한 요청을 나타낸다. 다음 필드로 구성된다:

Table 35: ModuleRequest Record Fields
필드 이름 값 타입 의미
[[Specifier]] String 모듈 지정자
[[Attributes]] ImportAttribute Record들의 List import 속성들

LoadedModuleRequest Record는 모듈 요청과 해당 결과 Module Record를 함께 나타낸다. 이는 Table 35에 정의된 동일한 필드에 [[Module]]이 추가된 형태이다:

Table 36: LoadedModuleRequest Record Fields
필드 이름 값 타입 의미
[[Specifier]] String 모듈 지정자
[[Attributes]] ImportAttribute Record들의 List import 속성들
[[Module]] Module Record 이 모듈 요청에 해당하는 로드된 모듈

ImportAttribute Record는 다음 필드로 구성된다:

Table 37: ImportAttribute Record Fields
필드 이름 값 타입 의미
[[Key]] String 속성 키
[[Value]] String 속성 값

16.2.1.3.1 ModuleRequestsEqual ( left, right )

The abstract operation ModuleRequestsEqual takes arguments left (ModuleRequest Record 또는 LoadedModuleRequest Record) and right (ModuleRequest Record 또는 LoadedModuleRequest Record) and returns 불리언. It performs the following steps when called:

  1. left.[[Specifier]]가 right.[[Specifier]]와 같지 않으면, false를 반환한다.
  2. leftAttrs를 left.[[Attributes]]로 둔다.
  3. rightAttrs를 right.[[Attributes]]로 둔다.
  4. leftAttrsCount를 leftAttrs의 요소 수로 둔다.
  5. rightAttrsCount를 rightAttrs의 요소 수로 둔다.
  6. leftAttrsCount ≠ rightAttrsCount이면, false를 반환한다.
  7. leftAttrs의 각 ImportAttribute Record l에 대해, 다음을 수행한다
    1. rightAttrs가 l.[[Key]]가 r.[[Key]]와 같고 l.[[Value]]가 r.[[Value]]와 같은 ImportAttribute Record r을 포함하지 않으면, false를 반환한다.
  8. true를 반환한다.

16.2.1.4 Static Semantics: ModuleRequests

The syntax-directed operation ModuleRequests takes no arguments and returns ModuleRequest Records의 List. It is defined piecewise over the following productions:

Module : [empty]
  1. 새로운 빈 List를 반환한다.
 ModuleItemList : ModuleItem
  1. ModuleItem의 ModuleRequests를 반환한다.
 ModuleItemList : ModuleItemList ModuleItem
  1. requests를 ModuleItemList의 ModuleRequests라고 하자.
  2. additionalRequests를 ModuleItem의 ModuleRequests라고 하자.
  3. additionalRequests의 각 ModuleRequest Record mr에 대해,
    1. requests가 ModuleRequestsEqual(mr, mr2)이 true인 ModuleRequest Record mr2를 포함하지 않으면,
      1. mr를 requests에 추가한다.
  4. requests를 반환한다.
 ModuleItem : StatementListItem
  1. 새로운 빈 List를 반환한다.
 ImportDeclaration : import ImportClause FromClause ;
  1. specifier를 FromClause의 SV라고 하자.
  2. 유일한 요소가 ModuleRequest Record { [[Specifier]]: specifier, [[Attributes]]: « » }인 List를 반환한다.
 ImportDeclaration : import ImportClause FromClause WithClause ;
  1. specifier를 FromClause의 SV라고 하자.
  2. attributes를 WithClause의 WithClauseToAttributes라고 하자.
  3. 유일한 요소가 ModuleRequest Record { [[Specifier]]: specifier, [[Attributes]]: attributes }인 List를 반환한다.
 ImportDeclaration : import ModuleSpecifier ;
  1. specifier를 ModuleSpecifier의 SV라고 하자.
  2. 유일한 요소가 ModuleRequest Record { [[Specifier]]: specifier, [[Attributes]]: « » }인 List를 반환한다.
 ImportDeclaration : import ModuleSpecifier WithClause ;
  1. specifier를 ModuleSpecifier의 SV라고 하자.
  2. attributes를 WithClause의 WithClauseToAttributes라고 하자.
  3. 유일한 요소가 ModuleRequest Record { [[Specifier]]: specifier, [[Attributes]]: attributes }인 List를 반환한다.
 ExportDeclaration : export ExportFromClause FromClause ;
  1. specifier를 FromClause의 SV라고 하자.
  2. 유일한 요소가 ModuleRequest Record { [[Specifier]]: specifier, [[Attributes]]: « » }인 List를 반환한다.
 ExportDeclaration : export ExportFromClause FromClause WithClause ;
  1. specifier를 FromClause의 SV라고 하자.
  2. attributes를 WithClause의 WithClauseToAttributes라고 하자.
  3. 유일한 요소가 ModuleRequest Record { [[Specifier]]: specifier, [[Attributes]]: attributes }인 List를 반환한다.
 ExportDeclaration : export NamedExports ; export VariableStatement export Declaration export default HoistableDeclaration export default ClassDeclaration export default AssignmentExpression ;
  1. 새로운 빈 List를 반환한다.

16.2.1.5 추상 모듈 레코드

모듈 레코드는 단일 모듈의 import/export에 대한 구조적 정보를 캡슐화합니다. 이 정보는 연결된 모듈 집합의 import/export 연결에 사용됩니다. 모듈 레코드에는 모듈 평가 시에만 사용되는 네 개의 필드가 포함되어 있습니다.

명세 목적상, 모듈 레코드는 Record 명세 타입의 값이며 간단한 객체지향 계층 구조에서 모듈 레코드가 추상 클래스이고 그 아래에 추상 및 구체 서브클래스가 존재하는 것으로 간주할 수 있습니다. 이 명세는 Cyclic Module Record라는 이름의 추상 서브클래스와 Source Text Module Record라는 이름의 구체 서브클래스를 정의합니다. 다른 명세와 구현에서는 자체적으로 정의한 대체 모듈 정의 수단에 상응하는 추가적인 모듈 레코드 서브클래스를 정의할 수 있습니다.

모듈 레코드는 Table 38 에 나열된 필드를 정의합니다. 모든 모듈 정의 서브클래스는 적어도 이들 필드를 포함합니다. 또한 Table 39 에 있는 추상 메서드 목록도 정의하며, 모든 모듈 정의 서브클래스는 해당 추상 메서드에 대한 구체 구현을 제공해야 합니다.

Table 38: Module Record Fields
필드 이름 값 타입 의미
[[Realm]] 영역(Realm) 레코드 이 모듈이 생성된 영역(Realm).
[[Environment]] 모듈 환경 레코드 또는 empty 이 모듈의 최상위 바인딩을 포함하는 환경 레코드. 이 필드는 모듈이 링크될 때 설정됩니다.
[[Namespace]] 객체 또는 empty 만약 이 모듈에 대해 생성된 경우, 모듈 네임스페이스 객체 (28.3).
[[HostDefined]] 임의 (기본값은 undefined) 호스트 환경이 모듈과 추가 정보를 연관시키기 위해 사용하는 예약 필드.
Table 39: Abstract Methods of Module Records
메서드 목적 정의
LoadRequestedModules ( [ hostDefined ] )

The abstract method LoadRequestedModules takes optional argument hostDefined (anything) and returns 프라미스(Promise).

모든 의존성을 재귀적으로 로드하여 모듈을 링크 준비 상태로 만든다.

이 명세에서는 다음 타입에 정의되어 있으며, 호스트는 자체 정의가 있는 추가 타입을 제공할 수 있습니다:
GetExportedNames ( [ exportStarSet ] )

The abstract method GetExportedNames takes optional argument exportStarSet (a List of Source Text Module Records) and returns a List of Strings.

이 모듈에서 직접 또는 간접적으로 내보내는 모든 이름의 목록을 반환한다.

이 메서드를 호출하기 전에 LoadRequestedModules가 성공적으로 완료되어야 한다.

이 명세에서는 다음 타입에 정의되어 있으며, 호스트는 자체 정의가 있는 추가 타입을 제공할 수 있습니다:
ResolveExport ( exportName [ , resolveSet ] )

The abstract method ResolveExport takes argument exportName (a String) and optional argument resolveSet (a List of Records with fields [[Module]] (a Module Record) and [[ExportName]] (a String)) and returns a ResolvedBinding Record, null, or ambiguous.

이 모듈이 내보내는 이름의 바인딩을 반환한다. 바인딩은 {[[Module]]: 모듈 레코드, [[BindingName]]: 문자열 | namespace} 형식의 ResolvedBinding 레코드 로 표현된다. 내보내기가 모듈 네임스페이스 객체이고 어느 모듈에도 직접 바인딩이 없으면 [[BindingName]]에 namespace가 들어간다. 이름을 해결할 수 없으면 null을, 여러 바인딩이 발견되면 ambiguous를 반환.

이 연산은 같은 exportName, resolveSet 쌍에 대해 호출할 때마다 동일한 결과를 반환해야 한다.

이 메서드를 호출하기 전에 LoadRequestedModules가 성공적으로 완료되어야 한다.

이 명세에서는 다음 타입에 정의되어 있으며, 호스트는 자체 정의가 있는 추가 타입을 제공할 수 있습니다:
Evaluate ( )

The abstract method Evaluate takes no arguments and returns 프라미스(Promise).

이 모듈과 그 의존성의 평가에 대한 프라미스를 반환하며, 성공하면 resolve 되고 이미 성공한 경우에도 resolve 되고, 평가 오류이거나 이전에 실패했다면 reject. reject 시 호스트는 프라미스 거부를 처리하고 평가 오류를 재throw해야 함. 이 모듈이 Cyclic Module Record가 아니라면, 반환된 프라미스는 이미 판정(settled)된 상태여야 한다.

이 메서드 호출 전 Link가 성공적으로 완료되어야 한다.

 이 명세에서는 다음 타입에 정의되어 있으며, 호스트는 자체 정의가 있는 추가 타입을 제공할 수 있습니다:

16.2.1.5.1 EvaluateModuleSync ( module )

The abstract operation EvaluateModuleSync takes argument module (a Module Record) and returns either a normal completion containing unused or a throw completion. 호출자가 module의 평가가 이미 정착(settled)된 프로미스를 반환한다는 것을 보장할 경우, module을 동기적으로 평가한다. It performs the following steps when called:

  1. Assert: module이 Cyclic Module Record가 아님을 보장한다.
  2. promise를 module.Evaluate()로 둔다.
  3. Assert: promise.[[PromiseState]]는 fulfilled 또는 rejected여야 한다.
  4. 만약 promise.[[PromiseState]]가 rejected라면,
    1. promise.[[PromiseIsHandled]]가 false이면, HostPromiseRejectionTracker(promise, "handle")를 수행한다.
    2. promise.[[PromiseIsHandled]]를 true로 설정한다.
    3. promise.[[PromiseResult]]를 throw한다.
  5. unused를 반환한다.

16.2.1.6 Cyclic Module Records

Cyclic Module Record는 다른 Cyclic Module Record 타입의 하위 클래스인 모듈들과 함께 의존성 순환에 참여할 수 있는 모듈에 대한 정보를 나타내기 위해 사용된다. Cyclic Module Record 타입의 하위 클래스가 아닌 Module Record는 Source Text Module Records와의 의존성 순환에 참여해서는 안 된다.

Table 38에서 정의된 필드에 추가로, Cyclic Module Records는 Table 40에 나열된 추가 필드를 가진다.

Table 40: Cyclic Module Records의 추가 필드
Field Name Value Type Meaning
[[Status]] new, unlinked, linking, linked, evaluating, evaluating-async, 또는 evaluated 초기값은 new이다. 모듈이 생명주기를 따라 진행됨에 따라 unlinked, linking, linked, evaluating, (필요 시) evaluating-async, evaluated 순으로 전이된다. evaluating-async는 이 모듈이 비동기 의존성 완료 후 실행 대기 중이거나 [[HasTLA]] 필드가 true인 모듈로 이미 실행되었지만 top-level 완료를 기다리는 상태임을 나타낸다.
[[EvaluationError]] throw completion 또는 empty 평가 중 발생한 예외를 나타내는 throw completion이다. 예외가 발생하지 않았거나 [[Status]]가 evaluated가 아닌 경우 empty이다.
[[DFSAncestorIndex]] 정수 또는 empty Link 및 Evaluate 과정에서만 사용되는 보조 필드이다. [[Status]]가 linking 또는 evaluating인 경우, 이는 모듈의 깊이 우선 탐색 인덱스이거나 동일한 강결합 컴포넌트 내의 더 "이전" 모듈의 인덱스이다.
[[RequestedModules]] ModuleRequest Records의 리스트 이 모듈의 import와 관련된 ModuleRequest Records의 리스트이다. 리스트는 소스 코드에서의 import 등장 순서를 따른다.
[[LoadedModules]] LoadedModuleRequest Records의 리스트 이 레코드가 나타내는 모듈이 상대적 import 속성과 함께 모듈을 요청할 때 사용한 specifier 문자열을, 해결된 Module Record로 매핑하는 구조이다. 이 리스트에는 ModuleRequestsEqual(r1, r2)가 true가 되는 서로 다른 두 레코드 r1, r2가 포함되지 않는다.
[[CycleRoot]] Cyclic Module Record 또는 empty 순환의 최초 방문 모듈이며, 강결합 컴포넌트의 루트 DFS 조상이다. 순환에 속하지 않은 모듈의 경우 자기 자신이 된다. Evaluate가 완료되면, 모듈의 [[DFSAncestorIndex]]는 [[CycleRoot]]의 깊이 우선 탐색 인덱스가 된다.
[[HasTLA]] Boolean 이 모듈이 개별적으로 비동기인지 여부를 나타낸다(예: top-level await을 포함하는 Source Text Module Record). 비동기 의존성이 있다고 해서 이 필드가 true가 되는 것은 아니다. 이 필드는 파싱 이후 변경되어서는 안 된다.
[[AsyncEvaluationOrder]] unset, 정수, 또는 done 초기값은 unset이며 완전히 동기적인 모듈의 경우 계속 unset 상태를 유지한다. 비동기이거나 비동기 의존성을 가진 모듈의 경우, 16.2.1.6.1.3.4에서 대기 중인 모듈 실행 순서를 결정하는 정수 값으로 설정된다. 대기 중인 모듈이 성공적으로 실행되면 done으로 설정된다.
[[TopLevelCapability]] PromiseCapability Record 또는 empty 이 모듈이 어떤 순환의 [[CycleRoot]]이고, 해당 순환 내 모듈 중 하나에서 Evaluate()가 호출된 경우, 이 필드는 전체 평가를 위한 PromiseCapability Record를 가진다. 이는 Evaluate() 추상 메서드가 반환하는 Promise 객체를 해결하기 위해 사용된다. 해당 모듈의 의존성들에서는, 그 의존성 중 일부에 대해 top-level Evaluate()가 시작된 경우가 아니라면 이 필드는 empty이다.
[[AsyncParentModules]] Cyclic Module Records의 리스트 이 모듈 또는 의존성 중 하나가 [[HasTLA]]가 true이고 실행이 진행 중인 경우, top-level 실행 작업에서 이 모듈의 부모 import 모듈들을 추적한다. 이 부모 모듈들은 이 모듈의 실행이 성공적으로 완료되기 전까지 실행을 시작하지 않는다.
[[PendingAsyncDependencies]] 정수 또는 empty 이 모듈이 비동기 의존성을 가지는 경우, 아직 실행되지 않은 비동기 의존 모듈의 개수를 추적한다. 이 값이 0이 되고 실행 오류가 없을 때 모듈이 실행된다.

Table 39에서 정의된 메서드에 추가로, Cyclic Module Records는 Table 41에 나열된 추가 메서드를 가진다:

Table 41: Cyclic Module Records의 추가 추상 메서드
Method Purpose Definitions
InitializeEnvironment ( )

The abstract method InitializeEnvironment takes no arguments and returns unused를 포함하는 normal completion 또는 throw completion.

모듈의 Environment Record를 초기화하며, 모든 import 바인딩을 해결하고 모듈의 실행 컨텍스트를 생성한다. 		이 명세에서는 다음 타입들에 정의가 존재하며, 호스트는 자체 정의를 가진 추가 타입을 제공할 수 있다:
ExecuteModule ( [ capability ] )

The abstract method ExecuteModule takes optional argument capability (PromiseCapability Record) and returns unused를 포함하는 normal completion 또는 throw completion.

실행 컨텍스트 내에서 모듈 코드를 평가한다. 이 모듈의 [[HasTLA]]가 true인 경우 PromiseCapability Record가 인자로 전달되며, 메서드는 해당 capability를 resolve 또는 reject해야 한다. 이 경우 메서드는 예외를 throw해서는 안 되며, 필요 시 PromiseCapability Record를 reject해야 한다. 		이 명세에서는 다음 타입들에 정의가 존재하며, 호스트는 자체 정의를 가진 추가 타입을 제공할 수 있다:

GraphLoadingState Record는 모듈 그래프의 로딩 과정에 대한 정보를 포함하는 Record이다. 이는 HostLoadImportedModule 호출 이후 로딩을 계속하기 위해 사용된다. 각 GraphLoadingState Record는 Table 42에 정의된 필드를 가진다:

Table 42: GraphLoadingState Record 필드
Field Name Value Type Meaning
[[PromiseCapability]] PromiseCapability Record 로딩 프로세스가 완료되면 resolve될 promise이다.
[[IsLoading]] Boolean 로딩 프로세스가 아직 완료되지 않았고, 성공도 실패도 아닌 상태일 때 true이다.
[[PendingModulesCount]] 0 이상의 정수 대기 중인 HostLoadImportedModule 호출의 수를 추적한다.
[[Visited]] Cyclic Module Records의 리스트 현재 로딩 과정에서 이미 로드된 Cyclic Module Records의 리스트로, 순환 의존성으로 인한 무한 루프를 방지한다.
[[HostDefined]] 아무 값 (기본값은 empty) LoadRequestedModules 호출자로부터 HostLoadImportedModule로 전달하기 위한 호스트 정의 데이터를 포함한다.

16.2.1.6.1 Module Record 추상 메서드의 구현

다음은 Table 39에 정의된 해당 Module Record 추상 메서드를 구현하는 Cyclic Module Record의 구체적인 메서드이다.

16.2.1.6.1.1 LoadRequestedModules ( [ hostDefined ] )

The LoadRequestedModules concrete method of a Cyclic Module Record module takes optional argument hostDefined (anything) and returns a Promise. module의 의존성 그래프에 있는 모든 Module Record의 [[LoadedModules]]를 채운다(대부분의 작업은 보조 함수 InnerModuleLoading이 수행한다). HostLoadImportedModule 훅에 전달되는 optional hostDefined 매개변수를 받는다. It performs the following steps when called:

  1. hostDefined가 존재하지 않으면, hostDefined를 empty로 설정한다.
  2. pc를 ! NewPromiseCapability(%Promise%)로 둔다.
  3. state를 GraphLoadingState Record { [[IsLoading]]: true, [[PendingModulesCount]]: 1, [[Visited]]: « », [[PromiseCapability]]: pc, [[HostDefined]]: hostDefined }로 둔다.
  4. InnerModuleLoading(state, module)을 수행한다.
  5. pc.[[Promise]]를 반환한다.
 Note
hostDefined 매개변수는 가져온 모듈을 fetch하는 데 필요한 추가 정보를 전달하는 데 사용할 수 있다. 예를 들어 HTML에서 <link rel="preload" as="..."> 태그에 대한 올바른 fetch destination을 설정하는 데 사용된다. import() 표현식은 절대로 hostDefined 매개변수를 설정하지 않는다.

16.2.1.6.1.1.1 InnerModuleLoading ( state, module )

The abstract operation InnerModuleLoading takes arguments state (a GraphLoadingState Record) and module (a Module Record) and returns unused. LoadRequestedModules가 module의 의존성 그래프에 대한 실제 로딩 과정을 재귀적으로 수행하는 데 사용한다. It performs the following steps when called:

  1. Assert: state.[[IsLoading]]은 true이다.
  2. module이 Cyclic Module Record이고, module.[[Status]]가 new이며, state.[[Visited]]가 module을 포함하지 않으면,
    1. module을 state.[[Visited]]에 추가한다.
    2. requestedModulesCount를 module.[[RequestedModules]]의 요소 개수로 둔다.
    3. state.[[PendingModulesCount]]를 state.[[PendingModulesCount]] + requestedModulesCount로 설정한다.
    4. module.[[RequestedModules]]의 각 ModuleRequest Record request에 대해,
      1. AllImportAttributesSupported(request.[[Attributes]])가 false이면,
        1. error를 ThrowCompletion(새로 생성된 SyntaxError 객체)로 둔다.
        2. ContinueModuleLoading(state, error)을 수행한다.
      2. 그렇지 않고 module.[[LoadedModules]]가 ModuleRequestsEqual(record, request)가 true인 LoadedModuleRequest Record record를 포함하면,
        1. InnerModuleLoading(state, record.[[Module]])을 수행한다.
      3. 그렇지 않으면,
        1. HostLoadImportedModule(module, request, state.[[HostDefined]], state)를 수행한다.
        2. NOTE: HostLoadImportedModule은 FinishLoadingImportedModule을 호출하며, 이는 ContinueModuleLoading을 통해 그래프 로딩 과정에 다시 진입한다.
      4. state.[[IsLoading]]이 false이면, unused를 반환한다.
  3. Assert: state.[[PendingModulesCount]] ≥ 1.
  4. state.[[PendingModulesCount]]를 state.[[PendingModulesCount]] - 1로 설정한다.
  5. state.[[PendingModulesCount]] = 0이면,
    1. state.[[IsLoading]]을 false로 설정한다.
    2. state.[[Visited]]의 각 Cyclic Module Record loaded에 대해,
      1. loaded.[[Status]]가 new이면, loaded.[[Status]]를 unlinked로 설정한다.
    3. ! Call(state.[[PromiseCapability]].[[Resolve]], undefined, « undefined »)을 수행한다.
  6. unused를 반환한다.

16.2.1.6.1.1.2 ContinueModuleLoading ( state, moduleCompletion )

The abstract operation ContinueModuleLoading takes arguments state (a GraphLoadingState Record) and moduleCompletion (either a normal completion containing a Module Record or a throw completion) and returns unused. HostLoadImportedModule 호출 이후 로딩 과정에 다시 진입하는 데 사용된다. It performs the following steps when called:

  1. state.[[IsLoading]]이 false이면, unused를 반환한다.
  2. moduleCompletion이 normal completion이면,
    1. InnerModuleLoading(state, moduleCompletion.[[Value]])을 수행한다.
  3. 그렇지 않으면,
    1. state.[[IsLoading]]을 false로 설정한다.
    2. ! Call(state.[[PromiseCapability]].[[Reject]], undefined, « moduleCompletion.[[Value]] »)을 수행한다.
  4. unused를 반환한다.

16.2.1.6.1.2 Link ( )

The Link concrete method of a Cyclic Module Record module takes no arguments and returns either a normal completion containing unused or a throw completion. 성공 시, Link는 이 모듈의 [[Status]]를 unlinked에서 linked로 전환한다. 실패 시, 예외가 던져지고 이 모듈의 [[Status]]는 unlinked로 남는다. (대부분의 작업은 보조 함수 InnerModuleLinking이 수행한다.) It performs the following steps when called:

  1. Assert: module.[[Status]]는 unlinked, linked, evaluating-async, 또는 evaluated 중 하나이다.
  2. stack을 새 빈 List로 둔다.
  3. result를 Completion(InnerModuleLinking(module, stack, 0))으로 둔다.
  4. result가 abrupt completion이면,
    1. stack의 각 Cyclic Module Record m에 대해,
      1. Assert: m.[[Status]]는 linking이다.
      2. m.[[Status]]를 unlinked로 설정한다.
    2. Assert: module.[[Status]]는 unlinked이다.
    3. ? result를 반환한다.
  5. Assert: module.[[Status]]는 linked, evaluating-async, 또는 evaluated 중 하나이다.
  6. Assert: stack은 비어 있다.
  7. unused를 반환한다.

16.2.1.6.1.2.1 InnerModuleLinking ( module, stack, index )

The abstract operation InnerModuleLinking takes arguments module (a Module Record), stack (a List of Cyclic Module Records), and index (a non-negative integer) and returns either a normal completion containing a non-negative integer or a throw completion. Link가 module에 대한 실제 링킹 과정을 수행하고, 의존성 그래프의 다른 모든 모듈에도 재귀적으로 수행하는 데 사용한다. stack 및 index 매개변수와 모듈의 [[DFSAncestorIndex]] 필드는 깊이 우선 탐색(DFS) 순회를 추적한다. 특히 [[DFSAncestorIndex]]는 강한 연결 요소(SCC)를 발견하는 데 사용되어, 하나의 SCC 안의 모든 모듈이 함께 linked로 전환되도록 한다. It performs the following steps when called:

  1. module이 Cyclic Module Record가 아니면,
    1. ? module.Link()를 수행한다.
    2. index를 반환한다.
  2. module.[[Status]]가 linking, linked, evaluating-async, 또는 evaluated 중 하나이면,
    1. index를 반환한다.
  3. Assert: module.[[Status]]는 unlinked이다.
  4. module.[[Status]]를 linking으로 설정한다.
  5. moduleIndex를 index로 둔다.
  6. module.[[DFSAncestorIndex]]를 index로 설정한다.
  7. index를 index + 1로 설정한다.
  8. module을 stack에 추가한다.
  9. module.[[RequestedModules]]의 각 ModuleRequest Record request에 대해,
    1. requiredModule을 GetImportedModule(module, request)로 둔다.
    2. index를 ? InnerModuleLinking(requiredModule, stack, index)로 설정한다.
    3. requiredModule이 Cyclic Module Record이면,
      1. Assert: requiredModule.[[Status]]는 linking, linked, evaluating-async, 또는 evaluated 중 하나이다.
      2. Assert: requiredModule.[[Status]]가 linking인 것은 stack이 requiredModule을 포함할 때 그리고 그때뿐이다.
      3. requiredModule.[[Status]]가 linking이면,
        1. module.[[DFSAncestorIndex]]를 min(module.[[DFSAncestorIndex]], requiredModule.[[DFSAncestorIndex]])로 설정한다.
  10. ? module.InitializeEnvironment()를 수행한다.
  11. Assert: module은 stack 안에 정확히 한 번 나타난다.
  12. Assert: module.[[DFSAncestorIndex]] ≤ moduleIndex.
  13. module.[[DFSAncestorIndex]] = moduleIndex이면,
    1. done을 false로 둔다.
    2. done이 false인 동안 반복한다.
      1. requiredModule을 stack의 마지막 요소로 둔다.
      2. stack의 마지막 요소를 제거한다.
      3. Assert: requiredModule은 Cyclic Module Record이다.
      4. requiredModule.[[Status]]를 linked로 설정한다.
      5. requiredModule과 module이 같은 Module Record이면, done을 true로 설정한다.
  14. index를 반환한다.

16.2.1.6.1.3 Evaluate ( )

The Evaluate concrete method of a Cyclic Module Record module takes no arguments and returns a Promise. Evaluate는 이 모듈의 [[Status]]를 linked에서 evaluating-async 또는 evaluated로 전환한다. 주어진 강한 연결 요소 안의 모듈에서 처음 호출될 때, Evaluate는 모듈 평가가 끝나면 resolve되는 Promise를 생성하고 반환한다. 이 Promise는 해당 요소의 [[CycleRoot]]의 [[TopLevelCapability]] 필드에 저장된다. 그 요소 안의 어떤 모듈에서 Evaluate가 나중에 호출되더라도 같은 Promise를 반환한다. (대부분의 작업은 보조 함수 InnerModuleEvaluation이 수행한다.) It performs the following steps when called:

  1. Assert: Evaluate에 대한 이 호출은 주변 agent 안에서 Evaluate에 대한 다른 호출과 동시에 일어나고 있지 않다.
  2. Assert: module.[[Status]]는 linked, evaluating-async, 또는 evaluated 중 하나이다.
  3. module.[[Status]]가 evaluating-async 또는 evaluated이면,
    1. module.[[CycleRoot]]가 empty가 아니면,
      1. module을 module.[[CycleRoot]]로 설정한다.
    2. 그렇지 않으면,
      1. Assert: module.[[Status]]는 evaluated이고 module.[[EvaluationError]]는 throw completion이다.
  4. module.[[TopLevelCapability]]가 empty가 아니면,
    1. module.[[TopLevelCapability]].[[Promise]]를 반환한다.
  5. stack을 새 빈 List로 둔다.
  6. capability를 ! NewPromiseCapability(%Promise%)로 둔다.
  7. module.[[TopLevelCapability]]를 capability로 설정한다.
  8. result를 Completion(InnerModuleEvaluation(module, stack, 0))으로 둔다.
  9. result가 abrupt completion이면,
    1. stack의 각 Cyclic Module Record m에 대해,
      1. Assert: m.[[Status]]는 evaluating이다.
      2. m.[[Status]]를 evaluated로 설정한다.
      3. m.[[EvaluationError]]를 result로 설정한다.
    2. Assert: module.[[Status]]는 evaluated이다.
    3. Assert: module.[[EvaluationError]]와 result는 같은 Completion Record이다.
    4. ! Call(capability.[[Reject]], undefined, « result.[[Value]] »)을 수행한다.
  10. 그렇지 않으면,
    1. Assert: module.[[Status]]는 evaluating-async 또는 evaluated이다.
    2. Assert: module.[[EvaluationError]]는 empty이다.
    3. module.[[Status]]가 evaluated이면,
      1. Assert: module.[[AsyncEvaluationOrder]]는 unset 또는 done이다.
      2. NOTE: module이 이미 평가되었고 그 평가가 비동기였을 때 그리고 그때에만 module.[[AsyncEvaluationOrder]]는 done이다.
      3. ! Call(capability.[[Resolve]], undefined, « undefined »)을 수행한다.
    4. Assert: stack은 비어 있다.
  11. capability.[[Promise]]를 반환한다.

16.2.1.6.1.3.1 InnerModuleEvaluation ( module, stack, index )

The abstract operation InnerModuleEvaluation takes arguments module (a Module Record), stack (a List of Cyclic Module Records), and index (a non-negative integer) and returns either a normal completion containing a non-negative integer or a throw completion. Evaluate가 module에 대한 실제 평가 과정을 수행하고, 의존성 그래프의 다른 모든 모듈에도 재귀적으로 수행하는 데 사용한다. stack 및 index 매개변수와 module의 [[DFSAncestorIndex]] 필드는 InnerModuleLinking에서와 같은 방식으로 사용된다. It performs the following steps when called:

  1. module이 Cyclic Module Record가 아니면,
    1. ? EvaluateModuleSync(module)를 수행한다.
    2. index를 반환한다.
  2. module.[[Status]]가 evaluating-async 또는 evaluated이면,
    1. module.[[EvaluationError]]가 empty이면, index를 반환한다.
    2. ? module.[[EvaluationError]]를 반환한다.
  3. module.[[Status]]가 evaluating이면, index를 반환한다.
  4. Assert: module.[[Status]]는 linked이다.
  5. module.[[Status]]를 evaluating으로 설정한다.
  6. moduleIndex를 index로 둔다.
  7. module.[[DFSAncestorIndex]]를 index로 설정한다.
  8. module.[[PendingAsyncDependencies]]를 0으로 설정한다.
  9. index를 index + 1로 설정한다.
  10. module을 stack에 추가한다.
  11. module.[[RequestedModules]]의 각 ModuleRequest Record request에 대해,
    1. requiredModule을 GetImportedModule(module, request)로 둔다.
    2. index를 ? InnerModuleEvaluation(requiredModule, stack, index)로 설정한다.
    3. requiredModule이 Cyclic Module Record이면,
      1. Assert: requiredModule.[[Status]]는 evaluating, evaluating-async, 또는 evaluated 중 하나이다.
      2. Assert: requiredModule.[[Status]]가 evaluating인 것은 stack이 requiredModule을 포함할 때 그리고 그때뿐이다.
      3. requiredModule.[[Status]]가 evaluating이면,
        1. module.[[DFSAncestorIndex]]를 min(module.[[DFSAncestorIndex]], requiredModule.[[DFSAncestorIndex]])로 설정한다.
      4. 그렇지 않으면,
        1. requiredModule을 requiredModule.[[CycleRoot]]로 설정한다.
        2. Assert: requiredModule.[[Status]]는 evaluating-async 또는 evaluated이다.
        3. requiredModule.[[EvaluationError]]가 empty가 아니면, ? requiredModule.[[EvaluationError]]를 반환한다.
      5. requiredModule.[[AsyncEvaluationOrder]]가 정수이면,
        1. module.[[PendingAsyncDependencies]]를 module.[[PendingAsyncDependencies]] + 1로 설정한다.
        2. module을 requiredModule.[[AsyncParentModules]]에 추가한다.
  12. module.[[PendingAsyncDependencies]] > 0이거나 module.[[HasTLA]]가 true이면,
    1. Assert: module.[[AsyncEvaluationOrder]]는 unset이다.
    2. module.[[AsyncEvaluationOrder]]를 IncrementModuleAsyncEvaluationCount()로 설정한다.
    3. module.[[PendingAsyncDependencies]] = 0이면, ExecuteAsyncModule(module)을 수행한다.
  13. 그렇지 않으면,
    1. ? module.ExecuteModule()을 수행한다.
  14. Assert: module은 stack 안에 정확히 한 번 나타난다.
  15. Assert: module.[[DFSAncestorIndex]] ≤ moduleIndex.
  16. module.[[DFSAncestorIndex]] = moduleIndex이면,
    1. done을 false로 둔다.
    2. done이 false인 동안 반복한다.
      1. requiredModule을 stack의 마지막 요소로 둔다.
      2. stack의 마지막 요소를 제거한다.
      3. Assert: requiredModule은 Cyclic Module Record이다.
      4. Assert: requiredModule.[[AsyncEvaluationOrder]]는 정수 또는 unset이다.
      5. requiredModule.[[AsyncEvaluationOrder]]가 unset이면, requiredModule.[[Status]]를 evaluated로 설정한다.
      6. 그렇지 않으면, requiredModule.[[Status]]를 evaluating-async로 설정한다.
      7. requiredModule과 module이 같은 Module Record이면, done을 true로 설정한다.
      8. requiredModule.[[CycleRoot]]를 module로 설정한다.
  17. index를 반환한다.
 Note 1

모듈은 InnerModuleEvaluation에 의해 순회되는 동안 evaluating이다. 모듈은 실행 완료 시 evaluated가 되거나, [[HasTLA]] 필드가 true이거나 비동기 의존성이 있으면 실행 중 evaluating-async가 된다.

 Note 2

비동기 cycle의 모듈에 의존하는 모든 모듈은, 그 cycle이 evaluating이 아닐 때, 대신 [[CycleRoot]]를 통해 cycle의 루트 실행에 의존한다. 이는 cycle 상태를 루트 모듈 상태를 통해 하나의 강한 연결 요소로 취급할 수 있게 보장한다.

16.2.1.6.1.3.2 ExecuteAsyncModule ( module )

The abstract operation ExecuteAsyncModule takes argument module (a Cyclic Module Record) and returns unused. It performs the following steps when called:

  1. Assert: module.[[Status]]는 evaluating 또는 evaluating-async이다.
  2. Assert: module.[[HasTLA]]는 true이다.
  3. capability를 ! NewPromiseCapability(%Promise%)로 둔다.
  4. fulfilledClosure를 module을 캡처하고 호출될 때 다음 단계를 수행하는, 매개변수가 없는 새 Abstract Closure로 둔다.
    1. AsyncModuleExecutionFulfilled(module)을 수행한다.
    2. NormalCompletion(undefined)을 반환한다.
  5. onFulfilled를 CreateBuiltinFunction(fulfilledClosure, 0, "", « »)로 둔다.
  6. rejectedClosure를 module을 캡처하고 호출될 때 다음 단계를 수행하는, 매개변수 (error)를 가진 새 Abstract Closure로 둔다.
    1. AsyncModuleExecutionRejected(module, error)를 수행한다.
    2. NormalCompletion(undefined)을 반환한다.
  7. onRejected를 CreateBuiltinFunction(rejectedClosure, 0, "", « »)로 둔다.
  8. PerformPromiseThen(capability.[[Promise]], onFulfilled, onRejected)을 수행한다.
  9. ! module.ExecuteModule(capability)을 수행한다.
  10. unused를 반환한다.

16.2.1.6.1.3.3 GatherAvailableAncestors ( module, execList )

The abstract operation GatherAvailableAncestors takes arguments module (a Cyclic Module Record) and execList (a List of Cyclic Module Records) and returns unused. It performs the following steps when called:

  1. module.[[AsyncParentModules]]의 각 Cyclic Module Record m에 대해,
    1. execList가 m을 포함하지 않고 m.[[CycleRoot]].[[EvaluationError]]가 empty이면,
      1. Assert: m.[[Status]]는 evaluating-async이다.
      2. Assert: m.[[EvaluationError]]는 empty이다.
      3. Assert: m.[[AsyncEvaluationOrder]]는 정수이다.
      4. Assert: m.[[PendingAsyncDependencies]] > 0.
      5. m.[[PendingAsyncDependencies]]를 m.[[PendingAsyncDependencies]] - 1로 설정한다.
      6. m.[[PendingAsyncDependencies]] = 0이면,
        1. m을 execList에 추가한다.
        2. m.[[HasTLA]]가 false이면, GatherAvailableAncestors(m, execList)를 수행한다.
  2. unused를 반환한다.
 Note

루트 module에 대한 비동기 실행이 fulfilled되면, 이 함수는 이 완료에서 함께 동기적으로 실행할 수 있는 모듈들의 목록을 결정하여 execList에 채운다.

16.2.1.6.1.3.4 AsyncModuleExecutionFulfilled ( module )

The abstract operation AsyncModuleExecutionFulfilled takes argument module (a Cyclic Module Record) and returns unused. It performs the following steps when called:

  1. module.[[Status]]가 evaluated이면,
    1. Assert: module.[[EvaluationError]]는 empty가 아니다.
    2. unused를 반환한다.
  2. Assert: module.[[Status]]는 evaluating-async이다.
  3. Assert: module.[[AsyncEvaluationOrder]]는 정수이다.
  4. Assert: module.[[EvaluationError]]는 empty이다.
  5. module.[[AsyncEvaluationOrder]]를 done으로 설정한다.
  6. module.[[Status]]를 evaluated로 설정한다.
  7. module.[[TopLevelCapability]]가 empty가 아니면,
    1. Assert: module.[[CycleRoot]]와 module은 같은 Module Record이다.
    2. ! Call(module.[[TopLevelCapability]].[[Resolve]], undefined, « undefined »)을 수행한다.
  8. execList를 새 빈 List로 둔다.
  9. GatherAvailableAncestors(module, execList)를 수행한다.
  10. Assert: execList의 모든 요소는 [[AsyncEvaluationOrder]] 필드가 정수로 설정되어 있고, [[PendingAsyncDependencies]] 필드가 0으로 설정되어 있으며, [[EvaluationError]] 필드가 empty로 설정되어 있다.
  11. sortedExecList를 execList의 요소들을 [[AsyncEvaluationOrder]] 필드의 오름차순으로 정렬한 요소들을 갖는 List로 둔다.
  12. sortedExecList의 각 Cyclic Module Record m에 대해,
    1. m.[[Status]]가 evaluated이면,
      1. Assert: m.[[EvaluationError]]는 empty가 아니다.
    2. 그렇지 않고 m.[[HasTLA]]가 true이면,
      1. ExecuteAsyncModule(m)을 수행한다.
    3. 그렇지 않으면,
      1. result를 Completion(m.ExecuteModule())으로 둔다.
      2. result가 abrupt completion이면,
        1. AsyncModuleExecutionRejected(m, result.[[Value]])를 수행한다.
      3. 그렇지 않으면,
        1. m.[[AsyncEvaluationOrder]]를 done으로 설정한다.
        2. m.[[Status]]를 evaluated로 설정한다.
        3. m.[[TopLevelCapability]]가 empty가 아니면,
          1. Assert: m.[[CycleRoot]]와 m은 같은 Module Record이다.
          2. ! Call(m.[[TopLevelCapability]].[[Resolve]], undefined, « undefined »)을 수행한다.
  13. unused를 반환한다.

16.2.1.6.1.3.5 AsyncModuleExecutionRejected ( module, error )

The abstract operation AsyncModuleExecutionRejected takes arguments module (a Cyclic Module Record) and error (an ECMAScript language value) and returns unused. It performs the following steps when called:

  1. module.[[Status]]가 evaluated이면,
    1. Assert: module.[[EvaluationError]]는 empty가 아니다.
    2. unused를 반환한다.
  2. Assert: module.[[Status]]는 evaluating-async이다.
  3. Assert: module.[[AsyncEvaluationOrder]]는 정수이다.
  4. Assert: module.[[EvaluationError]]는 empty이다.
  5. module.[[EvaluationError]]를 ThrowCompletion(error)로 설정한다.
  6. module.[[Status]]를 evaluated로 설정한다.
  7. module.[[AsyncEvaluationOrder]]를 done으로 설정한다.
  8. NOTE: module.[[AsyncEvaluationOrder]]는 AsyncModuleExecutionFulfilled와의 대칭성을 위해 done으로 설정된다. InnerModuleEvaluation에서 모듈의 [[AsyncEvaluationOrder]] 내부 슬롯 값은 그 [[EvaluationError]] 내부 슬롯이 empty가 아닐 때 사용되지 않는다.
  9. module.[[TopLevelCapability]]가 empty가 아니면,
    1. Assert: module.[[CycleRoot]]와 module은 같은 Module Record이다.
    2. ! Call(module.[[TopLevelCapability]].[[Reject]], undefined, « error »)을 수행한다.
  10. module.[[AsyncParentModules]]의 각 Cyclic Module Record m에 대해,
    1. AsyncModuleExecutionRejected(m, error)를 수행한다.
  11. unused를 반환한다.

16.2.1.6.2 Cyclic Module Record 그래프 예시

이 비규범 절은 몇 가지 일반적인 모듈 그래프의 링킹 및 평가 예시를, 오류가 어떻게 발생할 수 있는지에 특히 초점을 맞추어 제시한다.

먼저 다음의 단순한 모듈 그래프를 생각해 보자.

Figure 2: 단순한 모듈 그래프
모듈 A가 모듈 B에 의존하고, 모듈 B가 모듈 C에 의존하는 모듈 그래프

먼저 오류 조건이 없다고 가정하자. 호스트가 처음 A.LoadRequestedModules()를 호출하면, 가정에 따라 성공적으로 완료되고 B와 C의 의존성도 각각 재귀적으로 로드한다(각각 C 및 없음). 그런 다음 A.[[Status]] = B.[[Status]] = C.[[Status]] = unlinked로 설정한다. 이어서 호스트가 A.Link()를 호출하면, 이 역시 가정에 따라 성공적으로 완료되어 A.[[Status]] = B.[[Status]] = C.[[Status]] = linked가 된다. 이러한 준비 단계는 언제든 수행할 수 있다. 나중에 호스트가 모듈의 가능한 부수 효과를 감수할 준비가 되면 A.Evaluate()를 호출할 수 있으며, 이는 성공적으로 완료되어 undefined로 resolve되는 Promise를 반환한다(역시 가정에 따라). 이 과정에서 먼저 C, 그다음 B가 재귀적으로 평가된다. 이 시점에서 각 모듈의 [[Status]]는 evaluated가 된다.

그다음 A.LoadRequestedModules() 호출이 성공한 뒤 링킹 오류가 관련된 경우를 생각해 보자. C의 InnerModuleLinking은 성공하지만 그 이후 B에서 실패한다면, 예를 들어 C가 제공하지 않는 것을 import하기 때문이라면, 원래의 A.Link()는 실패하고 A와 B의 [[Status]]는 모두 unlinked로 남는다. 하지만 C의 [[Status]]는 linked가 된다.

마지막으로, Link() 호출이 성공한 뒤 평가 오류가 관련된 경우를 생각해 보자. C의 InnerModuleEvaluation은 성공하지만 그 이후 B에서 실패한다면, 예를 들어 B에 예외를 던지는 코드가 포함되어 있기 때문이라면, 원래의 A.Evaluate()는 실패하고 rejected Promise를 반환한다. 그 결과 예외는 A와 B의 [[EvaluationError]] 필드 모두에 기록되고, 이들의 [[Status]]는 evaluated가 된다. C도 evaluated가 되지만, A 및 B와 달리 평가를 성공적으로 완료했으므로 [[EvaluationError]] 없이 남는다. 예외를 저장하면 호스트가 Evaluate() 메서드를 호출해 A 또는 B를 재사용하려 할 때마다 같은 예외를 만나게 된다. (호스트가 Cyclic Module Record를 재사용해야 하는 것은 아니며, 마찬가지로 호스트가 이 메서드들이 던진 예외 객체를 노출해야 하는 것도 아니다. 그러나 명세는 그러한 사용을 가능하게 한다.)

이제 다른 유형의 오류 조건을 생각해 보자.

Figure 3: 해결할 수 없는 모듈이 있는 모듈 그래프
모듈 A가 ???로 표시된 누락된(해결할 수 없는) 모듈에 의존하는 모듈 그래프

이 시나리오에서 모듈 A는 어떤 다른 모듈에 대한 의존성을 선언하지만, 그 모듈에 대한 Module Record가 존재하지 않는다. 즉 HostLoadImportedModule은 그것을 요청받았을 때 예외와 함께 FinishLoadingImportedModule을 호출한다. 이는 해당 리소스가 존재하지 않거나, 리소스는 존재하지만 결과 소스 텍스트를 파싱하려 할 때 ParseModule이 오류를 반환하는 등 다양한 이유로 발생할 수 있다. 호스트는 FinishLoadingImportedModule에 전달하는 completion을 통해 실패 원인을 노출하도록 선택할 수 있다. 어떤 경우든 이 예외는 로딩 실패를 일으키며, 그 결과 A의 [[Status]]는 new로 남는다.

여기서 로딩, 링킹, 평가 오류 사이의 차이는 다음 특성 때문이다.

  • 평가는 부수 효과를 일으킬 수 있으므로 한 번만 수행되어야 한다. 따라서 평가가 이미 수행되었는지, 성공하지 못했더라도, 기억하는 것이 중요하다. (오류의 경우, 예외도 기억하는 것이 타당하다. 그렇지 않으면 이후 Evaluate() 호출이 새 예외를 합성해야 하기 때문이다.)
  • 반면 링킹은 부수 효과가 없으므로, 실패하더라도 나중에 문제없이 다시 시도할 수 있다.
  • 로딩은 호스트와 밀접하게 상호작용하며, 일부 호스트에서는 사용자가 실패한 로드를 다시 시도하도록 허용하는 것이 바람직할 수 있다(예를 들어 일시적인 네트워크 상태 불량으로 실패가 발생한 경우).

이제 cycle이 있는 모듈 그래프를 생각해 보자.

Figure 4: 순환 모듈 그래프
모듈 A가 모듈 B와 C에 의존하지만, 모듈 B도 모듈 A에 의존하는 모듈 그래프

여기서는 진입점이 모듈 A라고 가정하므로, 호스트는 A.LoadRequestedModules()를 호출하여 진행하고, 이는 A에 대해 InnerModuleLoading을 수행한다. 이는 다시 B와 C에 대해 InnerModuleLoading을 호출한다. cycle 때문에 다시 A에 대해 InnerModuleLoading이 트리거되지만, 이 시점에는 이 LoadRequestedModules 과정 중 A의 의존성 로딩이 이미 트리거되었으므로 no-op이다. 그래프의 모든 모듈이 성공적으로 로드되면, 이들의 [[Status]]는 동시에 new에서 unlinked로 전환된다.

그다음 호스트는 A.Link()를 호출하여 진행하고, 이는 A에 대해 InnerModuleLinking을 수행한다. 이는 다시 B에 대해 InnerModuleLinking을 호출한다. cycle 때문에 다시 A에 대해 InnerModuleLinking이 트리거되지만, 이 시점에는 A.[[Status]]가 이미 linking이므로 no-op이다. 제어가 A로 돌아와 C에 대해 InnerModuleLinking이 트리거될 때 B.[[Status]] 자체는 linking으로 남아 있다. 이것이 C.[[Status]]가 linked인 상태로 반환된 뒤, A와 B는 함께 linking에서 linked로 전환된다. 이는 이들이 강한 연결 요소를 형성하므로 의도된 동작이다. 이 단계에서는 모듈 그래프가 깊이 우선 탐색으로 순회되기 때문에 같은 SCC 안의 모듈들의 상태를 동시에 전환할 수 있다.

순환 모듈 그래프의 평가 단계에서도 성공 사례에서는 이와 유사한 이야기가 발생한다.

이제 A에 링킹 오류가 있는 경우를 생각해 보자. 예를 들어 C에 존재하지 않는 binding을 import하려 한다고 하자. 이 경우에도 A에 대한 두 번째 InnerModuleLinking 호출에서 조기 반환하는 것을 포함해 위 단계들은 여전히 발생한다. 그러나 원래의 A에 대한 InnerModuleLinking으로 되감아 돌아오면, InitializeEnvironment 중, 즉 C.ResolveExport() 직후에 실패한다. 던져진 SyntaxError 예외는 A.Link까지 전파되며, 이는 현재 자신의 stack 위에 있는 모든 모듈을 재설정한다(이들은 항상 아직 linking인 모듈과 정확히 같다). 따라서 A와 B는 모두 unlinked가 된다. C는 linked로 남는다는 점에 유의하라.

또는 A에 평가 오류가 있는 경우를 생각해 보자. 예를 들어 그 소스 코드가 예외를 던진다고 하자. 이 경우에도 A에 대한 두 번째 InnerModuleEvaluation 호출에서 조기 반환하는 것을 포함해 위 단계들의 평가 시점 대응 과정은 여전히 발생한다. 그러나 원래의 A에 대한 InnerModuleEvaluation으로 되감아 돌아오면, 가정에 따라 실패한다. 던져진 예외는 A.Evaluate()까지 전파되며, 이는 현재 자신의 stack 위에 있는 모든 모듈(즉 아직 evaluating인 모듈)뿐 아니라 [[AsyncParentModules]]를 통해서도 오류를 기록한다. [[AsyncParentModules]]는 AsyncModuleExecutionRejected 알고리즘을 통해 전체 의존성 그래프에서 top-level await를 포함하거나 이에 의존하는 모듈들을 위한 체인을 형성한다. 따라서 A와 B는 모두 evaluated가 되고 예외는 A와 B의 [[EvaluationError]] 필드 모두에 기록되며, C는 [[EvaluationError]] 없이 evaluated로 남는다.

마지막으로, 모든 모듈이 비동기적으로 완료되는 cycle이 있는 모듈 그래프를 생각해 보자.

Figure 5: 비동기 순환 모듈 그래프
모듈 A가 모듈 B와 C에 의존하고, 모듈 B는 모듈 D에 의존하며, 모듈 C는 모듈 D와 E에 의존하고, 모듈 D는 모듈 A에 의존하는 모듈 그래프

로딩과 링킹은 이전과 같이 발생하며, 모든 모듈은 [[Status]]가 linked로 설정된 상태가 된다.

A.Evaluate()를 호출하면 A, B, D에 대해 InnerModuleEvaluation을 호출하며, 이들은 모두 evaluating으로 전환된다. 그런 다음 A에 대해 InnerModuleEvaluation이 다시 호출되는데, 이미 evaluating이므로 no-op이다. 이 시점에서 D.[[PendingAsyncDependencies]]는 0이므로 ExecuteAsyncModule(D)가 호출되고, D의 비동기 실행을 추적하는 새 PromiseCapability와 함께 D.ExecuteModule을 호출한다. B에 대한 InnerModuleEvaluation으로 되감아 돌아와 B.[[PendingAsyncDependencies]]를 1로 설정하고 B.[[AsyncEvaluationOrder]]를 1로 설정한다. 원래의 A에 대한 InnerModuleEvaluation으로 되감아 돌아와 A.[[PendingAsyncDependencies]]를 1로 설정한다. A의 의존성에 대한 루프의 다음 반복에서 C에 대해, 따라서 D(다시 no-op)와 E에 대해 InnerModuleEvaluation을 호출한다. E는 의존성이 없고 cycle의 일부가 아니므로, D와 같은 방식으로 ExecuteAsyncModule(E)를 호출하고 E는 즉시 stack에서 제거된다. 다시 C에 대한 InnerModuleEvaluation으로 되감아 돌아와 C.[[AsyncEvaluationOrder]]를 3으로 설정한다. 이제 A의 의존성에 대한 루프를 끝내고, A.[[AsyncEvaluationOrder]]를 4로 설정한 뒤, 전체 강한 연결 요소를 stack에서 제거하여 모든 모듈을 한 번에 evaluating-async로 전환한다. 이 시점에서 모듈들의 필드는 Table 43에 주어진 것과 같다.

Table 43: 초기 Evaluate() 호출 이후 모듈 필드
필드
모듈 		A B C D E
[[DFSAncestorIndex]] 0 0 0 0 4
[[Status]] evaluating-async evaluating-async evaluating-async evaluating-async evaluating-async
[[AsyncEvaluationOrder]] 4 1 3 0 2
[[AsyncParentModules]] « » « A » « A » « B, C » « C »
[[PendingAsyncDependencies]] 2 (B 및 C) 1 (D) 2 (D 및 E) 0 0

E가 먼저 실행을 마친다고 가정하자. 그 일이 발생하면 AsyncModuleExecutionFulfilled가 호출되고, E.[[Status]]는 evaluated로 설정되며, C.[[PendingAsyncDependencies]]는 감소하여 1이 된다. 갱신된 모듈들의 필드는 Table 44에 주어진 것과 같다.

Table 44: 모듈 E가 실행을 마친 뒤의 모듈 필드
필드
모듈 		C E
[[DFSAncestorIndex]] 0 4
[[Status]] evaluating-async evaluated
[[AsyncEvaluationOrder]] 3 done
[[AsyncParentModules]] « A » « C »
[[PendingAsyncDependencies]] 1 (D) 0

다음으로 D가 완료된다(아직 실행 중이던 유일한 모듈이었기 때문이다). 그 일이 발생하면 AsyncModuleExecutionFulfilled가 다시 호출되고 D.[[Status]]는 evaluated로 설정된다. 실행 가능한 조상은 B([[AsyncEvaluationOrder]]가 1)와 C([[AsyncEvaluationOrder]]가 3)이므로, B가 먼저 처리된다. B.[[PendingAsyncDependencies]]는 감소하여 0이 되고, B에 대해 ExecuteAsyncModule이 호출되어 실행을 시작한다. C.[[PendingAsyncDependencies]]도 감소하여 0이 되고, C도 실행을 시작한다(B가 await를 포함한다면 B와 병렬로 실행될 수도 있다). 갱신된 모듈들의 필드는 Table 45에 주어진 것과 같다.

Table 45: 모듈 D가 실행을 마친 뒤의 모듈 필드
필드
모듈 		B C D
[[DFSAncestorIndex]] 0 0 0
[[Status]] evaluating-async evaluating-async evaluated
[[AsyncEvaluationOrder]] 1 3 done
[[AsyncParentModules]] « A » « A » « B, C »
[[PendingAsyncDependencies]] 0 0 0

C가 다음으로 실행을 마친다고 가정하자. 그 일이 발생하면 AsyncModuleExecutionFulfilled가 다시 호출되고, C.[[Status]]는 evaluated로 설정되며, A.[[PendingAsyncDependencies]]는 감소하여 1이 된다. 갱신된 모듈들의 필드는 Table 46에 주어진 것과 같다.

Table 46: 모듈 C가 실행을 마친 뒤의 모듈 필드
필드
모듈 		A C
[[DFSAncestorIndex]] 0 0
[[Status]] evaluating-async evaluated
[[AsyncEvaluationOrder]] 4 done
[[AsyncParentModules]] « » « A »
[[PendingAsyncDependencies]] 1 (B) 0

그런 다음 B가 실행을 마친다. 그 일이 발생하면 AsyncModuleExecutionFulfilled가 다시 호출되고 B.[[Status]]는 evaluated로 설정된다. A.[[PendingAsyncDependencies]]는 감소하여 0이 되므로, ExecuteAsyncModule이 호출되고 실행을 시작한다. 갱신된 모듈들의 필드는 Table 47에 주어진 것과 같다.

Table 47: 모듈 B가 실행을 마친 뒤의 모듈 필드
필드
모듈 		A B
[[DFSAncestorIndex]] 0 0
[[Status]] evaluating-async evaluated
[[AsyncEvaluationOrder]] 4 done
[[AsyncParentModules]] « » « A »
[[PendingAsyncDependencies]] 0 0

마지막으로 A가 실행을 마친다. 그 일이 발생하면 AsyncModuleExecutionFulfilled가 다시 호출되고 A.[[Status]]는 evaluated로 설정된다. 이 시점에서 A.[[TopLevelCapability]] 안의 Promise(A.Evaluate()에서 반환된 것)가 resolve되고, 이것으로 이 모듈 그래프의 처리가 끝난다. 갱신된 모듈의 필드는 Table 48에 주어진 것과 같다.

Table 48: 모듈 A가 실행을 마친 뒤의 모듈 필드
필드
모듈 		A
[[DFSAncestorIndex]] 0
[[Status]] evaluated
[[AsyncEvaluationOrder]] done
[[AsyncParentModules]] « »
[[PendingAsyncDependencies]] 0

또는 B가 실행을 마치기 전에 C가 실행에 실패하고 오류를 반환하는 실패 사례를 생각해 보자. 그 일이 발생하면 AsyncModuleExecutionRejected가 호출되어 C.[[Status]]를 evaluated로 설정하고 C.[[EvaluationError]]를 그 오류로 설정한다. 그런 다음 각 AsyncParentModules에 대해 AsyncModuleExecutionRejected를 수행하여 이 오류를 모든 AsyncParentModules로 전파한다. 갱신된 모듈들의 필드는 Table 49에 주어진 것과 같다.

Table 49: 모듈 C가 오류와 함께 완료된 뒤의 모듈 필드
필드
모듈 		A C
[[DFSAncestorIndex]] 0 0
[[Status]] evaluated evaluated
[[AsyncEvaluationOrder]] done done
[[AsyncParentModules]] « » « A »
[[PendingAsyncDependencies]] 1 (B) 0
[[EvaluationError]] empty C의 평가 오류

C가 C의 오류로 A에 대해 AsyncModuleExecutionRejected를 호출하므로, A는 C와 같은 오류로 reject된다. A.[[Status]]는 evaluated로 설정된다. 이 시점에서 A.[[TopLevelCapability]] 안의 Promise(A.Evaluate()에서 반환된 것)는 reject된다. 갱신된 모듈의 필드는 Table 50에 주어진 것과 같다.

Table 50: 모듈 A가 reject된 뒤의 모듈 필드
필드
모듈 		A
[[DFSAncestorIndex]] 0
[[Status]] evaluated
[[AsyncEvaluationOrder]] done
[[AsyncParentModules]] « »
[[PendingAsyncDependencies]] 0
[[EvaluationError]] C의 Evaluation Error

그런 다음 B가 오류 없이 실행을 마친다. 그 일이 발생하면 AsyncModuleExecutionFulfilled가 다시 호출되고 B.[[Status]]는 evaluated로 설정된다. GatherAvailableAncestors가 B에 대해 호출된다. 그러나 A.[[CycleRoot]]는 평가 오류가 있는 A이므로 반환되는 sortedExecList에 추가되지 않으며 AsyncModuleExecutionFulfilled는 추가 처리 없이 반환된다. 이후 B를 import하는 모든 모듈은 cycle root A에 설정된 C의 평가 오류에서 나온 B.[[CycleRoot]].[[EvaluationError]]의 rejection을 resolve하게 된다. 갱신된 모듈들의 필드는 Table 51에 주어진 것과 같다.

Table 51: 오류가 있는 그래프에서 모듈 B가 실행을 마친 뒤의 모듈 필드
필드
모듈 		A B
[[DFSAncestorIndex]] 0 0
[[Status]] evaluated evaluated
[[AsyncEvaluationOrder]] 4 1
[[AsyncParentModules]] « » « A »
[[PendingAsyncDependencies]] 0 0
[[EvaluationError]] C의 Evaluation Error empty

16.2.1.7 Source Text Module Record

Source Text Module Record는 목표 기호 Module을 사용해 파싱된 ECMAScript 소스 텍스트(11)로부터 정의된 모듈에 관한 정보를 나타내는 데 사용된다. 그 필드들은 모듈이 import하고 export하는 이름에 관한 요약 정보를 포함하며, 그 구체 메서드들은 이 요약 정보를 사용해 모듈을 링크하고 평가한다.

Source Text Module Record는 추상 Module Record 타입의 다른 서브클래스들과 함께 모듈 그래프 안에 존재할 수 있으며, Cyclic Module Record 타입의 다른 서브클래스들과 cycle에 참여할 수 있다.

Table 40에 정의된 필드에 더해, Source Text Module Record는 Table 52에 나열된 추가 필드를 가진다. 이 각 필드는 처음에 ParseModule에서 설정된다.

Table 52: Source Text Module Record의 추가 필드
필드 이름 값 타입 의미
[[ECMAScriptCode]] Parse Node 이 모듈의 소스 텍스트를 Module을 목표 기호로 사용해 파싱한 결과.
[[Context]] ECMAScript 코드 실행 컨텍스트 또는 empty 이 모듈과 관련된 실행 컨텍스트. 모듈의 환경이 초기화될 때까지 empty이다.
[[ImportMeta]] Object 또는 empty import.meta meta property를 통해 노출되는 객체. ECMAScript 코드에 의해 접근될 때까지 empty이다.
[[ImportEntries]] ImportEntry Record의 List 이 모듈의 코드에서 파생된 ImportEntry record의 List.
[[LocalExportEntries]] ExportEntry Record의 List 모듈 안에서 발생하는 선언에 대응하는, 이 모듈의 코드에서 파생된 ExportEntry record의 List.
[[IndirectExportEntries]] ExportEntry Record의 List 모듈 안에서 발생하는 재export된 import 또는 export * as namespace 선언의 export에 대응하는, 이 모듈의 코드에서 파생된 ExportEntry record의 List.
[[StarExportEntries]] ExportEntry Record의 List 모듈 안에서 발생하는 export * 선언에 대응하는, 이 모듈의 코드에서 파생된 ExportEntry record의 List. export * as namespace 선언은 포함하지 않는다.

ImportEntry Record는 단일 선언적 import에 관한 정보를 요약하는 Record이다. 각 ImportEntry Record는 Table 53에 정의된 필드를 가진다:

Table 53: ImportEntry Record 필드
필드 이름 값 타입 의미
[[ModuleRequest]] ModuleRequest Record ImportDeclaration의 ModuleSpecifier 및 import attributes를 나타내는 ModuleRequest Record.
[[ImportName]] String 또는 namespace 원하는 binding이 [[ModuleRequest]]로 식별되는 모듈에 의해 export되는 이름. 값 namespace는 import 요청이 대상 모듈의 namespace object에 대한 것임을 나타낸다.
[[LocalName]] String import하는 모듈 안에서 import된 값을 로컬로 접근하는 데 사용되는 이름.
Note 1

Table 54는 구문적 import 형식을 나타내는 데 사용되는 ImportEntry record 필드의 예를 제공한다:

Table 54 (Informative): Import 형식의 ImportEntry Record 매핑
Import 문 형식 [[ModuleRequest]] [[ImportName]] [[LocalName]]
import v from "mod"; "mod" "default" "v"
import * as ns from "mod"; "mod" namespace "ns"
import {x} from "mod"; "mod" "x" "x"
import {x as v} from "mod"; "mod" "x" "v"
import "mod"; ImportEntry Record는 생성되지 않는다.

ExportEntry Record는 단일 선언적 export에 관한 정보를 요약하는 Record이다. 각 ExportEntry Record는 Table 55에 정의된 필드를 가진다:

Table 55: ExportEntry Record 필드
필드 이름 값 타입 의미
[[ExportName]] String 또는 null 이 모듈이 이 binding을 export하는 데 사용하는 이름.
[[ModuleRequest]] ModuleRequest Record 또는 null ExportDeclaration의 ModuleSpecifier 및 import attributes를 나타내는 ModuleRequest Record. ExportDeclaration이 ModuleSpecifier를 가지지 않으면 null.
[[ImportName]] String, null, namespace, 또는 all-but-default 원하는 binding이 [[ModuleRequest]]로 식별되는 모듈에 의해 export되는 이름. ExportDeclaration이 ModuleSpecifier를 가지지 않으면 null. namespace는 export * as ns from "mod" 선언에 사용된다. all-but-default는 export * from "mod" 선언에 사용된다.
[[LocalName]] String 또는 null import하는 모듈 안에서 export된 값에 로컬로 접근하는 데 사용되는 이름. export된 값이 모듈 안에서 로컬로 접근 가능하지 않으면 null.
Note 2

Table 56는 구문적 export 형식을 나타내는 데 사용되는 ExportEntry record 필드의 예를 제공한다:

Table 56 (Informative): Export 형식의 ExportEntry Record 매핑
Export 문 형식 [[ExportName]] [[ModuleRequest]] [[ImportName]] [[LocalName]]
export var v; "v" null null "v"
export default function f() {} "default" null null "f"
export default function () {} "default" null null "*default*"
export default 42; "default" null null "*default*"
export {x}; "x" null null "x"
export {v as x}; "x" null null "v"
export {x} from "mod"; "x" "mod" "x" null
export {v as x} from "mod"; "x" "mod" "v" null
export * from "mod"; null "mod" all-but-default null
export * as ns from "mod"; "ns" "mod" namespace null

다음 정의들은 Source Text Module Record에 필요한 구체 메서드와 기타 추상 연산을 명시한다

16.2.1.7.1 ParseModule ( sourceText, realm, hostDefined )

The abstract operation ParseModule takes arguments sourceText (ECMAScript source text), realm (a Realm Record), and hostDefined (anything) and returns a Source Text Module Record or a non-empty List of SyntaxError objects. sourceText를 Module로 파싱한 결과를 기반으로 Source Text Module Record를 생성한다. It performs the following steps when called:

  1. body를 ParseText(sourceText, Module)로 둔다.
  2. body가 오류들의 List이면, body를 반환한다.
  3. requestedModules를 body의 ModuleRequests로 둔다.
  4. importEntries를 body의 ImportEntries로 둔다.
  5. importedBoundNames를 ImportedLocalNames(importEntries)로 둔다.
  6. indirectExportEntries를 새 빈 List로 둔다.
  7. localExportEntries를 새 빈 List로 둔다.
  8. starExportEntries를 새 빈 List로 둔다.
  9. exportEntries를 body의 ExportEntries로 둔다.
  10. exportEntries의 각 ExportEntry Record ee에 대해,
    1. ee.[[ModuleRequest]]가 null이면,
      1. importedBoundNames가 ee.[[LocalName]]을 포함하지 않으면,
        1. ee를 localExportEntries에 추가한다.
      2. 그렇지 않으면,
        1. NOTE: 원래 다른 모듈에서 import된 binding 또는 namespace object를 export할 때, ExportEntry Record는 그 binding 또는 namespace object가 import된 뒤 export된 것이 아니라 원래 모듈에서 직접 재export되었다면 가졌을 형식과 일치하도록 다시 작성된다. 이를 통해 export * from을 통해 같은 이름 아래 같은 binding 또는 namespace를 두 번 export하여 생기는 충돌을 Source Text Module Record의 ResolveExport 구체 메서드의 9.e.iii 단계에서 ambiguous로 처리하지 않고 무시할 수 있다.
        2. ie를 [[LocalName]]이 ee.[[LocalName]]인 importEntries의 요소로 둔다.
        3. ExportEntry Record { [[ModuleRequest]]: ie.[[ModuleRequest]], [[ImportName]]: ie.[[ImportName]], [[LocalName]]: null, [[ExportName]]: ee.[[ExportName]] }를 indirectExportEntries에 추가한다.
    2. 그렇지 않고 ee.[[ImportName]]이 all-but-default이면,
      1. Assert: ee.[[ExportName]]은 null이다.
      2. ee를 starExportEntries에 추가한다.
    3. 그렇지 않으면,
      1. ee를 indirectExportEntries에 추가한다.
  11. async를 body Contains await로 둔다.
  12. Source Text Module Record { [[Realm]]: realm, [[Environment]]: empty, [[Namespace]]: empty, [[CycleRoot]]: empty, [[HasTLA]]: async, [[AsyncEvaluationOrder]]: unset, [[TopLevelCapability]]: empty, [[AsyncParentModules]]: « », [[PendingAsyncDependencies]]: empty, [[Status]]: new, [[EvaluationError]]: empty, [[HostDefined]]: hostDefined, [[ECMAScriptCode]]: body, [[Context]]: empty, [[ImportMeta]]: empty, [[RequestedModules]]: requestedModules, [[LoadedModules]]: « », [[ImportEntries]]: importEntries, [[LocalExportEntries]]: localExportEntries, [[IndirectExportEntries]]: indirectExportEntries, [[StarExportEntries]]: starExportEntries, [[DFSAncestorIndex]]: empty }를 반환한다.
 Note

구현은 해당 모듈 소스 텍스트에 대해 ParseModule을 평가하기 전에 모듈 소스 텍스트를 파싱하고 Early Error 조건을 분석할 수 있다. 그러나 모든 오류 보고는 이 명세가 실제로 해당 소스 텍스트에 대해 ParseModule을 수행하는 시점까지 지연되어야 한다.

16.2.1.7.2 Module Record 추상 메서드의 구현

다음은 Table 39에 정의된 해당 Module Record 추상 메서드를 구현하는 Source Text Module Record의 구체 메서드이다.

16.2.1.7.2.1 GetExportedNames ( [ exportStarSet ] )

The GetExportedNames concrete method of a Source Text Module Record module takes optional argument exportStarSet (a List of Source Text Module Records) and returns a List of Strings. It performs the following steps when called:

  1. Assert: module.[[Status]]는 new가 아니다.
  2. exportStarSet이 존재하지 않으면, exportStarSet을 새 빈 List로 설정한다.
  3. exportStarSet이 module을 포함하면,
    1. Assert: export * 순환성의 시작점에 도달했다.
    2. 새 빈 List를 반환한다.
  4. module을 exportStarSet에 추가한다.
  5. exportedNames를 새 빈 List로 둔다.
  6. module.[[LocalExportEntries]]의 각 ExportEntry Record e에 대해,
    1. Assert: module은 이 export에 대한 직접 binding을 제공한다.
    2. Assert: e.[[ExportName]]은 null이 아니다.
    3. e.[[ExportName]]을 exportedNames에 추가한다.
  7. module.[[IndirectExportEntries]]의 각 ExportEntry Record e에 대해,
    1. Assert: module은 이 export에 대한 특정 binding을 import한다.
    2. Assert: e.[[ExportName]]은 null이 아니다.
    3. e.[[ExportName]]을 exportedNames에 추가한다.
  8. module.[[StarExportEntries]]의 각 ExportEntry Record e에 대해,
    1. Assert: e.[[ModuleRequest]]는 null이 아니다.
    2. requestedModule을 GetImportedModule(module, e.[[ModuleRequest]])로 둔다.
    3. starNames를 requestedModule.GetExportedNames(exportStarSet)로 둔다.
    4. starNames의 각 요소 n에 대해,
      1. n이 "default"가 아니면,
        1. exportedNames가 n을 포함하지 않으면,
          1. n을 exportedNames에 추가한다.
  9. exportedNames를 반환한다.
 Note

GetExportedNames는 ambiguous star export binding을 가진 이름을 걸러내거나 그에 대해 예외를 던지지 않는다.

16.2.1.7.2.2 ResolveExport ( exportName [ , resolveSet ] )

The ResolveExport concrete method of a Source Text Module Record module takes argument exportName (a String) and optional argument resolveSet (a List of Records with fields [[Module]] (a Module Record) and [[ExportName]] (a String)) and returns a ResolvedBinding Record, null, or ambiguous.

ResolveExport는 import된 binding을 실제 정의 모듈과 로컬 binding 이름으로 해석하려고 시도한다. 정의 모듈은 이 메서드가 호출된 Module Record가 나타내는 모듈일 수도 있고, 그 모듈이 import하는 다른 모듈일 수도 있다. resolveSet 매개변수는 해소되지 않은 순환 import/export 경로를 감지하는 데 사용된다. 특정 Module Record와 exportName으로 구성된 쌍이 이미 resolveSet에 있는 상태로 도달하면, import 순환성이 발견된 것이다. ResolveExport를 재귀적으로 호출하기 전에 module과 exportName으로 구성된 쌍이 resolveSet에 추가된다.

정의 모듈이 발견되면 ResolvedBinding Record { [[Module]], [[BindingName]] }가 반환된다. 이 record는 원래 요청된 export의 해소된 binding을 식별한다. 단, 로컬 binding이 없는 namespace의 export인 경우는 예외이다. 이 경우 [[BindingName]]은 namespace로 설정된다. 정의가 발견되지 않았거나 요청이 순환적인 것으로 밝혀지면 null이 반환된다. 요청이 ambiguous한 것으로 밝혀지면 ambiguous가 반환된다.

It performs the following steps when called:

  1. Assert: module.[[Status]]는 new가 아니다.
  2. resolveSet이 존재하지 않으면, resolveSet을 새 빈 List로 설정한다.
  3. resolveSet의 각 Record { [[Module]], [[ExportName]] } r에 대해,
    1. module과 r.[[Module]]이 같은 Module Record이고 exportName이 r.[[ExportName]]이면,
      1. Assert: 이것은 순환 import 요청이다.
      2. null을 반환한다.
  4. Record { [[Module]]: module, [[ExportName]]: exportName }를 resolveSet에 추가한다.
  5. module.[[LocalExportEntries]]의 각 ExportEntry Record e에 대해,
    1. e.[[ExportName]]이 exportName이면,
      1. Assert: module은 이 export에 대한 직접 binding을 제공한다.
      2. ResolvedBinding Record { [[Module]]: module, [[BindingName]]: e.[[LocalName]] }를 반환한다.
  6. module.[[IndirectExportEntries]]의 각 ExportEntry Record e에 대해,
    1. e.[[ExportName]]이 exportName이면,
      1. Assert: e.[[ModuleRequest]]는 null이 아니다.
      2. importedModule을 GetImportedModule(module, e.[[ModuleRequest]])로 둔다.
      3. e.[[ImportName]]이 namespace이면,
        1. Assert: module은 이 export에 대한 직접 binding을 제공하지 않는다.
        2. ResolvedBinding Record { [[Module]]: importedModule, [[BindingName]]: namespace }를 반환한다.
      4. Assert: module은 이 export에 대한 특정 binding을 import한다.
      5. Assert: e.[[ImportName]]은 String이다.
      6. importedModule.ResolveExport(e.[[ImportName]], resolveSet)를 반환한다.
  7. exportName이 "default"이면,
    1. Assert: default export는 이 모듈에 의해 명시적으로 정의되지 않았다.
    2. null을 반환한다.
    3. NOTE: default export는 export * from "mod" 선언으로 제공될 수 없다.
  8. starResolution을 null로 둔다.
  9. module.[[StarExportEntries]]의 각 ExportEntry Record e에 대해,
    1. Assert: e.[[ModuleRequest]]는 null이 아니다.
    2. importedModule을 GetImportedModule(module, e.[[ModuleRequest]])로 둔다.
    3. resolution을 importedModule.ResolveExport(exportName, resolveSet)로 둔다.
    4. resolution이 ambiguous이면, ambiguous를 반환한다.
    5. resolution이 null이 아니면,
      1. Assert: resolution은 ResolvedBinding Record이다.
      2. starResolution이 null이면,
        1. starResolution을 resolution으로 설정한다.
      3. 그렇지 않으면,
        1. Assert: 요청된 이름을 포함하는 * export가 둘 이상 있다.
        2. resolution.[[Module]]과 starResolution.[[Module]]이 같은 Module Record가 아니면, ambiguous를 반환한다.
        3. resolution.[[BindingName]]이 starResolution.[[BindingName]]이 아니면, ambiguous를 반환한다.
  10. starResolution을 반환한다.

16.2.1.7.3 Cyclic Module Record 추상 메서드의 구현

다음은 Table 41에 정의된 해당 Cyclic Module Record 추상 메서드를 구현하는 Source Text Module Record의 구체 메서드이다.

16.2.1.7.3.1 InitializeEnvironment ( )

The InitializeEnvironment concrete method of a Source Text Module Record module takes no arguments and returns either a normal completion containing unused or a throw completion. It performs the following steps when called:

  1. module.[[IndirectExportEntries]]의 각 ExportEntry Record e에 대해,
    1. Assert: e.[[ExportName]]은 null이 아니다.
    2. resolution을 module.ResolveExport(e.[[ExportName]])로 둔다.
    3. resolution이 null 또는 ambiguous이면, SyntaxError 예외를 던진다.
    4. Assert: resolution은 ResolvedBinding Record이다.
  2. Assert: module의 모든 named export는 해소 가능하다.
  3. realm을 module.[[Realm]]로 둔다.
  4. Assert: realm은 undefined가 아니다.
  5. env를 NewModuleEnvironment(realm.[[GlobalEnv]])로 둔다.
  6. module.[[Environment]]를 env로 설정한다.
  7. module.[[ImportEntries]]의 각 ImportEntry Record in에 대해,
    1. importedModule을 GetImportedModule(module, in.[[ModuleRequest]])로 둔다.
    2. in.[[ImportName]]이 namespace이면,
      1. namespace를 GetModuleNamespace(importedModule)로 둔다.
      2. ! env.CreateImmutableBinding(in.[[LocalName]], true)를 수행한다.
      3. ! env.InitializeBinding(in.[[LocalName]], namespace)를 수행한다.
    3. 그렇지 않으면,
      1. Assert: in.[[ImportName]]은 String이다.
      2. resolution을 importedModule.ResolveExport(in.[[ImportName]])로 둔다.
      3. resolution이 null 또는 ambiguous이면, SyntaxError 예외를 던진다.
      4. resolution.[[BindingName]]이 namespace이면,
        1. namespace를 GetModuleNamespace(resolution.[[Module]])로 둔다.
        2. ! env.CreateImmutableBinding(in.[[LocalName]], true)를 수행한다.
        3. ! env.InitializeBinding(in.[[LocalName]], namespace)를 수행한다.
      5. 그렇지 않으면,
        1. CreateImportBinding(env, in.[[LocalName]], resolution.[[Module]], resolution.[[BindingName]])을 수행한다.
  8. moduleContext를 새 ECMAScript 코드 실행 컨텍스트로 둔다.
  9. moduleContext의 Function을 null로 설정한다.
  10. Assert: module.[[Realm]]은 undefined가 아니다.
  11. moduleContext의 Realm을 module.[[Realm]]로 설정한다.
  12. moduleContext의 ScriptOrModule을 module로 설정한다.
  13. moduleContext의 VariableEnvironment를 module.[[Environment]]로 설정한다.
  14. moduleContext의 LexicalEnvironment를 module.[[Environment]]로 설정한다.
  15. moduleContext의 PrivateEnvironment를 null로 설정한다.
  16. module.[[Context]]를 moduleContext로 설정한다.
  17. moduleContext를 실행 컨텍스트 stack에 push한다; 이제 moduleContext가 실행 중인 실행 컨텍스트이다.
  18. code를 module.[[ECMAScriptCode]]로 둔다.
  19. varDeclarations를 code의 VarScopedDeclarations로 둔다.
  20. declaredVarNames를 새 빈 List로 둔다.
  21. varDeclarations의 각 요소 d에 대해,
    1. d의 BoundNames의 각 요소 dn에 대해,
      1. declaredVarNames가 dn을 포함하지 않으면,
        1. ! env.CreateMutableBinding(dn, false)를 수행한다.
        2. ! env.InitializeBinding(dn, undefined)를 수행한다.
        3. dn을 declaredVarNames에 추가한다.
  22. lexDeclarations를 code의 LexicallyScopedDeclarations로 둔다.
  23. privateEnv를 null로 둔다.
  24. lexDeclarations의 각 요소 d에 대해,
    1. d의 BoundNames의 각 요소 dn에 대해,
      1. d의 IsConstantDeclaration이 true이면,
        1. ! env.CreateImmutableBinding(dn, true)를 수행한다.
      2. 그렇지 않으면,
        1. ! env.CreateMutableBinding(dn, false)를 수행한다.
      3. d가 FunctionDeclaration, GeneratorDeclaration, AsyncFunctionDeclaration, 또는 AsyncGeneratorDeclaration 중 하나이면,
        1. fo를 인수 env와 privateEnv를 사용한 d의 InstantiateFunctionObject로 둔다.
        2. ! env.InitializeBinding(dn, fo)를 수행한다.
  25. 실행 컨텍스트 stack에서 moduleContext를 제거한다.
  26. unused를 반환한다.

16.2.1.7.3.2 ExecuteModule ( [ capability ] )

The ExecuteModule concrete method of a Source Text Module Record module takes optional argument capability (a PromiseCapability Record) and returns either a normal completion containing unused or a throw completion. It performs the following steps when called:

  1. Assert: module은 링크되었고 그 모듈 환경의 선언들이 인스턴스화되었다.
  2. moduleContext를 module.[[Context]]로 둔다.
  3. module.[[HasTLA]]가 false이면,
    1. Assert: capability는 존재하지 않는다.
    2. 실행 중인 실행 컨텍스트를 suspend한다.
    3. moduleContext를 실행 컨텍스트 stack에 push한다; 이제 moduleContext가 실행 중인 실행 컨텍스트이다.
    4. result를 Completion(module.[[ECMAScriptCode]]의 Evaluation)으로 둔다.
    5. moduleContext를 suspend하고 실행 컨텍스트 stack에서 제거한다.
    6. 이제 실행 컨텍스트 stack의 top에 있는 컨텍스트를 실행 중인 실행 컨텍스트로 resume한다.
    7. result가 abrupt completion이면,
      1. ? result를 반환한다.
  4. 그렇지 않으면,
    1. Assert: capability는 PromiseCapability Record이다.
    2. AsyncBlockStart(capability, module.[[ECMAScriptCode]], moduleContext)를 수행한다.
  5. unused를 반환한다.

16.2.1.8 Synthetic Module Records

Synthetic Module Record는 명세에 의해 정의된 모듈에 대한 정보를 나타내는 데 사용된다. 그 export된 이름들은 생성 시 정적으로 정의되지만, 해당 값들은 SetSyntheticModuleExport를 사용하여 시간이 지남에 따라 변경될 수 있다. 이들은 import나 의존성을 가지지 않는다.

Note
Synthetic Module Record는 다양한 모듈 타입을 정의하는 데 사용될 수 있다. 예를 들어 JSON 모듈이나 CSS 모듈 등이 있다.

Table 38에 정의된 필드에 더해, Synthetic Module Record는 Table 57에 나열된 추가 필드를 가진다.

Table 57: Synthetic Module Record의 추가 필드
필드 이름 값 타입 의미
[[ExportNames]] String의 List 모듈의 export 이름들. 이 리스트에는 중복이 없다.
[[EvaluationSteps]] Abstract Closure 모듈 평가 시 수행할 초기화 로직으로, Synthetic Module Record를 유일한 인수로 받는다. [[ExportNames]]를 수정해서는 안 된다. abrupt completion을 반환할 수 있다.

16.2.1.8.1 CreateDefaultExportSyntheticModule ( defaultExport )

The abstract operation CreateDefaultExportSyntheticModule takes argument defaultExport (an ECMAScript language value) and returns a Synthetic Module Record. default export가 defaultExport인 Synthetic Module Record를 생성한다. It performs the following steps when called:

  1. realm을 현재 Realm Record로 둔다.
  2. setDefaultExport를 (module)을 매개변수로 가지는 새로운 Abstract Closure로 두고, defaultExport를 캡처하며 호출 시 다음 단계를 수행한다:
    1. SetSyntheticModuleExport(module, "default", defaultExport)를 수행한다.
    2. NormalCompletion(unused)을 반환한다.
  3. Synthetic Module Record { [[Realm]]: realm, [[Environment]]: empty, [[Namespace]]: empty, [[HostDefined]]: undefined, [[ExportNames]]: « "default" », [[EvaluationSteps]]: setDefaultExport }를 반환한다.

16.2.1.8.2 ParseJSONModule ( source )

The abstract operation ParseJSONModule takes argument source (a String) and returns either a normal completion containing a Synthetic Module Record, or a throw completion. It performs the following steps when called:

  1. parseResult를 ? ParseJSON(source)로 둔다.
  2. CreateDefaultExportSyntheticModule(parseResult.[[Value]])를 반환한다.

16.2.1.8.3 SetSyntheticModuleExport ( module, exportName, exportValue )

The abstract operation SetSyntheticModuleExport takes arguments module (a Synthetic Module Record), exportName (a String), and exportValue (an ECMAScript language value) and returns unused. 기존 Synthetic Module Record의 export 값을 설정하거나 변경하는 데 사용할 수 있다. It performs the following steps when called:

  1. Assert: module.[[ExportNames]]는 exportName을 포함한다.
  2. envRec을 module.[[Environment]]로 둔다.
  3. Assert: envRec은 empty가 아니다.
  4. ! envRec.SetMutableBinding(exportName, exportValue, true)를 수행한다.
  5. unused를 반환한다.

16.2.1.8.4 Module Record 추상 메서드의 구현

다음은 Table 39에 정의된 해당 Module Record 추상 메서드를 구현하는 Synthetic Module Record의 구체 메서드이다.

16.2.1.8.4.1 LoadRequestedModules ( [ hostDefined ] )

The LoadRequestedModules concrete method of a Synthetic Module Record module takes optional argument hostDefined (anything) and returns a Promise. It performs the following steps when called:

  1. NOTE: 이 LoadRequestedModules 구현은 hostDefined를 사용하지 않는다.
  2. ! PromiseResolve(%Promise%, undefined)를 반환한다.
 Note
Synthetic Module Record는 의존성이 없다.

16.2.1.8.4.2 GetExportedNames ( [ exportStarSet ] )

The GetExportedNames concrete method of a Synthetic Module Record module takes optional argument exportStarSet (a List of Source Text Module Records) and returns a List of Strings. It performs the following steps when called:

  1. NOTE: 이 GetExportedNames 구현은 exportStarSet을 사용하지 않는다.
  2. module.[[ExportNames]]를 반환한다.

16.2.1.8.4.3 ResolveExport ( exportName [ , resolveSet ] )

The ResolveExport concrete method of a Synthetic Module Record module takes argument exportName (a String) and optional argument resolveSet (a List of Records with fields [[Module]] (a Module Record) and [[ExportName]] (a String)) and returns a ResolvedBinding Record, null, or ambiguous. It performs the following steps when called:

  1. NOTE: 이 ResolveExport 구현은 resolveSet을 사용하지 않는다.
  2. module.[[ExportNames]]가 exportName을 포함하지 않으면, null을 반환한다.
  3. ResolvedBinding Record { [[Module]]: module, [[BindingName]]: exportName }를 반환한다.

16.2.1.8.4.4 Link ( )

The Link concrete method of a Synthetic Module Record module takes no arguments and returns a normal completion containing unused. It performs the following steps when called:

  1. realm을 module.[[Realm]]로 둔다.
  2. env를 NewModuleEnvironment(realm.[[GlobalEnv]])로 둔다.
  3. module.[[Environment]]를 env로 설정한다.
  4. module.[[ExportNames]]의 각 String exportName에 대해,
    1. ! env.CreateMutableBinding(exportName, false)를 수행한다.
    2. ! env.InitializeBinding(exportName, undefined)를 수행한다.
  5. NormalCompletion(unused)을 반환한다.

16.2.1.8.4.5 Evaluate ( )

The Evaluate concrete method of a Synthetic Module Record module takes no arguments and returns a Promise. It performs the following steps when called:

  1. moduleContext를 새로운 ECMAScript 코드 실행 컨텍스트로 둔다.
  2. moduleContext의 Function을 null로 설정한다.
  3. moduleContext의 Realm을 module.[[Realm]]로 설정한다.
  4. moduleContext의 ScriptOrModule을 module로 설정한다.
  5. moduleContext의 VariableEnvironment를 module.[[Environment]]로 설정한다.
  6. moduleContext의 LexicalEnvironment를 module.[[Environment]]로 설정한다.
  7. 실행 중인 실행 컨텍스트를 suspend한다.
  8. moduleContext를 실행 컨텍스트 stack에 push한다; 이제 moduleContext가 실행 중인 실행 컨텍스트이다.
  9. steps를 module.[[EvaluationSteps]]로 둔다.
  10. result를 Completion(steps(module))로 둔다.
  11. moduleContext를 suspend하고 실행 컨텍스트 stack에서 제거한다.
  12. 이제 실행 컨텍스트 stack의 top에 있는 컨텍스트를 실행 중인 실행 컨텍스트로 resume한다.
  13. pc를 ! NewPromiseCapability(%Promise%)로 둔다.
  14. IfAbruptRejectPromise(result, pc).
  15. ! Call(pc.[[Resolve]], undefined, « undefined »)를 수행한다.
  16. pc.[[Promise]]를 반환한다.

16.2.1.9 GetImportedModule ( referrer, request )

The abstract operation GetImportedModule takes arguments referrer (a Cyclic Module Record) and request (a ModuleRequest Record) and returns a Module Record. It performs the following steps when called:

  1. records를 referrer.[[LoadedModules]]의 각 LoadedModuleRequest Record r 중 ModuleRequestsEqual(r, request)가 true인 것들로 구성된 List로 둔다.
  2. Assert: LoadRequestedModules가 이 추상 연산을 호출하기 전에 referrer에서 성공적으로 완료되었으므로 records는 정확히 하나의 요소를 가진다.
  3. record를 records의 유일한 요소로 둔다.
  4. record.[[Module]]을 반환한다.

16.2.1.10 HostLoadImportedModule ( referrer, moduleRequest, hostDefined, payload )

The host-defined abstract operation HostLoadImportedModule takes arguments referrer (a Script Record, a Cyclic Module Record, or a Realm Record), moduleRequest (a ModuleRequest Record), hostDefined (anything), and payload (a GraphLoadingState Record or a PromiseCapability Record) and returns unused.

Note 1

referrer가 Realm Record가 될 수 있는 예는 웹 브라우저 호스트에서 찾을 수 있다. 예를 들어 사용자가 다음과 같은 컨트롤을 클릭할 때

<button type="button" onclick="import('./foo.mjs')">Click me</button>

import() 표현식이 실행되는 시점에는 활성 script나 module이 존재하지 않는다. 더 일반적으로는, 호스트가 ScriptOrModule 구성 요소가 null인 실행 컨텍스트를 실행 컨텍스트 스택에 push하는 모든 상황에서 발생할 수 있다.

HostLoadImportedModule의 구현은 다음 요구 사항을 준수해야 한다:

실제 수행되는 과정은 호스트 정의이지만, 일반적으로 적절한 Module Record를 로드하기 위해 필요한 I/O 작업을 수행하는 것으로 구성된다. 서로 다른 (referrer, moduleRequest.[[Specifier]], moduleRequest.[[Attributes]]) 삼중 조합이 동일한 Module Record 인스턴스로 매핑될 수 있다. 실제 매핑 의미론은 호스트 정의이지만, 일반적으로 매핑 과정에서 specifier에 대한 정규화 과정이 적용된다. 전형적인 정규화 과정에는 상대 경로 및 축약된 경로 지정자의 확장과 같은 작업이 포함된다.

Note 2

위의 텍스트는 type: "json"으로 import될 때 JSON 모듈을 지원해야 함을 요구하지만(HostLoadImportedModule이 정상적으로 완료되는 경우), type: "json" 없이 import될 때 JSON 모듈을 지원하는 것을 금지하지는 않는다.

16.2.1.11 FinishLoadingImportedModule ( referrer, moduleRequest, payload, result )

The abstract operation FinishLoadingImportedModule takes arguments referrer (a Script Record, a Cyclic Module Record, or a Realm Record), moduleRequest (a ModuleRequest Record), payload (a GraphLoadingState Record or a PromiseCapability Record), and result (either a normal completion containing a Module Record or a throw completion) and returns unused. It performs the following steps when called:

  1. result가 normal completion이면,
    1. referrer.[[LoadedModules]]에 ModuleRequestsEqual(record, moduleRequest)가 true인 LoadedModuleRequest Record record가 포함되어 있으면,
      1. Assert: record.[[Module]]과 result.[[Value]]는 동일한 Module Record이다.
    2. 그렇지 않으면,
      1. LoadedModuleRequest Record { [[Specifier]]: moduleRequest.[[Specifier]], [[Attributes]]: moduleRequest.[[Attributes]], [[Module]]: result.[[Value]] }를 referrer.[[LoadedModules]]에 추가한다.
  2. payload가 GraphLoadingState Record이면,
    1. ContinueModuleLoading(payload, result)를 수행한다.
  3. 그렇지 않으면,
    1. ContinueDynamicImport(payload, result)를 수행한다.
  4. unused를 반환한다.

16.2.1.12 AllImportAttributesSupported ( attributes )

The abstract operation AllImportAttributesSupported takes argument attributes (a List of ImportAttribute Records) and returns a Boolean. It performs the following steps when called:

  1. supported를 HostGetSupportedImportAttributes()로 둔다.
  2. attributes의 각 ImportAttribute Record attribute에 대해,
    1. supported가 attribute.[[Key]]를 포함하지 않으면, false를 반환한다.
  3. true를 반환한다.

16.2.1.12.1 HostGetSupportedImportAttributes ( )

The host-defined abstract operation HostGetSupportedImportAttributes takes no arguments and returns a List of Strings. 호스트 환경이 지원하는 import attributes를 지정할 수 있도록 한다. 지원되는 키를 가진 attribute만 호스트에 전달된다.

HostGetSupportedImportAttributes의 구현은 다음 요구 사항을 준수해야 한다:

  • 각각 지원되는 attribute를 나타내는 String의 List를 반환해야 한다.
  • 이 연산이 호출될 때마다 동일한 순서와 동일한 내용을 가진 List를 반환해야 한다.

HostGetSupportedImportAttributes의 기본 구현은 새로운 빈 List를 반환하는 것이다.

Note
호스트가 처리할 attribute를 선택하도록 모든 attribute를 전달하는 대신, 지원되는 import attribute를 명시하도록 요구하는 목적은 지원되지 않는 attribute가 서로 다른 호스트 간에 일관되게 처리되도록 보장하기 위함이다.

16.2.1.13 GetModuleNamespace ( module )

The abstract operation GetModuleNamespace takes argument module (an instance of a concrete subclass of Module Record) and returns a Module Namespace Object. module의 export를 나타내는 Module Namespace Object를 가져오며, 처음 요청될 때 지연 생성하고 이후 재사용을 위해 module.[[Namespace]]에 저장한다. It performs the following steps when called:

  1. Assert: module이 Cyclic Module Record이면, module.[[Status]]는 new 또는 unlinked가 아니다.
  2. namespace를 module.[[Namespace]]로 둔다.
  3. namespace가 empty이면,
    1. exportedNames를 module.GetExportedNames()로 둔다.
    2. unambiguousNames를 새 빈 List로 둔다.
    3. exportedNames의 각 요소 name에 대해,
      1. resolution을 module.ResolveExport(name)로 둔다.
      2. resolution이 ResolvedBinding Record이면 name을 unambiguousNames에 추가한다.
    4. namespace를 ModuleNamespaceCreate(module, unambiguousNames)로 설정한다.
  4. namespace를 반환한다.
 Note

GetModuleNamespace는 절대 예외를 던지지 않는다. 대신 해소할 수 없는 이름은 이 시점에서 단순히 namespace에서 제외된다. 이러한 이름들은 나중에 실제 링크 오류로 이어지지만, 어디에서도 명시적으로 요청되지 않는 ambiguous star export인 경우에는 예외가 발생하지 않을 수 있다.

16.2.1.14 Runtime Semantics: Evaluation

Module : [empty]
  1. undefined를 반환한다.
 ModuleBody : ModuleItemList
  1. result를 ModuleItemList의 Evaluation의 Completion으로 둔다.
  2. result가 normal completion이고 result.[[Value]]가 empty이면,
    1. undefined를 반환한다.
  3. ? result를 반환한다.
 ModuleItemList : ModuleItemList ModuleItem
  1. sl을 ? ModuleItemList의 Evaluation으로 둔다.
  2. s를 ModuleItem의 Evaluation의 Completion으로 둔다.
  3. ? UpdateEmpty(s, sl)를 반환한다.
 Note

ModuleItemList의 값은 해당 리스트에서 값을 생성하는 마지막 항목의 값이다.

 ModuleItem : ImportDeclaration
  1. empty를 반환한다.

16.2.2 Imports

Syntax

ImportDeclaration : import ImportClause FromClause WithClauseopt ; import ModuleSpecifier WithClauseopt ; ImportClause : ImportedDefaultBinding NameSpaceImport NamedImports ImportedDefaultBinding , NameSpaceImport ImportedDefaultBinding , NamedImports ImportedDefaultBinding : ImportedBinding NameSpaceImport : * as ImportedBinding NamedImports : { } { ImportsList } { ImportsList , } FromClause : from ModuleSpecifier ImportsList : ImportSpecifier ImportsList , ImportSpecifier ImportSpecifier : ImportedBinding ModuleExportName as ImportedBinding ModuleSpecifier : StringLiteral ImportedBinding : BindingIdentifier[~Yield, +Await] WithClause : with { } with { WithEntries ,opt } WithEntries : AttributeKey : StringLiteral AttributeKey : StringLiteral , WithEntries AttributeKey : IdentifierName StringLiteral

16.2.2.1 Static Semantics: Early Errors

ModuleItem : ImportDeclaration WithClause : with { WithEntries ,opt }

16.2.2.2 Static Semantics: ImportEntries

The syntax-directed operation ImportEntries takes no arguments and returns a List of ImportEntry Records. It is defined piecewise over the following productions:

Module : [empty]
  1. 새 빈 List를 반환한다.
 ModuleItemList : ModuleItemList ModuleItem
  1. entries1을 ModuleItemList의 ImportEntries로 둔다.
  2. entries2를 ModuleItem의 ImportEntries로 둔다.
  3. entries1과 entries2의 list-concatenation을 반환한다.
 ModuleItem : ExportDeclaration StatementListItem
  1. 새 빈 List를 반환한다.
 ImportDeclaration : import ImportClause FromClause WithClauseopt ;
  1. module을 ImportDeclaration의 ModuleRequests의 유일한 요소로 둔다.
  2. 인수 module을 사용한 ImportClause의 ImportEntriesForModule을 반환한다.
 ImportDeclaration : import ModuleSpecifier WithClauseopt ;
  1. 새 빈 List를 반환한다.

16.2.2.3 Static Semantics: ImportEntriesForModule

The syntax-directed operation ImportEntriesForModule takes argument module (a ModuleRequest Record) and returns a List of ImportEntry Records. It is defined piecewise over the following productions:

ImportClause : ImportedDefaultBinding , NameSpaceImport
  1. entries1을 인수 module을 사용한 ImportedDefaultBinding의 ImportEntriesForModule로 둔다.
  2. entries2를 인수 module을 사용한 NameSpaceImport의 ImportEntriesForModule로 둔다.
  3. entries1과 entries2의 list-concatenation을 반환한다.
 ImportClause : ImportedDefaultBinding , NamedImports
  1. entries1을 인수 module을 사용한 ImportedDefaultBinding의 ImportEntriesForModule로 둔다.
  2. entries2를 인수 module을 사용한 NamedImports의 ImportEntriesForModule로 둔다.
  3. entries1과 entries2의 list-concatenation을 반환한다.
 ImportedDefaultBinding : ImportedBinding
  1. localName을 ImportedBinding의 BoundNames의 유일한 요소로 둔다.
  2. defaultEntry를 ImportEntry Record { [[ModuleRequest]]: module, [[ImportName]]: "default", [[LocalName]]: localName }로 둔다.
  3. « defaultEntry »를 반환한다.
 NameSpaceImport : * as ImportedBinding
  1. localName을 ImportedBinding의 StringValue로 둔다.
  2. entry를 ImportEntry Record { [[ModuleRequest]]: module, [[ImportName]]: namespace, [[LocalName]]: localName }로 둔다.
  3. « entry »를 반환한다.
 NamedImports : { }
  1. 새 빈 List를 반환한다.
 ImportsList : ImportsList , ImportSpecifier
  1. specs1을 인수 module을 사용한 ImportsList의 ImportEntriesForModule로 둔다.
  2. specs2를 인수 module을 사용한 ImportSpecifier의 ImportEntriesForModule로 둔다.
  3. specs1과 specs2의 list-concatenation을 반환한다.
 ImportSpecifier : ImportedBinding
  1. localName을 ImportedBinding의 BoundNames의 유일한 요소로 둔다.
  2. entry를 ImportEntry Record { [[ModuleRequest]]: module, [[ImportName]]: localName, [[LocalName]]: localName }로 둔다.
  3. « entry »를 반환한다.
 ImportSpecifier : ModuleExportName as ImportedBinding
  1. importName을 ModuleExportName의 StringValue로 둔다.
  2. localName을 ImportedBinding의 StringValue로 둔다.
  3. entry를 ImportEntry Record { [[ModuleRequest]]: module, [[ImportName]]: importName, [[LocalName]]: localName }로 둔다.
  4. « entry »를 반환한다.

16.2.2.4 Static Semantics: WithClauseToAttributes

The syntax-directed operation WithClauseToAttributes takes no arguments and returns a List of ImportAttribute Records. It is defined piecewise over the following productions:

WithClause : with { }
  1. 새 빈 List를 반환한다.
 WithClause : with { WithEntries ,opt }
  1. attributes를 WithEntries의 WithClauseToAttributes로 둔다.
  2. attributes를 [[Key]] 필드의 사전식 순서에 따라 정렬하되, 각 해당 필드의 값을 UTF-16 코드 단위 값의 시퀀스로 취급한다. NOTE: 이 정렬은 호스트가 attribute가 열거되는 순서를 기반으로 동작을 변경하는 것이 금지된다는 점에서만 관찰 가능하다.
  3. attributes를 반환한다.
 WithEntries : AttributeKey : StringLiteral
  1. key를 AttributeKey의 PropName으로 둔다.
  2. entry를 ImportAttribute Record { [[Key]]: key, [[Value]]: StringLiteral의 SV }로 둔다.
  3. « entry »를 반환한다.
 WithEntries : AttributeKey : StringLiteral , WithEntries
  1. key를 AttributeKey의 PropName으로 둔다.
  2. entry를 ImportAttribute Record { [[Key]]: key, [[Value]]: StringLiteral의 SV }로 둔다.
  3. rest를 WithEntries의 WithClauseToAttributes로 둔다.
  4. « entry »와 rest의 list-concatenation을 반환한다.

16.2.3 Exports

Syntax

ExportDeclaration : export ExportFromClause FromClause WithClauseopt ; export NamedExports ; export VariableStatement[~Yield, +Await] export Declaration[~Yield, +Await] export default HoistableDeclaration[~Yield, +Await, +Default] export default ClassDeclaration[~Yield, +Await, +Default] export default [lookahead ∉ { function, async [no LineTerminator here] function, class }] AssignmentExpression[+In, ~Yield, +Await] ; ExportFromClause : * * as ModuleExportName NamedExports NamedExports : { } { ExportsList } { ExportsList , } ExportsList : ExportSpecifier ExportsList , ExportSpecifier ExportSpecifier : ModuleExportName ModuleExportName as ModuleExportName

16.2.3.1 Static Semantics: Early Errors

ExportDeclaration : export NamedExports ; Note

위 규칙은 NamedExports의 각 ReferencedBindings가 IdentifierReference로 취급됨을 의미한다.

16.2.3.2 Static Semantics: ExportedBindings

The syntax-directed operation ExportedBindings takes no arguments and returns a List of Strings.

Note

ExportedBindings는 Module의 ExportedNames와 명시적으로 연결된 로컬 바인딩 이름이다.

It is defined piecewise over the following productions:

ModuleItemList : ModuleItemList ModuleItem
  1. names1을 ModuleItemList의 ExportedBindings로 둔다.
  2. names2를 ModuleItem의 ExportedBindings로 둔다.
  3. names1과 names2의 list-concatenation을 반환한다.
 ModuleItem : ImportDeclaration StatementListItem
  1. 새 빈 List를 반환한다.
 ExportDeclaration : export ExportFromClause FromClause WithClauseopt ;
  1. 새 빈 List를 반환한다.
 ExportDeclaration : export NamedExports ;
  1. NamedExports의 ExportedBindings를 반환한다.
 ExportDeclaration : export VariableStatement
  1. VariableStatement의 BoundNames를 반환한다.
 ExportDeclaration : export Declaration
  1. Declaration의 BoundNames를 반환한다.
 ExportDeclaration : export default HoistableDeclaration export default ClassDeclaration export default AssignmentExpression ;
  1. 이 ExportDeclaration의 BoundNames를 반환한다.
 NamedExports : { }
  1. 새 빈 List를 반환한다.
 ExportsList : ExportsList , ExportSpecifier
  1. names1을 ExportsList의 ExportedBindings로 둔다.
  2. names2를 ExportSpecifier의 ExportedBindings로 둔다.
  3. names1과 names2의 list-concatenation을 반환한다.
 ExportSpecifier : ModuleExportName
  1. 유일한 요소가 ModuleExportName의 StringValue인 List를 반환한다.
 ExportSpecifier : ModuleExportName as ModuleExportName
  1. 유일한 요소가 첫 번째 ModuleExportName의 StringValue인 List를 반환한다.

16.2.3.3 Static Semantics: ExportedNames

The syntax-directed operation ExportedNames takes no arguments and returns a List of Strings.

Note

ExportedNames는 Module이 자신의 로컬 이름 binding 중 하나에 명시적으로 매핑하는 외부에 보이는 이름이다.

It is defined piecewise over the following productions:

ModuleItemList : ModuleItemList ModuleItem
  1. names1을 ModuleItemList의 ExportedNames로 둔다.
  2. names2를 ModuleItem의 ExportedNames로 둔다.
  3. names1과 names2의 list-concatenation을 반환한다.
 ModuleItem : ExportDeclaration
  1. ExportDeclaration의 ExportedNames를 반환한다.
 ModuleItem : ImportDeclaration StatementListItem
  1. 새 빈 List를 반환한다.
 ExportDeclaration : export ExportFromClause FromClause WithClauseopt ;
  1. ExportFromClause의 ExportedNames를 반환한다.
 ExportFromClause : *
  1. 새 빈 List를 반환한다.
 ExportFromClause : * as ModuleExportName
  1. 유일한 요소가 ModuleExportName의 StringValue인 List를 반환한다.
 ExportFromClause : NamedExports
  1. NamedExports의 ExportedNames를 반환한다.
 ExportDeclaration : export VariableStatement
  1. VariableStatement의 BoundNames를 반환한다.
 ExportDeclaration : export Declaration
  1. Declaration의 BoundNames를 반환한다.
 ExportDeclaration : export default HoistableDeclaration export default ClassDeclaration export default AssignmentExpression ;
  1. « "default" »를 반환한다.
 NamedExports : { }
  1. 새 빈 List를 반환한다.
 ExportsList : ExportsList , ExportSpecifier
  1. names1을 ExportsList의 ExportedNames로 둔다.
  2. names2를 ExportSpecifier의 ExportedNames로 둔다.
  3. names1과 names2의 list-concatenation을 반환한다.
 ExportSpecifier : ModuleExportName
  1. 유일한 요소가 ModuleExportName의 StringValue인 List를 반환한다.
 ExportSpecifier : ModuleExportName as ModuleExportName
  1. 유일한 요소가 두 번째 ModuleExportName의 StringValue인 List를 반환한다.

16.2.3.4 Static Semantics: ExportEntries

The syntax-directed operation ExportEntries takes no arguments and returns a List of ExportEntry Records. It is defined piecewise over the following productions:

Module : [empty]
  1. 새 빈 List를 반환한다.
 ModuleItemList : ModuleItemList ModuleItem
  1. entries1을 ModuleItemList의 ExportEntries로 둔다.
  2. entries2를 ModuleItem의 ExportEntries로 둔다.
  3. entries1과 entries2의 list-concatenation을 반환한다.
 ModuleItem : ImportDeclaration StatementListItem
  1. 새 빈 List를 반환한다.
 ExportDeclaration : export ExportFromClause FromClause WithClauseopt ;
  1. module을 ExportDeclaration의 ModuleRequests의 유일한 요소로 둔다.
  2. 인수 module을 사용한 ExportFromClause의 ExportEntriesForModule을 반환한다.
 ExportDeclaration : export NamedExports ;
  1. 인수 null을 사용한 NamedExports의 ExportEntriesForModule을 반환한다.
 ExportDeclaration : export VariableStatement
  1. entries를 새 빈 List로 둔다.
  2. names를 VariableStatement의 BoundNames로 둔다.
  3. names의 각 요소 name에 대해,
    1. ExportEntry Record { [[ModuleRequest]]: null, [[ImportName]]: null, [[LocalName]]: name, [[ExportName]]: name }를 entries에 추가한다.
  4. entries를 반환한다.
 ExportDeclaration : export Declaration
  1. entries를 새 빈 List로 둔다.
  2. names를 Declaration의 BoundNames로 둔다.
  3. names의 각 요소 name에 대해,
    1. ExportEntry Record { [[ModuleRequest]]: null, [[ImportName]]: null, [[LocalName]]: name, [[ExportName]]: name }를 entries에 추가한다.
  4. entries를 반환한다.
 ExportDeclaration : export default HoistableDeclaration
  1. names를 HoistableDeclaration의 BoundNames로 둔다.
  2. localName을 names의 유일한 요소로 둔다.
  3. 유일한 요소가 새 ExportEntry Record { [[ModuleRequest]]: null, [[ImportName]]: null, [[LocalName]]: localName, [[ExportName]]: "default" }인 List를 반환한다.
 ExportDeclaration : export default ClassDeclaration
  1. names를 ClassDeclaration의 BoundNames로 둔다.
  2. localName을 names의 유일한 요소로 둔다.
  3. 유일한 요소가 새 ExportEntry Record { [[ModuleRequest]]: null, [[ImportName]]: null, [[LocalName]]: localName, [[ExportName]]: "default" }인 List를 반환한다.
 ExportDeclaration : export default AssignmentExpression ;
  1. entry를 ExportEntry Record { [[ModuleRequest]]: null, [[ImportName]]: null, [[LocalName]]: "*default*", [[ExportName]]: "default" }로 둔다.
  2. « entry »를 반환한다.
 Note

"*default*"는 이 명세 안에서 익명 default export 값에 대한 synthetic name으로 사용된다. 자세한 내용은 이 노트를 보라.

16.2.3.5 Static Semantics: ExportEntriesForModule

The syntax-directed operation ExportEntriesForModule takes argument module (a ModuleRequest Record or null) and returns a List of ExportEntry Records. It is defined piecewise over the following productions:

ExportFromClause : *
  1. entry를 ExportEntry Record { [[ModuleRequest]]: module, [[ImportName]]: all-but-default, [[LocalName]]: null, [[ExportName]]: null }로 둔다.
  2. « entry »를 반환한다.
 ExportFromClause : * as ModuleExportName
  1. exportName을 ModuleExportName의 StringValue로 둔다.
  2. entry를 ExportEntry Record { [[ModuleRequest]]: module, [[ImportName]]: namespace, [[LocalName]]: null, [[ExportName]]: exportName }로 둔다.
  3. « entry »를 반환한다.
 NamedExports : { }
  1. 새 빈 List를 반환한다.
 ExportsList : ExportsList , ExportSpecifier
  1. specs1을 인수 module을 사용한 ExportsList의 ExportEntriesForModule로 둔다.
  2. specs2를 인수 module을 사용한 ExportSpecifier의 ExportEntriesForModule로 둔다.
  3. specs1과 specs2의 list-concatenation을 반환한다.
 ExportSpecifier : ModuleExportName
  1. sourceName을 ModuleExportName의 StringValue로 둔다.
  2. module이 null이면,
    1. localName을 sourceName으로 둔다.
    2. importName을 null로 둔다.
  3. 그렇지 않으면,
    1. localName을 null로 둔다.
    2. importName을 sourceName으로 둔다.
  4. 유일한 요소가 새 ExportEntry Record { [[ModuleRequest]]: module, [[ImportName]]: importName, [[LocalName]]: localName, [[ExportName]]: sourceName }인 List를 반환한다.
 ExportSpecifier : ModuleExportName as ModuleExportName
  1. sourceName을 첫 번째 ModuleExportName의 StringValue로 둔다.
  2. exportName을 두 번째 ModuleExportName의 StringValue로 둔다.
  3. module이 null이면,
    1. localName을 sourceName으로 둔다.
    2. importName을 null로 둔다.
  4. 그렇지 않으면,
    1. localName을 null로 둔다.
    2. importName을 sourceName으로 둔다.
  5. 유일한 요소가 새 ExportEntry Record { [[ModuleRequest]]: module, [[ImportName]]: importName, [[LocalName]]: localName, [[ExportName]]: exportName }인 List를 반환한다.

16.2.3.6 Static Semantics: ReferencedBindings

The syntax-directed operation ReferencedBindings takes no arguments and returns a List of Parse Nodes. It is defined piecewise over the following productions:

NamedExports : { }
  1. 새 빈 List를 반환한다.
 ExportsList : ExportsList , ExportSpecifier
  1. names1을 ExportsList의 ReferencedBindings로 둔다.
  2. names2를 ExportSpecifier의 ReferencedBindings로 둔다.
  3. names1과 names2의 list-concatenation을 반환한다.
 ExportSpecifier : ModuleExportName as ModuleExportName
  1. 첫 번째 ModuleExportName의 ReferencedBindings를 반환한다.
 ModuleExportName : IdentifierName
  1. 유일한 요소가 IdentifierName인 List를 반환한다.
 ModuleExportName : StringLiteral
  1. 유일한 요소가 StringLiteral인 List를 반환한다.

16.2.3.7 Runtime Semantics: Evaluation

ExportDeclaration : export ExportFromClause FromClause WithClauseopt ; export NamedExports ;
  1. empty를 반환한다.
 ExportDeclaration : export VariableStatement
  1. ? VariableStatement의 Evaluation을 반환한다.
 ExportDeclaration : export Declaration
  1. ? Declaration의 Evaluation을 반환한다.
 ExportDeclaration : export default HoistableDeclaration
  1. ? HoistableDeclaration의 Evaluation을 반환한다.
 ExportDeclaration : export default ClassDeclaration
  1. value를 ? ClassDeclaration의 BindingClassDeclarationEvaluation으로 둔다.
  2. className을 ClassDeclaration의 BoundNames의 유일한 요소로 둔다.
  3. className이 "*default*"이면,
    1. env를 실행 중인 실행 컨텍스트의 LexicalEnvironment로 둔다.
    2. ? InitializeBoundName("*default*", value, env)를 수행한다.
  4. empty를 반환한다.
 ExportDeclaration : export default AssignmentExpression ;
  1. IsAnonymousFunctionDefinition(AssignmentExpression)이 true이면,
    1. value를 인수 "default"를 사용한 AssignmentExpression의 ? NamedEvaluation으로 둔다.
  2. 그렇지 않으면,
    1. rhs를 ? AssignmentExpression의 Evaluation으로 둔다.
    2. value를 ? GetValue(rhs)로 둔다.
  3. env를 실행 중인 실행 컨텍스트의 LexicalEnvironment로 둔다.
  4. ? InitializeBoundName("*default*", value, env)를 수행한다.
  5. empty를 반환한다.