서비스 워커 나이트리

3.1.4. postMessage(message, transfer)

postMessage(message, transfer) 메서드 단계:

1. options를 «[ "transfer" → transfer ]»로 한다.

2. postMessage(message, options) 를 message와 options로 호출한다.

3.1.5. postMessage(message, options)

postMessage(message, options) 메서드 단계:

1. serviceWorker를 service worker로, this가 나타내는 서비스 워커로 설정한다.

2. incumbentSettings를 현재 settings object로 설정한다.

3. incumbentGlobal를 incumbentSettings의 글로벌 객체로 설정한다.

4. serializeWithTransferResult를 StructuredSerializeWithTransfer(message, options["transfer"]) 호출 결과로 설정한다. 예외가 발생하면 다시 던진다.

5. "message"와 serviceWorker를 인자로 Should Skip Event 알고리즘을 실행한 결과가 true라면, return 한다.

6. 다음 하위 단계들을 병렬로 실행한다:

   1. Run Service Worker 알고리즘을 serviceWorker로 실행한 결과가 failure이면, return 한다.

   2. Queue a task를 DOM manipulation task source 에 생성하여, 다음 단계들을 실행한다:

      1. source를 incumbentGlobal 타입에 따라 결정한다:

         ServiceWorkerGlobalScope

         incumbentGlobal의 service worker를 relevant settings object(즉, serviceWorker의 글로벌 객체에 해당하는 설정 객체)에서 get the service worker object 실행 결과로 선택한다.

         Window

         incumbentGlobal의 relevant settings object를 나타내는 새로운 WindowClient 객체로 선택한다.

         그 외

         incumbentGlobal의 연결된 worker를 나타내는 새로운 Client 객체로 선택한다.

      2. origin을 incumbentSettings의 origin 값으로 설정한다.

      3. destination을 serviceWorker에 연결된 ServiceWorkerGlobalScope 객체로 설정한다.

      4. deserializeRecord를 StructuredDeserializeWithTransfer(serializeWithTransferResult, destination의 Realm) 실행 결과로 설정한다.

         예외가 발생하면, e를 event 생성 결과로 설정한다. 이벤트 이름은 messageerror이고, ExtendableMessageEvent를 사용하며, origin을 origin으로, source 속성을 source로 초기화한다.

      5. 그 외의 경우:

         1. messageClone을 deserializeRecord의 [[Deserialized]] 값으로 설정한다.

         2. newPorts를 frozen array로 생성하며, deserializeRecord의 [[TransferredValues]] 내 모든 MessagePort 객체를 포함, 상대 순서 유지한다.

         3. e를 event 생성 결과로 설정. 이름은 message이고, ExtendableMessageEvent 사용. origin을 origin으로, source를 source로, data를 messageClone으로, ports를 newPorts로 초기화한다.

      6. Dispatch e를 destination에 보낸다.

      7. Update Service Worker Extended Events Set을 serviceWorker와 e를 인자로 호출한다.

3.2.2. installing

installing 속성은 마지막으로 설정된 값을 반환해야 합니다.

참고: Realm 내에서는, 연관된 서비스 워커마다 하나의 ServiceWorker 객체만 존재합니다.

3.2.3. waiting

waiting 속성은 마지막으로 설정된 값을 반환해야 합니다.

참고: Realm 내에서는, 연관된 서비스 워커마다 하나의 ServiceWorker 객체만 존재합니다.

3.2.4. active

active 속성은 마지막으로 설정된 값을 반환해야 합니다.

참고: Realm 내에서는, 연관된 서비스 워커마다 하나의 ServiceWorker 객체만 존재합니다.

3.2.5. navigationPreload

navigationPreload getter 단계는 서비스 워커 등록의 NavigationPreloadManager 객체를 반환한다.

3.2.6. scope

scope getter 단계는 서비스 워커 등록의 직렬화된 scope url을 반환한다.

3.2.7. updateViaCache

updateViaCache getter 단계는 서비스 워커 등록의 update via cache mode를 반환한다.

3.2.8. update()

update() 메서드 단계:

1. registration을 서비스 워커 등록으로 한다.

2. newestWorker를 최신 워커 얻기 알고리즘을 registration을 인자로 실행한 결과로 한다.

3. newestWorker가 null이면, "InvalidStateError" DOMException으로 거부된 프라미스를 반환하고 단계를 중단한다.

4. this의 관련 글로벌 객체 globalObject가 ServiceWorkerGlobalScope 객체이고, globalObject에 연관된 서비스 워커의 상태가 "installing"이면, "InvalidStateError" DOMException으로 거부된 프라미스를 반환하고 단계를 중단한다.

5. promise를 프라미스로 한다.

6. job을 작업 생성 알고리즘을 update, registration의 storage key, registration의 scope url, newestWorker의 script url, promise, this의 관련 settings object를 인자로 실행한 결과로 한다.

7. job의 worker type을 newestWorker의 type으로 설정한다.

8. 작업 예약을 job로 호출한다.

9. promise를 반환한다.

3.2.9. unregister()

참고: unregister() 메서드는 서비스 워커 등록을 등록 해제합니다. 현재 제어된 서비스 워커 클라이언트의 active service worker의 등록 정보는 해당 서비스 워커 등록을 사용하는 모든 서비스 워커 클라이언트 (자기 자신 포함)가 언로드될 때까지 유효합니다. 즉, unregister() 메서드는 이후의 내비게이션에만 영향을 미칩니다.

unregister() 메서드 단계:

1. registration을 서비스 워커 등록으로 한다.

2. promise를 새 프라미스로 한다.

3. job을 작업 생성 알고리즘을 unregister, registration의 storage key, registration의 scope url, null, promise, this의 관련 settings object를 인자로 실행한 결과로 한다.

4. 작업 예약을 job로 호출한다.

5. promise를 반환한다.

3.4.1. controller

controller 속성은 다음 단계를 반드시 실행해야 한다:

1. client를 this의 서비스 워커 클라이언트로 한다.

2. client의 active service worker 값이 null이면, null을 반환한다.

3. client의 active service worker를 서비스 워커 객체 얻기로 얻은 값을 this의 settings object에서 반환한다.

참고: navigator.serviceWorker.controller 는 요청이 강제 새로고침(shift+refresh)일 때 null을 반환한다.

3.4.2. ready

ready 속성은 다음 단계를 반드시 실행해야 한다:

1. this의 ready promise가 null이면, this의 ready promise를 새 프라미스로 설정한다.

2. readyPromise를 this의 ready promise로 한다.

3. readyPromise가 pending이면, 다음 하위 단계를 병렬로 실행한다:

   1. client를 this의 서비스 워커 클라이언트로 한다.

   2. storage key를 obtain a storage key를 client에 대해 실행한 결과로 한다.

   3. registration을 서비스 워커 등록 매칭을 storage key와 client의 creation URL을 인자로 실행한 결과로 한다.

   4. registration이 null이 아니고, registration의 active worker가 null이 아니면, 작업 큐에 추가를 readyPromise의 settings object의 responsible event loop에서 DOM manipulation 작업 소스로 실행하여, readyPromise를 서비스 워커 등록 객체 얻기로 registration을 readyPromise의 settings object에서 반환한 값으로 resolve한다.

4. readyPromise를 반환한다.

참고: 반환된 ready promise는 절대 reject되지 않는다. 만약 이 알고리즘에서 resolve되지 않으면, 매칭되는 서비스 워커 등록이 등록되고 active worker가 설정될 때 결국 resolve된다. (Activate 알고리즘 단계 참고)

3.4.3. register(scriptURL, options)

참고: register(scriptURL, options) 메서드는 주어진 scope url에 대해 서비스 워커 등록을 생성하거나 업데이트한다. 성공 시, 서비스 워커 등록은 제공된 scriptURL을 scope url에 연결하며, 이후 navigation matching에 사용된다.

register(scriptURL, options) 메서드 단계:

1. p를 프라미스(promise)로 두자.

2. scriptURL을 Trusted Type 호환 문자열 얻기를 TrustedScriptURL, this의 관련된 글로벌 오브젝트, scriptURL, "ServiceWorkerContainer register", "script"와 함께 호출한 결과로 설정한다.

3. client를 this의 service worker 클라이언트로 둔다.

4. scriptURL을 파싱 scriptURL에 대해 this의 관련 설정 객체의 API 기본 URL과 함께 파싱한 결과로 한다.

5. scopeURL을 null로 둔다.

6. 만약 options["scope"] 가 존재한다면, scopeURL을 파싱 options["scope"] 에 대해 this의 관련 설정 객체의 API 기본 URL과 함께 파싱한 결과로 설정한다.

7. 등록 시작을 scopeURL, scriptURL, p, client, client의 생성 URL, options["type"], 및 options["updateViaCache"] 와 함께 호출한다.

8. p를 반환한다.

3.4.4. getRegistration(clientURL)

getRegistration(clientURL) 메서드 단계:

1. client를 this의 서비스 워커 클라이언트로 둔다.

2. storage key를 client가 주어졌을 때 스토리지 키를 얻는 알고리즘을 실행한 결과로 둔다.

3. clientURL을 this의 관련 설정 객체의 API 기준 URL을 사용하여 clientURL을 구문 분석한 결과로 둔다.

4. clientURL이 실패이면, TypeError로 거부된 프로미스를 반환한다.

5. clientURL의 프래그먼트를 null로 설정한다.

6. clientURL의 출처가 client의 출처와 같지 않으면, "SecurityError" DOMException으로 거부된 promise를 반환한다.

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

8. 다음 하위 단계를 병렬로 실행한다.

   1. registration을 storage key와 clientURL이 주어졌을 때 서비스 워커 등록 일치시키기를 실행한 결과로 둔다.

   2. promise의 관련 설정 객체의 담당 이벤트 루프에, DOM 조작 태스크 소스를 사용하여 다음 단계를 실행하는 태스크를 큐에 넣는다.

      1. registration이 null이면, promise를 undefined로 이행하고 이 단계를 중단한다.

      2. promise의 관련 설정 객체에서 registration을 나타내는 서비스 워커 등록 객체를 가져온 결과로 promise를 이행한다.

9. promise를 반환한다.

3.4.5. getRegistrations()

getRegistrations() 메서드 단계:

1. client를 this의 서비스 워커 클라이언트로 둔다.

2. client storage key를 client가 주어졌을 때 스토리지 키를 얻는 알고리즘을 실행한 결과로 둔다.

3. promise를 새 프로미스로 둔다.

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

   1. registrations를 새로운 리스트로 둔다.

   2. 각각에 대해 등록 맵의 (storage key, scope) → registration:

      1. storage key가 client storage key와 같으면, registration을 registrations에 추가한다.

   3. promise의 관련 설정 객체의 담당 이벤트 루프에, DOM 조작 태스크 소스를 사용하여 다음 단계를 실행하는 태스크를 큐에 넣는다.

      1. registrationObjects를 새로운 리스트로 둔다.

      2. registrations의 각 registration에 대해 반복한다.

         1. registrationObj를 promise의 관련 설정 객체에서 registration을 나타내는 서비스 워커 등록 객체를 가져온 결과로 둔다.

         2. registrationObj를 registrationObjects에 추가한다.

      3. promise의 관련 Realm에서 registrationObjects의 새 동결 배열로 promise를 이행한다.

5. promise를 반환한다.

3.4.6. startMessages()

startMessages() 메서드 단계는 this의 클라이언트 메시지 큐가 비활성화 상태라면 활성화한다.

4.1.4. skipWaiting()

참고: skipWaiting() 메서드는 이 서비스 워커가 registration의 대기 위치에서 활성으로 진행하도록 한다. 서비스 워커 클라이언트가 사용 중이어도 registration이 진행된다.

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

1. promise를 새로운 프라미스로 설정한다.

2. 다음 하위 단계들을 병렬로 실행한다:

   1. 서비스 워커의 skip waiting 플래그를 설정한다.

   2. Try Activate를 서비스 워커의 containing service worker registration에 대해 호출한다.

   3. 태스크를 큐에 넣는다 서비스 워커의 담당 이벤트 루프에서, promise를 undefined로 이행하기 위해 태스크를 큐에 넣는다.

3. promise를 반환한다.

4.2.5. postMessage(message, transfer)

postMessage(message, transfer) 메서드 단계는 다음과 같다:

1. options를 «[ "transfer" → transfer ]»로 한다.

2. postMessage(message, options) 를 message와 options를 인수로 하여 호출한다.

4.2.6. postMessage(message, options)

postMessage(message, options) 메서드 단계는 다음과 같다:

1. contextObject를 this로 둔다.

2. sourceSettings를 contextObject의 relevant settings object로 둔다.

3. serializeWithTransferResult를 StructuredSerializeWithTransfer(message, options["transfer"])의 결과로 둔다. 예외가 있으면 그대로 다시 던진다.

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

   1. targetClient를 null로 둔다.

   2. 각 service worker client client에 대해:

      1. client가 contextObject의 service worker client이면, targetClient를 client로 설정하고, 중단한다.

   3. targetClient가 null이면, 반환한다.

   4. destination을, 연관된 service worker client가 targetClient인 ServiceWorkerContainer 객체로 둔다.

   5. 다음 단계를 실행하는 task를 destination의 client message queue에 추가한다:

      1. origin을 sourceSettings의 origin으로 둔다.

      2. source를, contextObject의 relevant global object의 service worker를 targetClient에서 나타내는 service worker object를 가져온 결과로 둔다.

      3. deserializeRecord를 StructuredDeserializeWithTransfer(serializeWithTransferResult, destination의 relevant Realm)으로 둔다.

         이 과정에서 예외가 발생하면 이를 포착하고, destination에서 이름이 messageerror인 이벤트를 발생시키며 MessageEvent를 사용한다. 이때 그 origin은 origin으로 초기화하고 source 속성은 source로 초기화한 다음, 이 단계들을 중단한다.

      4. messageClone을 deserializeRecord.[[Deserialized]]로 둔다.

      5. newPorts를, 있다면 deserializeRecord.[[TransferredValues]]에 있는 모든 MessagePort 객체로 구성된 새로운 frozen array로 둔다.

      6. destination에서 이름이 message인 이벤트를 디스패치하며 MessageEvent를 사용한다. 이때 그 origin은 origin으로 초기화하고, source 속성은 source로, data 속성은 messageClone으로, ports 속성은 newPorts로 초기화한다.

4.2.10. focus()

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

1. 이 origin에 속한 어떤 Window도 transient activation을 갖고 있지 않다면, "InvalidAccessError" DOMException으로 거부된 promise를 반환한다.

2. serviceWorkerEventLoop를 surrounding agent의 event loop로 둔다.

3. promise를 새로운 promise로 둔다.

4. task를 큐에 넣어 this의 연관된 service worker client의 responsible event loop에서, user interaction task source를 사용해 다음 단계를 실행한다:

   1. focusing steps를 this의 browsing context와 함께 실행한다.

   2. frameType을, Get Frame Type을 this의 browsing context와 함께 실행한 결과로 둔다.

   3. visibilityState를 this의 browsing context의 active document의 visibilityState 속성 값으로 둔다.

   4. focusState를 has focus steps를 this의 browsing context의 active document와 함께 실행한 결과로 둔다.

   5. ancestorOriginsList를 this의 browsing context의 active document의 ancestor origins list의 연관된 목록으로 둔다.

   6. task를 큐에 넣어 serviceWorkerEventLoop에서 DOM manipulation task source를 사용해 다음 단계를 실행한다:

      1. windowClient를 Create Window Client를 this의 연관된 service worker client, frameType, visibilityState, focusState, ancestorOriginsList와 함께 실행한 결과로 둔다.

      2. windowClient의 focus state가 true이면, promise를 windowClient로 resolve한다.

      3. 그렇지 않으면, promise를 TypeError로 reject한다.

5. promise를 반환한다.

4.2.11. navigate(url)

navigate(url) 메서드 단계는 다음과 같다:

1. url을 파싱한 결과를 url로 두되, 기준은 this의 relevant settings object의 API base URL로 한다.

2. url이 failure이면, promise를 TypeError로 거부하여 반환한다.

3. url이 about:blank이면, promise를 TypeError로 거부하여 반환한다.

4. this의 연관된 service worker client의 active service worker가 this의 relevant global object의 service worker가 아니면, promise를 TypeError로 거부하여 반환한다.

5. serviceWorkerEventLoop를 current global object의 event loop로 둔다.

6. promise를 새로운 promise로 둔다.

7. task를 큐에 넣어 this의 연관된 service worker client의 responsible event loop에서 user interaction task source를 사용하여 다음 단계를 실행한다:

   1. browsingContext를 this의 browsing context로 둔다.

   2. browsingContext의 associated document가 fully active가 아니면, task를 큐에 넣어 serviceWorkerEventLoop에서 DOM manipulation task source를 사용해 promise를 TypeError로 reject하고, 이 단계들을 중단한다.

   3. HandleNavigate: Navigate를 실행하여 browsingContext를 url로 이동시키되, browsingContext의 associated document를 사용하고 exceptionsEnabled를 true로 한다.

   4. HandleNavigate 단계에서 호출된 알고리즘 단계가 예외를 던지면, task를 큐에 넣어 serviceWorkerEventLoop에서 DOM manipulation task source를 사용해 그 예외로 promise를 reject하고, 이 단계들을 중단한다.

   5. frameType을 Get Frame Type을 browsingContext와 함께 실행한 결과로 둔다.

   6. visibilityState를 browsingContext의 active document의 visibilityState 속성 값으로 둔다.

   7. focusState를 has focus steps를 browsingContext의 active document와 함께 실행한 결과로 둔다.

   8. ancestorOriginsList를 browsingContext의 active document의 ancestor origins list의 연관된 목록으로 둔다.

   9. task를 큐에 넣어 serviceWorkerEventLoop에서 DOM manipulation task source를 사용해 다음 단계를 실행한다:

      1. browsingContext의 Window 객체의 environment settings object의 creation URL의 origin이 동일한 것이 service worker의 origin이 아니면, promise를 null로 resolve하고 이 단계들을 중단한다.

      2. windowClient를 Create Window Client를 this의 service worker client, frameType, visibilityState, focusState, ancestorOriginsList와 함께 실행한 결과로 둔다.

      3. promise를 windowClient로 resolve한다.

8. promise를 반환한다.

4.3.1. get(id)

get(id) 메서드 단계는 다음과 같다:

1. promise를 새로운 promise로 둔다.

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

   1. service worker client client 각각에 대해, client가 주어졌을 때 storage key를 얻기를 실행한 결과가 연관된 service worker의 containing service worker registration의 storage key와 같은 경우:

      1. client의 id가 id가 아니면, continue한다.

      2. client의 execution ready flag가 설정되거나 client의 discarded flag가 설정될 때까지 기다린다.

      3. client의 execution ready flag가 설정되어 있으면, task를 큐에 넣어 promise의 relevant settings object의 responsible event loop에서, DOM manipulation task source를 사용하여 다음 단계를 실행한다:

         1. Resolve Get Client Promise를 client와 promise로 호출한다.

         2. 이 단계들을 중단한다.

   2. task를 큐에 넣어 promise의 relevant settings object의 responsible event loop에서, DOM manipulation task source를 사용해 promise를 undefined로 resolve한다.

3. promise를 반환한다.

4.3.2. matchAll(options)

matchAll(options) 메서드 단계는 다음과 같다:

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

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

   1. targetClients를 새 목록으로 둔다.

   2. client가 주어졌을 때 스토리지 키를 얻기를 실행한 결과가 연결된 서비스 워커의 포함 서비스 워커 등록의 스토리지 키와 같은 각 서비스 워커 클라이언트 client에 대해:

      1. client의 실행 준비 플래그가 설정되지 않았거나 client의 폐기 플래그가 설정되어 있으면, 계속한다.

      2. client가 보안 컨텍스트가 아니면, 계속한다.

      3. options["includeUncontrolled"]가 false이고, client의 활성 서비스 워커가 연결된 서비스 워커가 아니면, 계속한다.

      4. client를 targetClients에 추가한다.

   3. matchedWindowData를 새 목록으로 둔다.

   4. matchedClients를 새 목록으로 둔다.

   5. targetClients에 있는 각 서비스 워커 클라이언트 client에 대해:

      1. options["type"]이 "window" 또는 "all"이고, client가 환경 설정 객체가 아니거나 윈도 클라이언트이면:

         1. windowData를 «[ "client" → client, "ancestorOriginsList" → 새 목록 ]»으로 둔다.

         2. browsingContext를 null로 둔다.

         3. isClientEnumerable을 true로 둔다.

         4. client가 환경 설정 객체이면, browsingContext를 client의 전역 객체의 브라우징 컨텍스트로 설정한다.

         5. 그렇지 않으면, browsingContext를 client의 대상 브라우징 컨텍스트로 설정한다.

         6. browsingContext의 이벤트 루프에서 사용자 상호작용 태스크 소스를 사용하여 다음 하위 단계를 실행하도록 태스크 task를 큐에 넣는다.

            1. browsingContext가 폐기되었으면, isClientEnumerable을 false로 설정하고 이 단계들을 중단한다.

            2. client가 윈도 클라이언트이고 client의 연결된 문서가 browsingContext의 활성 문서가 아니면, isClientEnumerable을 false로 설정하고 이 단계들을 중단한다.

            3. windowData["frameType"]을 browsingContext로 프레임 유형 가져오기를 실행한 결과로 설정한다.

            4. windowData["visibilityState"]를 browsingContext의 활성 문서의 visibilityState 속성 값으로 설정한다.

            5. windowData["focusState"]를 browsingContext의 활성 문서를 인수로 하여 포커스 여부 단계를 실행한 결과로 설정한다.

            6. client가 윈도 클라이언트이면, windowData["ancestorOriginsList"]를 browsingContext의 활성 문서의 조상 출처 목록에 연결된 목록으로 설정한다.

         7. task의 실행이 완료될 때까지 기다린다.

            참고: 이 대기는 차단 대기이지만, 상태가 손상되지 않는 한 구현자는 반복을 병렬로 실행할 수 있다.

         8. isClientEnumerable이 true이면:

            1. windowData를 matchedWindowData에 추가한다.

      2. 그렇지 않고 options["type"]이 "worker" 또는 "all"이고 client가 전용 워커 클라이언트이거나, options["type"]이 "sharedworker" 또는 "all"이고 client가 공유 워커 클라이언트이면:

         1. client를 matchedClients에 추가한다.

   6. task를 큐에 넣어 다음 단계를 promise의 relevant settings object의 responsible event loop에서 DOM manipulation task source를 사용하여 실행한다:

      1. clientObjects를 새 목록으로 둔다.

      2. matchedWindowData에 있는 각 windowData에 대해 반복한다.

         1. windowClient를 windowData["client"], windowData["frameType"], windowData["visibilityState"], windowData["focusState"] 및 windowData["ancestorOriginsList"]를 인수로 하여 윈도 클라이언트 생성 알고리즘을 실행한 결과로 둔다.

         2. windowClient를 clientObjects에 추가한다.

      3. matchedClients에 있는 각 client에 대해 반복한다.

         1. clientObject를 client를 인수로 하여 클라이언트 생성 알고리즘을 실행한 결과로 둔다.

         2. clientObject를 clientObjects에 추가한다.

      4. clientObjects를 다음과 같이 정렬한다.

         • 브라우징 컨텍스트가 포커스된 적이 있는 WindowClient 객체를 먼저 배치하고, 가장 최근에 포커스된 순서로 정렬한다.

         • 브라우징 컨텍스트가 한 번도 포커스되지 않은 WindowClient 객체를 그다음에 배치하고, 해당 서비스 워커 클라이언트의 생성 순서로 정렬한다.

         • 연결된 서비스 워커 클라이언트가 워커 클라이언트인 Client 객체를 그다음에 배치하고, 해당 서비스 워커 클라이언트의 생성 순서로 정렬한다.

         참고: 윈도 클라이언트는 항상 워커 클라이언트보다 먼저 배치된다.

      5. promise의 관련 Realm에서 clientObjects의 새 고정 배열로 promise를 이행한다.

3. promise를 반환한다.

4.3.3. openWindow(url)

openWindow(url) 메서드 단계는 다음과 같다:

1. url을 파싱한 결과로 둔다. 이때 this의 관련 설정 객체의 API 기본 URL을 사용하여 url을 파싱한다.

2. url이 실패이면, TypeError로 거부된 프로미스를 반환한다.

3. url이 about:blank이면, TypeError로 거부된 프로미스를 반환한다.

4. 이 출처의 어떠한 Window도 일시적 활성화를 갖고 있지 않으면, "InvalidAccessError" DOMException으로 거부된 프로미스를 반환한다.

5. serviceWorkerEventLoop를 현재 전역 객체의 이벤트 루프로 둔다.

6. promise를 새 프로미스로 둔다.

7. 다음 하위 단계를 병렬로 실행한다:

   1. newContext를 새 최상위 브라우징 컨텍스트로 둔다.

   2. newContext의 Window 객체의 환경 설정 객체의 담당 이벤트 루프에서 사용자 상호작용 태스크 소스를 사용하여 다음 단계를 실행하도록 태스크를 큐에 추가한다:

      1. HandleNavigate: newContext를 url로 내비게이트하며, exceptionsEnabled는 true로 하고, historyHandling은 "replace"로 한다.

      2. HandleNavigate라는 레이블이 지정된 단계에서 호출된 알고리즘 단계가 예외를 던지면, serviceWorkerEventLoop에서 DOM 조작 태스크 소스를 사용하여 promise를 그 예외로 거부하도록 태스크를 큐에 추가하고, 이 단계들을 중단한다.

      3. frameType을 newContext를 사용하여 프레임 유형 가져오기를 실행한 결과로 둔다.

      4. visibilityState를 newContext의 활성 문서의 visibilityState 속성 값으로 둔다.

      5. focusState를 newContext의 활성 문서를 인수로 사용하여 포커스 보유 단계를 실행한 결과로 둔다.

      6. ancestorOriginsList를 newContext의 활성 문서의 상위 출처 목록에 연결된 목록으로 둔다.

      7. serviceWorkerEventLoop에서 DOM 조작 태스크 소스를 사용하여 다음 단계를 실행하도록 태스크를 큐에 추가한다:

         1. newContext의 Window 객체의 환경 설정 객체가 주어졌을 때 저장소 키를 얻기를 실행한 결과가 서비스 워커의 포함하는 서비스 워커 등록의 저장소 키와 같지 않으면, promise를 null로 이행하고 이 단계들을 중단한다.

         2. client를 newContext의 Window 객체의 환경 설정 객체, frameType, visibilityState, focusState, ancestorOriginsList를 인수로 사용하여 윈도우 클라이언트 생성을 실행한 결과로 둔다.

         3. promise를 client로 이행한다.

8. promise를 반환한다.

4.3.4. claim()

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

1. 서비스 워커가 활성 워커가 아니면, "InvalidStateError" DOMException으로 거부된 프로미스를 반환한다.

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

3. 다음 하위 단계를 병렬로 실행한다.

   1. client가 주어졌을 때 스토리지 키를 얻기를 실행한 결과가 서비스 워커의 포함 서비스 워커 등록의 스토리지 키와 같은 각 서비스 워커 클라이언트 client에 대해:

      1. client의 실행 준비 플래그가 설정되지 않았거나 client의 폐기 플래그가 설정되어 있으면, 계속한다.

      2. client가 보안 컨텍스트가 아니면, 계속한다.

      3. storage key를 client가 주어졌을 때 스토리지 키를 얻기를 실행한 결과로 둔다.

      4. registration을 storage key와 client의 생성 URL이 주어졌을 때 서비스 워커 등록 일치시키기를 실행한 결과로 둔다.

      5. registration이 서비스 워커의 포함 서비스 워커 등록이 아니면, 계속한다.

         참고: 서비스 워커의 포함 서비스 워커 등록이 등록 해제됨 상태이면 registration은 null이다.

      6. client의 활성 서비스 워커가 서비스 워커가 아니면:

         1. client를 인수로 하여 서비스 워커 클라이언트 언로드 처리를 호출한다.

         2. client의 활성 서비스 워커를 서비스 워커로 설정한다.

         3. client를 인수로 하여 컨트롤러 변경 알림 알고리즘을 호출한다.

   2. task를 큐에 넣어 promise의 relevant settings object의 responsible event loop에서 DOM manipulation task source를 사용하여 promise를 undefined로 resolve한다.

4. promise를 반환한다.

4.4.1. event.waitUntil(f)

참고: waitUntil() 메서드는 이벤트의 수명을 연장한다.

waitUntil(f) 메서드 단계는 수명 연장 프라미스 추가 f를 this에 추가하는 것이다.

1. event의 isTrusted 속성이 false이면, "InvalidStateError" DOMException을 throw한다.

2. event가 활성 상태가 아니면, "InvalidStateError" DOMException을 throw한다.

   참고: 이벤트 핸들러를 호출한 태스크에서 수명 연장 프라미스가 추가되지 않았다면, 이후 비동기 태스크에서 waitUntil()을 호출하면 예외가 발생한다.

3. promise를 event의 수명 연장 프라미스에 추가한다.

4. event의 대기 중 프라미스 수를 1 증가시킨다.

   참고: 주어진 프라미스가 이미 settle된 경우에도 대기 중 프라미스 수는 증가한다. 해당 카운트 감소는 프라미스 반응의 미크로태스크에서 처리된다.

5. promise가 이행 또는 거부될 때, 미크로태스크를 큐에 추가하여 다음 하위 단계들을 실행한다:

   1. event의 대기 중 프라미스 수를 1 감소시킨다.

   2. event의 대기 중 프라미스 수가 0이면:

      1. registration을 현재 글로벌 객체의 서비스 워커의 등록 객체로 한다.

      2. registration이 등록 해제됨이면, Try Clear Registration을 registration을 인수로 실행한다.

      3. registration이 null이 아니면, Try Activate를 registration을 인수로 실행한다.

사용자 에이전트는 서비스 워커에 대기 중 이벤트 없음이 서비스 워커에 대해 false를 반환하면 해당 서비스 워커를 종료하지 않아야 한다.

4.6.7. event.respondWith(r)

참고: 개발자는 r 인수에 promise나 Response 객체를 직접 넣을 수 있다(Response 객체는 자동으로 promise로 캐스팅됨). 그렇지 않으면 네트워크 에러가 Fetch로 반환된다. 렌더러 측 보안 검사는 cross-origin 콘텐츠의 tainting과 관련이 있으며 filtered responses 타입에 따라 결정된다(Fetch 참고).

respondWith(r) 메서드 단계는 다음과 같다:

1. event를 this로 한다.

2. event의 dispatch 플래그가 unset이면, "InvalidStateError" DOMException을 throw한다.

3. event의 respondWith 진입 플래그가 설정되어 있으면, "InvalidStateError" DOMException을 throw한다.

4. 수명 연장 프라미스 추가 r를 event에 추가한다.

   참고: event.respondWith(r) 호출은 event.waitUntil(r)과 같이 이벤트의 수명을 기본적으로 연장한다.

5. event의 stop propagation 플래그와 stop immediate propagation 플래그를 설정한다.

6. event의 respondWith 진입 플래그를 설정한다.

7. event의 응답 대기 플래그를 설정한다.

8. targetRealm을 event의 relevant Realm으로 한다.

9. r가 reject될 때:

   1. event의 respondWith 오류 플래그를 설정한다.

   2. event의 응답 대기 플래그를 unset한다.

10. r가 이행될 때 response로:

    1. response가 Response 객체가 아니면 respondWith 오류 플래그를 설정한다.

       참고: respondWith 오류 플래그가 설정되면, 네트워크 에러가 Fetch로 Handle Fetch 알고리즘을 통해 반환된다(21.1단계 참고). 그렇지 않으면 response 값이 Fetch로 Handle Fetch 알고리즘을 통해 반환된다(22.1단계 참고).

    2. 그 외에는:

       1. bytes를 빈 바이트 시퀀스로 한다.

       2. end-of-body를 false로 한다.

       3. done을 false로 한다.

       4. potentialResponse를 response의 연관 response의 복사본으로 하되, body는 제외한다.

       5. response의 body가 null이 아니면, 다음 하위 단계를 실행한다:

          1. reader를 reader 얻기를 response의 body의 stream에 대해 실행한 결과로 한다.

          2. pullAlgorithm을 다음 단계들을 실행하는 액션으로 한다:

             1. readRequest를 새로운 read request로 하고, 다음 항목을 포함한다:

                chunk 단계, chunk가 주어졌을 때

                1. 단언: chunk는 Uint8Array이다.

                2. chunk가 나타내는 바이트를 bytes에 추가한다.

                3. potentialResponse의 body info의 encoded size를 bytes의 byte length만큼 증가시킨다.

                4. potentialResponse의 body info의 decoded size를 bytes의 byte length만큼 증가시킨다.

                5. ! DetachArrayBuffer(chunk.[[ViewedArrayBuffer]])를 수행한다.

                close 단계

                1. end-of-body를 true로 한다.

                error 단계

                1. newStream을 에러 처리(TypeError 사용).

             2. reader에서 chunk 읽기를 readRequest로 실행한다.

          3. cancelAlgorithm을 reader cancel을 실행하는 액션으로 한다.

          4. highWaterMark를 사용자 에이전트가 선택한 0 이상의 NaN이 아닌 값으로 한다.

          5. sizeAlgorithm을 chunk 객체를 받아서 0 이상의 NaN/무한대가 아닌 값을 반환하는 알고리즘으로 한다(사용자 에이전트가 선택).

          6. newStream을 ReadableStream의 새 인스턴스로 만들고, set up에 pullAlgorithm pullAlgorithm, cancelAlgorithm cancelAlgorithm, highWaterMark highWaterMark, sizeAlgorithm sizeAlgorithm을 targetRealm에서 실행한다.

          7. potentialResponse의 body를, body의 새 인스턴스로 하고 그 stream을 newStream으로 한다.

          8. done이 false인 동안 반복적으로 다음 하위 단계를 병렬로 실행한다:

             1. newStream이 errored면 done을 true로 한다.

             2. 그 외에 bytes가 비어 있고 end-of-body가 true면, newStream 닫기를 하고 done을 true로 한다.

             3. 그 외에 bytes가 비어 있지 않으면 다음 하위 단계를 실행한다:

                1. chunk를 bytes 처음부터의 부분 시퀀스로 한다.

                2. chunk를 bytes에서 제거한다.

                3. buffer를 ArrayBuffer의 새 인스턴스로 만들고, targetRealm에서 chunk를 담는다.

                4. newStream에 enqueue한다. Uint8Array로 targetRealm에서 buffer를 감싼다.

          참고: 이 단계들은 response의 body의 stream을 potentialResponse에 "파이프"하는 것과 동등한 observable 결과를 만든다.

          참고: 서비스 워커가 chunk 단위로 쓴 데이터는 클라이언트가 동일 chunk 단위로 읽는다고 보장되지 않는다. 즉, 클라이언트는 동일 데이터를 읽지만 chunk 분할은 브라우저에 따라 다를 수 있다.

       6. event의 잠재적 응답을 potentialResponse로 한다.

    3. event의 응답 대기 플래그를 unset한다.

5.4.1. match(request, options)

match(request, options) 메서드 단계는 다음과 같습니다:

1. promise를 새로운 promise로 둡니다.

2. 다음 하위 단계를 병렬로 실행합니다:

   1. p를 matchAll(request, options) 메서드에 request와 options를 전달하여 실행한 결과로 둡니다.

   2. p가 완료될 때까지 대기합니다.

   3. p가 예외와 함께 reject되면,

      1. promise를 해당 예외로 reject합니다.

   4. 그렇지 않고 p가 배열 responses로 resolve되면,

      1. responses가 빈 배열이면,

         1. promise를 undefined로 resolve합니다.

      2. 그 외의 경우:

         1. promise를 responses의 첫 번째 요소로 resolve합니다.

3. promise를 반환합니다.

5.4.2. matchAll(request, options)

matchAll(request, options) 메서드 단계는 다음과 같습니다:

1. r을 null로 둔다.

2. 선택적 인수 request가 생략되지 않았으면:

   1. request가 Request 객체이면:

      1. r을 request의 요청으로 설정한다.

      2. r의 메서드가 `GET`이 아니고 options.ignoreMethod가 false이면, 빈 배열로 이행된 프로미스를 반환한다.

   2. 그렇지 않고 request가 문자열이면:

      1. request를 인수로 하여 Request의 초기 값을 생성자로 호출한 결과에 연결된 요청으로 r을 설정한다. 이 과정에서 예외를 던지면, 해당 예외로 거부된 프로미스를 반환한다.

3. realm을 this의 관련 Realm으로 둔다.

4. promise를 새 프로미스로 둔다.

5. 다음 하위 단계를 병렬로 실행한다.

   1. responses를 빈 목록으로 둔다.

   2. 선택적 인수 request가 생략되었으면:

      1. 각 관련 요청 응답 목록의 requestResponse에 대해:

         1. requestResponse의 응답 복사본을 responses에 추가한다.

   3. 그렇지 않으면:

      1. requestResponses를 r과 options로 캐시 질의를 실행한 결과로 둔다.

      2. 각 requestResponses의 requestResponse에 대해:

         1. requestResponse의 응답 복사본을 responses에 추가한다.

   4. responses의 각 response에 대해:

      1. response의 type이 "opaque"이고 promise의 relevant settings object의 origin, promise의 relevant settings object, "", 그리고 response의 internal response로 cross-origin resource policy check를 수행한 결과가 blocked를 반환하면, promise를 TypeError로 reject하고 이 단계들을 중단한다.

   5. task를 큐에 넣어, promise의 relevant settings object의 responsible event loop에서 DOM manipulation task source를 사용해 다음 단계를 수행한다:

      1. responseList를 list로 둔다.

      2. responses의 각 response에 대해:

         1. response와 연관된 새 Response 객체와, guard가 "immutable"인 새 Headers 객체를 responseList에 추가한다.

      3. realm에서 responseList로부터 생성된 frozen array로 promise를 resolve한다.

6. promise를 반환한다.

5.4.3. add(request)

add(request) 메서드 단계는 다음과 같습니다:

1. requests를 request만을 포함하는 배열로 둡니다.

2. responseArrayPromise를 addAll(requests) 알고리즘에 requests를 인자로 전달하여 실행한 결과로 둡니다.

3. responseArrayPromise가 fulfill될 때 undefined를 반환하는 fulfillment handler와 함께 reacting한 결과를 반환합니다.

5.4.4. addAll(requests)

addAll(requests) 메서드 단계는 다음과 같습니다:

1. responsePromises를 빈 리스트로 둔다.

2. requestList를 빈 리스트로 둔다.

3. requests에서 유형이 Request인 각 request에 대해:

   1. r을 request의 요청으로 둔다.

   2. r의 URL의 스킴이 "http"와 "https" 중 하나가 아니거나, r의 메서드가 `GET`이 아니면, TypeError로 거부된 프로미스를 반환한다.

4. fetchControllers를 가져오기 컨트롤러의 리스트로 둔다.

5. requests의 각 request에 대해:

   1. r을 request를 인수로 사용하여 Request의 초기 값을 생성자로 호출한 결과와 연결된 요청으로 둔다. 이것이 예외를 던지면, 해당 예외로 거부된 프로미스를 반환한다.

   2. r의 URL의 스킴이 "http"와 "https" 중 하나가 아니면:

      1. fetchControllers의 각 fetchController에 대해 반복하여, fetchController를 중단한다.

      2. TypeError로 거부된 프로미스를 반환한다.

   3. r의 클라이언트의 전역 객체가 ServiceWorkerGlobalScope 객체이면, request의 서비스 워커 모드를 "none"으로 설정한다.

   4. r을 requestList에 추가한다.

   5. responsePromise를 새 프로미스로 둔다.

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

      • r을 가져온 결과를 추가한다.

      • response에 대한 processResponse로서 다음 하위 단계를 실행한다.

        1. response의 유형이 "error"이거나, response의 상태가 정상 상태가 아니거나 206이면, responsePromise를 TypeError로 거부한다.

        2. 그렇지 않고 response의 헤더 리스트에 `Vary`라는 이름의 헤더가 포함되어 있으면:

           1. fieldValues를 Vary 헤더의 필드 값에 해당하는 요소를 포함하는 리스트로 둔다.

           2. fieldValues의 각 fieldValue에 대해 반복한다.

              1. fieldValue가 "*"와 일치하면:

                 1. responsePromise를 TypeError로 거부한다.

                 2. fetchControllers의 각 fetchController에 대해 반복하여, fetchController를 중단한다.

                 3. 이 단계를 중단한다.

      • response에 대한 processResponseEndOfBody로서 다음 하위 단계를 실행한다.

        1. response의 중단됨 플래그가 설정되어 있으면, responsePromise를 "AbortError" DOMException으로 거부하고 이 단계를 중단한다.

        2. responsePromise를 response로 이행한다.

        참고: 응답의 본문이 완전히 수신되면 캐시 커밋이 허용된다.

   7. responsePromise를 responsePromises에 추가한다.

6. p를 responsePromises의 모든 항목을 기다리는 프로미스를 얻은 결과로 둔다.

7. p에 반응한 결과를 반환한다. 이때 이행 핸들러는 인수 responses로 호출되면 다음 하위 단계를 수행한다.

   1. operations를 빈 목록으로 둔다.

   2. index를 0으로 둔다.

   3. responses의 각 response에 대해:

      1. operation을 캐시 일괄 작업으로 둔다.

      2. operation의 유형을 "put"으로 설정한다.

      3. operation의 요청을 requestList[index]로 설정한다.

      4. operation의 응답을 response로 설정한다.

      5. operation을 operations에 추가한다.

      6. index를 1 증가시킨다.

   4. realm을 this의 관련 Realm으로 둔다.

   5. cacheJobPromise를 새 프로미스로 둔다.

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

      1. errorData를 null로 둔다.

      2. Batch Cache Operations를 operations와 함께 호출한다. 이 과정에서 예외를 던지면, errorData를 해당 예외로 설정한다.

      3. task를 큐에 넣어, cacheJobPromise의 relevant settings object의 responsible event loop에서 DOM manipulation task source를 사용하여 다음 하위 단계를 수행한다:

         1. errorData가 null이면, cacheJobPromise를 undefined로 resolve한다.

         2. 그렇지 않으면, realm에서 errorData로 새로 생성된 exception으로 cacheJobPromise를 reject한다.

   7. cacheJobPromise를 반환한다.

5.4.5. put(request, response)

put(request, response) 메서드 단계는 다음과 같습니다:

1. innerRequest를 null로 둔다.

2. 만약 request가 Request 객체라면, innerRequest를 request의 request로 설정한다.

3. 그렇지 않으면:

   1. requestObj를 Request의 생성자에 request를 인자로 넘겨 호출한 결과로 둔다. 만약 이것이 예외(exception)를 발생시키면, 해당 예외와 함께 거부된 프라미스를 반환한다.

   2. innerRequest를 requestObj의 request로 설정한다.

4. 만약 innerRequest의 url의 scheme이 "http"와 "https" 중 하나가 아니거나, innerRequest의 method가 `GET`이 아니라면, TypeError와 함께 거부된 프라미스를 반환한다.

5. innerResponse를 response의 response로 둔다.

6. 만약 innerResponse의 status가 206이라면, TypeError와 함께 거부된 프라미스를 반환한다.

7. 만약 innerResponse의 header list에 header 이름이 `Vary`인 항목이 있다면:

   1. fieldValues를 리스트(list)로, 해당 아이템이 Vary 헤더의 필드 값(field-values)을 포함하도록 한다.

   2. 각 fieldValue에 대하여 fieldValues에서:

      1. 만약 fieldValue가 "*"와 일치한다면, TypeError와 함께 거부된 프라미스를 반환한다.

8. 만약 innerResponse의 body가 disturbed 상태이거나, locked 상태라면, TypeError와 함께 거부된 프라미스를 반환한다.

9. clonedResponse를 innerResponse의 복제(clone)로 둔다.

10. bodyReadPromise를 undefined로 resolve된 프라미스로 한다.

11. 만약 innerResponse의 body가 null이 아니라면, 다음 하위 단계를 실행한다:

    1. stream을 innerResponse의 body의 stream으로 둔다.

    2. reader를 stream에 대해 reader 얻기의 결과로 한다.

    3. bodyReadPromise를 reader로부터 모든 바이트를 읽는 결과로 설정한다.

    참고: 이는 innerResponse의 body가 locked 상태가 되며, clonedResponse에 버퍼링된 전체 본문 복사본이 존재함을 보장한다. 구현에서는 메모리 대신 디스크 스트리밍 최적화가 가능하다.

12. operations를 빈 리스트로 둔다.

13. operation을 캐시 배치 작업(cache batch operation)으로 둔다.

14. operation의 type을 "put"으로 설정한다.

15. operation의 request를 innerRequest로 설정한다.

16. operation의 response를 clonedResponse로 설정한다.

17. operation을 operations에 추가(append)한다.

18. realm을 this의 관련 realm으로 둔다.

19. bodyReadPromise의 이행(fulfillment) 결과를 반환한다:

    1. cacheJobPromise를 새로운 프라미스로 둔다.

    2. cacheJobPromise를 반환하고, 다음 단계를 병렬로 실행:

       1. errorData를 null로 둔다.

       2. operations를 사용하여 캐시 작업 일괄 처리를 호출한다. 이 호출이 예외를 던지면, errorData를 해당 예외로 설정한다.

       3. cacheJobPromise의 관련 설정 객체의 담당 이벤트 루프에서 DOM 조작 태스크 소스를 사용하여, 다음 하위 단계를 수행하도록 태스크를 큐에 넣는다:

          1. errorData가 null이면, cacheJobPromise를 undefined로 이행한다.

          2. 그렇지 않으면 realm에서 errorData를 사용하여 새 예외를 생성하고, 이를 사용하여 cacheJobPromise를 거부한다.

5.4.6. delete(request, options)

delete(request, options) 메서드 단계는 다음과 같습니다:

1. r을 null로 둡니다.

2. request가 Request 객체라면:

   1. r에 request의 request를 설정합니다.

   2. r의 method가 `GET`이 아니고 options.ignoreMethod가 false인 경우, false로 resolve된 promise를 반환합니다.

3. 그 외에 request가 문자열이라면:

   1. r을 Request 생성자에 request를 인자로 하여 얻은 결과의 관련 request로 설정합니다. 만약 예외가 발생하면 해당 예외로 reject된 promise를 반환합니다.

4. operations를 빈 리스트로 둡니다.

5. operation을 캐시 배치 작업(cache batch operation)으로 둡니다.

6. operation의 type을 "delete"로 설정합니다.

7. operation의 request를 r로 설정합니다.

8. operation의 options를 options로 설정합니다.

9. Append를 통해 operation을 operations에 추가합니다.

10. realm을 this의 관련 realm으로 둡니다.

11. cacheJobPromise를 새로운 promise로 둡니다.

12. 다음 하위 단계를 병렬로 실행합니다:

    1. errorData를 null로 둔다.

    2. requestResponses를 operations로 캐시 작업 일괄 수행을 실행한 결과로 둔다. 이 과정에서 예외를 던지면, errorData를 해당 예외로 설정한다.

    3. task를 큐에 넣어, cacheJobPromise의 relevant settings object의 responsible event loop에서 DOM manipulation task source를 사용해 다음 하위 단계를 수행한다:

       1. errorData가 null이면:

          1. requestResponses가 비어 있지 않으면, cacheJobPromise를 true로 이행한다.

          2. 그렇지 않으면, cacheJobPromise를 false로 이행한다.

       2. 그렇지 않으면, realm에서 errorData를 사용하여 새로 생성한 예외로 cacheJobPromise를 거부한다.

13. cacheJobPromise를 반환합니다.

5.4.7. keys(request, options)

keys(request, options) 메서드 단계는 다음과 같습니다:

1. r을 null로 둡니다.

2. 선택적 인자인 request가 생략되지 않았다면:

   1. request가 Request 객체라면:

      1. r을 request의 request로 설정합니다.

      2. r의 method가 `GET`이 아니고 options.ignoreMethod가 false인 경우, 빈 배열로 resolve된 promise를 반환합니다.

   2. 그 외에 request가 문자열이라면:

      1. r을 Request 생성자에 request를 인자로 하여 얻은 결과의 관련 request로 설정합니다. 만약 예외가 발생하면, 해당 예외로 reject된 promise를 반환합니다.

3. realm을 this의 관련 realm으로 둡니다.

4. promise를 새로운 promise로 둡니다.

5. 다음 하위 단계를 병렬로 실행합니다:

   1. requests를 빈 리스트로 둡니다.

   2. 선택적 인자인 request가 생략된 경우,

      1. 각 requestResponse를 relevant request response list에서 반복하여:

         1. requestResponse의 request를 requests에 추가합니다.

   3. 그 외의 경우:

      1. requestResponses를 Query Cache에 r과 options를 전달하여 실행한 결과로 둡니다.

      2. 각 requestResponse를 requestResponses에서 반복하여:

         1. requestResponse의 request를 requests에 추가합니다.

   4. task를 큐에 넣어, promise의 relevant settings object의 responsible event loop에서 DOM manipulation task source를 사용해 다음 단계를 수행한다:

      1. requestList를 리스트로 둡니다.

      2. 각 request를 requests에서 반복하여:

         1. request와 Headers 객체(해당 guard가 "immutable"인 새 객체)를 연결하여 새로운 Request 객체를 requestList에 추가합니다.

      3. promise를 frozen array로 생성된 requestList로, realm에서 resolve합니다.

6. promise를 반환합니다.

5.5.1. match(request, options)

match(request, options) 메서드 단계는 다음과 같습니다:

1. 만약 options["cacheName"] 존재한다면,

   1. 새로운 프라미스(promise) promise를 반환하고, 다음 하위 단계를 병렬로 실행한다:

      1. 각 cacheName → cache에 대해 관련 name to cache 맵에서 순회한다:

         1. 만약 options["cacheName"] 이 cacheName에 일치하면,

            1. promise를 Cache 인터페이스의 match(request, options) 메서드에 request와 options를 인자로 넘기고(cache를 match(request, options)의 \[[Call]] 내부 메서드의 thisArgument로 제공) 지정된 알고리즘의 결과로 resolve한다.

            2. 이 단계를 중단한다.

      2. promise를 undefined로 resolve한다.

2. 그렇지 않으면:

   1. promise를 undefined로 resolve된 프라미스로 둔다.

   2. 각 cacheName → cache에 대해 관련 name to cache 맵에서 순회한다:

      1. promise를, fulfillment 핸들러가 호출될 때(인자로 response를 받음) 다음 하위 단계를 수행하는 방식으로, 자기 자신에 대해 reacting한 결과로 설정한다:

         1. 만약 response가 undefined가 아니라면, response를 반환한다.

         2. Cache 인터페이스의 match(request, options) 메서드에 request와 options를 인자로 넘기고(cache를 match(request, options)의 \[[Call]] 내부 메서드의 thisArgument로 제공) 지정된 알고리즘의 결과로 반환한다.

   3. promise를 반환한다.

5.5.2. has(cacheName)

has(cacheName) 메서드 단계는 다음과 같습니다:

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

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

   1. 각 key → value에 대해 관련 name to cache 맵을 순회한다:

      1. cacheName이 key와 일치하면, promise를 true로 resolve하고 이 단계를 중단한다.

   2. promise를 false로 resolve한다.

3. promise를 반환한다.

5.5.3. open(cacheName)

open(cacheName) 메서드 단계는 다음과 같다:

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

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

   1. 각 key → value에 대하여, 관련 name to cache map에서 순회한다:

      1. 만약 cacheName이 key와 일치하면:

         1. promise를 value를 나타내는 새로운 Cache 객체로 resolve한다.

         2. 이 단계를 중단한다.

   2. cache를 새로운 request response list로 둔다.

   3. Set 관련 name to cache map[cacheName]을 cache로 설정한다. 이 캐시 쓰기 작업이 할당된 quota 한도를 초과하여 실패한 경우, promise를 QuotaExceededError로 reject하고 이 단계를 중단한다.

   4. promise를 cache를 나타내는 새로운 Cache 객체로 resolve한다.

3. promise를 반환한다.

5.5.4. delete(cacheName)

delete(cacheName) 메서드 단계는 다음과 같다:

1. promise를 has(cacheName) 메서드에서 cacheName으로 지정된 알고리즘을 실행한 결과로 둔다.

2. promise에 fulfillment 핸들러로 reacting(reacting) 한 결과를 반환한다. 이 핸들러는 cacheExists 인자를 받으면 다음 하위 단계를 수행한다:

   1. 만약 cacheExists가 false라면:

      1. false를 반환한다.

   2. cacheJobPromise를 새로운 프라미스로 둔다.

   3. 다음 하위 단계를 병렬로 실행한다:

      1. Remove 관련 name to cache map[cacheName].

      2. cacheJobPromise를 true로 resolve한다.

      참고: 이 단계가 끝난 후, 기존 DOM 객체(즉, 현재 참조된 Cache, Request, Response 객체)는 계속 동작해야 한다.

   4. cacheJobPromise를 반환한다.

5.5.5. keys()

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

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

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

   1. cacheKeys를 관련 name to cache map의 키를 얻은 결과로 둔다.

      참고: 결과 ordered set에 있는 항목들은 name to cache map에 해당 엔트리가 추가된 순서대로 정렬되어 있다.

   2. promise를 cacheKeys로 resolve한다.

3. promise를 반환한다.